Rust-language senso-concept-Mcs
(Rust_lago)

overview of Rust_lago

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!⇒Rust_lago,
* McshEngl.Rust_lago!=Rust-language,
* McshEngl.Rust_lago!@McshTchInf000030,
* McshEngl.McshTchInf000030.last.html//dirTchInf//dirMcsh!⇒Rust_lago,
* McshEngl.dirTchInf/McshTchInf000030.last.html!⇒Rust_lago,
* McshEngl.lagoRust!⇒Rust_lago,
* McshEngl.Lrst!⇒Rust_lago,
* McshEngl.Rustlag!⇒Rust_lago,

archetype (input) of Rust_lago

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

name::
* McshEngl.Rust_lago'archetype,

generic-tree::
* McshEngl.Rust_lago'archetype_Gntr,
===
* archetype-of--source-language,

algo (output) of Rust_lago

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

name::
* McshEngl.Rust_lago_algo,
* McshEngl.Rustalgo!⇒Rust_lago_algo,
* McshEngl.Rust_lago'algorithm!⇒Rust_lago_algo,
* McshEngl.Rust_lago'source-doc!⇒Rust_lago_algo,

encoding of Rust_lago_algo

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

name::
* McshEngl.Rust_lago'source-encoding,
* McshEngl.Rustalgo'encoding,
* McshEngl.Rust_lago_algo'encoding,

machine of Rust_lago_algo

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

name::
* McshEngl.Rust_lago_machine,
* McshEngl.Rust_lago-machine!⇒Rust_lago_machine,
* McshEngl.Rustalgo'machine!⇒Rust_lago_machine,
* McshEngl.Rust_lago_algo'machine!⇒Rust_lago_machine,

heap of machine-memory of Rust_lago_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.Rust_lago-heap,
* McshEngl.Rust_lago-machine'heap,
* McshEngl.Rust_lago_machine'heap,

stack of machine-memory of Rust_lago_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.Rust_lago-machine'stack,
* McshEngl.Rust_lago-stack,
* McshEngl.Rust_lago_machine'stack,

source-code of Rust_lago_algo

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

name::
* McshEngl.Rust_lago'source-code,
* McshEngl.Rustalgo'code,
* McshEngl.Rust_lago_algo'source-code,

codomain of Rust_lago_algo

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

name::
* McshEngl.Rust_lago'codomain,
* McshEngl.Rustalgo'codomain,
* McshEngl.Rust_lago_algo'codomain,

syntax-tree of Rust_lago_algo

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

name::
* McshEngl.Rust_lago'source-syntax-tree,
* McshEngl.Rustalgo'syntax-tree,
* McshEngl.Rust_lago_algo'syntax-tree,

file of Rust_lago_algo

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

name::
* McshEngl.Rust_lago'source-file,
* McshEngl.Rustalgo'file,
* McshEngl.Rust_lago_algo'file,

file.rs

file.Cargo.toml

algo'node of Rust_lago

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

name::
* McshEngl.Rust_lago_node,
* McshEngl.Rustnode!⇒Rust_lago_node,
* McshEngl.Rust_lago'source-node!⇒Rust_lago_node,
* McshEngl.Rustalgo'node!⇒Rust_lago_node,
* McshEngl.Rustalgo'structure!⇒Rust_lago_node,
* McshEngl.Rust_lago'algo'node!⇒Rust_lago_node,

scope of node of Rust_lago_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.Rust_lago'scope,
* McshEngl.Rustnode'scope,
* McshEngl.Rust_lago_node'scope,

GENERIC-SPECIFIC-TREE of Rust_lago_node

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

name::
* McshEngl.Rust_lago_node'generic-specific-tree,
* McshEngl.Rust_lago_node'specific-generic-tree,

generic-tree::
* McshEngl.Rust_lago_node_Gntr,
===
* Srcd_lago_node_Gntr,
* ... entity_Gntr,

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

node.named of algo of Rust_lago

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

name::
* McshEngl.Rust_lago'named-node,
* McshEngl.Rustnode.named,

node.namedNo of algo of Rust_lago

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

name::
* McshEngl.Rust_lago'namedNo-node,
* McshEngl.Rustnode.namedNo,

algo'unit of Rust_lago

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

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

generic-tree::
* McshEngl.Rustalgo'unit_Gntr,
===
* unit-of--source-language,

algo'word of Rust_lago

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

name::
* McshEngl.Rust_lago_word,
* McshEngl.Rust_lago-word!⇒Rust_lago_word,
* McshEngl.Rustalgo'word!⇒Rust_lago_word,
* McshEngl.Rust_lago'algo'word!⇒Rust_lago_word,

GENERIC-SPECIFIC-TREE of Rust_lago_word

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

name::
* McshEngl.Rust_lago_word'generic-specific-tree,
* McshEngl.Rust_lago_word'specific-generic-tree,

generic-tree::
* McshEngl.Rust_lago_word_Gntr,
===
* Srcdalgowork_Gntr,
* ... entity_Gntr,

specific-tree::
* McshEngl.Rust_lago_word.specific,
* McshEngl.Rust_lago_word_Sptr,
===
* identifier,
* keyword!@McshTchInf000030#idLRustkwd,

word.identifier of Rust_lago

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

name::
* McshEngl.Rust_lago_identifier,
* McshEngl.Rust_lago-identifier!⇒Rust_lago_identifier,
* McshEngl.Rust_lago'identifier!⇒Rust_lago_identifier,
* McshEngl.Rust_lago-word.identifier!⇒Rust_lago_identifier,
* McshEngl.Rust_lago'word.identifier!⇒Rust_lago_identifier,

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

word.keyword of Rust_lago

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

name::
* McshEngl.Rust_lago_keyword,
* McshEngl.Rust_lago-keyword!⇒Rust_lago_keyword,
* McshEngl.Rust_lago'keyword!⇒Rust_lago_keyword,
* McshEngl.Rust_lago-word.keyword!⇒Rust_lago_keyword,
* McshEngl.Rust_lago'word.keyword!⇒Rust_lago_keyword,

GENERIC-SPECIFIC-TREE of Rust_lago_keyword

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

name::
* McshEngl.Rust_lago_keyword'generic-specific-tree,
* McshEngl.Rust_lago_keyword'specific-generic-tree,

generic-tree::
* McshEngl.Rust_lago_keyword_Gntr,
===
* Srcd_lago-keyword!@McshTchInf000006#idLSrcdwrdRsvd,
* Rust_lago_word_Gntr,
* ... entity_Gntr,

specific-tree::
* McshEngl.Rust_lago_keyword.specific,
* McshEngl.Rust_lago_keyword_Sptr,
===
* reserved-keyword--of-Rust_lago,
* used-keyword--of-Rust_lago,

keyword.used of Rust_lago

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

name::
* McshEngl.Rust_lago_used_keyword,
* McshEngl.Rust_lago-used-keyword!⇒Rust_lago_used_keyword,
* McshEngl.Rust_lago'used-keyword!⇒Rust_lago_used_keyword,
* McshEngl.Rust_lago-keyword.used!⇒Rust_lago_used_keyword,
* McshEngl.Rust_lago'keyword.used!⇒Rust_lago_used_keyword,

used-keyword.as of Rust_lago

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.Rust_lago'as--used-keyword,
* McshEngl.Rust_lago-used-keyword.as,
* McshEngl.Rust_lago'used-keyword.as,

used-keyword.break of Rust_lago

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

name::
* McshEngl.Rust_lago'break--used-keyword,
* McshEngl.Rust_lago-used-keyword.break,
* McshEngl.Rust_lago'used-keyword.break,

used-keyword.const of Rust_lago

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.Rust_lago'const--used-keyword,
* McshEngl.Rust_lago-used-keyword.const,
* McshEngl.Rust_lago'used-keyword.const,

used-keyword.continue of Rust_lago

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.Rust_lago'continue--used-keyword,
* McshEngl.Rust_lago-used-keyword.continue,
* McshEngl.Rust_lago'used-keyword.continue,

