Rust-language senso-concept-Mcs
(Rustlago)

overview of Rustlago

description::
× Mcsh-creation: {2019-06-29}
"Rust is a modern systems programming language focusing on safety, speed, and concurrency. It accomplishes these goals by being memory safe without using garbage collection."
[https://doc.rust-lang.org/rust-by-example/]

name::
* McshEngl.Rust-language!⇒Rustlago,
* McshEngl.Rustlago!=Rust-language,
* McshEngl.Rustlago!@McshTchInf000030,
* McshEngl.McshTchInf000030.last.html//dirTchInf//dirMcsh!⇒Rustlago,
* McshEngl.dirTchInf/McshTchInf000030.last.html!⇒Rustlago,
* McshEngl.lagoRust!⇒Rustlago,
* McshEngl.Lrst!⇒Rustlago,
* McshEngl.Rustlag!⇒Rustlago,

attribute::
* Rustlago'attribute,
===
* Rustlago:generic,
===
* Rustlago.specific,
===
* Rustlago//whole,
===
* Rustlago/part,
===
* Rustlago;;parent,
===
* Rustlago;child,

archetype (input) of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· archetype of Rustlago is a-document describing information-processing as done by humans or other machines.

name::
* McshEngl.Rustlago'archetype,

generic-tree::
* McshEngl.Rustlago'archetype:generic,
===
* Srcdlago_archetype:generic,

algo (output) of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· source-algo of Rustlago[a] is the-document that maps its[a] archetype using it[a].

name::
* McshEngl.Rustlago_algo,
* McshEngl.Rustalgo!⇒Rustlago_algo,
* McshEngl.Rustlago'algorithm!⇒Rustlago_algo,
* McshEngl.Rustlago'source_doc!⇒Rustlago_algo,

encoding of Rustlago_algo

description::
× Mcsh-creation: {2026-10-04}
· the-source-doc of Rustlago is digital-text and therefore uses a-character-encoding, the-UTF-8.
[https://doc.rust-lang.org/reference/input-format.html]

name::
* McshEngl.Rustlago'source_encoding,
* McshEngl.Rustalgo'encoding,
* McshEngl.Rustlago_algo'encoding,

machine of Rustlago_algo

description::
× Mcsh-creation: {2026-10-04}
· the-machine that understands a-Rustalgo is an-abstract-machine with memory.

name::
* McshEngl.Rustlago_machine,
* McshEngl.Rustlago-machine!⇒Rustlago_machine,
* McshEngl.Rustalgo'machine!⇒Rustlago_machine,
* McshEngl.Rustlago_algo'machine!⇒Rustlago_machine,

heap of machine-memory of Rustlago_algo

description::
× Mcsh-creation: {2026-10-04}
· the-heap is memory less organized than stack.
"when you put data on the heap, you request a certain amount of space. The operating system finds an empty spot in the heap that is big enough, marks it as being in use, and returns a pointer, which is the address of that location. This process is called allocating on the heap and is sometimes abbreviated as just allocating. Pushing values onto the stack is not considered allocating. Because the pointer is a known, fixed size, you can store the pointer on the stack, but when you want the actual data, you must follow the pointer."
· data with an-unknown size or a-size that might-change must-be-stored on the-heap.
[https://doc.rust-lang.org/book/ch04-01-what-is-ownership.html#the-stack-and-the-heap]

name::
* McshEngl.Rustlago-heap,
* McshEngl.Rustlago_machine'heap,

stack of machine-memory of Rustlago_algo

description::
× Mcsh-creation: {2026-10-04}
· the-stack is memory that stores values as last in, first out.
· all data stored on the-stack must-have a-known, fixed size.
[https://doc.rust-lang.org/book/ch04-01-what-is-ownership.html#the-stack-and-the-heap]

name::
* McshEngl.Rustlago-stack,
* McshEngl.Rustlago_machine'stack,

source-code of Rustlago_algo

description::
× Mcsh-creation: {2026-10-04}
· source-code[a] of Rustlago[b] is code written in human readable format.
· it[a] is any part of its[b] algo.

name::
* McshEngl.Rustlago_source_code,
* McshEngl.Rustlago'source_code!⇒Rustlago_source_code,
* McshEngl.Rustlago_algo'source_code!⇒Rustlago_source_code,
* McshEngl.Rustalgo'code,
* McshEngl.Rustlago_algo'source_code,

codomain of Rustlago_algo

description::
× Mcsh-creation: {2026-10-04}
· codomain of Rustlago is the-set of all algorithms that are-produced.

name::
* McshEngl.Rustlago'codomain,
* McshEngl.Rustalgo'codomain,
* McshEngl.Rustlago_algo'codomain,

syntax-tree of Rustlago_algo

description::
× Mcsh-creation: {2026-10-04}
· source-syntax-tree of Rustlago[a] is the-whole-part-tree of the-source-nodes of its[a] algo.

name::
* McshEngl.Rustlago_source_syntax_tree,
* McshEngl.Rustlago'source_syntax_tree!⇒Rustlago_source_syntax_tree,
* McshEngl.Rustlago_algo'syntax_tree!⇒Rustlago_source_syntax_tree,
* McshEngl.Rustalgo'syntax_tree,
* McshEngl.Rustlago_algo'syntax_tree,

file of Rustlago_algo

description::
× Mcsh-creation: {2026-10-04}
· the-files with source-code end with .rs
· the-Cargo.toml contains meta info needed.

name::
* McshEngl.Rustlago'source_file,
* McshEngl.Rustalgo'file,
* McshEngl.Rustlago_algo'file,

file.rs

file.Cargo.toml

01_ATTRIBUTE of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· any attribute of Rustlago.

name::
* McshEngl.Rustlago_att,
* McshEngl.Rustlago-att!⇒Rustlago_att,
* McshEngl.Rustlago'attribute!⇒Rustlago_att,

02_algo'node of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· source-node of lagRst[a] is any identifiable part of its[a] algo.

name::
* McshEngl.Rustlago_node,
* McshEngl.Rustnode!⇒Rustlago_node,
* McshEngl.Rustlago'source_node!⇒Rustlago_node,
* McshEngl.Rustalgo'node!⇒Rustlago_node,
* McshEngl.Rustalgo'structure!⇒Rustlago_node,
* McshEngl.Rustlago'algo'node!⇒Rustlago_node,

scope of node of Rustlago_algo

description::
× Mcsh-creation: {2026-10-04}
"A scope is the range within a program for which an item is valid."
[https://doc.rust-lang.org/book/ch04-01-what-is-ownership.html#variable-scope]

name::
* McshEngl.Rustlago'scope,
* McshEngl.Rustnode'scope,
* McshEngl.Rustlago_node'scope,

node.named of algo of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· named-node of Rustlago is a-node[a] with an-identifier associated with it[a].

name::
* McshEngl.Rustlago'named_node,
* McshEngl.Rustnode.named,

node.namedNo of algo of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· namedNo-node of Rustlago is a-node[a] without an-identifier associated with it[a].

name::
* McshEngl.Rustlago'namedNo_node,
* McshEngl.Rustnode.namedNo,

GENERIC-SPECIFIC-TREE of Rustlago_node

description::
× Mcsh-creation: {2026-10-04}

name::
* McshEngl.Rustlago_node'generic_specific_tree,

generic-tree::
* McshEngl.Rustlago_node:generic,
===
* Srcdlago_node:generic,
* ...entity:generic,

specific-tree::
* McshEngl.Rustlago_node.specific,
===
* named-node,
* namedNo-node,

03_algo'unit of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· source-unit of Rustlago is the-indivisible parts of an-algo.

name::
* McshEngl.Rustalgo_unit,
* McshEngl.Rustalgo'unit!⇒Rustalgo_unit,
* McshEngl.Rustlago'algo'unit!⇒Rustalgo_unit,

generic-tree::
* McshEngl.Rustalgo_unit:generic,
===
* Srcalgounit:generic,
* Pgmgunit:generic,
* Calgonode:generic,
* ...entity:generic,

algo'semantic-unit of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· source-semantic-unit of Rustlago is a-Srcdlago-Sunt that

name::
* McshEngl.Rustsunt,
* McshEngl.Rustlago'algo'semantic_unit!⇒Rustsunt,
* McshEngl.Rustlago'semantic_unit!⇒Rustsunt,
* McshEngl.Rustalgo'semantic_unit!⇒Rustsunt,

Sunt.character (ch) of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· a-character denotes a-single Unicode-char.
· a-Rust-character is-mapped with 32bit in its binary-algo.
· thus, Rust can-represents ALL the-Unicode-characters assigned to Unicode-code-points, Latin, Greek, Chinese, all of them.

name::
* McshEngl.Rustlago_ch,
* McshEngl.Rustlago-ch!⇒Rustlago_ch,
* McshEngl.Rustlago'character!⇒Rustlago_ch,
* McshEngl.Rustsunt.character!⇒Rustlago_ch,

generic-tree::
* McshEngl.Rustlago_ch:generic,
===
* Srcdlago_ch:generic,
* ...entity:generic,

Sunt.string (s) of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· string of Rustlago is a-collection of characters.

name::
* McshEngl.Rustlago_s,
* McshEngl.Rustlago-s!⇒Rustlago_s,
* McshEngl.Rustlago'string!⇒Rustlago_s,
* McshEngl.Rustsunt.string!⇒Rustlago_s,

string.literal of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· let s = "hello";
· literal-strings are immutable.
[https://doc.rust-lang.org/book/ch04-01-what-is-ownership.html#the-string-type]

name::
* McshEngl.Rustlago'literal_string,
* McshEngl.Rustlago_literal.string,
* McshEngl.Rustlago_s.literal,
* McshEngl.Rustlago'string.literal,

string.String-type of Rustlago (link)

Sunt.boolean (b) of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· source-boolean of Rustlago is any of the-two semantic-units true and false that denote the-same with the-same human-code.

name::
* McshEngl.Rustlago'boolean,
* McshEngl.Rustlago-b,

Sunt.number (n) of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· source-number of Rustlago is the-semantic-unit that denotes human-numbers.

name::
* McshEngl.Rustn,
* McshEngl.Rustlago'number!⇒Rustn,

GENERIC-SPECIFIC-TREE of Rustn

description::
× Mcsh-creation: {2026-10-04}

name::
* McshEngl.Rustn'generic_specific_tree,

generic-tree::
* McshEngl.Rustn:generic,
===
* ...entity:generic,

specific-tree::
* McshEngl.Rustn.specific,
===
* integer-number,
* integerNo-number,
* signed-number,
* signedNo-number,
===
* f32_number.floating_point.32bit,
* f64_number.floating_point.64bit,
* i8_number.signed.8bit,
* i16_number.signed.16bit,
* i32_number.signed.32bit,
* i64_number.signed.64bit,
* i128_number.signed.128bit,
* u8_number.unsigned.8bit,
* u16_number.unsigned.16bit,
* u32_number.unsigned.32bit,
* u64_number.unsigned.64bit,
* u128_number.unsigned.128bit,

Rustn.integer

description::
× Mcsh-creation: {2026-10-04}
· integer is a-number that denotes whole quantities.

name::
* McshEngl.Rustlago_ni,
* McshEngl.Rustni!⇒Rustlago_ni,
* McshEngl.Rustn.integer!⇒Rustlago_ni,

Rustlago_ni.literal

description::
× Mcsh-creation: {2026-10-04}
· example:
* Decimal 98_222
* Hex 0xff
* Octal 0o77
* Binary 0b1111_0000
* Byte (u8 only) b'A'

name::
* McshEngl.Rustlago_literal.ni,
* McshEngl.Rustni.literal,
* McshEngl.Rustlago_ni.literal,

Rustlago_ni.signed

description::
× Mcsh-creation: {2026-10-04}
· negative and positive numbers.
· they can-represent numbers from -2^(n-1) to 2^(n-1)-1, where n is the-number of bits used in bin-code representation.

name::
* McshEngl.RustniSigned,
* McshEngl.Rustni.signed!⇒RustniSigned,
* McshEngl.Rustlago_ni.signed!⇒RustniSigned,

Rustlago_ni.signedNo

description::
× Mcsh-creation: {2026-10-04}
· positive only numbers.
· they can-represent numbers from 0 to 2^n-1, where n is the-number of bits used in bin-code representation.

name::
* McshEngl.Rustni.signedNo,
* McshEngl.Rustni.unsigned,
* McshEngl.Rustlago_ni.signedNo,

Rustlago_ni.i8

description::
× Mcsh-creation: {2026-10-01}

name::
* McshEngl.Rustlago'i8,
* McshEngl.Rustsunt.i8,
* McshEngl.Rustni.i8,
* McshEngl.Rustlago_ni.i8,

Rustlago_ni.i16

description::
× Mcsh-creation: {2026-10-01}

name::
* McshEngl.Rustlago'i16,
* McshEngl.Rustsunt.i16,
* McshEngl.Rustni.i16,
* McshEngl.Rustlago_ni.i16,

Rustlago_ni.i32

description::
× Mcsh-creation: {2026-10-01}

name::
* McshEngl.Rustlago'i32,
* McshEngl.Rustsunt.i32,
* McshEngl.Rustni.i32,
* McshEngl.Rustlago_ni.i32,

Rustlago_ni.i64

description::
× Mcsh-creation: {2026-10-01}

name::
* McshEngl.Rustlago'i64,
* McshEngl.Rustsunt.i64,
* McshEngl.Rustni.i64,
* McshEngl.Rustlago_ni.i64,

Rustlago_ni.i128

description::
× Mcsh-creation: {2026-10-01}

name::
* McshEngl.Rustlago'i128,
* McshEngl.Rustsunt.i128,
* McshEngl.Rustni.i128,
* McshEngl.Rustlago_ni.i128,

Rustlago_ni.isize

description::
× Mcsh-creation: {2026-10-01}

name::
* McshEngl.Rustlago'isize,
* McshEngl.Rustsunt.isize,
* McshEngl.Rustni.isize,
* McshEngl.Rustlago_ni.isize,

Rustlago_ni.u8

description::
× Mcsh-creation: {2026-10-04}
· range: 0-(2^8-1) 256 numbers.

name::
* McshEngl.Rustlago'u8,
* McshEngl.Rustsunt.u8,
* McshEngl.Rustni.u8,
* McshEngl.Rustlago_ni.u8,

Rustlago_ni.u16

description::
× Mcsh-creation: {2026-10-04}
· range: 0-(2^16-1) 65536 numbers.

name::
* McshEngl.Rustlago'u16,
* McshEngl.Rustsunt.u16,
* McshEngl.Rustni.u16,
* McshEngl.Rustlago_ni.u16,

Rustlago_ni.u32

description::
× Mcsh-creation: {2026-10-04}
· range: 0-(2^32-1) 4294967296 numbers.

name::
* McshEngl.Rustlago'u32,
* McshEngl.Rustsunt.u32,
* McshEngl.Rustni.u32,
* McshEngl.Rustlago_ni.u32,

Rustlago_ni.u64

description::
× Mcsh-creation: {2026-10-04}
· range: 0-(2^64-1) 18,446,744,073,709,551,616 numbers.

name::
* McshEngl.Rustlago'u64,
* McshEngl.Rustsunt.u64,
* McshEngl.Rustni.u64,
* McshEngl.Rustlago_ni.u64,

Rustlago_ni.u128

description::
× Mcsh-creation: {2026-10-04}
· range: 0-(2^128-1) 3,4e+38 numbers.
· bin-code: 128 bit.

name::
* McshEngl.Rustlago'u128,
* McshEngl.Rustsunt.u128,
* McshEngl.Rustni.u128,
* McshEngl.Rustlago_ni.u128,

Rustlago_ni.usize

description::
× Mcsh-creation: {2026-10-04}
"Additionally, the isize and usize types depend on the kind of computer your program is running on: 64 bits if you’re on a 64-bit architecture and 32 bits if you’re on a 32-bit architecture."
[https://doc.rust-lang.org/book/ch03-02-data-types.html#integer-types]

name::
* McshEngl.Rustlago'usize,
* McshEngl.Rustsunt.usize,
* McshEngl.Rustni.usize,
* McshEngl.Rustlago_ni.usize,

GENERIC-SPECIFIC-TREE of Rustlago_ni

description::
× Mcsh-creation: {2026-10-04}

name::
* McshEngl.Rustlago_ni'generic_specific_tree,

generic-tree::
* McshEngl.Rustlago_ni:generic,
===
* ...entity:generic,

specific-tree::
* McshEngl.Rustlago_ni.specific,
===
* linteral-integer,
* signed-integer,
* signedNo-integer,

Rustn.floating_point

description::
× Mcsh-creation: {2026-10-04}
· floating-point is a-number that maps decimal-numbers.

name::
* McshEngl.Rustlago_nf,
* McshEngl.Rustnf!⇒Rustlago_nf,
* McshEngl.Rustn.decimal!⇒Rustlago_nf,
* McshEngl.Rustn.floating_point!⇒Rustlago_nf,
* McshEngl.Rustn.integerNo!⇒Rustlago_nf,

GENERIC-SPECIFIC-TREE of Rustlago_nf

description::
× Mcsh-creation: {2026-10-04}

name::
* McshEngl.Rustlago_nf'generic_specific_tree,

generic-tree::
* McshEngl.Rustlago_nf:generic,
===
* ...entity:generic,

specific-tree::
* McshEngl.Rustlago_nf.specific,
===
* Rustnf.f32!@McshTchInf000030#idLRustsuntNFp32,
* Rustnf.f64!@McshTchInf000030#idLRustsuntNFp64,

Rustlago_nf.f32

description::
× Mcsh-creation: {2026-10-01}

name::
* McshEngl.Rustlago'f32,
* McshEngl.Rustsunt.f32,
* McshEngl.Rustnf.f32,
* McshEngl.Rustlago_nf.f32,

Rustlago_nf.f64

description::
× Mcsh-creation: {2026-10-04}
"The default type is f64 because on modern CPUs it’s roughly the same speed as f32 but is capable of more precision."
[https://doc.rust-lang.org/book/ch03-02-data-types.html#floating-point-types]

name::
* McshEngl.Rustlago'f64,
* McshEngl.Rustsunt.f64,
* McshEngl.Rustnf.f64,
* McshEngl.Rustlago_nf.f64,

Sunt.function (f) of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· source-function of Rustlago is a-semantic-unit that PROCESS information.

name::
* McshEngl.Rustlago_f,
* McshEngl.Rustlago-f!⇒Rustlago_f,
* McshEngl.Rustlago'function!⇒Rustlago_f,
* McshEngl.Rustsunt.function!⇒Rustlago_f,

Rustlago.operator

description::
× Mcsh-creation: {2026-10-04}
· source-operator of Rustlago is a-special function with syntax like math-operators.

name::
* McshEngl.Rustlago_opr,
* McshEngl.Rustlago-opr!⇒Rustlago_opr,
* McshEngl.Rustlago'operator!⇒Rustlago_opr,
* McshEngl.Rustsunt.operator!⇒Rustlago_opr,
* McshEngl.Rustlago_f.operator!⇒Rustlago_opr,

addressWpg::
* https://doc.rust-lang.org/book/appendix-02-operators.html,

overloading of opr of Rustlago

description::
× Mcsh-creation: {2026-10-04}
"Operator overloading is customizing the behavior of an operator (such as +) in particular situations.
Rust doesn’t allow you to create your own operators or overload arbitrary operators. But you can overload the operations and corresponding traits listed in std::ops by implementing the traits associated with the operator."
[https://doc.rust-lang.org/book/ch19-03-advanced-traits.html#default-generic-type-parameters-and-operator-overloading]

name::
* McshEngl.Rustlago_opr'overloading,

opr.!33 of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· 33 (!): ident!(...), ident!{...}, ident![...]: Macro expansion:
: !expr: Bitwise or logical complement: Not
[https://doc.rust-lang.org/book/appendix-02-operators.html]

name::
* McshEngl.Rustlago'!33--opr,
* McshEngl.Rustlago_opr.!33,
* McshEngl.Rustlago'opr.!33,

opr.!=3361 of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· 3361 (!=): var != expr: Nonequality comparison: PartialEq
[https://doc.rust-lang.org/book/appendix-02-operators.html]

name::
* McshEngl.Rustlago'!=3361--opr,
* McshEngl.Rustlago_opr.!=3361,
* McshEngl.Rustlago'opr.!=3361,

opr.%37 of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· 37 (%): expr % expr: Arithmetic remainder: Rem
[https://doc.rust-lang.org/book/appendix-02-operators.html]

name::
* McshEngl.Rustlago'%37__opr,
* McshEngl.Rustlago_opr.%37,
* McshEngl.Rustlago'opr.%37,

opr.%=3761 of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· 3761 (%=): var %= expr: Arithmetic remainder and assignment: RemAssign
[https://doc.rust-lang.org/book/appendix-02-operators.html]

name::
* McshEngl.Rustlago'%=3761__opr,
* McshEngl.Rustlago_opr.%=3761,
* McshEngl.Rustlago'opr.%=3761,

opr.&38 of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· 38 (&): &expr, &mut expr: Borrow:
: &type, &mut type, &'a type, &'a mut type: Borrowed pointer type:
: expr & expr: Bitwise AND: BitAnd
[https://doc.rust-lang.org/book/appendix-02-operators.html]

name::
* McshEngl.Rustlago'&38__opr,
* McshEngl.Rustlago_opr.&38,
* McshEngl.Rustlago'opr.&38,

opr.&=3861 of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· 3861 (&=): var &= expr: Bitwise AND and assignment: BitAndAssign
[https://doc.rust-lang.org/book/appendix-02-operators.html]

name::
* McshEngl.Rustlago'&=3861__opr,
* McshEngl.Rustlago_opr.&=3861,
* McshEngl.Rustlago'opr.&=3861,

opr.&&3838 of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· 3838 (&&): expr && expr: Logical AND:
[https://doc.rust-lang.org/book/appendix-02-operators.html]

name::
* McshEngl.Rustlago'&&3838__opr,
* McshEngl.Rustlago_opr.&&3838,
* McshEngl.Rustlago'opr.&&3838,

opr.*42 of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· 42 (*): expr * expr: Arithmetic multiplication: Mul
: *expr: Dereference:
: *const type, *mut type: Raw pointer:
[https://doc.rust-lang.org/book/appendix-02-operators.html]

name::
* McshEngl.Rustlago'*42__opr,
* McshEngl.Rustlago_opr.*42,
* McshEngl.Rustlago'opr.*42,

opr.*=4261 of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· 4261 (*=): var *= expr: Arithmetic multiplication and assignment: MulAssign
[https://doc.rust-lang.org/book/appendix-02-operators.html]

name::
* McshEngl.Rustlago'*=4261__opr,
* McshEngl.Rustlago_opr.*=4261,
* McshEngl.Rustlago'opr.*=4261,

opr.+43 of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· 43 (+): trait + trait, 'a + trait: Compound type constraint:
: expr + expr: Arithmetic addition: Add
[https://doc.rust-lang.org/book/appendix-02-operators.html]

name::
* McshEngl.Rustlago'+43__opr,
* McshEngl.Rustlago_opr.+43,
* McshEngl.Rustlago'opr.+43,

opr.+=4361 of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· 4361 (+=): var += expr: Arithmetic addition and assignment: AddAssign
[https://doc.rust-lang.org/book/appendix-02-operators.html]

name::
* McshEngl.Rustlago'+=4361__opr,
* McshEngl.Rustlago_opr.+=4361,
* McshEngl.Rustlago'opr.+=4361,

opr.,44 of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· 44 (,): expr, expr: Argument and element separator:
[https://doc.rust-lang.org/book/appendix-02-operators.html]

name::
* McshEngl.Rustlago',44__opr,
* McshEngl.Rustlago_opr.,44,
* McshEngl.Rustlago'opr.,44,

opr.-45 of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· 45 (-): - expr: Arithmetic negation: Neg
: expr - expr: Arithmetic subtraction: Sub
[https://doc.rust-lang.org/book/appendix-02-operators.html]

name::
* McshEngl.Rustlago__45__opr,
* McshEngl.Rustlago'_45__opr!⇒Rustlago__45__opr,
* McshEngl.Rustlago'opr._45!⇒Rustlago__45__opr,
* McshEngl.Rustlago_opr._45,
* McshEngl.Rustlago'opr._45,

opr.=4561 of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· 4561 (=): var -= expr: Arithmetic subtraction and assignment: SubAssign
[https://doc.rust-lang.org/book/appendix-02-operators.html]

name::
* McshEngl.Rustlago'=4561__opr,
* McshEngl.Rustlago_opr.=4561,
* McshEngl.Rustlago'opr.=4561,

opr.->4562 of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· 4562 (->): fn(...) ⭢ type, |...| ⭢ type: Function and closure return type:
[https://doc.rust-lang.org/book/appendix-02-operators.html]

name::
* McshEngl.Rustlago'_>4562__opr,
* McshEngl.Rustlago_opr._>4562,

opr..46 of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· 46 (.): expr.ident: Member access:
[https://doc.rust-lang.org/book/appendix-02-operators.html]

name::
* McshEngl.Rustlago'.46_opr,
* McshEngl.Rustlago_opr..46,
* McshEngl.Rustlago'opr..46,

opr...4646 of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· 4646 (..): .., expr.., ..expr, expr..expr: Right-exclusive range literal:
: ..expr: Struct literal update syntax:
: variant(x, ..), struct_type { x, .. }: “And the rest” pattern binding:
[https://doc.rust-lang.org/book/appendix-02-operators.html]

name::
* McshEngl.Rustlago'..4646_opr,
* McshEngl.Rustlago_opr...4646,
* McshEngl.Rustlago'opr...4646,

opr...=464661 of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· 464661 (..=): ..=expr, expr..=expr: Right-inclusive range literal:
[https://doc.rust-lang.org/book/appendix-02-operators.html]

name::
* McshEngl.Rustlago'..=464661__opr,
* McshEngl.Rustlago_opr...=464661,
* McshEngl.Rustlago'opr...=464661,

opr....464646 of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· 464646 (...): expr...expr: In a pattern: inclusive range pattern:
[https://doc.rust-lang.org/book/appendix-02-operators.html]

name::
* McshEngl.Rustlago'...464646_opr,
* McshEngl.Rustlago_opr....464646,
* McshEngl.Rustlago'opr....464646,

opr./47 of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· 47 (/): expr / expr: Arithmetic division: Div
[https://doc.rust-lang.org/book/appendix-02-operators.html]

name::
* McshEngl.Rustlago'/47__opr,
* McshEngl.Rustlago_opr./47,
* McshEngl.Rustlago'opr./47,

opr./=4761 of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· 4761 (/=): var /= expr: Arithmetic division and assignment: DivAssign
[https://doc.rust-lang.org/book/appendix-02-operators.html]

name::
* McshEngl.Rustlago'/=4761__opr,
* McshEngl.Rustlago_opr./=4761,
* McshEngl.Rustlago'opr./=4761,

opr.:58 of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· 58 (:): pat: type, ident: type: Constraints:
: ident: expr: Struct field initializer:
: 'a: loop {...}: Loop label:
[https://doc.rust-lang.org/book/appendix-02-operators.html]

name::
* McshEngl.Rustlago':58__opr,
* McshEngl.Rustlago_opr.:58,
* McshEngl.Rustlago'opr.:58,

opr.;59 of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· 59 (;): expr;: Statement and item terminator:
: [...; len]: Part of fixed-size array syntax:
[https://doc.rust-lang.org/book/appendix-02-operators.html]

name::
* McshEngl.Rustlago';59__opr,
* McshEngl.Rustlago_opr.;59,
* McshEngl.Rustlago'opr.;59,

opr.;6060 of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· 6060 (<<): expr << expr: Left-shift: Shl
[https://doc.rust-lang.org/book/appendix-02-operators.html]

name::
* McshEngl.Rustlago';6060__opr,
* McshEngl.Rustlago_opr.;6060,
* McshEngl.Rustlago'opr.;6060,

opr.;606061 of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· 606061 (<<=): var <<= expr: Left-shift and assignment: ShlAssign
[https://doc.rust-lang.org/book/appendix-02-operators.html]

name::
* McshEngl.Rustlago';606061__opr,
* McshEngl.Rustlago_opr.;606061,
* McshEngl.Rustlago'opr.;606061,

opr.;60 of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· 60 (<): expr < expr: Less than comparison: PartialOrd
[https://doc.rust-lang.org/book/appendix-02-operators.html]

name::
* McshEngl.Rustlago';60__opr,
* McshEngl.Rustlago_opr.;60,
* McshEngl.Rustlago'opr.;60,

opr.;6061 of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· 6061 (<=): expr <= expr: Less than or equal to comparison: PartialOrd
[https://doc.rust-lang.org/book/appendix-02-operators.html]

name::
* McshEngl.Rustlago';6061__opr,
* McshEngl.Rustlago_opr.;6061,
* McshEngl.Rustlago'opr.;6061,

opr.=61 of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· 61 (=): var = expr, ident = type: Assignment/equivalence:
[https://doc.rust-lang.org/book/appendix-02-operators.html]

name::
* McshEngl.Rustlago'=61__opr,
* McshEngl.Rustlago_opr.=61,
* McshEngl.Rustlago'opr.=61,

opr.==6161 of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· 6161 (==): expr == expr: Equality comparison: PartialEq
[https://doc.rust-lang.org/book/appendix-02-operators.html]

name::
* McshEngl.Rustlago'==6161__opr,
* McshEngl.Rustlago_opr.==6161,
* McshEngl.Rustlago'opr.==6161,

opr.=>6162 of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· 6162 (=>): pat => expr: Part of match arm syntax:
[https://doc.rust-lang.org/book/appendix-02-operators.html]

name::
* McshEngl.Rustlago'=>6162__opr,
* McshEngl.Rustlago_opr.=>6162,
* McshEngl.Rustlago'opr.=>6162,

opr.>62 of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· 62 (>): expr > expr: Greater than comparison: PartialOrd
[https://doc.rust-lang.org/book/appendix-02-operators.html]

name::
* McshEngl.Rustlago'>62__opr,
* McshEngl.Rustlago_opr.>62,
* McshEngl.Rustlago'opr.>62,

opr.>=6261 of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· 6261 (>=): expr >= expr: Greater than or equal to comparison: PartialOrd
[https://doc.rust-lang.org/book/appendix-02-operators.html]

name::
* McshEngl.Rustlago'>=6261__opr,
* McshEngl.Rustlago_opr.>=6261,
* McshEngl.Rustlago'opr.>=6261,

opr.>>6262 of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· 6262 (>>): expr >> expr: Right-shift: Shr
[https://doc.rust-lang.org/book/appendix-02-operators.html]

name::
* McshEngl.Rustlago'>>6262__opr,
* McshEngl.Rustlago_opr.>>6262,
* McshEngl.Rustlago'opr.>>6262,

opr.>>=626261 of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· 626261 (>>=): var >>= expr: Right-shift and assignment: ShrAssign
[https://doc.rust-lang.org/book/appendix-02-operators.html]

name::
* McshEngl.Rustlago'>>=626261__opr,
* McshEngl.Rustlago_opr.>>=626261,
* McshEngl.Rustlago'opr.>>=626261,

opr.@64 of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· 64 (@): ident @ pat: Pattern binding:
[https://doc.rust-lang.org/book/appendix-02-operators.html]

name::
* McshEngl.Rustlago'@64__opr,
* McshEngl.Rustlago_opr.@64,
* McshEngl.Rustlago'opr.@64,

opr.^94 of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· 94 (^): expr ^ expr: Bitwise exclusive OR: BitXor
[https://doc.rust-lang.org/book/appendix-02-operators.html]

name::
* McshEngl.Rustlago'^94__opr,
* McshEngl.Rustlago_opr.^94,
* McshEngl.Rustlago'opr.^94,

opr.^=9461 of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· 9461 (^=): var ^= expr: Bitwise exclusive OR and assignment: BitXorAssign
[https://doc.rust-lang.org/book/appendix-02-operators.html]

name::
* McshEngl.Rustlago'^=9461__opr,
* McshEngl.Rustlago_opr.^=9461,
* McshEngl.Rustlago'opr.^=9461,

opr.|124 of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· 124 (|): pat | pat: Pattern alternatives:
: expr | expr: Bitwise OR: BitOr
[https://doc.rust-lang.org/book/appendix-02-operators.html]

name::
* McshEngl.Rustlago'|124__opr,
* McshEngl.Rustlago_opr.|124,
* McshEngl.Rustlago'opr.|124,

opr.|=12461 of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· 12461 (|=): var |= expr: Bitwise OR and assignment: BitOrAssign
[https://doc.rust-lang.org/book/appendix-02-operators.html]

name::
* McshEngl.Rustlago'|=12461__opr,
* McshEngl.Rustlago_opr.|=12461,
* McshEngl.Rustlago'opr.|=12461,

opr.||124124 of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· 124124 (||): expr || expr: Logical OR:
[https://doc.rust-lang.org/book/appendix-02-operators.html]

name::
* McshEngl.Rustlago'||124124__opr,
* McshEngl.Rustlago_opr.||124124,
* McshEngl.Rustlago'opr.||124124,

opr.?63 of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· 63 (?): expr?: Error propagation
[https://doc.rust-lang.org/book/appendix-02-operators.html]

name::
* McshEngl.Rustlago'?63__opr,
* McshEngl.Rustlago_opr.?63,
* McshEngl.Rustlago'opr.?63,

GENERIC-SPECIFIC-TREE of Rustlago_opr

description::
× Mcsh-creation: {2026-10-04}

name::
* McshEngl.Rustlago_opr'generic_specific_tree,

generic-tree::
* McshEngl.Rustlago_opr:generic,
===
* Srcdlago_opr:generic,
* ...entity:generic,

specific-tree::
* McshEngl.Rustlago_opr.specific,
===
* unary-operator,
* binary-operator,
* ternary-operator,

GENERIC-SPECIFIC-TREE of Rustlago_f

description::
× Mcsh-creation: {2026-10-04}

name::
* McshEngl.Rustlago_f'generic_specific_tree,

generic-tree::
* McshEngl.Rustlago_f:generic,
===
* Rustsunt:generic,
* source-function--of-Srcdlago,
* ...entity:generic,

specific-tree::
* McshEngl.Rustlago_f.specific,
===
* main-function,
* operator,

Sunt.array (a) of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· source-array of Rustlago is an-orderd-list of same type semantic-units with fixed length.
· let a = [1, 2, 3, 4, 5];

name::
* McshEngl.Rustlago'array,
* McshEngl.Rustlago-a,

Sunt.tuple () of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· source-tuple of Rustlago is an-orderd-list of different type semantic-units with fixed length.
· let t: (i32, f64, u8) = (500, 6.4, 1);

name::
* McshEngl.Rustsunt.tuple,

Sunt.struct () of Rustlago

description::
× Mcsh-creation: {2026-10-04}
"Structs are similar to tuples, which were discussed in Chapter 3. Like tuples, the pieces of a struct can be different types. Unlike with tuples, you’ll name each piece of data so it’s clear what the values mean. As a result of these names, structs are more flexible than tuples: you don’t have to rely on the order of the data to specify or access the values of an instance."
· example:
struct User {
  username: String,
  count: u64,
  active: bool,
}
[https://doc.rust-lang.org/book/ch05-01-defining-structs.html]

name::
* McshEngl.Rustlago_struct,
* McshEngl.Rustlago-struct!⇒Rustlago_struct,
* McshEngl.Rustsunt.struct!⇒Rustlago_struct,

generic-tree::
* McshEngl.Rustlago_struct:generic,
===
* ...entity:generic,

specific-tree::
* McshEngl.Rustlago_struct.specific,
===
* Rustlago_struct.Rustlago_Vec!@McshTchInf000030#idLRustalgStdpldVec,

Sunt.enum () of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· example:
enum IpAddrKind {
  V4,
  V6,
}

name::
* McshEngl.Rustlago_enum,
* McshEngl.Rustlago-enum!⇒Rustlago_enum,
* McshEngl.Rustsunt.enum!⇒Rustlago_enum,

Sunt.trait () of Rustlago

description::
× Mcsh-creation: {2026-10-04}
"A trait tells the Rust compiler about functionality a particular type has and can share with other types. We can use traits to define shared behavior in an abstract way. We can use trait bounds to specify that a generic can be any type that has certain behavior.
Note: Traits are similar to a feature often called interfaces in other languages, although with some differences."
[https://doc.rust-lang.org/book/ch10-02-traits.html]

name::
* McshEngl.Rustlago_trait,
* McshEngl.Rustlago-trait!⇒Rustlago_trait,
* McshEngl.Rustlago'trait!⇒Rustlago_trait,
* McshEngl.Rustsunt.trait!⇒Rustlago_trait,

Sunt.instance (literal) of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· literal of Rustlago is an-individual Sunt.

name::
* McshEngl.Rustlago_literal,
* McshEngl.Rustlago-literal!⇒Rustlago_literal,
* McshEngl.Rustsunt.instance!⇒Rustlago_literal,

Sunt.instanceNo (type) of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· type of Rustlago is a-generic Sunt.

name::
* McshEngl.Rustlago_type,
* McshEngl.Rustlago-type!⇒Rustlago_type,
* McshEngl.Rustlago'type!⇒Rustlago_type,
* McshEngl.Rustsunt.instanceNo!⇒Rustlago_type,

Sunt.named of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· named-Sunt of Rustlago is a-semantic-unit associated with an-identifier.

name::
* McshEngl.Rustlago_named_Sunt,
* McshEngl.Rustnamed-Sunt!⇒Rustlago_named_Sunt,
* McshEngl.Rustlago'named_Sunt!⇒Rustlago_named_Sunt,
* McshEngl.Rustsunt.named!⇒Rustlago_named_Sunt,
* McshEngl.Rustlago'Sunt.named!⇒Rustlago_named_Sunt,

generic-tree::
* McshEngl.Rustlago_named_Sunt:generic,
===
* named-Sunt--of-Lsrc,

value of named-Sunt

description::
× Mcsh-creation: {2026-10-04}
· value of Rustlago is the-semantic-unit associated with an-identifier.

name::
* McshEngl.Rustlago'value,
* McshEngl.Rustnamed_Sunt'value,
* McshEngl.Rustlago_named_Sunt'value,

named_Sunt.variable

description::
× Mcsh-creation: {2026-10-04}
· variable of Rustlago is a-named-Sunt whose value is immutable but we can-make mutable.
· example:
let s = "hello";
let mut x = 5;

name::
* McshEngl.Rustlago_var,
* McshEngl.Rustlago-var!⇒Rustlago_var,
* McshEngl.Rustlago'variable!⇒Rustlago_var,
* McshEngl.Rustnamed_Sunt.variable!⇒Rustlago_var,
* McshEngl.Rustlago_named_Sunt.variable!⇒Rustlago_var,

named_Sunt.constant

description::
× Mcsh-creation: {2026-10-04}
· const MAX_POINTS: u32 = 100_000;
"Like immutable variables, constants are values that are bound to a name and are not allowed to change, but there are a few differences between constants and variables.
First, you aren’t allowed to use mut with constants. Constants aren’t just immutable by default—they’re always immutable."
[https://doc.rust-lang.org/book/ch03-01-variables-and-mutability.html#differences-between-variables-and-constants]

name::
* McshEngl.Rustlago_cnst,
* McshEngl.Rustlago-cnst!⇒Rustlago_cnst,
* McshEngl.Rustlago'constant!⇒Rustlago_cnst,
* McshEngl.Rustnamed_Sunt.constant!⇒Rustlago_cnst,
* McshEngl.Rustlago_named_Sunt.constant!⇒Rustlago_cnst,

Sunt.namedNo of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· anonymous-Sunt is a-semantic-unit NOT associated with an-identifier.

name::
* McshEngl.Rustlago_namedNo_Sunt,
* McshEngl.RustnamedNo-Sunt!⇒Rustlago_namedNo_Sunt,
* McshEngl.Rustlago'anonymous_Sunt!⇒Rustlago_namedNo_Sunt,
* McshEngl.Rustsunt.namedNo!⇒Rustlago_namedNo_Sunt,
* McshEngl.Rustlago'Sunt.namedNo!⇒Rustlago_namedNo_Sunt,

Sunt.heap of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· heap-Sunt is a-Sunt stored on heap.

name::
* McshEngl.Rustlago-heap-Sunt,
* McshEngl.Rustlago'Sunt.heap,

pointer of heap-Sunt of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· pointer of Rustlago-heap-Sunt is the-address of the-location of the-Sunt on heap.

name::
* McshEngl.Rustlago'pointer,
* McshEngl.Rustlago_heap_Sunt'pointer,

length of heap-Sunt of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· length is the-quantity in bytes, the-Sunt is-using in heap.

name::
* McshEngl.Rustlago_heap_Sunt'length,

capacity of heap-Sunt of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· capacity is the-total quantity in bytes, the-Sunt in heap has-received from the-operating-system.

name::
* McshEngl.Rustlago_heap_Sunt'capacity,

Sunt.stack of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· stack-Sunt is a-Sunt stored on stack.

name::
* McshEngl.Rustlago-stack-Sunt,
* McshEngl.Rustlago'Sunt.stack,

Sunt.compound of Rustlago

description::
× Mcsh-creation: {2026-10-04}
"Compound types can group multiple values into one type. Rust has two primitive compound types: tuples and arrays."
[https://doc.rust-lang.org/book/ch03-02-data-types.html#compound-types]

name::
* McshEngl.Rustsunt.compound,
* McshEngl.Rustlago'Sunt.compound,

Sunt.compoundNo of Rustlago

description::
× Mcsh-creation: {2026-10-04}
"A scalar type represents a single value.
Rust has four primary scalar types: integers, floating-point numbers, Booleans, and characters."
[https://doc.rust-lang.org/book/ch03-02-data-types.html#scalar-types]

name::
* McshEngl.Rustlago'scalar_type,
* McshEngl.Rustsunt.compoundNo,
* McshEngl.Rustsunt.primitive,
* McshEngl.Rustsunt.scalar,
* McshEngl.Rustlago'Sunt.compoundNo,

GENERIC-SPECIFIC-TREE of Rustsunt

description::
× Mcsh-creation: {2026-10-04}

name::
* McshEngl.Rustsunt'generic_specific_tree,

generic-tree::
* McshEngl.Rustsunt:generic,
===
* Srcdlago_Sunt:generic,
* Pgmgalgo_Sunt:generic,
* Calgonode:generic,
* ...entity:generic,

specific-tree::
* McshEngl.Rustsunt.specific,
===

Sunt.specific_on_keyword

description::
× Mcsh-creation: {2026-10-04}
* bool-boolean,
* char-character,
* enum-enumeration,
* fn-function,
* f32_number.floating_point.32bit,
* f64_number.floating_point.64bit,
* i8_number.signed.8bit,
* i16_number.signed.16bit,
* i32_number.signed.32bit,
* i64_number.signed.64bit,
* i128_number.signed.128bit,
* impl,
* let-variable,
* mod-module,
* str-string,
* struct,
* trait,
* u8_number.unsigned.8bit,
* u16_number.unsigned.16bit,
* u32_number.unsigned.32bit,
* u64_number.unsigned.64bit,
* u128_number.unsigned.128bit,

name::
* McshEngl.Rustsunt.specific_on_keyword,

algo'phrase of Rustlago

description::
× Mcsh-creation: {2026-10-04}

name::
* McshEngl.Rustalgo_phrase,
* McshEngl.Rustalgo'phrase!⇒Rustalgo_phrase,
* McshEngl.Rustlago'algo'phrase!⇒Rustalgo_phrase,

generic-tree::
* McshEngl.Rustalgo_phrase:generic,
===
* Srcdphrs:generic,
* Pgmgphrase:generic,
* Calgonode:generic,
* ...entity:generic,

algo'sentence of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· source-sentence of Rustlago is a-structure of algo-nodes that denotes COMPLETE relations or processes ( 3 + 5 = 8 ).

name::
* McshEngl.Rustlago_sentence,
* McshEngl.Rustlago-sentence!⇒Rustlago_sentence,
* McshEngl.Rustalgo'sentence!⇒Rustlago_sentence,
* McshEngl.Rustlago'algo'sentence!⇒Rustlago_sentence,

sentence.loop-gnc of Rustlago

description::
× Mcsh-creation: {2026-10-04}
* for-sentence,
* loop-sentence,
* while-sentence,

name::
* McshEngl.Rustlago_loop_gnc,
* McshEngl.Rustlago'sentence.loop_gnc!⇒Rustlago_loop_gnc,
* McshEngl.Rustlago-loop-gnc!⇒Rustlago_loop_gnc,
* McshEngl.Rustlago'loop_gnc!⇒Rustlago_loop_gnc,
* McshEngl.Rustlago_sentence.loop_gnc!⇒Rustlago_loop_gnc,

loop-gnc.for of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· example:
let a = [10, 20, 30, 40, 50];
for element in a.iter() {
  println!("the value is: {}", element);
}

name::
* McshEngl.Rustlago_for_sentence,
* McshEngl.Rustlago'for_sentence!⇒Rustlago_for_sentence,
* McshEngl.Rustlago'loop_gnc.for!⇒Rustlago_for_sentence,
* McshEngl.Rustlago-for,
* McshEngl.Rustlago_loop_gnc.for,
* McshEngl.Rustlago'loop_gnc.for,

loop-gnc.loop of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· example:
let mut counter = 0;
let result = loop {
  counter += 1;
  if counter == 10 {
    break counter * 2;
  }
};
println!("The result is {}", result);

name::
* McshEngl.Rustlago_loop_sentence,
* McshEngl.Rustlago'loop_sentence!⇒Rustlago_loop_sentence,
* McshEngl.Rustlago'loop_gnc.loop!⇒Rustlago_loop_sentence,
* McshEngl.Rustlago-loop,
* McshEngl.Rustlago_loop_gnc.loop,
* McshEngl.Rustlago'loop_gnc.loop,

loop-gnc.while of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· example:
let mut number = 3;
while number != 0 {
  println!("{}!", number);
  number -= 1;
}

name::
* McshEngl.Rustlago_while_sentence,
* McshEngl.Rustlago'while_sentence!⇒Rustlago_while_sentence,
* McshEngl.Rustlago'loop_gnc.while!⇒Rustlago_while_sentence,
* McshEngl.Rustlago-while,
* McshEngl.Rustlago_loop_gnc.while,
* McshEngl.Rustlago'loop_gnc.while,

sentence.use of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· brings named-nodes into scope.
· example:
use std::fmt::Result;
use std::io::Result as IoResult;
use std::{cmp::Ordering, io};
use std::io::{self, Write};
use std::collections::*;

name::
* McshEngl.Rustlago_use,
* McshEngl.Rustlago-use!⇒Rustlago_use,
* McshEngl.Rustlago'use_sentence!⇒Rustlago_use,
* McshEngl.Rustlago_sentence.use!⇒Rustlago_use,
* McshEngl.Rustlago'sentence.use!⇒Rustlago_use,

GENERIC-SPECIFIC-TREE of Rustlago_sentence

description::
× Mcsh-creation: {2026-10-04}

name::
* McshEngl.Rustlago_sentence'generic_specific_tree,

generic-tree::
* McshEngl.Rustlago_sentence:generic,
===
* Srcdsent:generic,
* Pgmgsent:generic,
* Calgonode:generic,
* ...entity:generic,

specific-tree::
* McshEngl.Rustlago_sentence.specific,
===
* assignment-sentence,
* definition-sentence,
* conditional-sentence,
* loop-sentence,
* use-sentence,

04_algo'word of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· source-word of Rustlago is a-structure of units the-language uses to create more compound algo-structures.

name::
* McshEngl.Rustlago_word,
* McshEngl.Rustlago-word!⇒Rustlago_word,
* McshEngl.Rustalgo'word!⇒Rustlago_word,
* McshEngl.Rustlago'algo'word!⇒Rustlago_word,

word.identifier of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· identifier of Rustlago is a-word, not a-keyword, that folows concrete rules to be-constructed and used to construct named-algo-nodes.

name::
* McshEngl.Rustlago_identifier,
* McshEngl.Rustlago-identifier!⇒Rustlago_identifier,
* McshEngl.Rustlago'identifier!⇒Rustlago_identifier,
* McshEngl.Rustlago_word.identifier!⇒Rustlago_identifier,
* McshEngl.Rustlago'word.identifier!⇒Rustlago_identifier,

addressWpg::
* https://doc.rust-lang.org/reference/identifiers.html,

GENERIC-SPECIFIC-TREE of Rustlago_word

description::
× Mcsh-creation: {2026-10-04}

name::
* McshEngl.Rustlago_word'generic_specific_tree,

generic-tree::
* McshEngl.Rustlago_word:generic,
===
* Srcdalgowork:generic,
* Prmgalgoword:generic,
* Calgonode:generic,
* ...entity:generic,

specific-tree::
* McshEngl.Rustlago_word.specific,
===
* identifier,
* Rustlago_word.Rustkeyword!@McshTchInf000030#idLRustkwd,

word.keyword of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· source-keyword of Rustlago is a-word reserved by the-language to create algo-nodes.

name::
* McshEngl.Rustkeyword,
* McshEngl.Rustlago-keyword!⇒Rustkeyword,
* McshEngl.Rustlago'keyword!⇒Rustkeyword,
* McshEngl.Rustlago_word.keyword!⇒Rustkeyword,
* McshEngl.Rustlago'word.keyword!⇒Rustkeyword,

keyword.used of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· used-keyword of Rustlago is a-keyword currently used.

name::
* McshEngl.Rustlago_used_keyword,
* McshEngl.Rustlago-used-keyword!⇒Rustlago_used_keyword,
* McshEngl.Rustlago'used_keyword!⇒Rustlago_used_keyword,
* McshEngl.Rustlago_keyword.used!⇒Rustlago_used_keyword,
* McshEngl.Rustlago'keyword.used!⇒Rustlago_used_keyword,

used-keyword.as of Rustlago

description::
× Mcsh-creation: {2026-10-04}
"as: perform primitive casting, disambiguate the specific trait containing an item, or rename items in use and extern crate statements."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McshEngl.Rustlago_as__used_keyword,
* McshEngl.Rustlago'as__used_keyword!⇒Rustlago_as__used_keyword,
* McshEngl.Rustlago'used_keyword.as!⇒Rustlago_as__used_keyword,
* McshEngl.Rustlago_used_keyword.as,
* McshEngl.Rustlago'used_keyword.as,

used-keyword.break of Rustlago

description::
× Mcsh-creation: {2026-10-04}
"break: exit a loop immediately."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McshEngl.Rustlago_break__used_keyword,
* McshEngl.Rustlago'break__used_keyword!⇒Rustlago_break__used_keyword,
* McshEngl.Rustlago'used_keyword.break!⇒Rustlago_break__used_keyword,
* McshEngl.Rustlago_used_keyword.break,
* McshEngl.Rustlago'used_keyword.break,

used-keyword.const of Rustlago

description::
× Mcsh-creation: {2026-10-04}
"const: define constant items or constant raw pointers."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McshEngl.Rustlago_const__used_keyword,
* McshEngl.Rustlago'const__used_keyword!⇒Rustlago_const__used_keyword,
* McshEngl.Rustlago'used_keyword.const!⇒Rustlago_const__used_keyword,
* McshEngl.Rustlago_used_keyword.const,
* McshEngl.Rustlago'used_keyword.const,

used-keyword.continue of Rustlago

description::
× Mcsh-creation: {2026-10-04}
"continue: continue to the next loop iteration."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McshEngl.Rustlago_continue__used_keyword,
* McshEngl.Rustlago'continue__used_keyword!⇒Rustlago_continue__used_keyword,
* McshEngl.Rustlago'used_keyword.continue!⇒Rustlago_continue__used_keyword,
* McshEngl.Rustlago_used_keyword.continue,
* McshEngl.Rustlago'used_keyword.continue,

used-keyword.crate of Rustlago

description::
× Mcsh-creation: {2026-10-04}
"crate: link an external crate or a macro variable representing the crate in which the macro is defined."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McshEngl.Rustlago_crate__used_keyword,
* McshEngl.Rustlago'crate__used_keyword!⇒Rustlago_crate__used_keyword,
* McshEngl.Rustlago'used_keyword.crate!⇒Rustlago_crate__used_keyword,
* McshEngl.Rustlago_used_keyword.crate,
* McshEngl.Rustlago'used_keyword.crate,

used-keyword.dyn of Rustlago

description::
× Mcsh-creation: {2026-10-04}
"dyn: dynamic dispatch to a trait object."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McshEngl.Rustlago_dyn__used_keyword,
* McshEngl.Rustlago'dyn__used_keyword!⇒Rustlago_dyn__used_keyword,
* McshEngl.Rustlago'used_keyword.dyn!⇒Rustlago_dyn__used_keyword,
* McshEngl.Rustlago_used_keyword.dyn,
* McshEngl.Rustlago'used_keyword.dyn,

used-keyword.else of Rustlago

description::
× Mcsh-creation: {2026-10-04}
"else: fallback for if and if let control flow constructs."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McshEngl.Rustlago_else__used_keyword,
* McshEngl.Rustlago'else__used_keyword!⇒Rustlago_else__used_keyword,
* McshEngl.Rustlago'used_keyword.else!⇒Rustlago_else__used_keyword,
* McshEngl.Rustlago_used_keyword.else,
* McshEngl.Rustlago'used_keyword.else,

used-keyword.enum of Rustlago

description::
× Mcsh-creation: {2026-10-04}
"enum: define an enumeration."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McshEngl.Rustlago_enum__used_keyword,
* McshEngl.Rustlago'enum__used_keyword!⇒Rustlago_enum__used_keyword,
* McshEngl.Rustlago'used_keyword.enum!⇒Rustlago_enum__used_keyword,
* McshEngl.Rustlago_used_keyword.enum,
* McshEngl.Rustlago'used_keyword.enum,

used-keyword.extern of Rustlago

description::
× Mcsh-creation: {2026-10-04}
"extern: link an external crate, function, or variable."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McshEngl.Rustlago_extern__used_keyword,
* McshEngl.Rustlago'extern__used_keyword!⇒Rustlago_extern__used_keyword,
* McshEngl.Rustlago'used_keyword.extern!⇒Rustlago_extern__used_keyword,
* McshEngl.Rustlago_used_keyword.extern,
* McshEngl.Rustlago'used_keyword.extern,

used-keyword.false of Rustlago

description::
× Mcsh-creation: {2026-10-04}
"false: Boolean false literal."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McshEngl.Rustlago_false__used_keyword,
* McshEngl.Rustlago'false__used_keyword!⇒Rustlago_false__used_keyword,
* McshEngl.Rustlago'used_keyword.false!⇒Rustlago_false__used_keyword,
* McshEngl.Rustlago_used_keyword.false,
* McshEngl.Rustlago'used_keyword.false,

used-keyword.fn of Rustlago

description::
× Mcsh-creation: {2026-10-04}
"fn: define a function or the function pointer type."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McshEngl.Rustlago_fn__used_keyword,
* McshEngl.Rustlago'fn__used_keyword!⇒Rustlago_fn__used_keyword,
* McshEngl.Rustlago'used_keyword.fn!⇒Rustlago_fn__used_keyword,
* McshEngl.Rustlago_used_keyword.fn,
* McshEngl.Rustlago'used_keyword.fn,

used-keyword.for of Rustlago

description::
× Mcsh-creation: {2026-10-04}
"for: loop over items from an iterator, implement a trait, or specify a higher-ranked lifetime."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McshEngl.Rustlago_for__used_keyword,
* McshEngl.Rustlago'for__used_keyword!⇒Rustlago_for__used_keyword,
* McshEngl.Rustlago'used_keyword.for!⇒Rustlago_for__used_keyword,
* McshEngl.Rustlago_used_keyword.for,
* McshEngl.Rustlago'used_keyword.for,

used-keyword.if of Rustlago

description::
× Mcsh-creation: {2026-10-04}
"if: branch based on the result of a conditional expression."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McshEngl.Rustlago_if__used_keyword,
* McshEngl.Rustlago'if__used_keyword!⇒Rustlago_if__used_keyword,
* McshEngl.Rustlago'used_keyword.if!⇒Rustlago_if__used_keyword,
* McshEngl.Rustlago_used_keyword.if,
* McshEngl.Rustlago'used_keyword.if,

used-keyword.impl of Rustlago

description::
× Mcsh-creation: {2026-10-04}
"impl: implement inherent or trait functionality."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McshEngl.Rustlago_impl__used_keyword,
* McshEngl.Rustlago'impl__used_keyword!⇒Rustlago_impl__used_keyword,
* McshEngl.Rustlago'used_keyword.impl!⇒Rustlago_impl__used_keyword,
* McshEngl.Rustlago_used_keyword.impl,
* McshEngl.Rustlago'used_keyword.impl,

used-keyword.in of Rustlago

description::
× Mcsh-creation: {2026-10-04}
"in: part of for loop syntax."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McshEngl.Rustlago_in__used_keyword,
* McshEngl.Rustlago'in__used_keyword!⇒Rustlago_in__used_keyword,
* McshEngl.Rustlago'used_keyword.in!⇒Rustlago_in__used_keyword,
* McshEngl.Rustlago_used_keyword.in,
* McshEngl.Rustlago'used_keyword.in,

used-keyword.let of Rustlago

description::
× Mcsh-creation: {2026-10-04}
"let: bind a variable."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McshEngl.Rustlago_let__used_keyword,
* McshEngl.Rustlago'let__used_keyword!⇒Rustlago_let__used_keyword,
* McshEngl.Rustlago'used_keyword.let!⇒Rustlago_let__used_keyword,
* McshEngl.Rustlago_used_keyword.let,
* McshEngl.Rustlago'used_keyword.let,

used-keyword.loop of Rustlago

description::
× Mcsh-creation: {2026-10-04}
"loop: loop unconditionally."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McshEngl.Rustlago_loop__used_keyword,
* McshEngl.Rustlago'loop__used_keyword!⇒Rustlago_loop__used_keyword,
* McshEngl.Rustlago'used_keyword.loop!⇒Rustlago_loop__used_keyword,
* McshEngl.Rustlago_used_keyword.loop,
* McshEngl.Rustlago'used_keyword.loop,

used-keyword.match of Rustlago

description::
× Mcsh-creation: {2026-10-04}
"match: match a value to patterns."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McshEngl.Rustlago_match__used_keyword,
* McshEngl.Rustlago'match__used_keyword!⇒Rustlago_match__used_keyword,
* McshEngl.Rustlago'used_keyword.match!⇒Rustlago_match__used_keyword,
* McshEngl.Rustlago_used_keyword.match,
* McshEngl.Rustlago'used_keyword.match,

used-keyword.mod of Rustlago

description::
× Mcsh-creation: {2026-10-04}
"mod: define a module."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McshEngl.Rustlago_mod__used_keyword,
* McshEngl.Rustlago'mod__used_keyword!⇒Rustlago_mod__used_keyword,
* McshEngl.Rustlago'used_keyword.mod!⇒Rustlago_mod__used_keyword,
* McshEngl.Rustlago_used_keyword.mod,
* McshEngl.Rustlago'used_keyword.mod,

used-keyword.move of Rustlago

description::
× Mcsh-creation: {2026-10-04}
"move: make a closure take ownership of all its captures."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McshEngl.Rustlago_move__used_keyword,
* McshEngl.Rustlago'move__used_keyword!⇒Rustlago_move__used_keyword,
* McshEngl.Rustlago'used_keyword.move!⇒Rustlago_move__used_keyword,
* McshEngl.Rustlago_used_keyword.move,
* McshEngl.Rustlago'used_keyword.move,

used-keyword.mut of Rustlago

description::
× Mcsh-creation: {2026-10-04}
"mut: denote mutability in references, raw pointers, or pattern bindings."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McshEngl.Rustlago_mut__used_keyword,
* McshEngl.Rustlago'mut__used_keyword!⇒Rustlago_mut__used_keyword,
* McshEngl.Rustlago'used_keyword.mut!⇒Rustlago_mut__used_keyword,
* McshEngl.Rustlago_used_keyword.mut,
* McshEngl.Rustlago'used_keyword.mut,

used-keyword.pub of Rustlago

description::
× Mcsh-creation: {2026-10-04}
"pub: denote public visibility in struct fields, impl blocks, or modules."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McshEngl.Rustlago_pub__used_keyword,
* McshEngl.Rustlago'pub__used_keyword!⇒Rustlago_pub__used_keyword,
* McshEngl.Rustlago'used_keyword.pub!⇒Rustlago_pub__used_keyword,
* McshEngl.Rustlago_used_keyword.pub,
* McshEngl.Rustlago'used_keyword.pub,

used-keyword.ref of Rustlago

description::
× Mcsh-creation: {2026-10-04}
"ref: bind by reference."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McshEngl.Rustlago_ref__used_keyword,
* McshEngl.Rustlago'ref__used_keyword!⇒Rustlago_ref__used_keyword,
* McshEngl.Rustlago'used_keyword.ref!⇒Rustlago_ref__used_keyword,
* McshEngl.Rustlago_used_keyword.ref,
* McshEngl.Rustlago'used_keyword.ref,

used-keyword.return of Rustlago

description::
× Mcsh-creation: {2026-10-04}
"return: return from function."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McshEngl.Rustlago_return__used_keyword,
* McshEngl.Rustlago'return__used_keyword!⇒Rustlago_return__used_keyword,
* McshEngl.Rustlago'used_keyword.return!⇒Rustlago_return__used_keyword,
* McshEngl.Rustlago_used_keyword.return,
* McshEngl.Rustlago'used_keyword.return,

used-keyword.Self of Rustlago

description::
× Mcsh-creation: {2026-10-04}
"Self: a type alias for the type implementing a trait."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McshEngl.Rustlago_Self__used_keyword,
* McshEngl.Rustlago'Self__used_keyword!⇒Rustlago_Self__used_keyword,
* McshEngl.Rustlago'used_keyword.Self!⇒Rustlago_Self__used_keyword,
* McshEngl.Rustlago_used_keyword.Self,
* McshEngl.Rustlago'used_keyword.Self,

used-keyword.self of Rustlago

description::
× Mcsh-creation: {2026-10-04}
"self: method subject or current module."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McshEngl.Rustlago_self__used_keyword,
* McshEngl.Rustlago'self__used_keyword!⇒Rustlago_self__used_keyword,
* McshEngl.Rustlago'used_keyword.self!⇒Rustlago_self__used_keyword,
* McshEngl.Rustlago_used_keyword.self,
* McshEngl.Rustlago'used_keyword.self,

used-keyword.static of Rustlago

description::
× Mcsh-creation: {2026-10-04}
"static: global variable or lifetime lasting the entire program execution."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McshEngl.Rustlago_static__used_keyword,
* McshEngl.Rustlago'static__used_keyword!⇒Rustlago_static__used_keyword,
* McshEngl.Rustlago'used_keyword.static!⇒Rustlago_static__used_keyword,
* McshEngl.Rustlago_used_keyword.static,
* McshEngl.Rustlago'used_keyword.static,

used-keyword.struct of Rustlago

description::
× Mcsh-creation: {2026-10-04}
"struct: define a structure."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McshEngl.Rustlago_struct__used_keyword,
* McshEngl.Rustlago'struct__used_keyword!⇒Rustlago_struct__used_keyword,
* McshEngl.Rustlago'used_keyword.struct!⇒Rustlago_struct__used_keyword,
* McshEngl.Rustlago_used_keyword.struct,
* McshEngl.Rustlago'used_keyword.struct,

used-keyword.super of Rustlago

description::
× Mcsh-creation: {2026-10-04}
"super: parent module of the current module."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McshEngl.Rustlago_super__used_keyword,
* McshEngl.Rustlago'super__used_keyword!⇒Rustlago_super__used_keyword,
* McshEngl.Rustlago'used_keyword.super!⇒Rustlago_super__used_keyword,
* McshEngl.Rustlago_used_keyword.super,
* McshEngl.Rustlago'used_keyword.super,

used-keyword.trait of Rustlago

description::
× Mcsh-creation: {2026-10-04}
"trait: define a trait."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McshEngl.Rustlago_trait__used_keyword,
* McshEngl.Rustlago'trait__used_keyword!⇒Rustlago_trait__used_keyword,
* McshEngl.Rustlago'used_keyword.trait!⇒Rustlago_trait__used_keyword,
* McshEngl.Rustlago_used_keyword.trait,
* McshEngl.Rustlago'used_keyword.trait,

used-keyword.true of Rustlago

description::
× Mcsh-creation: {2026-10-04}
"true: Boolean true literal."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McshEngl.Rustlago_true__used_keyword,
* McshEngl.Rustlago'true__used_keyword!⇒Rustlago_true__used_keyword,
* McshEngl.Rustlago'used_keyword.true!⇒Rustlago_true__used_keyword,
* McshEngl.Rustlago_used_keyword.true,
* McshEngl.Rustlago'used_keyword.true,

used-keyword.type of Rustlago

description::
× Mcsh-creation: {2026-10-04}
"type: define a type alias or associated type."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McshEngl.Rustlago_type__used_keyword,
* McshEngl.Rustlago'type__used_keyword!⇒Rustlago_type__used_keyword,
* McshEngl.Rustlago'used_keyword.type!⇒Rustlago_type__used_keyword,
* McshEngl.Rustlago_used_keyword.type,
* McshEngl.Rustlago'used_keyword.type,

used-keyword.unsafe of Rustlago

description::
× Mcsh-creation: {2026-10-04}
"unsafe: denote unsafe code, functions, traits, or implementations."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McshEngl.Rustlago_unsafe__used_keyword,
* McshEngl.Rustlago'unsafe__used_keyword!⇒Rustlago_unsafe__used_keyword,
* McshEngl.Rustlago'used_keyword.unsafe!⇒Rustlago_unsafe__used_keyword,
* McshEngl.Rustlago_used_keyword.unsafe,
* McshEngl.Rustlago'used_keyword.unsafe,

used-keyword.use of Rustlago

description::
× Mcsh-creation: {2026-10-04}
"use: bring symbols into scope."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McshEngl.Rustlago_use__used_keyword,
* McshEngl.Rustlago'use__used_keyword!⇒Rustlago_use__used_keyword,
* McshEngl.Rustlago'used_keyword.use!⇒Rustlago_use__used_keyword,
* McshEngl.Rustlago_used_keyword.use,
* McshEngl.Rustlago'used_keyword.use,

used-keyword.where of Rustlago

description::
× Mcsh-creation: {2026-10-04}
"where: denote clauses that constrain a type."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McshEngl.Rustlago_where__used_keyword,
* McshEngl.Rustlago'where__used_keyword!⇒Rustlago_where__used_keyword,
* McshEngl.Rustlago'used_keyword.where!⇒Rustlago_where__used_keyword,
* McshEngl.Rustlago_used_keyword.where,
* McshEngl.Rustlago'used_keyword.where,

used-keyword.while of Rustlago

description::
× Mcsh-creation: {2026-10-04}
"while: loop conditionally based on the result of an expression."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McshEngl.Rustlago_while__used_keyword,
* McshEngl.Rustlago'while__used_keyword!⇒Rustlago_while__used_keyword,
* McshEngl.Rustlago'used_keyword.while!⇒Rustlago_while__used_keyword,
* McshEngl.Rustlago_used_keyword.while,
* McshEngl.Rustlago'used_keyword.while,

keyword.usedNo of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· reserved-keyword of Rustlago is a-keyword NOT used currently.

name::
* McshEngl.Rustlago_usedNo_keyword,
* McshEngl.Rustlago-usedNo-keyword!⇒Rustlago_usedNo_keyword,
* McshEngl.Rustlago'reserved_keyword!⇒Rustlago_usedNo_keyword,
* McshEngl.Rustlago_keyword.reserved!⇒Rustlago_usedNo_keyword,
* McshEngl.Rustlago'keyword.usedNo!⇒Rustlago_usedNo_keyword,

usedNo-keyword.abstract of Rustlago

description::
× Mcsh-creation: {2026-10-04}
"abstract: reserved for potential future use."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McshEngl.Rustlago_abstract__usedNo_keyword,
* McshEngl.Rustlago'abstract__usedNo_keyword!⇒Rustlago_abstract__usedNo_keyword,
* McshEngl.Rustlago'usedNo_keyword.abstract!⇒Rustlago_abstract__usedNo_keyword,
* McshEngl.Rustlago_usedNo_keyword.abstract,
* McshEngl.Rustlago'usedNo_keyword.abstract,

usedNo-keyword.async of Rustlago

description::
× Mcsh-creation: {2026-10-04}
"async: reserved for potential future use."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McshEngl.Rustlago_async__usedNo_keyword,
* McshEngl.Rustlago'async__usedNo_keyword!⇒Rustlago_async__usedNo_keyword,
* McshEngl.Rustlago'usedNo_keyword.async!⇒Rustlago_async__usedNo_keyword,
* McshEngl.Rustlago_usedNo_keyword.async,
* McshEngl.Rustlago'usedNo_keyword.async,

usedNo-keyword.become of Rustlago

description::
× Mcsh-creation: {2026-10-04}
"become: reserved for potential future use."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McshEngl.Rustlago_become__usedNo_keyword,
* McshEngl.Rustlago'become__usedNo_keyword!⇒Rustlago_become__usedNo_keyword,
* McshEngl.Rustlago'usedNo_keyword.become!⇒Rustlago_become__usedNo_keyword,
* McshEngl.Rustlago_usedNo_keyword.become,
* McshEngl.Rustlago'usedNo_keyword.become,

usedNo-keyword.box of Rustlago

description::
× Mcsh-creation: {2026-10-04}
"box: reserved for potential future use."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McshEngl.Rustlago_box__usedNo_keyword,
* McshEngl.Rustlago'box__usedNo_keyword!⇒Rustlago_box__usedNo_keyword,
* McshEngl.Rustlago'usedNo_keyword.box!⇒Rustlago_box__usedNo_keyword,
* McshEngl.Rustlago_usedNo_keyword.box,
* McshEngl.Rustlago'usedNo_keyword.box,

usedNo-keyword.do of Rustlago

description::
× Mcsh-creation: {2026-10-04}
"do: reserved for potential future use."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McshEngl.Rustlago_do__usedNo_keyword,
* McshEngl.Rustlago'do__usedNo_keyword!⇒Rustlago_do__usedNo_keyword,
* McshEngl.Rustlago'usedNo_keyword.do!⇒Rustlago_do__usedNo_keyword,
* McshEngl.Rustlago_usedNo_keyword.do,
* McshEngl.Rustlago'usedNo_keyword.do,

usedNo-keyword.final of Rustlago

description::
× Mcsh-creation: {2026-10-04}
"final: reserved for potential future use."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McshEngl.Rustlago_final__usedNo_keyword,
* McshEngl.Rustlago'final__usedNo_keyword!⇒Rustlago_final__usedNo_keyword,
* McshEngl.Rustlago'usedNo_keyword.final!⇒Rustlago_final__usedNo_keyword,
* McshEngl.Rustlago_usedNo_keyword.final,
* McshEngl.Rustlago'usedNo_keyword.final,

usedNo-keyword.macro of Rustlago

description::
× Mcsh-creation: {2026-10-04}
"macro: reserved for potential future use."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McshEngl.Rustlago_macro__usedNo_keyword,
* McshEngl.Rustlago'macro__usedNo_keyword!⇒Rustlago_macro__usedNo_keyword,
* McshEngl.Rustlago'usedNo_keyword.macro!⇒Rustlago_macro__usedNo_keyword,
* McshEngl.Rustlago_usedNo_keyword.macro,
* McshEngl.Rustlago'usedNo_keyword.macro,

usedNo-keyword.override of Rustlago

description::
× Mcsh-creation: {2026-10-04}
"override: reserved for potential future use."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McshEngl.Rustlago_override__usedNo_keyword,
* McshEngl.Rustlago'override__usedNo_keyword!⇒Rustlago_override__usedNo_keyword,
* McshEngl.Rustlago'usedNo_keyword.override!⇒Rustlago_override__usedNo_keyword,
* McshEngl.Rustlago_usedNo_keyword.override,
* McshEngl.Rustlago'usedNo_keyword.override,

usedNo-keyword.priv of Rustlago

description::
× Mcsh-creation: {2026-10-04}
"priv: reserved for potential future use."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McshEngl.Rustlago_priv__usedNo_keyword,
* McshEngl.Rustlago'priv__usedNo_keyword!⇒Rustlago_priv__usedNo_keyword,
* McshEngl.Rustlago'usedNo_keyword.priv!⇒Rustlago_priv__usedNo_keyword,
* McshEngl.Rustlago_usedNo_keyword.priv,
* McshEngl.Rustlago'usedNo_keyword.priv,

usedNo-keyword.try of Rustlago

description::
× Mcsh-creation: {2026-10-04}
"try: reserved for potential future use."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McshEngl.Rustlago_try__usedNo_keyword,
* McshEngl.Rustlago'try__usedNo_keyword!⇒Rustlago_try__usedNo_keyword,
* McshEngl.Rustlago'usedNo_keyword.try!⇒Rustlago_try__usedNo_keyword,
* McshEngl.Rustlago_usedNo_keyword.try,
* McshEngl.Rustlago'usedNo_keyword.try,

usedNo-keyword.typeof of Rustlago

description::
× Mcsh-creation: {2026-10-04}
"typeof: reserved for potential future use."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McshEngl.Rustlago_typeof__usedNo_keyword,
* McshEngl.Rustlago'typeof__usedNo_keyword!⇒Rustlago_typeof__usedNo_keyword,
* McshEngl.Rustlago'usedNo_keyword.typeof!⇒Rustlago_typeof__usedNo_keyword,
* McshEngl.Rustlago_usedNo_keyword.typeof,
* McshEngl.Rustlago'usedNo_keyword.typeof,

usedNo-keyword.unsized of Rustlago

description::
× Mcsh-creation: {2026-10-04}
"unsized: reserved for potential future use."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McshEngl.Rustlago_unsized__usedNo_keyword,
* McshEngl.Rustlago'unsized__usedNo_keyword!⇒Rustlago_unsized__usedNo_keyword,
* McshEngl.Rustlago'usedNo_keyword.unsized!⇒Rustlago_unsized__usedNo_keyword,
* McshEngl.Rustlago_usedNo_keyword.unsized,
* McshEngl.Rustlago'usedNo_keyword.unsized,

usedNo-keyword.virtual of Rustlago

description::
× Mcsh-creation: {2026-10-04}
"virtual: reserved for potential future use."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McshEngl.Rustlago_virtual__usedNo_keyword,
* McshEngl.Rustlago'virtual__usedNo_keyword!⇒Rustlago_virtual__usedNo_keyword,
* McshEngl.Rustlago'usedNo_keyword.virtual!⇒Rustlago_virtual__usedNo_keyword,
* McshEngl.Rustlago_usedNo_keyword.virtual,
* McshEngl.Rustlago'usedNo_keyword.virtual,

usedNo-keyword.yield of Rustlago

description::
× Mcsh-creation: {2026-10-04}
"yield: reserved for potential future use."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McshEngl.Rustlago_yield__usedNo_keyword,
* McshEngl.Rustlago'yield__usedNo_keyword!⇒Rustlago_yield__usedNo_keyword,
* McshEngl.Rustlago'usedNo_keyword.yield!⇒Rustlago_yield__usedNo_keyword,
* McshEngl.Rustlago_usedNo_keyword.yield,
* McshEngl.Rustlago'usedNo_keyword.yield,

GENERIC-SPECIFIC-TREE of Rustkeyword

description::
× Mcsh-creation: {2026-10-04}

name::
* McshEngl.Rustkeyword'generic_specific_tree,

generic-tree::
* McshEngl.Rustkeyword:generic,
===
* keyword-of-Srcdlago!@McshTchInf000006#idLSrcdwrdRsvd,
* Rustlago_word:generic,
* ...entity:generic,

specific-tree::
* McshEngl.Rustkeyword.specific,
===
* reserved-keyword--of-Rustlago,
* used-keyword--of-Rustlago,

algo'root of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· source-root of Rustlago[a] is the-outermost structure of its[a] source-syntax-tree.

name::
* McshEngl.Rustalgo'root!⇒Rustroot,
* McshEngl.Rustroot!=Rustalgo'root,
* McshEngl.Rustlago'root!⇒Rustroot,
* McshEngl.Rustlago'algo'root!⇒Rustroot,

generic-tree::
* McshEngl.Rustroot:generic,
===
* algo-root--of-Srcdlago,

GENERIC-SPECIFIC-TREE of Rustlago_algo

description::
× Mcsh-creation: {2026-10-04}

name::
* McshEngl.Rustalgo'generic_specific_tree,
* McshEngl.Rustlago_algo'generic_specific_tree,

generic-tree::
* McshEngl.Rustlago_algo:generic,
* McshEngl.Rustalgo:generic,
===
* Srcdalgo:generic,
* Pgmgalgo:generic,
* techCmpr_software:generic,
* compiled--programing-language!@McshTchInf000006#idLSrcdCmpd,
* ...entity:generic,

specific-tree::
* McshEngl.Rustlago_algo.specific,
* McshEngl.Rustalgo.specific,
===
* library,
* program,

algo.module of Rustlago

description::
× Mcsh-creation: {2026-10-04}
"Modules let us organize code within a crate into groups for readability and easy reuse. Modules also control the privacy of items, which is whether an item can be used by outside code (public) or whether it’s an internal implementation detail and not available for outside use (private)."
· example:
mod m_whole {
mod m_part {
}
}
[https://doc.rust-lang.org/book/ch07-02-defining-modules-to-control-scope-and-privacy.html]

name::
* McshEngl.Rustlago_mod,
* McshEngl.Rustlago-mod!⇒Rustlago_mod,
* McshEngl.Rustlago'module!⇒Rustlago_mod,
* McshEngl.Rustlago'algo.module!⇒Rustlago_mod,

08_algo'section of Rustlago

description::
× Mcsh-creation: {2026-10-04}

name::
* McshEngl.Rustalgo_section,
* McshEngl.Rustalgo'section!⇒Rustalgo_section,
* McshEngl.Rustlago'algo'section!⇒Rustalgo_section,

generic-tree::
* McshEngl.Rustalgo_section:generic,
===
* Srcdalgosect:generic,
* Pgmgalgo_section:generic,
* Calgonode:generic,
* ...entity:generic,

algo'titledNo-section of Rustlago

description::
× Mcsh-creation: {2026-10-17}

name::
* McshEngl.Rustalgo_section_algo_titledNo_section,
* McshEngl.Rustalgo'section'algo'titledNo_section!⇒Rustalgo_section_algo_titledNo_section,
* McshEngl.Rustlago'algo'titledNo_section!⇒Rustalgo_section_algo_titledNo_section,
* McshEngl.Rustlago'algo'titledNo_section,

algo'titled-section of Rustlago

description::
× Mcsh-creation: {2026-10-17}

name::
* McshEngl.Rustalgo_section_algo_titled_section,
* McshEngl.Rustalgo'section'algo'titled_section!⇒Rustalgo_section_algo_titled_section,
* McshEngl.Rustlago'algo'titled_section!⇒Rustalgo_section_algo_titled_section,
* McshEngl.Rustlago'algo'titled_section,

algo.package of Rustlago

description::
× Mcsh-creation: {2026-10-04}
"A package is one or more crates that provide a set of functionality.
A package contains a Cargo.toml file that describes how to build those crates."
[https://doc.rust-lang.org/book/ch07-01-packages-and-crates.html]

name::
* McshEngl.Rustlago_pkg,
* McshEngl.Rustlago-pkg!⇒Rustlago_pkg,
* McshEngl.Rustlago'Cargo_package!⇒Rustlago_pkg,
* McshEngl.Rustlago'package!⇒Rustlago_pkg,
* McshEngl.Rustlago'algo.package!⇒Rustlago_pkg,

Cargo.toml-file of package of Rustlago

description::
× Mcsh-creation: {2026-10-04}
"The Cargo.toml file for each package is called its manifest. Every manifest file consists of one or more sections."
[https://doc.rust-lang.org/cargo/reference/manifest.html]

name::
* McshEngl.Cargo.toml-file-of-package-of-Rustlago!⇒RustcargoToml,
* McshEngl.RustcargoToml!=Cargo.toml-file-of-package-of-Rustlago,
* McshEngl.Rustcargo.toml!⇒RustcargoToml,
* McshEngl.Rustlago_pkg'Cargo.toml_file!⇒RustcargoToml,
* McshEngl.Rustlago_source_file.Cargo.toml_file!⇒RustcargoToml,

algo.program of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· source-program of Rustlago is a-source-algo WITH an-executing-entry-point.

name::
* McshEngl.Rustlago_pgm,
* McshEngl.Rustlago-pgm!⇒Rustlago_pgm,
* McshEngl.Rustalgo.executable!⇒Rustlago_pgm,
* McshEngl.Rustalgo.program!⇒Rustlago_pgm,
* McshEngl.Rustlago'algo.program!⇒Rustlago_pgm,

program.command-line of Rustlago

description::
× Mcsh-creation: {2026-10-01}

name::
* McshEngl.Rustlago_clip,
* McshEngl.Rustlago'program.command_line!⇒Rustlago_clip,
* McshEngl.Rustlago-clip!⇒Rustlago_clip,
* McshEngl.Rustlago_pgm.command_line!⇒Rustlago_clip,

info-resource of clip of Rustlago

description::
× Mcsh-creation: {2026-10-04}
* https://doc.rust-lang.org/book/ch12-00-an-io-project.html,

name::
* McshEngl.clip of Rustlago'info_resource,
* McshEngl.clip_of_Rustlago'info_resource,
* McshEngl.Rustlago_clip'info_resource,

program.command-line.no of Rustlago

description::
× Mcsh-creation: {2026-10-01}

name::
* McshEngl.Rustlago_guip,
* McshEngl.Rustlago'program.command_line.no!⇒Rustlago_guip,
* McshEngl.Rustlago-guip!⇒Rustlago_guip,
* McshEngl.Rustlago_pgm.command_line.no!⇒Rustlago_guip,

binary-algo of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· Rust[a] is a-compiled-language.
· its[a]-algo, written by a-programer, is-compiled to a-binary-algo a-real-machine understands.

name::
* McshEngl.Rustlago_bin_algo,
* McshEngl.Rustlago'binary_algo!⇒Rustlago_bin_algo,
* McshEngl.Rustlago-bin-algo!⇒Rustlago_bin_algo,

bin-code of bin-algo of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· bin-code of Rustlago is any part of its bin-algo.

name::
* McshEngl.Rustlago'bin_code,
* McshEngl.Rustlago_bin_algo'code,
* McshEngl.Rustlago_bin_algo'bin_code,

bin-algo.program of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· executable of Rustlago is a-bin-algo with an-executable-entry-point.

name::
* McshEngl.Rustlago_exe,
* McshEngl.Rustlago'bin_algo.program!⇒Rustlago_exe,
* McshEngl.Rustlago-exe!⇒Rustlago_exe,
* McshEngl.Rustlago'bin_program!⇒Rustlago_exe,
* McshEngl.Rustlago'executable!⇒Rustlago_exe,
* McshEngl.Rustlago_bin_algo.program!⇒Rustlago_exe,

GENERIC-SPECIFIC-TREE of Rustlago_bin_algo

description::
× Mcsh-creation: {2026-10-04}

name::
* McshEngl.Rustlago_bin_algo'generic_specific_tree,

generic-tree::
* McshEngl.Rustlago_bin_algo:generic,
===
* ...entity:generic,

specific-tree::
* McshEngl.Rustlago_bin_algo.specific,
===
* bin-program,

11_human of Rustlago

description::
× Mcsh-creation: {2026-10-04}

name::
* McshEngl.Rustlago'human,

human.programer

description::
× Mcsh-creation: {2026-10-04}

name::
* McshEngl.Rustlago'Rustacean,
* McshEngl.Rustlago'programer,
* McshEngl.Rustlago'human.programer,

GENERIC-SPECIFIC-TREE of Rustlago'human

description::
× Mcsh-creation: {2026-10-04}

name::
* McshEngl.Rustlago'human'generic_specific_tree,

generic-tree::
* McshEngl.Rustlago'human:generic,
===
* ...entity:generic,

specific-tree::
* McshEngl.Rustlago'human.specific,
===
* creator,
* programer,

12_evaluation of Rustlago

description::
× Mcsh-creation: {2026-10-04}

name::
* McshEngl.evaluation-of-Rustlago!⇒Rustevaln,
* McshEngl.Rustevaln!=evaluation-of-Rustlago,
* McshEngl.Rustevalg!⇒Rustevaln,
* McshEngl.Rustlago'evaluation!⇒Rustevaln,

benefit of Rustlago

description::
× Mcsh-creation: {2026-10-17}

name::
* McshEngl.Rustlago'evaluation'benefit,
* McshEngl.Rustlago'benefit,

benefitNo of Rustlago

description::
× Mcsh-creation: {2026-10-17}

name::
* McshEngl.Rustlago'evaluation'benefitNo,
* McshEngl.Rustlago'benefitNo,

18_algo.crate of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· source-crate of Rustlago is an-algo which can-produce a-bin-library or a-bin-program.
"Crates: A tree of modules that produces a library or executable"
[https://doc.rust-lang.org/book/ch07-00-managing-growing-projects-with-packages-crates-and-modules.html]

name::
* McshEngl.Rustlago_crate,
* McshEngl.Rustlago-crate!⇒Rustlago_crate,
* McshEngl.Rustlago'crate!⇒Rustlago_crate,
* McshEngl.Rustlago'library!⇒Rustlago_crate,
* McshEngl.Rustalgo.crate!⇒Rustlago_crate,
* McshEngl.Rustlago'algo.crate!⇒Rustlago_crate,

main-module of crate of Rustlago

description::
× Mcsh-creation: {2026-10-04}
""

name::
* McshEngl.Rustlago_crate'main_module,

crate.standard of Rustlago

description::
× Mcsh-creation: {2026-10-04}
"The Rust Standard Library is the foundation of portable Rust software, a set of minimal and battle-tested shared abstractions for the broader Rust ecosystem. It offers core types, like Vec<T> and Option<T>, library-defined operations on language primitives, standard macros, I/O and multithreading, among many other things.
std is available to all Rust crates by default. Therefore, the standard library can be accessed in use statements through the path std, as in use std::env."
[https://doc.rust-lang.org/std/index.html]

name::
* McshEngl.Rustlago_std,
* McshEngl.Rustlago-std!⇒Rustlago_std,
* McshEngl.Rust-Standard-Library!⇒Rustlago_std,
* McshEngl.Rustlago'standard_library!⇒Rustlago_std,
* McshEngl.Rustlago'crate.standard!⇒Rustlago_std,

part of Rustlago_std

description::
× Mcsh-creation: {2026-10-04}
* structs,
* enums,
* unions,
* primitives,
* traits,
* macros,
* functions,
* typedefs,
* constants,
===
* re-exports,
* primitive-types,
* modules,
* macros,

name::
* McshEngl.Rustlago_std'part,

module of Rustlago_std

description::
× Mcsh-creation: {2026-10-01}

name::
* McshEngl.Rustlago_std'module,

info-resource of Rustlago_std

description::
× Mcsh-creation: {2026-10-04}
* https://doc.rust-lang.org/std/,

name::
* McshEngl.Rustlago_std'info_resource,

std::prelude of Rustlago

description::
× Mcsh-creation: {2026-10-04}
"Rust comes with a variety of things in its standard library. However, if you had to manually import every single thing that you used, it would be very verbose. But importing a lot of things that a program never uses isn't good either. A balance needs to be struck.
The prelude is the list of things that Rust automatically imports into every Rust program. It's kept as small as possible, and is focused on things, particularly traits, which are used in almost every single Rust program.
On a technical level, Rust inserts
extern crate std;
into the crate root of every crate, and
use std::prelude::v1::*;
into every module."
[https://doc.rust-lang.org/std/prelude/index.html]

name::
* McshEngl.Rustlago_prelude,
* McshEngl.Rustlago-prelude!⇒Rustlago_prelude,
* McshEngl.Rustlago'prelude_of_std!⇒Rustlago_prelude,
* McshEngl.Rustlago_std::prelude!⇒Rustlago_prelude,
* McshEngl.Rustlago_crate'std::prelude!⇒Rustlago_prelude,
* McshEngl.Rustlago'std::prelude!⇒Rustlago_prelude,

part of prelude of Rustlago

description::
× Mcsh-creation: {2026-10-04}
The current version of the prelude (version 1) lives in std::prelude::v1, and re-exports the following.
♦ std::marker::{Copy, Send, Sized, Sync, Unpin}. The marker traits indicate fundamental properties of types.
♦ std::ops::{Drop, Fn, FnMut, FnOnce}. Various operations for both destructors and overloading ().
♦ std::mem::drop, a convenience function for explicitly dropping a value.
♦ std::boxed::Box, a way to allocate values on the heap.
♦ std::borrow::ToOwned, The conversion trait that defines to_owned, the generic method for creating an owned type from a borrowed type.
♦ std::clone::Clone, the ubiquitous trait that defines clone, the method for producing a copy of a value.
♦ std::cmp::{PartialEq, PartialOrd, Eq, Ord }. The comparison traits, which implement the comparison operators and are often seen in trait bounds.
♦ std::convert::{AsRef, AsMut, Into, From}. Generic conversions, used by savvy API authors to create overloaded methods.
♦ std::default::Default, types that have default values.
♦ std::iter::{Iterator, Extend, IntoIterator, DoubleEndedIterator, ExactSizeIterator}. Iterators of various kinds.
♦ std::option::Option::{self, Some, None}. A type which expresses the presence or absence of a value. This type is so commonly used, its variants are also exported.
♦ std::result::Result::{self, Ok, Err}. A type for functions that may succeed or fail. Like Option, its variants are exported as well.
♦ std::slice::SliceConcatExt, a trait that exists for technical reasons, but shouldn't have to exist. It provides a few useful methods on slices.
♦ std::string::{String, ToString}, heap allocated strings.
♦ std::vec::Vec, a growable, heap-allocated vector.
[https://doc.rust-lang.org/std/prelude/index.html#prelude-contents]

name::
* McshEngl.Rustlago_prelude'part,

std::string::String-struct of prelude of Rustlago

description::
× Mcsh-creation: {2026-10-04}
let mut s = String::from("hello");
"A UTF-8 encoded, growable string.
The String type is the most common string type that has ownership over the contents of the string. It has a close relationship with its borrowed counterpart, the primitive str."
[https://doc.rust-lang.org/std/string/struct.String.html]

name::
* McshEngl.Rustlago_String,
* McshEngl.Rustlago-String!⇒Rustlago_String,
* McshEngl.Rustlago'String_struct!⇒Rustlago_String,
* McshEngl.Rustlago_prelude'String_struct!⇒Rustlago_String,
* McshEngl.Rustlago_struct.String!⇒Rustlago_String,
* McshEngl.Rustlago_prelude'std::string::String_struct!⇒Rustlago_String,

std::vec::Vec-struct of prelude of Rustlago

description::
× Mcsh-creation: {2026-10-04}
"A contiguous growable array type, written Vec<T> but pronounced 'vector'."
[https://doc.rust-lang.org/std/vec/struct.Vec.html]
· vectors store values of the-same type.
· vectors are-stored on the-heap-memory.
· example:
let v: Vec<i32> = Vec::new();
let v2 = vec![1, 2, 3];

name::
* McshEngl.Rustlago_Vec,
* McshEngl.Rustlago-Vec!⇒Rustlago_Vec,
* McshEngl.Rustlago'Vec_struct!⇒Rustlago_Vec,
* McshEngl.Rustlago'vector!⇒Rustlago_Vec,
* McshEngl.Rustlago_struct.Vec!⇒Rustlago_Vec,
* McshEngl.Rustlago_prelude'std::vec::Vec_struct!⇒Rustlago_Vec,

generic-tree::
* McshEngl.Rustlago_Vec:generic,
===
* Rustlago-struct,

GENERIC-SPECIFIC-TREE of Rustlago_crate

description::
× Mcsh-creation: {2026-10-04}

name::
* McshEngl.Rustlago_crate'generic_specific_tree,

generic-tree::
* McshEngl.Rustlago_crate:generic,
===
* ...entity:generic,

specific-tree::
* McshEngl.Rustlago_crate.specific,
===
* package-registry: https://crates.io/,
===
* standard-library,

info-resource of Rustlago

description::
× Mcsh-creation: {2026-10-04}
* https://www.rust-lang.org/,
* https://github.com/rust-lang,
=== learning:
* https://www.rust-lang.org/learn,
* https://doc.rust-lang.org/reference/introduction.html,
* https://doc.rust-lang.org/book/,
* https://rust-lang-nursery.github.io/rust-cookbook/,
=== community:
* https://discord.gg/rust-lang,
* https://twitter.com/rustlang,

name::
* McshEngl.Rustlago'info_resource,

35_tool of Rustlago

description::
× Mcsh-creation: {2026-10-04}

name::
* McshEngl.Rusttool,
* McshEngl.Rustlago-tool!⇒Rusttool,
* McshEngl.Rustlago'tool!⇒Rusttool,

rustc of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· rustc is a-lagoPrgm-compiler.

name::
* McshEngl.Rustlago_rustc,
* McshEngl.Rustlago-rustc!⇒Rustlago_rustc,
* McshEngl.Rustlago'compiler!⇒Rustlago_rustc,
* McshEngl.Rusttool.compiler!⇒Rustlago_rustc,
* McshEngl.Rust-compiler!⇒Rustlago_rustc,
* McshEngl.Rusttool'rustc!⇒Rustlago_rustc,
* McshEngl.Rustlago'rustc!⇒Rustlago_rustc,

error of rustc

description::
× Mcsh-creation: {2026-10-04}
· E0001 to E0725 are-recorded in docs.

name::
* McshEngl.Rustlago_rustc_error,
* McshEngl.Rustlago_rustc'error!⇒Rustlago_rustc_error,
* McshEngl.rustc'error!⇒Rustlago_rustc_error,

addressWpg::
* https://doc.rust-lang.org/error-index.html,
* https://doc.rust-lang.org/error-index.html#E0019,
- $ rustc --explain E0019

info-resource of rustc

description::
× Mcsh-creation: {2026-10-04}
* https://doc.rust-lang.org/rustc/index.html,
* https://blog.rust-lang.org/2016/04/19/MIR.html,

name::
* McshEngl.rustc'info_resource,
* McshEngl.Rustlago_rustc'info_resource,

Cargo of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· Cargo is Rust’s package-manager and build-tool.

name::
* McshEngl.Rusttool.Cargo!⇒Rustcargo,
* McshEngl.Rustcargo!=Rusttool.Cargo,
* McshEngl.Rustlago-Cargo!⇒Rustcargo,
* McshEngl.Rust-Cargo!⇒Rustcargo,
* McshEngl.Rustlago'Cargo_tool!⇒Rustcargo,
* McshEngl.Rusttool'Cargo!⇒Rustcargo,
* McshEngl.Rustlago'Cargo!⇒Rustcargo,

command of Cargo

description::
× Mcsh-creation: {2026-10-04}
· Cargo is a-command-line tool, so it has many commands that do different things.

name::
* McshEngl.Rustcargocmnd,
* McshEngl.Cargo'command!⇒Rustcargocmnd,
* McshEngl.Rustlago-Cargo-cmd!⇒Rustcargocmnd,
* McshEngl.Rustcargo'command!⇒Rustcargocmnd,

Cargo-cmd.bench of Rustlago

description::
× Mcsh-creation: {2026-10-04}
* bench: Execute all benchmarks of a local package

name::
* McshEngl.RustcargocmndBench,
* McshEngl.Rustcargocmnd.bench!⇒RustcargocmndBench,
* McshEngl.Rustlago'Cargo_cmd.bench!⇒RustcargocmndBench,
* McshEngl.Rustlago'Cargo_cmd.bench,

Cargo-cmd.build of Rustlago

description::
× Mcsh-creation: {2026-10-04}
* build: Compile a local package and all of its dependencies

name::
* McshEngl.RustcargocmndBuild,
* McshEngl.Rustcargocmnd.build!⇒RustcargocmndBuild,
* McshEngl.Rustlago'Cargo_cmd.build!⇒RustcargocmndBuild,
* McshEngl.Rustlago'Cargo_cmd.build,

Cargo-cmd.check of Rustlago

description::
× Mcsh-creation: {2026-10-04}
* check: Check a local package and all of its dependencies for errors

name::
* McshEngl.RustcargocmndCheck,
* McshEngl.Rustcargocmnd.check!⇒RustcargocmndCheck,
* McshEngl.Rustlago'Cargo_cmd.check!⇒RustcargocmndCheck,
* McshEngl.Rustlago'Cargo_cmd.check,

Cargo-cmd.clean of Rustlago

description::
× Mcsh-creation: {2026-10-04}
* clean: Remove artifacts that cargo has generated in the past

name::
* McshEngl.RustcargocmndClean,
* McshEngl.Rustcargocmnd.clean!⇒RustcargocmndClean,
* McshEngl.Rustlago'Cargo_cmd.clean!⇒RustcargocmndClean,
* McshEngl.Rustlago'Cargo_cmd.clean,

Cargo-cmd.clippy-preview of Rustlago

description::
× Mcsh-creation: {2026-10-04}
* clippy-preview: Checks a package to catch common mistakes and improve your Rust code,

name::
* McshEngl.Cargo-cmd.clippy-preview-of-Rustlago!⇒RustcargocmndClippy_preview,
* McshEngl.RustcargocmndClippy_preview!=Cargo-cmd.clippy-preview-of-Rustlago,
* McshEngl.Rustcargocmnd.clippy_preview!⇒RustcargocmndClippy_preview,
* McshEngl.Rustlago'Cargo_cmd.clippy_preview!⇒RustcargocmndClippy_preview,
* McshEngl.Rustlago'Cargo_cmd.clippy_preview,

Cargo-cmd.doc of Rustlago

description::
× Mcsh-creation: {2026-10-04}
* doc: Build a package's documentation

name::
* McshEngl.RustcargocmndDoc,
* McshEngl.Rustcargocmnd.doc!⇒RustcargocmndDoc,
* McshEngl.Rustlago'Cargo_cmd.doc!⇒RustcargocmndDoc,
* McshEngl.Rustlago'Cargo_cmd.doc,

Cargo-cmd.fetch of Rustlago

description::
× Mcsh-creation: {2026-10-04}
* fetch: Fetch dependencies of a package from the network

name::
* McshEngl.RustcargocmndFetch,
* McshEngl.Rustcargocmnd.fetch!⇒RustcargocmndFetch,
* McshEngl.Rustlago'Cargo_cmd.fetch!⇒RustcargocmndFetch,
* McshEngl.Rustlago'Cargo_cmd.fetch,

Cargo-cmd.fix of Rustlago

description::
× Mcsh-creation: {2026-10-04}
* fix: Automatically fix lint warnings reported by rustc

name::
* McshEngl.RustcargocmndFix,
* McshEngl.Rustcargocmnd.fix!⇒RustcargocmndFix,
* McshEngl.Rustlago'Cargo_cmd.fix!⇒RustcargocmndFix,
* McshEngl.Rustlago'Cargo_cmd.fix,

Cargo-cmd.generate-lockfile of Rustlago

description::
× Mcsh-creation: {2026-10-04}
* generate-lockfile: Generate the lockfile for a package

name::
* McshEngl.Cargo-cmd.generate-lockfile-of-Rustlago!⇒RustcargocmndGenerate_lockfile,
* McshEngl.RustcargocmndGenerate_lockfile!=Cargo-cmd.generate-lockfile-of-Rustlago,
* McshEngl.Rustcargocmnd.generate_lockfile!⇒RustcargocmndGenerate_lockfile,
* McshEngl.Rustlago'Cargo_cmd.generate_lockfile!⇒RustcargocmndGenerate_lockfile,
* McshEngl.Rustlago'Cargo_cmd.generate_lockfile,

Cargo-cmd.git-checkout of Rustlago

description::
× Mcsh-creation: {2026-10-04}
* git-checkout: Checkout a copy of a Git repository

name::
* McshEngl.Cargo-cmd.git-checkout-of-Rustlago!⇒RustcargocmndGit_checkout,
* McshEngl.RustcargocmndGit_checkout!=Cargo-cmd.git-checkout-of-Rustlago,
* McshEngl.Rustcargocmnd.git_checkout!⇒RustcargocmndGit_checkout,
* McshEngl.Rustlago'Cargo_cmd.git_checkout!⇒RustcargocmndGit_checkout,
* McshEngl.Rustlago'Cargo_cmd.git_checkout,

Cargo-cmd.init of Rustlago

description::
× Mcsh-creation: {2026-10-04}
* init: Create a new cargo package in an existing directory

name::
* McshEngl.RustcargocmndInit,
* McshEngl.Rustcargocmnd.init!⇒RustcargocmndInit,
* McshEngl.Rustlago'Cargo_cmd.init!⇒RustcargocmndInit,
* McshEngl.Rustlago'Cargo_cmd.init,

Cargo-cmd.install of Rustlago

description::
× Mcsh-creation: {2026-10-04}
* install: Install a Rust binary. Default location is $HOME/.cargo/bin

name::
* McshEngl.RustcargocmndInstall,
* McshEngl.Rustcargocmnd.install!⇒RustcargocmndInstall,
* McshEngl.Rustlago'Cargo_cmd.install!⇒RustcargocmndInstall,
* McshEngl.Rustlago'Cargo_cmd.install,

Cargo-cmd.locate-project of Rustlago

description::
× Mcsh-creation: {2026-10-04}
* locate-project: Print a JSON representation of a Cargo.toml file's location

name::
* McshEngl.Cargo-cmd.locate-project-of-Rustlago!⇒RustcargocmndLocate_project,
* McshEngl.RustcargocmndLocate_project!=Cargo-cmd.locate-project-of-Rustlago,
* McshEngl.Rustcargocmnd.locate_project!⇒RustcargocmndLocate_project,
* McshEngl.Rustlago'Cargo_cmd.locate_project!⇒RustcargocmndLocate_project,
* McshEngl.Rustlago'Cargo_cmd.locate_project,

Cargo-cmd.login of Rustlago

description::
× Mcsh-creation: {2026-10-04}
* login: Save an api token from the registry locally. If token is not specified, it will be read from stdin,

name::
* McshEngl.RustcargocmndLogin,
* McshEngl.Rustcargocmnd.login!⇒RustcargocmndLogin,
* McshEngl.Rustlago'Cargo_cmd.login!⇒RustcargocmndLogin,
* McshEngl.Rustlago'Cargo_cmd.login,

Cargo-cmd.metadata of Rustlago

description::
× Mcsh-creation: {2026-10-04}
* metadata: Output the resolved dependencies of a package, the concrete used versions including overrides, in machine-readable format

name::
* McshEngl.RustcargocmndMetadata,
* McshEngl.Rustcargocmnd.metadata!⇒RustcargocmndMetadata,
* McshEngl.Rustlago'Cargo_cmd.metadata!⇒RustcargocmndMetadata,
* McshEngl.Rustlago'Cargo_cmd.metadata,

Cargo-cmd.new of Rustlago

description::
× Mcsh-creation: {2026-10-04}
* creates a-new cargo-package at <path>
· $ cargo new  path>

name::
* McshEngl.RustcargocmndNew,
* McshEngl.Rustcargocmnd.new!⇒RustcargocmndNew,
* McshEngl.Rustlago'Cargo_cmd.new!⇒RustcargocmndNew,
* McshEngl.Rustlago'Cargo_cmd.new,

Cargo-cmd.owner of Rustlago

description::
× Mcsh-creation: {2026-10-04}
* owner: Manage the owners of a crate on the registry

name::
* McshEngl.RustcargocmndOwner,
* McshEngl.Rustcargocmnd.owner!⇒RustcargocmndOwner,
* McshEngl.Rustlago'Cargo_cmd.owner!⇒RustcargocmndOwner,
* McshEngl.Rustlago'Cargo_cmd.owner,

Cargo-cmd.package of Rustlago

description::
× Mcsh-creation: {2026-10-04}
* package: Assemble the local package into a distributable tarball

name::
* McshEngl.RustcargocmndPackage,
* McshEngl.Rustcargocmnd.package!⇒RustcargocmndPackage,
* McshEngl.Rustlago'Cargo_cmd.package!⇒RustcargocmndPackage,
* McshEngl.Rustlago'Cargo_cmd.package,

Cargo-cmd.pkgid of Rustlago

description::
× Mcsh-creation: {2026-10-04}
* pkgid: Print a fully qualified package specification

name::
* McshEngl.RustcargocmndPkgid,
* McshEngl.Rustcargocmnd.pkgid!⇒RustcargocmndPkgid,
* McshEngl.Rustlago'Cargo_cmd.pkgid!⇒RustcargocmndPkgid,
* McshEngl.Rustlago'Cargo_cmd.pkgid,

Cargo-cmd.publish of Rustlago

description::
× Mcsh-creation: {2026-10-04}
* publish: Upload a package to the registry

name::
* McshEngl.RustcargocmndPublish,
* McshEngl.Rustcargocmnd.publish!⇒RustcargocmndPublish,
* McshEngl.Rustlago'Cargo_cmd.publish!⇒RustcargocmndPublish,
* McshEngl.Rustlago'Cargo_cmd.publish,

Cargo-cmd.read-manifest of Rustlago

description::
× Mcsh-creation: {2026-10-04}
* read-manifest: Print a JSON representation of a Cargo.toml manifest,

name::
* McshEngl.Cargo-cmd.read-manifest-of-Rustlago!⇒RustcargocmndRead_manifest,
* McshEngl.RustcargocmndRead_manifest!=Cargo-cmd.read-manifest-of-Rustlago,
* McshEngl.Rustcargocmnd.read_manifest!⇒RustcargocmndRead_manifest,
* McshEngl.Rustlago'Cargo_cmd.read_manifest!⇒RustcargocmndRead_manifest,
* McshEngl.Rustlago'Cargo_cmd.read_manifest,

Cargo-cmd.run of Rustlago

description::
× Mcsh-creation: {2026-10-04}
* run: Run a binary or example of the local package

name::
* McshEngl.RustcargocmndRun,
* McshEngl.Rustcargocmnd.run!⇒RustcargocmndRun,
* McshEngl.Rustlago'Cargo_cmd.run!⇒RustcargocmndRun,
* McshEngl.Rustlago'Cargo_cmd.run,

Cargo-cmd.rustc of Rustlago

description::
× Mcsh-creation: {2026-10-04}
* rustc: Compile a package and all of its dependencies

name::
* McshEngl.RustcargocmndRustc,
* McshEngl.Rustcargocmnd.rustc!⇒RustcargocmndRustc,
* McshEngl.Rustlago'Cargo_cmd.rustc!⇒RustcargocmndRustc,
* McshEngl.Rustlago'Cargo_cmd.rustc,

Cargo-cmd.rustdoc of Rustlago

description::
× Mcsh-creation: {2026-10-04}
* rustdoc: Build a package's documentation, using specified custom flags,

name::
* McshEngl.RustcargocmndRustdoc,
* McshEngl.Rustcargocmnd.rustdoc!⇒RustcargocmndRustdoc,
* McshEngl.Rustlago'Cargo_cmd.rustdoc!⇒RustcargocmndRustdoc,
* McshEngl.Rustlago'Cargo_cmd.rustdoc,

Cargo-cmd.search of Rustlago

description::
× Mcsh-creation: {2026-10-04}
* search: Search packages in crates.io

name::
* McshEngl.RustcargocmndSearch,
* McshEngl.Rustcargocmnd.search!⇒RustcargocmndSearch,
* McshEngl.Rustlago'Cargo_cmd.search!⇒RustcargocmndSearch,
* McshEngl.Rustlago'Cargo_cmd.search,

Cargo-cmd.test of Rustlago

description::
× Mcsh-creation: {2026-10-04}
* test: Execute all unit and integration tests and build examples of a local package

name::
* McshEngl.RustcargocmndTest,
* McshEngl.Rustcargocmnd.test!⇒RustcargocmndTest,
* McshEngl.Rustlago'Cargo_cmd.test!⇒RustcargocmndTest,
* McshEngl.Rustlago'Cargo_cmd.test,

Cargo-cmd.uninstall of Rustlago

description::
× Mcsh-creation: {2026-10-04}
* uninstall: Remove a Rust binary

name::
* McshEngl.RustcargocmndUninstall,
* McshEngl.Rustcargocmnd.uninstall!⇒RustcargocmndUninstall,
* McshEngl.Rustlago'Cargo_cmd.uninstall!⇒RustcargocmndUninstall,
* McshEngl.Rustlago'Cargo_cmd.uninstall,

Cargo-cmd.update of Rustlago

description::
× Mcsh-creation: {2026-10-04}
* update: Update dependencies as recorded in the local lock file

name::
* McshEngl.RustcargocmndUpdate,
* McshEngl.Rustcargocmnd.update!⇒RustcargocmndUpdate,
* McshEngl.Rustlago'Cargo_cmd.update!⇒RustcargocmndUpdate,
* McshEngl.Rustlago'Cargo_cmd.update,

Cargo-cmd.verify-project of Rustlago

description::
× Mcsh-creation: {2026-10-04}
* verify-project: Check correctness of crate manifest

name::
* McshEngl.Cargo-cmd.verify-project-of-Rustlago!⇒RustcargocmndVerify_project,
* McshEngl.RustcargocmndVerify_project!=Cargo-cmd.verify-project-of-Rustlago,
* McshEngl.Rustcargocmnd.verify_project!⇒RustcargocmndVerify_project,
* McshEngl.Rustlago'Cargo_cmd.verify_project!⇒RustcargocmndVerify_project,
* McshEngl.Rustlago'Cargo_cmd.verify_project,

Cargo-cmd.version of Rustlago

description::
× Mcsh-creation: {2026-10-04}
* version: Show version information

name::
* McshEngl.RustcargocmndVersion,
* McshEngl.Rustcargocmnd.version!⇒RustcargocmndVersion,
* McshEngl.Rustlago'Cargo_cmd.version!⇒RustcargocmndVersion,
* McshEngl.Rustlago'Cargo_cmd.version,

Cargo-cmd.yank of Rustlago

description::
× Mcsh-creation: {2026-10-04}
* yank: Remove a pushed crate from the index

name::
* McshEngl.RustcargocmndYank,
* McshEngl.Rustcargocmnd.yank!⇒RustcargocmndYank,
* McshEngl.Rustlago'Cargo_cmd.yank!⇒RustcargocmndYank,
* McshEngl.Rustlago'Cargo_cmd.yank,

Cargo-cmd.clippy of Rustlago

description::
× Mcsh-creation: {2026-10-04}
* clippy:

name::
* McshEngl.RustcargocmndClippy,
* McshEngl.Rustcargocmnd.clippy!⇒RustcargocmndClippy,
* McshEngl.Rustlago'Cargo_cmd.clippy!⇒RustcargocmndClippy,
* McshEngl.Rustlago'Cargo_cmd.clippy,

Cargo-cmd.fmt of Rustlago

description::
× Mcsh-creation: {2026-10-04}
* fmt:

name::
* McshEngl.RustcargocmndFmt,
* McshEngl.Rustcargocmnd.fmt!⇒RustcargocmndFmt,
* McshEngl.Rustlago'Cargo_cmd.fmt!⇒RustcargocmndFmt,
* McshEngl.Rustlago'Cargo_cmd.fmt,

Cargo-cmd.miri of Rustlago

description::
× Mcsh-creation: {2026-10-04}
* miri:

name::
* McshEngl.RustcargocmndMiri,
* McshEngl.Rustcargocmnd.miri!⇒RustcargocmndMiri,
* McshEngl.Rustlago'Cargo_cmd.miri!⇒RustcargocmndMiri,
* McshEngl.Rustlago'Cargo_cmd.miri,

GENERIC-SPECIFIC-TREE of Rustcargocmnd

description::
× Mcsh-creation: {2026-10-04}

name::
* McshEngl.Rustcargocmnd'generic_specific_tree,

generic-tree::
* McshEngl.Rustcargocmnd:generic,
===
* ...entity:generic,

specific-tree::
* McshEngl.Rustcargocmnd.specific,
===
* bench!@McshTchInf000030#idLRustcrgcmdbench: Execute all benchmarks of a local package
* build!@McshTchInf000030#idLRustcrgcmdbuild: Compile a local package and all of its dependencies
* check!@McshTchInf000030#idLRustcrgcmdcheck: Check a local package and all of its dependencies for errors
* clean!@McshTchInf000030#idLRustcrgcmdclean: Remove artifacts that cargo has generated in the past
* clippy-preview!@McshTchInf000030#idLRustcrgcmdclippy: Checks a package to catch common mistakes and improve your Rust code,
* doc!@McshTchInf000030#idLRustcrgcmddoc: Build a package's documentation
* fetch!@McshTchInf000030#idLRustcrgcmdfetch: Fetch dependencies of a package from the network
* fix!@McshTchInf000030#idLRustcrgcmdfix: Automatically fix lint warnings reported by rustc
* generate-lockfile!@McshTchInf000030#idLRustcrgcmdgenerate: Generate the lockfile for a package
* git-checkout!@McshTchInf000030#idLRustcrgcmdgit: Checkout a copy of a Git repository
* init!@McshTchInf000030#idLRustcrgcmdinit: Create a new cargo package in an existing directory
* install!@McshTchInf000030#idLRustcrgcmdinstall: Install a Rust binary. Default location is $HOME/.cargo/bin
* locate-project!@McshTchInf000030#idLRustcrgcmdlocate: Print a JSON representation of a Cargo.toml file's location
* login!@McshTchInf000030#idLRustcrgcmdlogin: Save an api token from the registry locally. If token is not specified, it will be read from stdin,
* metadata!@McshTchInf000030#idLRustcrgcmdmetadata: Output the resolved dependencies of a package, the concrete used versions including overrides, in machine-readable format
* new!@McshTchInf000030#idLRustcrgcmdnew: create a new cargo-package at <path>
* owner!@McshTchInf000030#idLRustcrgcmdowner: Manage the owners of a crate on the registry
* package!@McshTchInf000030#idLRustcrgcmdpackage: Assemble the local package into a distributable tarball
* pkgid!@McshTchInf000030#idLRustcrgcmdpkgid: Print a fully qualified package specification
* publish!@McshTchInf000030#idLRustcrgcmdpublish: Upload a package to the registry
* read-manifest!@McshTchInf000030#idLRustcrgcmdread: Print a JSON representation of a Cargo.toml manifest,
* run!@McshTchInf000030#idLRustcrgcmdrun: Run a binary or example of the local package
* rustc!@McshTchInf000030#idLRustcrgcmdrustc: Compile a package and all of its dependencies
* rustdoc!@McshTchInf000030#idLRustcrgcmdrustdoc: Build a package's documentation, using specified custom flags,
* search!@McshTchInf000030#idLRustcrgcmdsearch: Search packages in crates.io
* test!@McshTchInf000030#idLRustcrgcmdtest: Execute all unit and integration tests and build examples of a local package
* uninstall!@McshTchInf000030#idLRustcrgcmduninstall: Remove a Rust binary
* update!@McshTchInf000030#idLRustcrgcmdupdate: Update dependencies as recorded in the local lock file
* verify-project!@McshTchInf000030#idLRustcrgcmdverify: Check correctness of crate manifest
* version!@McshTchInf000030#idLRustcrgcmdversion: Show version information
* yank!@McshTchInf000030#idLRustcrgcmdyank: Remove a pushed crate from the index
* clippy!@McshTchInf000030#idLRustcrgcmdclippy:
* fmt!@McshTchInf000030#idLRustcrgcmdfmt:
* miri!@McshTchInf000030#idLRustcrgcmdmiri:

info-resource of Cargo

description::
× Mcsh-creation: {2026-10-04}
* https://doc.rust-lang.org/cargo/,
* https://doc.rust-lang.org/cargo/guide/,

name::
* McshEngl.Cargo'info_resource,
* McshEngl.Rustcargo'info_resource,

rustup of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· rustup doc opens local documentation in your browser.

name::
* McshEngl.Rustlago'rustup,
* McshEngl.Rusttool.rustup,
* McshEngl.Rusttool'rustup,

GENERIC-SPECIFIC-TREE of Rusttool

description::
× Mcsh-creation: {2026-10-04}

name::
* McshEngl.Rusttool'generic_specific_tree,

generic-tree::
* McshEngl.Rusttool:generic,
===
* ...entity:generic,

specific-tree::
* McshEngl.Rusttool.specific,
===
* rustc,
* cargo,
===
* https://play.rust-lang.org/,

DOING of Rustlago

description::
× Mcsh-creation: {2026-10-04}

name::
* McshEngl.doing-of-Rustlago!⇒Rustdoing,
* McshEngl.Rustdoing!=doing-of-Rustlago,
* McshEngl.Rustlago'doing!⇒Rustdoing,

main-functing of Rustlago

description::
× Mcsh-creation: {2026-10-04}
"Hundreds of companies, large and small, use Rust in production for a variety of tasks. Those tasks include command line tools, web services, DevOps tooling, embedded devices, audio and video analysis and transcoding, cryptocurrencies, bioinformatics, search engines, Internet of Things applications, machine learning, and even major parts of the Firefox web browser."
[https://doc.rust-lang.org/book/ch00-00-introduction.html#companies]

name::
* McshEngl.Rustlago_main_functing,
* McshEngl.Rustlago'main_functing!⇒Rustlago_main_functing,
* McshEngl.Rustlago'doing'main_functing!⇒Rustlago_main_functing,

updating of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· $ rustup update

name::
* McshEngl.Rustlago_updating,
* McshEngl.Rustlago'updating!⇒Rustlago_updating,
* McshEngl.Rustlago'doing'updating!⇒Rustlago_updating,

uninstalling of Rustlago

description::
× Mcsh-creation: {2026-10-04}
· $ rustup self uninstall

name::
* McshEngl.Rustlago_unistalling,
* McshEngl.Rustlago'unistalling!⇒Rustlago_unistalling,
* McshEngl.Rustlago'doing'uninstalling!⇒Rustlago_unistalling,
* McshEngl.Rustlago'uninstalling!⇒Rustlago_unistalling,

GENERIC-SPECIFIC-TREE of Rustdoing

description::
× Mcsh-creation: {2026-10-04}

name::
* McshEngl.Rustdoing'generic_specific_tree,

generic-tree::
* McshEngl.Rustdoing:generic,
===
* ...entity:generic,

specific-tree::
* McshEngl.Rustdoing.specific,
===
* main-functing,
* installing,
* updating,
* uninstalling,

evoluting of Rustlago

description::
× Mcsh-creation: {2026-10-04}
"evolution of rust-language:
draft2
The Rust programming language was created by Graydon Hoare in 2006 as a personal project, but it didn't gain widespread attention until Mozilla sponsored the project in 2009. The first stable version of Rust, 1.0, was released in 2015. Since then, the language has quickly gained popularity, becoming one of the most loved and respected programming languages in the world.

There are many reasons for Rust's popularity, including its safety, performance, and expressiveness. Rust is a memory-safe language, which means that it is very difficult to write code that can cause memory leaks or other memory-related errors. This is because Rust uses a unique ownership system that tracks who owns each piece of data. Rust is also a very performant language, comparable to C and C++, but without the risk of memory-related errors. Rust is also a very expressive language, allowing developers to write concise, readable, and idiomatic code.

Rust has been adopted by many large companies, including Amazon, Google, and Microsoft, and is used in a wide variety of applications, including web development, systems programming, and game development. The language is still under development, but it has a strong community of contributors and is constantly evolving.

Here are some of the key milestones in the evolution of the Rust programming language:
* **2006:** Graydon Hoare begins working on Rust as a personal project.
* **2009:** Mozilla sponsors the Rust project.
* **2010:** The first public release of Rust is made.
* **2015:** The first stable release of Rust, 1.0, is released.
* **2016:** Rust is ranked the 20th most popular language in the Stack Overflow Developer Survey.
* **2017:** Rust is ranked the 16th most popular language in the Stack Overflow Developer Survey.
* **2018:** Rust is ranked the 11th most popular language in the Stack Overflow Developer Survey.
* **2019:** Rust is ranked the 10th most popular language in the Stack Overflow Developer Survey.
* **2020:** Rust is ranked the 8th most popular language in the Stack Overflow Developer Survey.
* **2021:** Rust is ranked the 6th most popular language in the Stack Overflow Developer Survey.
* **2022:** Rust is ranked the 4th most popular language in the Stack Overflow Developer Survey.
* **2023:** Rust is ranked the 3rd most popular language in the Stack Overflow Developer Survey.

Rust is a rapidly evolving language with a bright future. It is a safe, performant, and expressive language that is well-suited for a wide variety of applications. As the language continues to mature and grow, it is likely to become even more popular and widely adopted."
[{2023-11-05 retrieved} https://bard.google.com/chat/b8d63d2a20b82270?hl=en&pli=1]

name::
* McshEngl.evoluting-of-Rustlago!⇒Rustevolg,
* McshEngl.Rustevolg!=evoluting-of-Rustlago,
* McshEngl.Rustlago'evoluting!⇒Rustevolg,

release of Rustlago

description::
× Mcsh-creation: {2026-10-04}
"The Rust language and compiler have a six-week release cycle, meaning users get a constant stream of new features. Other programming languages release larger changes less often; Rust releases smaller updates more frequently. After a while, all of these tiny changes add up. But from release to release, it can be difficult to look back and say, “Wow, between Rust 1.10 and Rust 1.31, Rust has changed a lot!”"
[https://doc.rust-lang.org/book/appendix-05-editions.html]

name::
* McshEngl.Rustlago'release,

edition of Rustlago

description::
× Mcsh-creation: {2026-10-04}
"Every two or three years, the Rust team produces a new Rust edition. Each edition brings together the features that have landed into a clear package with fully updated documentation and tooling. New editions ship as part of the usual six-week release process.
Editions serve different purposes for different people:
- For active Rust users, a new edition brings together incremental changes into an easy-to-understand package.
- For non-users, a new edition signals that some major advancements have landed, which might make Rust worth another look.
- For those developing Rust, a new edition provides a rallying point for the project as a whole.
At the time of this writing, two Rust editions are available: Rust 2015 and Rust 2018. This book is written using Rust 2018 edition idioms.
The edition key in Cargo.toml indicates which edition the compiler should use for your code. If the key doesn’t exist, Rust uses 2015 as the edition value for backward compatibility reasons."
[https://doc.rust-lang.org/book/appendix-05-editions.html]

name::
* McshEngl.Rustlago'edition,

GENERIC-SPECIFIC-TREE of Rustlago

description::
× Mcsh-creation: {2026-10-04}

name::
* McshEngl.Rustlago'generic_specific_tree,

generic-tree::
* McshEngl.Rustlago:generic,
===
* compiled--programing-language!@McshTchInf000006#idLSrcdCmpd,
* statically-typed-language!@McshTchInf000006#idLSrcdStctp,
* Pgmglago:generic,
* Hmanlago:generic,
* ...entity:generic,

specific-tree::
* McshEngl.Rustlago.specific,
===

meta-info

this webpage was-visited times since {2019-06-29}

page-wholepath:: synagonism.net / worldviewSngu / dirTchInf / Rustlago

SEARCH::
· this page uses 'locator-names', names that when you find them, you find the-LOCATION of the-concept they denote.
⊛ GLOBAL-SEARCH:
· clicking on the-green-BAR of a-page you have access to the-global--locator-names of my-site.
· use the-prefix 'Rustlago' for structured-concepts related to current concept 'Rust-language'.
⊛ LOCAL-SEARCH:
· TYPE CTRL+F "CTRL+F "McshLag4.words-of-con", to go to the-LOCATION of the-concept.
· a-preview of the-description of a-global-name makes reading fast.

footer::
• author: Kaseluris.Nikos.1959
• email:
 mail
• twitter: @synagonism

webpage-versions::
• version.last.dynamic: ../../dirMcsh/dirTchInf/McshTchInf000030.last.html,
• version.previous: ../../dirMcs/dirTchInf/McsTchInf000030.last.html,
• version.1-0-0.2021-04-10: (0-20) ../../dirMiwMcs/dirTchInf/filMcsLagRust.1-0-0.2021-04-10.html,
• version.0-1-0.2019-06-29 draft creation,

support (link)