used-keyword.crate of Rust_lago

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.Rust_lago'crate--used-keyword,
* McshEngl.Rust_lago-used-keyword.crate,
* McshEngl.Rust_lago'used-keyword.crate,

used-keyword.dyn of Rust_lago

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.Rust_lago'dyn--used-keyword,
* McshEngl.Rust_lago-used-keyword.dyn,
* McshEngl.Rust_lago'used-keyword.dyn,

used-keyword.else of Rust_lago

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.Rust_lago'else--used-keyword,
* McshEngl.Rust_lago-used-keyword.else,
* McshEngl.Rust_lago'used-keyword.else,

used-keyword.enum of Rust_lago

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

name::
* McshEngl.Rust_lago'enum--used-keyword,
* McshEngl.Rust_lago-used-keyword.enum,
* McshEngl.Rust_lago'used-keyword.enum,

used-keyword.extern of Rust_lago

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.Rust_lago'extern--used-keyword,
* McshEngl.Rust_lago-used-keyword.extern,
* McshEngl.Rust_lago'used-keyword.extern,

used-keyword.false of Rust_lago

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

name::
* McshEngl.Rust_lago'false--used-keyword,
* McshEngl.Rust_lago-used-keyword.false,
* McshEngl.Rust_lago'used-keyword.false,

used-keyword.fn of Rust_lago

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.Rust_lago'fn--used-keyword,
* McshEngl.Rust_lago-used-keyword.fn,
* McshEngl.Rust_lago'used-keyword.fn,

used-keyword.for of Rust_lago

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.Rust_lago'for--used-keyword,
* McshEngl.Rust_lago-used-keyword.for,
* McshEngl.Rust_lago'used-keyword.for,

used-keyword.if of Rust_lago

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.Rust_lago'if--used-keyword,
* McshEngl.Rust_lago-used-keyword.if,
* McshEngl.Rust_lago'used-keyword.if,

used-keyword.impl of Rust_lago

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

name::
* McshEngl.Rust_lago'impl--used-keyword,
* McshEngl.Rust_lago-used-keyword.impl,
* McshEngl.Rust_lago'used-keyword.impl,

used-keyword.in of Rust_lago

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

name::
* McshEngl.Rust_lago'in--used-keyword,
* McshEngl.Rust_lago-used-keyword.in,
* McshEngl.Rust_lago'used-keyword.in,

used-keyword.let of Rust_lago

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

name::
* McshEngl.Rust_lago'let--used-keyword,
* McshEngl.Rust_lago-used-keyword.let,
* McshEngl.Rust_lago'used-keyword.let,

used-keyword.loop of Rust_lago

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

name::
* McshEngl.Rust_lago'loop--used-keyword,
* McshEngl.Rust_lago-used-keyword.loop,
* McshEngl.Rust_lago'used-keyword.loop,

used-keyword.match of Rust_lago

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

name::
* McshEngl.Rust_lago'match--used-keyword,
* McshEngl.Rust_lago-used-keyword.match,
* McshEngl.Rust_lago'used-keyword.match,

used-keyword.mod of Rust_lago

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

name::
* McshEngl.Rust_lago'mod--used-keyword,
* McshEngl.Rust_lago-used-keyword.mod,
* McshEngl.Rust_lago'used-keyword.mod,

used-keyword.move of Rust_lago

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.Rust_lago'move--used-keyword,
* McshEngl.Rust_lago-used-keyword.move,
* McshEngl.Rust_lago'used-keyword.move,

used-keyword.mut of Rust_lago

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.Rust_lago'mut--used-keyword,
* McshEngl.Rust_lago-used-keyword.mut,
* McshEngl.Rust_lago'used-keyword.mut,

used-keyword.pub of Rust_lago

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.Rust_lago'pub--used-keyword,
* McshEngl.Rust_lago-used-keyword.pub,
* McshEngl.Rust_lago'used-keyword.pub,

used-keyword.ref of Rust_lago

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

name::
* McshEngl.Rust_lago'ref--used-keyword,
* McshEngl.Rust_lago-used-keyword.ref,
* McshEngl.Rust_lago'used-keyword.ref,

used-keyword.return of Rust_lago

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

name::
* McshEngl.Rust_lago'return--used-keyword,
* McshEngl.Rust_lago-used-keyword.return,
* McshEngl.Rust_lago'used-keyword.return,

used-keyword.Self of Rust_lago

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.Rust_lago'Self--used-keyword,
* McshEngl.Rust_lago-used-keyword.Self,
* McshEngl.Rust_lago'used-keyword.Self,

used-keyword.self of Rust_lago

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

name::
* McshEngl.Rust_lago'self--used-keyword,
* McshEngl.Rust_lago-used-keyword.self,
* McshEngl.Rust_lago'used-keyword.self,

used-keyword.static of Rust_lago

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.Rust_lago'static--used-keyword,
* McshEngl.Rust_lago-used-keyword.static,
* McshEngl.Rust_lago'used-keyword.static,

used-keyword.struct of Rust_lago

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

name::
* McshEngl.Rust_lago'struct--used-keyword,
* McshEngl.Rust_lago-used-keyword.struct,
* McshEngl.Rust_lago'used-keyword.struct,

used-keyword.super of Rust_lago

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.Rust_lago'super--used-keyword,
* McshEngl.Rust_lago-used-keyword.super,
* McshEngl.Rust_lago'used-keyword.super,

used-keyword.trait of Rust_lago

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

name::
* McshEngl.Rust_lago'trait--used-keyword,
* McshEngl.Rust_lago-used-keyword.trait,
* McshEngl.Rust_lago'used-keyword.trait,

used-keyword.true of Rust_lago

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

name::
* McshEngl.Rust_lago'true--used-keyword,
* McshEngl.Rust_lago-used-keyword.true,
* McshEngl.Rust_lago'used-keyword.true,

used-keyword.type of Rust_lago

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.Rust_lago'type--used-keyword,
* McshEngl.Rust_lago-used-keyword.type,
* McshEngl.Rust_lago'used-keyword.type,

used-keyword.unsafe of Rust_lago

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.Rust_lago'unsafe--used-keyword,
* McshEngl.Rust_lago-used-keyword.unsafe,
* McshEngl.Rust_lago'used-keyword.unsafe,

used-keyword.use of Rust_lago

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

name::
* McshEngl.Rust_lago'use--used-keyword,
* McshEngl.Rust_lago-used-keyword.use,
* McshEngl.Rust_lago'used-keyword.use,

used-keyword.where of Rust_lago

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.Rust_lago'where--used-keyword,
* McshEngl.Rust_lago-used-keyword.where,
* McshEngl.Rust_lago'used-keyword.where,

used-keyword.while of Rust_lago

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.Rust_lago'while--used-keyword,
* McshEngl.Rust_lago-used-keyword.while,
* McshEngl.Rust_lago'used-keyword.while,

keyword.usedNo of Rust_lago

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

name::
* McshEngl.Rust_lago_usedNo_keyword,
* McshEngl.Rust_lago-usedNo-keyword!⇒Rust_lago_usedNo_keyword,
* McshEngl.Rust_lago'reserved-keyword!⇒Rust_lago_usedNo_keyword,
* McshEngl.Rust_lago-keyword.reserved!⇒Rust_lago_usedNo_keyword,
* McshEngl.Rust_lago'keyword.usedNo!⇒Rust_lago_usedNo_keyword,

usedNo-keyword.abstract of Rust_lago

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

name::
* McshEngl.Rust_lago'abstract--usedNo-keyword,
* McshEngl.Rust_lago-usedNo-keyword.abstract,
* McshEngl.Rust_lago'usedNo-keyword.abstract,

usedNo-keyword.async of Rust_lago

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

name::
* McshEngl.Rust_lago'async--usedNo-keyword,
* McshEngl.Rust_lago-usedNo-keyword.async,
* McshEngl.Rust_lago'usedNo-keyword.async,

usedNo-keyword.become of Rust_lago

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

name::
* McshEngl.Rust_lago'become--usedNo-keyword,
* McshEngl.Rust_lago-usedNo-keyword.become,
* McshEngl.Rust_lago'usedNo-keyword.become,

usedNo-keyword.box of Rust_lago

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

name::
* McshEngl.Rust_lago'box--usedNo-keyword,
* McshEngl.Rust_lago-usedNo-keyword.box,
* McshEngl.Rust_lago'usedNo-keyword.box,

usedNo-keyword.do of Rust_lago

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

name::
* McshEngl.Rust_lago'do--usedNo-keyword,
* McshEngl.Rust_lago-usedNo-keyword.do,
* McshEngl.Rust_lago'usedNo-keyword.do,

usedNo-keyword.final of Rust_lago

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

name::
* McshEngl.Rust_lago'final--usedNo-keyword,
* McshEngl.Rust_lago-usedNo-keyword.final,
* McshEngl.Rust_lago'usedNo-keyword.final,

usedNo-keyword.macro of Rust_lago

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

name::
* McshEngl.Rust_lago'macro--usedNo-keyword,
* McshEngl.Rust_lago-usedNo-keyword.macro,
* McshEngl.Rust_lago'usedNo-keyword.macro,

usedNo-keyword.override of Rust_lago

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

name::
* McshEngl.Rust_lago'override--usedNo-keyword,
* McshEngl.Rust_lago-usedNo-keyword.override,
* McshEngl.Rust_lago'usedNo-keyword.override,

usedNo-keyword.priv of Rust_lago

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

name::
* McshEngl.Rust_lago'priv--usedNo-keyword,
* McshEngl.Rust_lago-usedNo-keyword.priv,
* McshEngl.Rust_lago'usedNo-keyword.priv,

usedNo-keyword.try of Rust_lago

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

name::
* McshEngl.Rust_lago'try--usedNo-keyword,
* McshEngl.Rust_lago-usedNo-keyword.try,
* McshEngl.Rust_lago'usedNo-keyword.try,

usedNo-keyword.typeof of Rust_lago

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

name::
* McshEngl.Rust_lago'typeof--usedNo-keyword,
* McshEngl.Rust_lago-usedNo-keyword.typeof,
* McshEngl.Rust_lago'usedNo-keyword.typeof,

usedNo-keyword.unsized of Rust_lago

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

name::
* McshEngl.Rust_lago'unsized--usedNo-keyword,
* McshEngl.Rust_lago-usedNo-keyword.unsized,
* McshEngl.Rust_lago'usedNo-keyword.unsized,

usedNo-keyword.virtual of Rust_lago

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

name::
* McshEngl.Rust_lago'virtual--usedNo-keyword,
* McshEngl.Rust_lago-usedNo-keyword.virtual,
* McshEngl.Rust_lago'usedNo-keyword.virtual,

usedNo-keyword.yield of Rust_lago

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

name::
* McshEngl.Rust_lago'yield--usedNo-keyword,
* McshEngl.Rust_lago-usedNo-keyword.yield,
* McshEngl.Rust_lago'usedNo-keyword.yield,

algo'semantic-unit of Rust_lago

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

name::
* McshEngl.Rustsunt,
* McshEngl.Rust_lago'semantic-unit!⇒Rustsunt,
* McshEngl.Rustalgo'semantic-unit!⇒Rustsunt,
* McshEngl.Rust_lago'algo'semantic-unit!⇒Rustsunt,

GENERIC-SPECIFIC-TREE of Rustsunt

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

name::
* McshEngl.Rustsunt'generic-specific-tree,
* McshEngl.Rustsunt'specific-generic-tree,

generic-tree::
* McshEngl.Rustsunt_Gntr,
===
* Srcd_lago_Sunt_Gntr,
* ... entity_Gntr,

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

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,

Sunt.character (ch) of Rust_lago

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.Rust_lago_ch,
* McshEngl.Rust_lago-ch!⇒Rust_lago_ch,
* McshEngl.Rust_lago'character!⇒Rust_lago_ch,
* McshEngl.Rustsunt.character!⇒Rust_lago_ch,

generic-tree::
* McshEngl.Rust_lago_ch_Gntr,
===
* Srcd_lago_ch_Gntr,
* ... entity_Gntr,

Sunt.string (s) of Rust_lago

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

name::
* McshEngl.Rust_lago_s,
* McshEngl.Rust_lago-s!⇒Rust_lago_s,
* McshEngl.Rust_lago'string!⇒Rust_lago_s,
* McshEngl.Rustsunt.string!⇒Rust_lago_s,

string.literal of Rust_lago

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.Rust_lago'literal-string,
* McshEngl.Rust_lago-literal.string,
* McshEngl.Rust_lago-s.literal,
* McshEngl.Rust_lago'string.literal,

string.String-type of Rust_lago (link)

Sunt.boolean (b) of Rust_lago

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

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

Sunt.number (n) of Rust_lago

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

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

GENERIC-SPECIFIC-TREE of Rustn

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

name::
* McshEngl.Rustn'generic-specific-tree,
* McshEngl.Rustn'specific-generic-tree,

generic-tree::
* McshEngl.Rustn_Gntr,
===
* ... entity_Gntr,

specific-tree::
* McshEngl.Rustn.specific,
* McshEngl.Rustn_Sptr,
===
* 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.Rust_lago_ni,
* McshEngl.Rustni!⇒Rust_lago_ni,
* McshEngl.Rustn.integer!⇒Rust_lago_ni,

GENERIC-SPECIFIC-TREE of Rust_lago_ni

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

name::
* McshEngl.Rust_lago_ni'generic-specific-tree,
* McshEngl.Rust_lago_ni'specific-generic-tree,

generic-tree::
* McshEngl.Rust_lago_ni_Gntr,
===
* ... entity_Gntr,

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

Rustni.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.Rust_lago-literal.ni,
* McshEngl.Rustni.literal,
* McshEngl.Rust_lago_ni.literal,

Rustni.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.Rustni.signed,
* McshEngl.Rust_lago_ni.signed!⇒Rustni.signed,

Rustni.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.Rust_lago_ni.signedNo,

Rustni.i8

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

name::
* McshEngl.Rust_lago'i8,
* McshEngl.Rustsunt.i8,
* McshEngl.Rustni.i8,
* McshEngl.Rust_lago_ni.i8,

Rustni.i16

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

name::
* McshEngl.Rust_lago'i16,
* McshEngl.Rustsunt.i16,
* McshEngl.Rustni.i16,
* McshEngl.Rust_lago_ni.i16,

Rustni.i32

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

name::
* McshEngl.Rust_lago'i32,
* McshEngl.Rustsunt.i32,
* McshEngl.Rustni.i32,
* McshEngl.Rust_lago_ni.i32,

Rustni.i64

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

name::
* McshEngl.Rust_lago'i64,
* McshEngl.Rustsunt.i64,
* McshEngl.Rustni.i64,
* McshEngl.Rust_lago_ni.i64,

Rustni.i128

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

name::
* McshEngl.Rust_lago'i128,
* McshEngl.Rustsunt.i128,
* McshEngl.Rustni.i128,
* McshEngl.Rust_lago_ni.i128,

Rustni.isize

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

name::
* McshEngl.Rust_lago'isize,
* McshEngl.Rustsunt.isize,
* McshEngl.Rustni.isize,
* McshEngl.Rust_lago_ni.isize,

Rustni.u8

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

name::
* McshEngl.Rust_lago'u8,
* McshEngl.Rustsunt.u8,
* McshEngl.Rustni.u8,
* McshEngl.Rust_lago_ni.u8,

Rustni.u16

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

name::
* McshEngl.Rust_lago'u16,
* McshEngl.Rustsunt.u16,
* McshEngl.Rustni.u16,
* McshEngl.Rust_lago_ni.u16,

Rustni.u32

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

name::
* McshEngl.Rust_lago'u32,
* McshEngl.Rustsunt.u32,
* McshEngl.Rustni.u32,
* McshEngl.Rust_lago_ni.u32,

Rustni.u64

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

name::
* McshEngl.Rust_lago'u64,
* McshEngl.Rustsunt.u64,
* McshEngl.Rustni.u64,
* McshEngl.Rust_lago_ni.u64,

Rustni.u128

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

name::
* McshEngl.Rust_lago'u128,
* McshEngl.Rustsunt.u128,
* McshEngl.Rustni.u128,
* McshEngl.Rust_lago_ni.u128,

Rustni.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.Rust_lago'usize,
* McshEngl.Rustsunt.usize,
* McshEngl.Rustni.usize,
* McshEngl.Rust_lago_ni.usize,

Rustn.floating-point

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

name::
* McshEngl.Rust_lago_nf,
* McshEngl.Rustnf!⇒Rust_lago_nf,
* McshEngl.Rustn.decimal!⇒Rust_lago_nf,
* McshEngl.Rustn.floating-point!⇒Rust_lago_nf,
* McshEngl.Rustn.integerNo!⇒Rust_lago_nf,

GENERIC-SPECIFIC-TREE of Rust_lago_nf

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

name::
* McshEngl.Rust_lago_nf'generic-specific-tree,
* McshEngl.Rust_lago_nf'specific-generic-tree,

generic-tree::
* McshEngl.Rust_lago_nf_Gntr,
===
* ... entity_Gntr,

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

Rustnf.f32

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

name::
* McshEngl.Rust_lago'f32,
* McshEngl.Rustsunt.f32,
* McshEngl.Rustnf.f32,
* McshEngl.Rust_lago_nf.f32,

Rustnf.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.Rust_lago'f64,
* McshEngl.Rustsunt.f64,
* McshEngl.Rustnf.f64,
* McshEngl.Rust_lago_nf.f64,

Sunt.function (f) of Rust_lago

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

name::
* McshEngl.Rust_lago_f,
* McshEngl.Rust_lago-f!⇒Rust_lago_f,
* McshEngl.Rust_lago'function!⇒Rust_lago_f,
* McshEngl.Rustsunt.function!⇒Rust_lago_f,

GENERIC-SPECIFIC-TREE of Rust_lago_f

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

name::
* McshEngl.Rust_lago_f'generic-specific-tree,
* McshEngl.Rust_lago_f'specific-generic-tree,

generic-tree::
* McshEngl.Rust_lago_f_Gntr,
===
* Rustsunt_Gntr,
* source-function--of-Srcd_lago,
* ... entity_Gntr,

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

Rust_lago.operator

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

name::
* McshEngl.Rust_lago_opr,
* McshEngl.Rust_lago-opr!⇒Rust_lago_opr,
* McshEngl.Rust_lago'operator!⇒Rust_lago_opr,
* McshEngl.Rustsunt.operator!⇒Rust_lago_opr,
* McshEngl.Rust_lago_f.operator!⇒Rust_lago_opr,

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

overloading of opr of Rust_lago

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.Rust_lago-opr'overloading,
* McshEngl.Rust_lago_opr'overloading!⇒Rust_lago-opr'overloading,

GENERIC-SPECIFIC-TREE of Rust_lago_opr

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

name::
* McshEngl.Rust_lago_opr'generic-specific-tree,
* McshEngl.Rust_lago_opr'specific-generic-tree,

generic-tree::
* McshEngl.Rust_lago_opr_Gntr,
===
* Srcd_lago_opr_Gntr,
* ... entity_Gntr,

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

opr.!33 of Rust_lago

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.Rust_lago'!33--opr,
* McshEngl.Rust_lago-opr.!33,
* McshEngl.Rust_lago'opr.!33,

opr.!=3361 of Rust_lago

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

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

opr.%37 of Rust_lago

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

name::
* McshEngl.Rust_lago'%37--opr,
* McshEngl.Rust_lago-opr.%37,
* McshEngl.Rust_lago'opr.%37,

opr.%=3761 of Rust_lago

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.Rust_lago'%=3761--opr,
* McshEngl.Rust_lago-opr.%=3761,
* McshEngl.Rust_lago'opr.%=3761,

opr.&38 of Rust_lago

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.Rust_lago'&38--opr,
* McshEngl.Rust_lago-opr.&38,
* McshEngl.Rust_lago'opr.&38,

opr.&=3861 of Rust_lago

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.Rust_lago'&=3861--opr,
* McshEngl.Rust_lago-opr.&=3861,
* McshEngl.Rust_lago'opr.&=3861,

opr.&&3838 of Rust_lago

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

name::
* McshEngl.Rust_lago'&&3838--opr,
* McshEngl.Rust_lago-opr.&&3838,
* McshEngl.Rust_lago'opr.&&3838,

opr.*42 of Rust_lago

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.Rust_lago'*42--opr,
* McshEngl.Rust_lago-opr.*42,
* McshEngl.Rust_lago'opr.*42,

opr.*=4261 of Rust_lago

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.Rust_lago'*=4261--opr,
* McshEngl.Rust_lago-opr.*=4261,
* McshEngl.Rust_lago'opr.*=4261,

opr.+43 of Rust_lago

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.Rust_lago'+43--opr,
* McshEngl.Rust_lago-opr.+43,
* McshEngl.Rust_lago'opr.+43,

opr.+=4361 of Rust_lago

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.Rust_lago'+=4361--opr,
* McshEngl.Rust_lago-opr.+=4361,
* McshEngl.Rust_lago'opr.+=4361,

opr.,44 of Rust_lago

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.Rust_lago',44--opr,
* McshEngl.Rust_lago-opr.,44,
* McshEngl.Rust_lago'opr.,44,

opr.-45 of Rust_lago

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.Rust_lago'-45--opr,
* McshEngl.Rust_lago-opr.-45,
* McshEngl.Rust_lago'opr.-45,

opr.=4561 of Rust_lago

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.Rust_lago'=4561--opr,
* McshEngl.Rust_lago-opr.=4561,
* McshEngl.Rust_lago'opr.=4561,

opr.->4562 of Rust_lago

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.Rust_lago'->4562--opr,
* McshEngl.Rust_lago-opr.->4562,
* McshEngl.Rust_lago'opr.->4562,

opr..46 of Rust_lago

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

name::
* McshEngl.Rust_lago'.46--opr,
* McshEngl.Rust_lago-opr..46,
* McshEngl.Rust_lago'opr..46,

opr...4646 of Rust_lago

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.Rust_lago'..4646--opr,
* McshEngl.Rust_lago-opr...4646,
* McshEngl.Rust_lago'opr...4646,

opr...=464661 of Rust_lago

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.Rust_lago'..=464661--opr,
* McshEngl.Rust_lago-opr...=464661,
* McshEngl.Rust_lago'opr...=464661,

opr....464646 of Rust_lago

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.Rust_lago'...464646--opr,
* McshEngl.Rust_lago-opr....464646,
* McshEngl.Rust_lago'opr....464646,

opr./47 of Rust_lago

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

name::
* McshEngl.Rust_lago'/47--opr,
* McshEngl.Rust_lago-opr./47,
* McshEngl.Rust_lago'opr./47,

opr./=4761 of Rust_lago

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.Rust_lago'/=4761--opr,
* McshEngl.Rust_lago-opr./=4761,
* McshEngl.Rust_lago'opr./=4761,

opr.:58 of Rust_lago

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.Rust_lago':58--opr,
* McshEngl.Rust_lago-opr.:58,
* McshEngl.Rust_lago'opr.:58,

opr.;59 of Rust_lago

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.Rust_lago';59--opr,
* McshEngl.Rust_lago-opr.;59,
* McshEngl.Rust_lago'opr.;59,

opr.;6060 of Rust_lago

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

name::
* McshEngl.Rust_lago';6060--opr,
* McshEngl.Rust_lago-opr.;6060,
* McshEngl.Rust_lago'opr.;6060,

opr.;606061 of Rust_lago

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.Rust_lago';606061--opr,
* McshEngl.Rust_lago-opr.;606061,
* McshEngl.Rust_lago'opr.;606061,

opr.;60 of Rust_lago

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.Rust_lago';60--opr,
* McshEngl.Rust_lago-opr.;60,
* McshEngl.Rust_lago'opr.;60,

opr.;6061 of Rust_lago

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.Rust_lago';6061--opr,
* McshEngl.Rust_lago-opr.;6061,
* McshEngl.Rust_lago'opr.;6061,

opr.=61 of Rust_lago

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.Rust_lago'=61--opr,
* McshEngl.Rust_lago-opr.=61,
* McshEngl.Rust_lago'opr.=61,

opr.==6161 of Rust_lago

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

name::
* McshEngl.Rust_lago'==6161--opr,
* McshEngl.Rust_lago-opr.==6161,
* McshEngl.Rust_lago'opr.==6161,

opr.=>6162 of Rust_lago

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.Rust_lago'=>6162--opr,
* McshEngl.Rust_lago-opr.=>6162,
* McshEngl.Rust_lago'opr.=>6162,

opr.>62 of Rust_lago

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.Rust_lago'>62--opr,
* McshEngl.Rust_lago-opr.>62,
* McshEngl.Rust_lago'opr.>62,

opr.>=6261 of Rust_lago

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.Rust_lago'>=6261--opr,
* McshEngl.Rust_lago-opr.>=6261,
* McshEngl.Rust_lago'opr.>=6261,

opr.>>6262 of Rust_lago

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

name::
* McshEngl.Rust_lago'>>6262--opr,
* McshEngl.Rust_lago-opr.>>6262,
* McshEngl.Rust_lago'opr.>>6262,

opr.>>=626261 of Rust_lago

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.Rust_lago'>>=626261--opr,
* McshEngl.Rust_lago-opr.>>=626261,
* McshEngl.Rust_lago'opr.>>=626261,

opr.@64 of Rust_lago

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

name::
* McshEngl.Rust_lago'@64--opr,
* McshEngl.Rust_lago-opr.@64,
* McshEngl.Rust_lago'opr.@64,

opr.^94 of Rust_lago

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.Rust_lago'^94--opr,
* McshEngl.Rust_lago-opr.^94,
* McshEngl.Rust_lago'opr.^94,

opr.^=9461 of Rust_lago

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.Rust_lago'^=9461--opr,
* McshEngl.Rust_lago-opr.^=9461,
* McshEngl.Rust_lago'opr.^=9461,

opr.|124 of Rust_lago

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.Rust_lago'|124--opr,
* McshEngl.Rust_lago-opr.|124,
* McshEngl.Rust_lago'opr.|124,

opr.|=12461 of Rust_lago

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.Rust_lago'|=12461--opr,
* McshEngl.Rust_lago-opr.|=12461,
* McshEngl.Rust_lago'opr.|=12461,

opr.||124124 of Rust_lago

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

name::
* McshEngl.Rust_lago'||124124--opr,
* McshEngl.Rust_lago-opr.||124124,
* McshEngl.Rust_lago'opr.||124124,

opr.?63 of Rust_lago

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

name::
* McshEngl.Rust_lago'?63--opr,
* McshEngl.Rust_lago-opr.?63,
* McshEngl.Rust_lago'opr.?63,

Sunt.array (a) of Rust_lago

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

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

Sunt.tuple () of Rust_lago

description::
× Mcsh-creation: {2026-10-04}
· source-tuple of Rust_lago 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 Rust_lago

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.Rust_lago_struct,
* McshEngl.Rust_lago-struct!⇒Rust_lago_struct,
* McshEngl.Rustsunt.struct!⇒Rust_lago_struct,

Sunt.enum () of Rust_lago

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

name::
* McshEngl.Rust_lago_enum,
* McshEngl.Rust_lago-enum!⇒Rust_lago_enum,
* McshEngl.Rustsunt.enum!⇒Rust_lago_enum,

Sunt.trait () of Rust_lago

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.Rust_lago_trait,
* McshEngl.Rust_lago-trait!⇒Rust_lago_trait,
* McshEngl.Rust_lago'trait!⇒Rust_lago_trait,
* McshEngl.Rustsunt.trait!⇒Rust_lago_trait,

Sunt.instance (literal) of Rust_lago

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

name::
* McshEngl.Rust_lago_literal,
* McshEngl.Rust_lago-literal!⇒Rust_lago_literal,
* McshEngl.Rustsunt.instance!⇒Rust_lago_literal,

Sunt.instanceNo (type) of Rust_lago

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

name::
* McshEngl.Rust_lago_type,
* McshEngl.Rust_lago-type!⇒Rust_lago_type,
* McshEngl.Rust_lago'type!⇒Rust_lago_type,
* McshEngl.Rustsunt.instanceNo!⇒Rust_lago_type,

Sunt.named of Rust_lago

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

name::
* McshEngl.Rust_lago_named_Sunt,
* McshEngl.Rustnamed-Sunt!⇒Rust_lago_named_Sunt,
* McshEngl.Rust_lago'named-Sunt!⇒Rust_lago_named_Sunt,
* McshEngl.Rustsunt.named!⇒Rust_lago_named_Sunt,
* McshEngl.Rust_lago'Sunt.named!⇒Rust_lago_named_Sunt,

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

value of named-Sunt

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

name::
* McshEngl.Rust_lago'value,
* McshEngl.Rustnamed-Sunt'value,
* McshEngl.Rust_lago_named_Sunt'value,

named-Sunt.variable

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

name::
* McshEngl.Rust_lago_var,
* McshEngl.Rust_lago-var!⇒Rust_lago_var,
* McshEngl.Rust_lago'variable!⇒Rust_lago_var,
* McshEngl.Rustnamed-Sunt.variable!⇒Rust_lago_var,
* McshEngl.Rust_lago_named_Sunt.variable!⇒Rust_lago_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.Rust_lago_cnst,
* McshEngl.Rust_lago-cnst!⇒Rust_lago_cnst,
* McshEngl.Rust_lago'constant!⇒Rust_lago_cnst,
* McshEngl.Rustnamed-Sunt.constant!⇒Rust_lago_cnst,
* McshEngl.Rust_lago_named_Sunt.constant!⇒Rust_lago_cnst,

Sunt.namedNo of Rust_lago

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

name::
* McshEngl.Rust_lago_namedNo_Sunt,
* McshEngl.RustnamedNo-Sunt!⇒Rust_lago_namedNo_Sunt,
* McshEngl.Rust_lago'anonymous-Sunt!⇒Rust_lago_namedNo_Sunt,
* McshEngl.Rustsunt.namedNo!⇒Rust_lago_namedNo_Sunt,
* McshEngl.Rust_lago'Sunt.namedNo!⇒Rust_lago_namedNo_Sunt,

Sunt.heap of Rust_lago

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

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

pointer of heap-Sunt of Rust_lago

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

name::
* McshEngl.Rust_lago'pointer,
* McshEngl.Rust_lago-heap-Sunt'pointer,

length of heap-Sunt of Rust_lago

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

name::
* McshEngl.Rust_lago-heap-Sunt'length,

capacity of heap-Sunt of Rust_lago

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.Rust_lago-heap-Sunt'capacity,

Sunt.stack of Rust_lago

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

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

Sunt.compound of Rust_lago

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.Rust_lago'Sunt.compound,

Sunt.compoundNo of Rust_lago

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.Rust_lago'scalar-type,
* McshEngl.Rustsunt.compoundNo,
* McshEngl.Rustsunt.primitive,
* McshEngl.Rustsunt.scalar,
* McshEngl.Rust_lago'Sunt.compoundNo,

algo'phrase of Rust_lago

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

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

generic-tree::
* McshEngl.Rustalgo'phrase_Gntr,
===
* phrase-of-Lsrc,

algo'sentence of Rust_lago

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

name::
* McshEngl.Rust_lago_sentence,
* McshEngl.Rust_lago-sentence!⇒Rust_lago_sentence,
* McshEngl.Rustalgo'sentence!⇒Rust_lago_sentence,
* McshEngl.Rust_lago'algo'sentence!⇒Rust_lago_sentence,

GENERIC-SPECIFIC-TREE of Rust_lago_sentence

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

name::
* McshEngl.Rust_lago_sentence'generic-specific-tree,
* McshEngl.Rust_lago_sentence'specific-generic-tree,

generic-tree::
* McshEngl.Rust_lago_sentence_Gntr,
===
* Srcdsent_Gntr,
* ... entity_Gntr,

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

sentence.loop-gnc of Rust_lago

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

name::
* McshEngl.Rust_lago_loop_gnc,
* McshEngl.Rust_lago-loop-gnc!⇒Rust_lago_loop_gnc,
* McshEngl.Rust_lago'loop-gnc!⇒Rust_lago_loop_gnc,
* McshEngl.Rust_lago-sentence.loop-gnc!⇒Rust_lago_loop_gnc,
* McshEngl.Rust_lago'sentence.loop-gnc!⇒Rust_lago_loop_gnc,

loop-gnc.for of Rust_lago

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.Rust_lago'for-sentence,
* McshEngl.Rust_lago-for,
* McshEngl.Rust_lago-loop-gnc.for,
* McshEngl.Rust_lago'loop-gnc.for,

loop-gnc.loop of Rust_lago

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.Rust_lago'loop-sentence,
* McshEngl.Rust_lago-loop,
* McshEngl.Rust_lago-loop-gnc.loop,
* McshEngl.Rust_lago'loop-gnc.loop,

loop-gnc.while of Rust_lago

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

name::
* McshEngl.Rust_lago'while-sentence,
* McshEngl.Rust_lago-while,
* McshEngl.Rust_lago-loop-gnc.while,
* McshEngl.Rust_lago'loop-gnc.while,

sentence.use of Rust_lago

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.Rust_lago_use,
* McshEngl.Rust_lago-use!⇒Rust_lago_use,
* McshEngl.Rust_lago'use-sentence!⇒Rust_lago_use,
* McshEngl.Rust_lago-sentence.use!⇒Rust_lago_use,
* McshEngl.Rust_lago'sentence.use!⇒Rust_lago_use,

algo'section of Rust_lago

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

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

generic-tree::
* McshEngl.Rustalgo'section_Gntr,
===
* Srcdalgosect_Gntr,

algo'titledNo-section of Rust_lago

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

name::
* McshEngl.Rustalgo'section'algo'titledNo-section,
* McshEngl.Rust_lago'algo'titledNo-section,

algo'titled-section of Rust_lago

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

name::
* McshEngl.Rustalgo'section'algo'titled-section,
* McshEngl.Rust_lago'algo'titled-section,

algo'root of Rust_lago

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

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

generic-tree::
* McshEngl.Rustroot_Gntr,
===
* algo-root--of-Srcd_lago,

GENERIC-SPECIFIC-TREE of Rust_lago_algo

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

name::
* McshEngl.Rust_lago_algo'specific-generic-tree,
* McshEngl.Rustalgo'generic-specific-tree,
* McshEngl.Rustalgo'specific-generic-tree,
* McshEngl.Rust_lago_algo'generic-specific-tree,

generic-tree::
* McshEngl.Rust_lago_algo_Gntr,
* McshEngl.Rustalgo_Gntr,
===
* Srcdalgo_Gntr,
* ... entity_Gntr,

specific-tree::
* McshEngl.Rust_lago_algo.specific,
* McshEngl.Rust_lago_algo_Sptr,
* McshEngl.Rustalgo.specific,
* McshEngl.Rustalgo_Sptr,
===
* library,
* program,

algo.module of Rust_lago

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.Rust_lago_mod,
* McshEngl.Rust_lago-mod!⇒Rust_lago_mod,
* McshEngl.Rust_lago'module!⇒Rust_lago_mod,
* McshEngl.Rust_lago'algo.module!⇒Rust_lago_mod,

algo.crate of Rust_lago

description::
× Mcsh-creation: {2026-10-04}
· source-crate of Rust_lago 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.Rust_lago_crate,
* McshEngl.Rust_lago-crate!⇒Rust_lago_crate,
* McshEngl.Rust_lago'crate!⇒Rust_lago_crate,
* McshEngl.Rust_lago'library!⇒Rust_lago_crate,
* McshEngl.Rustalgo.crate!⇒Rust_lago_crate,
* McshEngl.Rust_lago'algo.crate!⇒Rust_lago_crate,

main-module of crate of Rust_lago

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

name::
* McshEngl.Rust_lago-crate'main-module,
* McshEngl.Rust_lago_crate'main-module!⇒Rust_lago-crate'main-module,

GENERIC-SPECIFIC-TREE of Rust_lago_crate

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

name::
* McshEngl.Rust_lago_crate'generic-specific-tree,
* McshEngl.Rust_lago_crate'specific-generic-tree,

generic-tree::
* McshEngl.Rust_lago_crate_Gntr,
===
* ... entity_Gntr,

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

crate.standard of Rust_lago

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.Rust_lago_std,
* McshEngl.Rust_lago-std!⇒Rust_lago_std,
* McshEngl.Rust-Standard-Library!⇒Rust_lago_std,
* McshEngl.Rust_lago'standard-library!⇒Rust_lago_std,
* McshEngl.Rust_lago'crate.standard!⇒Rust_lago_std,

part of Rust_lago_std

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

name::
* McshEngl.Rust_lago-std'part,
* McshEngl.Rust_lago_std'part,

module of Rust_lago_std

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

name::
* McshEngl.Rust_lago-std'module,
* McshEngl.Rust_lago_std'module,

info-resource of Rust_lago_std

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

name::
* McshEngl.Rust_lago-std'info-resource,
* McshEngl.Rust_lago_std'info-resource,

std::prelude of Rust_lago

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.Rust_lago_prelude,
* McshEngl.Rust_lago-prelude!⇒Rust_lago_prelude,
* McshEngl.Rust_lago'prelude-of-std!⇒Rust_lago_prelude,
* McshEngl.Rust_lago-std::prelude!⇒Rust_lago_prelude,
* McshEngl.Rust_lago_crate'std::prelude!⇒Rust_lago_prelude,
* McshEngl.Rust_lago'std::prelude!⇒Rust_lago_prelude,

part of prelude of Rust_lago

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.Rust_lago-prelude'part,
* McshEngl.Rust_lago_prelude'part!⇒Rust_lago-prelude'part,

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

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.Rust_lago_String,
* McshEngl.Rust_lago-String!⇒Rust_lago_String,
* McshEngl.Rust_lago'String-struct!⇒Rust_lago_String,
* McshEngl.Rust_lago-prelude'String-struct!⇒Rust_lago_String,
* McshEngl.Rust_lago-struct.String!⇒Rust_lago_String,
* McshEngl.Rust_lago_prelude'std::string::String-struct!⇒Rust_lago_String,

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

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.Rust_lago_Vec,
* McshEngl.Rust_lago-Vec!⇒Rust_lago_Vec,
* McshEngl.Rust_lago'Vec-struct!⇒Rust_lago_Vec,
* McshEngl.Rust_lago'vector!⇒Rust_lago_Vec,
* McshEngl.Rust_lago-struct.Vec!⇒Rust_lago_Vec,
* McshEngl.Rust_lago_prelude'std::vec::Vec-struct!⇒Rust_lago_Vec,

generic-tree::
* McshEngl.Rust_lago_Vec_Gntr,
===
* Rust_lago-struct,

algo.package of Rust_lago

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.Rust_lago_pkg,
* McshEngl.Rust_lago-pkg!⇒Rust_lago_pkg,
* McshEngl.Rust_lago'Cargo-package!⇒Rust_lago_pkg,
* McshEngl.Rust_lago'package!⇒Rust_lago_pkg,
* McshEngl.Rust_lago'algo.package!⇒Rust_lago_pkg,

Cargo.toml-file of package of Rust_lago

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.Rust_lago_Cargo.toml,
* McshEngl.Rust_lago-Cargo.toml!⇒Rust_lago_Cargo.toml,
* McshEngl.Rust_lago-pkg'Cargo.toml-file!⇒Rust_lago_Cargo.toml,
* McshEngl.Rust_lago-source-file.Cargo.toml-file!⇒Rust_lago_Cargo.toml,

algo.program of Rust_lago

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

name::
* McshEngl.Rust_lago_pgm,
* McshEngl.Rust_lago-pgm!⇒Rust_lago_pgm,
* McshEngl.Rustalgo.executable!⇒Rust_lago_pgm,
* McshEngl.Rustalgo.program!⇒Rust_lago_pgm,
* McshEngl.Rust_lago'algo.program!⇒Rust_lago_pgm,

program.command-line of Rust_lago

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

name::
* McshEngl.Rust_lago_clip,
* McshEngl.Rust_lago-clip!⇒Rust_lago_clip,
* McshEngl.Rust_lago-pgm.command-line!⇒Rust_lago_clip,
* McshEngl.Rust_lago'program.command-line!⇒Rust_lago_clip,

info-resource of clip of Rust_lago

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

name::
* McshEngl.info-resource-of-clip-of-Rust_lago,
* McshEngl.clip-of-Rust_lago'info-resource,
* McshEngl.Rust_lago_clip'info-resource,

program.command-line.no of Rust_lago

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

name::
* McshEngl.Rust_lago_guip,
* McshEngl.Rust_lago-guip!⇒Rust_lago_guip,
* McshEngl.Rust_lago-pgm.command-line.no!⇒Rust_lago_guip,
* McshEngl.Rust_lago'program.command-line.no!⇒Rust_lago_guip,

binary-algo of Rust_lago

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.Rust_lago_bin_algo,
* McshEngl.Rust_lago-bin-algo!⇒Rust_lago_bin_algo,
* McshEngl.Rust_lago'binary-algo!⇒Rust_lago_bin_algo,

bin-code of bin-algo of Rust_lago

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

name::
* McshEngl.Rust_lago'bin-code,
* McshEngl.Rust_lago-bin-algo'code,
* McshEngl.Rust_lago_bin_algo'bin-code,

GENERIC-SPECIFIC-TREE of Rust_lago_bin_algo

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

name::
* McshEngl.Rust_lago_bin_algo'generic-specific-tree,
* McshEngl.Rust_lago_bin_algo'specific-generic-tree,

generic-tree::
* McshEngl.Rust_lago_bin_algo_Gntr,
===
* ... entity_Gntr,

specific-tree::
* McshEngl.Rust_lago_bin_algo.specific,
* McshEngl.Rust_lago_bin_algo_Sptr,
===
* bin-program,

bin-algo.program of Rust_lago

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

name::
* McshEngl.Rust_lago_exe,
* McshEngl.Rust_lago-exe!⇒Rust_lago_exe,
* McshEngl.Rust_lago'bin-program!⇒Rust_lago_exe,
* McshEngl.Rust_lago'executable!⇒Rust_lago_exe,
* McshEngl.Rust_lago-bin-algo.program!⇒Rust_lago_exe,
* McshEngl.Rust_lago'bin-algo.program!⇒Rust_lago_exe,

evaluation of Rust_lago

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

name::
* McshEngl.Rust_lago'evaluation,

benefit of Rust_lago

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

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

benefitNo of Rust_lago

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

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

tool of Rust_lago

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

name::
* McshEngl.Rust_lago_tool,
* McshEngl.Rust_lago-tool!⇒Rust_lago_tool,
* McshEngl.Rust_lago'tool!⇒Rust_lago_tool,

GENERIC-SPECIFIC-TREE of Rust_lago_tool

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

name::
* McshEngl.Rust_lago_tool'generic-specific-tree,
* McshEngl.Rust_lago_tool'specific-generic-tree,

generic-tree::
* McshEngl.Rust_lago_tool_Gntr,
===
* ... entity_Gntr,

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

rustc of Rust_lago

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

name::
* McshEngl.Rust_lago_rustc,
* McshEngl.Rust_lago-rustc!⇒Rust_lago_rustc,
* McshEngl.Rust_lago'compiler!⇒Rust_lago_rustc,
* McshEngl.Rust_lago-tool.compiler!⇒Rust_lago_rustc,
* McshEngl.Rust-compiler!⇒Rust_lago_rustc,
* McshEngl.Rust_lago_tool'rustc!⇒Rust_lago_rustc,
* McshEngl.Rust_lago'rustc!⇒Rust_lago_rustc,

error of rustc

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

name::
* McshEngl.Rust_lago-rustc'error,
* McshEngl.Rust_lago_rustc'error!⇒Rust_lago-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.Rust_lago-rustc'info-resource,
* McshEngl.Rust_lago_rustc'info-resource!⇒Rust_lago-rustc'info-resource,

Cargo of Rust_lago

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

name::
* McshEngl.Rust_lago_Cargo,
* McshEngl.Rust_lago-Cargo!⇒Rust_lago_Cargo,
* McshEngl.Rust-Cargo!⇒Rust_lago_Cargo,
* McshEngl.Rust_lago'Cargo-tool!⇒Rust_lago_Cargo,
* McshEngl.Rust_lago-tool.Cargo!⇒Rust_lago_Cargo,
* McshEngl.Rust_lago_tool'Cargo!⇒Rust_lago_Cargo,
* McshEngl.Rust_lago'Cargo!⇒Rust_lago_Cargo,

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.Rust_lago_Cargo_cmd,
* McshEngl.Rust_lago-Cargo-cmd!⇒Rust_lago_Cargo_cmd,
* McshEngl.Rust_lago-Cargo'command!⇒Rust_lago_Cargo_cmd,
* McshEngl.Rust_lago_Cargo'command!⇒Rust_lago_Cargo_cmd,

GENERIC-SPECIFIC-TREE of Rust_lago_Cargo_cmd

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

name::
* McshEngl.Rust_lago_Cargo_cmd'generic-specific-tree,
* McshEngl.Rust_lago_Cargo_cmd'specific-generic-tree,

generic-tree::
* McshEngl.Rust_lago_Cargo_cmd_Gntr,
===
* ... entity_Gntr,

specific-tree::
* McshEngl.Rust_lago_Cargo_cmd.specific,
* McshEngl.Rust_lago_Cargo_cmd_Sptr,
===
* 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:

Cargo-cmd.bench of Rust_lago

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

name::
* McshEngl.Rust_lago-Cargo-cmd.bench,
* McshEngl.Rust_lago'Cargo-cmd.bench,

Cargo-cmd.build of Rust_lago

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

name::
* McshEngl.Rust_lago-Cargo-cmd.build,
* McshEngl.Rust_lago'Cargo-cmd.build,

Cargo-cmd.check of Rust_lago

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

name::
* McshEngl.Rust_lago-Cargo-cmd.check,
* McshEngl.Rust_lago'Cargo-cmd.check,

Cargo-cmd.clean of Rust_lago

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

name::
* McshEngl.Rust_lago-Cargo-cmd.clean,
* McshEngl.Rust_lago'Cargo-cmd.clean,

Cargo-cmd.clippy-preview of Rust_lago

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

name::
* McshEngl.Rust_lago-Cargo-cmd.clippy-preview,
* McshEngl.Rust_lago'Cargo-cmd.clippy-preview,

Cargo-cmd.doc of Rust_lago

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

name::
* McshEngl.Rust_lago-Cargo-cmd.doc,
* McshEngl.Rust_lago'Cargo-cmd.doc,

Cargo-cmd.fetch of Rust_lago

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

name::
* McshEngl.Rust_lago-Cargo-cmd.fetch,
* McshEngl.Rust_lago'Cargo-cmd.fetch,

Cargo-cmd.fix of Rust_lago

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

name::
* McshEngl.Rust_lago-Cargo-cmd.fix,
* McshEngl.Rust_lago'Cargo-cmd.fix,

Cargo-cmd.generate-lockfile of Rust_lago

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

name::
* McshEngl.Rust_lago-Cargo-cmd.generate-lockfile,
* McshEngl.Rust_lago'Cargo-cmd.generate-lockfile,

Cargo-cmd.git-checkout of Rust_lago

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

name::
* McshEngl.Rust_lago-Cargo-cmd.git-checkout,
* McshEngl.Rust_lago'Cargo-cmd.git-checkout,

Cargo-cmd.init of Rust_lago

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

name::
* McshEngl.Rust_lago-Cargo-cmd.init,
* McshEngl.Rust_lago'Cargo-cmd.init,

Cargo-cmd.install of Rust_lago

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

name::
* McshEngl.Rust_lago-Cargo-cmd.install,
* McshEngl.Rust_lago'Cargo-cmd.install,

Cargo-cmd.locate-project of Rust_lago

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

name::
* McshEngl.Rust_lago-Cargo-cmd.locate-project,
* McshEngl.Rust_lago'Cargo-cmd.locate-project,

Cargo-cmd.login of Rust_lago

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.Rust_lago-Cargo-cmd.login,
* McshEngl.Rust_lago'Cargo-cmd.login,

Cargo-cmd.metadata of Rust_lago

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.Rust_lago-Cargo-cmd.metadata,
* McshEngl.Rust_lago'Cargo-cmd.metadata,

Cargo-cmd.new of Rust_lago

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

name::
* McshEngl.Rust_lago-Cargo-cmd.new,
* McshEngl.Rust_lago'Cargo-cmd.new,

Cargo-cmd.owner of Rust_lago

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

name::
* McshEngl.Rust_lago-Cargo-cmd.owner,
* McshEngl.Rust_lago'Cargo-cmd.owner,

Cargo-cmd.package of Rust_lago

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

name::
* McshEngl.Rust_lago-Cargo-cmd.package,
* McshEngl.Rust_lago'Cargo-cmd.package,

Cargo-cmd.pkgid of Rust_lago

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

name::
* McshEngl.Rust_lago-Cargo-cmd.pkgid,
* McshEngl.Rust_lago'Cargo-cmd.pkgid,

Cargo-cmd.publish of Rust_lago

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

name::
* McshEngl.Rust_lago-Cargo-cmd.publish,
* McshEngl.Rust_lago'Cargo-cmd.publish,

Cargo-cmd.read-manifest of Rust_lago

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

name::
* McshEngl.Rust_lago-Cargo-cmd.read-manifest,
* McshEngl.Rust_lago'Cargo-cmd.read-manifest,

Cargo-cmd.run of Rust_lago

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

name::
* McshEngl.Rust_lago-Cargo-cmd.run,
* McshEngl.Rust_lago'Cargo-cmd.run,

Cargo-cmd.rustc of Rust_lago

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

name::
* McshEngl.Rust_lago-Cargo-cmd.rustc,
* McshEngl.Rust_lago'Cargo-cmd.rustc,

Cargo-cmd.rustdoc of Rust_lago

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

name::
* McshEngl.Rust_lago-Cargo-cmd.rustdoc,
* McshEngl.Rust_lago'Cargo-cmd.rustdoc,

Cargo-cmd.search of Rust_lago

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

name::
* McshEngl.Rust_lago-Cargo-cmd.search,
* McshEngl.Rust_lago'Cargo-cmd.search,

Cargo-cmd.test of Rust_lago

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

name::
* McshEngl.Rust_lago-Cargo-cmd.test,
* McshEngl.Rust_lago'Cargo-cmd.test,

Cargo-cmd.uninstall of Rust_lago

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

name::
* McshEngl.Rust_lago-Cargo-cmd.uninstall,
* McshEngl.Rust_lago'Cargo-cmd.uninstall,

Cargo-cmd.update of Rust_lago

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

name::
* McshEngl.Rust_lago-Cargo-cmd.update,
* McshEngl.Rust_lago'Cargo-cmd.update,

Cargo-cmd.verify-project of Rust_lago

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

name::
* McshEngl.Rust_lago-Cargo-cmd.verify-project,
* McshEngl.Rust_lago'Cargo-cmd.verify-project,

Cargo-cmd.version of Rust_lago

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

name::
* McshEngl.Rust_lago-Cargo-cmd.version,
* McshEngl.Rust_lago'Cargo-cmd.version,

Cargo-cmd.yank of Rust_lago

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

name::
* McshEngl.Rust_lago-Cargo-cmd.yank,
* McshEngl.Rust_lago'Cargo-cmd.yank,

Cargo-cmd.clippy of Rust_lago

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

name::
* McshEngl.Rust_lago-Cargo-cmd.clippy,
* McshEngl.Rust_lago'Cargo-cmd.clippy,

Cargo-cmd.fmt of Rust_lago

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

name::
* McshEngl.Rust_lago-Cargo-cmd.fmt,
* McshEngl.Rust_lago'Cargo-cmd.fmt,

Cargo-cmd.miri of Rust_lago

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

name::
* McshEngl.Rust_lago-Cargo-cmd.miri,
* McshEngl.Rust_lago'Cargo-cmd.miri,

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.Rust_lago-Cargo'info-resource,
* McshEngl.Rust_lago_Cargo'info-resource!⇒Rust_lago-Cargo'info-resource,

rustup of Rust_lago

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

name::
* McshEngl.Rust_lago'rustup,
* McshEngl.Rust_lago-tool.rustup,
* McshEngl.Rust_lago_tool'rustup,

human of Rust_lago

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

name::
* McshEngl.Rust_lago'human,

GENERIC-SPECIFIC-TREE of Rust_lago'human

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

name::
* McshEngl.Rust_lago'human'generic-specific-tree,
* McshEngl.Rust_lago'human'specific-generic-tree,

generic-tree::
* McshEngl.Rust_lago'human_Gntr,
===
* ... entity_Gntr,

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

human.programer

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

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

info-resource of Rust_lago

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.Rust_lago'info-resource,

ATTRIBUTE of Rust_lago

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

name::
* McshEngl.Rust_lago_att,
* McshEngl.Rust_lago-att!⇒Rust_lago_att,
* McshEngl.Rust_lago'attribute!⇒Rust_lago_att,

DOING of Rust_lago

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

name::
* McshEngl.Rust_lago'doing,

GENERIC-SPECIFIC-TREE of Rust_lago'doing

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

name::
* McshEngl.Rust_lago'doing'generic-specific-tree,
* McshEngl.Rust_lago'doing'specific-generic-tree,

generic-tree::
* McshEngl.Rust_lago'doing_Gntr,
===
* ... entity_Gntr,

specific-tree::
* McshEngl.Rust_lago'doing.specific,
* McshEngl.Rust_lago'doing_Sptr,
===
* main-functing,
* installing,
* updating,
* uninstalling,

main-functing of Rust_lago

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.Rust_lago'main-functing,
* McshEngl.Rust_lago'doing'main-functing!⇒Rust_lago'main-functing,

updating of Rust_lago

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

name::
* McshEngl.Rust_lago'updating,
* McshEngl.Rust_lago'doing'updating!⇒Rust_lago'updating,

uninstalling of Rust_lago

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

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

evoluting of Rust_lago

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-Rust_lago,
* McshEngl.Rust_lago'evoluting,

release of Rust_lago

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.Rust_lago'release,

edition of Rust_lago

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.Rust_lago'edition,

GENERIC-SPECIFIC-TREE of Rust_lago

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

name::
* McshEngl.Rust_lago'generic-specific-tree,
* McshEngl.Rust_lago'specific-generic-tree,

generic-tree::
* McshEngl.Rust_lago_Gntr,
===
* compiled-language!@McshTchInf000006#idLSrcdCmpd,
* statically-typed-language!@McshTchInf000006#idLSrcdStctp,
* programing-language!@McshTchInf000006,
* language,
* ... entity_Gntr,

specific-tree::
* McshEngl.Rust_lago.specific,
* McshEngl.Rust_lago_Sptr,
===

meta-info

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

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

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 'Rust_lago' for structured-concepts related to current concept 'Rust-language'.
⊛ LOCAL-SEARCH:
· TYPE CTRL+F "McsLag4.words-of-concept's-name", 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)