Rust-language senso-concept-Mcs
(lagRust)

McsHitp-creation:: {2019-06-29},

overview of lagRust

description::
"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::
* McsEngl.McsTchInf000030.last.html//dirTchInf//dirMcs!⇒lagRust,
* McsEngl.dirMcs/dirTchInf/McsTchInf000030.last.html!⇒lagRust,
* McsEngl.Lrst!⇒lagRust,
* McsEngl.Rust-language!⇒lagRust,
* McsEngl.Rustlag!⇒lagRust,
* McsEngl.lagRust!=McsTchInf000030,
* McsEngl.lagRust!=Rust-language,

archetype (input) of lagRust

description::
· archetype of lagRust is a-document describing information-processing as done by humans or other machines.

name::
* McsEngl.lagRust'archetype,

generic-tree::
* archetype-of--source-language,

algo (output) of lagRust

description::
· source-algo of lagRust[a] is the-document that maps its[a] archetype using it[a].

name::
* McsEngl.lagRust'algorithm!⇒lagRust-algo,
* McsEngl.lagRust'source-doc!⇒lagRust-algo,
* McsEngl.lagRust-algo,

generic-tree::
* algorithm-of--source-language,

encoding of lagRust-algo

description::
· the-source-doc of lagRust is digital-text and therefore uses a-character-encoding, the-UTF-8.
[https://doc.rust-lang.org/reference/input-format.html]

name::
* McsEngl.lagRust'source-encoding,
* McsEngl.lagRust-algo'encoding,

machine of lagRust-algo

description::
· the-machine that understands a-lagRust-algo is an-abstract-machine with memory.

name::
* McsEngl.lagRust-algo'machine!⇒lagRust-machine,
* McsEngl.lagRust-machine,

heap of machine-memory of lagRust-algo

description::
· 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::
* McsEngl.lagRust-heap,
* McsEngl.lagRust-machine'heap,

stack of machine-memory of lagRust-algo

description::
· 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::
* McsEngl.lagRust-machine'stack,
* McsEngl.lagRust-stack,

source-code of lagRust-algo

description::
· source-code[a] of lagRust[b] is code written in human readable format.
· it[a] is any part of its[b] algo.

name::
* McsEngl.lagRust'source-code,
* McsEngl.lagRust-algo'code,

codomain of lagRust-algo

description::
· codomain of lagRust is the-set of all algorithms that are-produced.

name::
* McsEngl.lagRust'codomain,
* McsEngl.lagRust-algo'codomain,

syntax-tree of lagRust-algo

description::
· source-syntax-tree of lagRust[a] is the-whole-part-tree of the-source-nodes of its[a] algo.

name::
* McsEngl.lagRust'source-syntax-tree,
* McsEngl.lagRust-algo'syntax-tree,

file of lagRust-algo

description::
· the-files with source-code end with .rs
· the-Cargo.toml contains meta info needed.

name::
* McsEngl.lagRust'source-file,
* McsEngl.lagRust-algo'file,

file.rs

file.Cargo.toml

algo'node of lagRust

description::
· source-node of lagRst[a] is any identifiable part of its[a] algo.

name::
* McsEngl.lagRust'source-node!⇒lagRust-node,
* McsEngl.lagRust-algo'node!⇒lagRust-node,
* McsEngl.lagRust-algo'structure!⇒lagRust-node,
* McsEngl.lagRust-node,

generic-tree::
* algo-node-of-lagSrc,

scope of node of lagRust-algo

description::
"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::
* McsEngl.lagRust'scope,
* McsEngl.lagRust-node'scope,

node.SPECIFIC of algo of lagRust

description::
* named-node,
* namedNo-node,

name::
* McsEngl.lagRust-node.specific,

node.named of algo of lagRust

description::
· named-node of lagRust is a-node[a] with an-identifier associated with it[a].

name::
* McsEngl.lagRust'named-node,
* McsEngl.lagRust-node.named,

node.namedNo of algo of lagRust

description::
· namedNo-node of lagRust is a-node[a] without an-identifier associated with it[a].

name::
* McsEngl.lagRust'namedNo-node,
* McsEngl.lagRust-node.namedNo,

algo'unit of lagRust

description::
· source-unit of lagRust is the-indivisible parts of an-algo.

name::
* McsEngl.lagRust-algo'unit,

generic-tree::
* unit-of--source-language,

algo'word of lagRust

description::
· source-word of lagRust is a-structure of units the-language uses to create more compound algo-structures.

name::
* McsEngl.lagRust-algo'word!⇒lagRust-word,
* McsEngl.lagRust-word,

generic-tree::
* word-of-Lsrc,

specific::
* identifier,
* keyword,

word.identifier of lagRust

description::
· identifier of lagRust is a-word, not a-keyword, that folows concrete rules to be-constructed and used to construct named-algo-nodes.

name::
* McsEngl.lagRust'identifier!⇒lagRust-identifier,
* McsEngl.lagRust-identifier,
* McsEngl.lagRust-word.identifier!⇒lagRust-identifier,

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

word.keyword of lagRust

description::
· source-keyword of lagRust is a-word reserved by the-language to create algo-nodes.

name::
* McsEngl.lagRust'keyword!⇒lagRust-keyword,
* McsEngl.lagRust-word.keyword!⇒lagRust-keyword,
* McsEngl.lagRust-keyword,

generic-tree::
* lagSrc-keyword,

specific::
* reserved-keyword--of-lagRust,
* used-keyword--of-lagRust,

keyword.used of lagRust

description::
· used-keyword of lagRust is a-keyword currently used.

name::
* McsEngl.lagRust'used-keyword!⇒lagRust-used-keyword,
* McsEngl.lagRust-keyword.used!⇒lagRust-used-keyword,
* McsEngl.lagRust-used-keyword,

used-keyword.as of lagRust

description::
"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::
* McsEngl.lagRust'as--used-keyword,
* McsEngl.lagRust-used-keyword.as,

used-keyword.break of lagRust

description::
"break: exit a loop immediately."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McsEngl.lagRust'break--used-keyword,
* McsEngl.lagRust-used-keyword.break,

used-keyword.const of lagRust

description::
"const: define constant items or constant raw pointers."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McsEngl.lagRust'const--used-keyword,
* McsEngl.lagRust-used-keyword.const,

used-keyword.continue of lagRust

description::
"continue: continue to the next loop iteration."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McsEngl.lagRust'continue--used-keyword,
* McsEngl.lagRust-used-keyword.continue,

used-keyword.crate of lagRust

description::
"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::
* McsEngl.lagRust'crate--used-keyword,
* McsEngl.lagRust-used-keyword.crate,

used-keyword.dyn of lagRust

description::
"dyn: dynamic dispatch to a trait object."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McsEngl.lagRust'dyn--used-keyword,
* McsEngl.lagRust-used-keyword.dyn,

used-keyword.else of lagRust

description::
"else: fallback for if and if let control flow constructs."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McsEngl.lagRust'else--used-keyword,
* McsEngl.lagRust-used-keyword.else,

used-keyword.enum of lagRust

description::
"enum: define an enumeration."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McsEngl.lagRust'enum--used-keyword,
* McsEngl.lagRust-used-keyword.enum,

used-keyword.extern of lagRust

description::
"extern: link an external crate, function, or variable."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McsEngl.lagRust'extern--used-keyword,
* McsEngl.lagRust-used-keyword.extern,

used-keyword.false of lagRust

description::
"false: Boolean false literal."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McsEngl.lagRust'false--used-keyword,
* McsEngl.lagRust-used-keyword.false,

used-keyword.fn of lagRust

description::
"fn: define a function or the function pointer type."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McsEngl.lagRust'fn--used-keyword,
* McsEngl.lagRust-used-keyword.fn,

used-keyword.for of lagRust

description::
"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::
* McsEngl.lagRust'for--used-keyword,
* McsEngl.lagRust-used-keyword.for,

used-keyword.if of lagRust

description::
"if: branch based on the result of a conditional expression."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McsEngl.lagRust'if--used-keyword,
* McsEngl.lagRust-used-keyword.if,

used-keyword.impl of lagRust

description::
"impl: implement inherent or trait functionality."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McsEngl.lagRust'impl--used-keyword,
* McsEngl.lagRust-used-keyword.impl,

used-keyword.in of lagRust

description::
"in: part of for loop syntax."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McsEngl.lagRust'in--used-keyword,
* McsEngl.lagRust-used-keyword.in,

used-keyword.let of lagRust

description::
"let: bind a variable."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McsEngl.lagRust'let--used-keyword,
* McsEngl.lagRust-used-keyword.let,

used-keyword.loop of lagRust

description::
"loop: loop unconditionally."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McsEngl.lagRust'loop--used-keyword,
* McsEngl.lagRust-used-keyword.loop,

used-keyword.match of lagRust

description::
"match: match a value to patterns."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McsEngl.lagRust'match--used-keyword,
* McsEngl.lagRust-used-keyword.match,

used-keyword.mod of lagRust

description::
"mod: define a module."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McsEngl.lagRust'mod--used-keyword,
* McsEngl.lagRust-used-keyword.mod,

used-keyword.move of lagRust

description::
"move: make a closure take ownership of all its captures."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McsEngl.lagRust'move--used-keyword,
* McsEngl.lagRust-used-keyword.move,

used-keyword.mut of lagRust

description::
"mut: denote mutability in references, raw pointers, or pattern bindings."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McsEngl.lagRust'mut--used-keyword,
* McsEngl.lagRust-used-keyword.mut,

used-keyword.pub of lagRust

description::
"pub: denote public visibility in struct fields, impl blocks, or modules."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McsEngl.lagRust'pub--used-keyword,
* McsEngl.lagRust-used-keyword.pub,

used-keyword.ref of lagRust

description::
"ref: bind by reference."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McsEngl.lagRust'ref--used-keyword,
* McsEngl.lagRust-used-keyword.ref,

used-keyword.return of lagRust

description::
"return: return from function."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McsEngl.lagRust'return--used-keyword,
* McsEngl.lagRust-used-keyword.return,

used-keyword.Self of lagRust

description::
"Self: a type alias for the type implementing a trait."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McsEngl.lagRust'Self--used-keyword,
* McsEngl.lagRust-used-keyword.Self,

used-keyword.self of lagRust

description::
"self: method subject or current module."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McsEngl.lagRust'self--used-keyword,
* McsEngl.lagRust-used-keyword.self,

used-keyword.static of lagRust

description::
"static: global variable or lifetime lasting the entire program execution."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McsEngl.lagRust'static--used-keyword,
* McsEngl.lagRust-used-keyword.static,

used-keyword.struct of lagRust

description::
"struct: define a structure."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McsEngl.lagRust'struct--used-keyword,
* McsEngl.lagRust-used-keyword.struct,

used-keyword.super of lagRust

description::
"super: parent module of the current module."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McsEngl.lagRust'super--used-keyword,
* McsEngl.lagRust-used-keyword.super,

used-keyword.trait of lagRust

description::
"trait: define a trait."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McsEngl.lagRust'trait--used-keyword,
* McsEngl.lagRust-used-keyword.trait,

used-keyword.true of lagRust

description::
"true: Boolean true literal."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McsEngl.lagRust'true--used-keyword,
* McsEngl.lagRust-used-keyword.true,

used-keyword.type of lagRust

description::
"type: define a type alias or associated type."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McsEngl.lagRust'type--used-keyword,
* McsEngl.lagRust-used-keyword.type,

used-keyword.unsafe of lagRust

description::
"unsafe: denote unsafe code, functions, traits, or implementations."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McsEngl.lagRust'unsafe--used-keyword,
* McsEngl.lagRust-used-keyword.unsafe,

used-keyword.use of lagRust

description::
"use: bring symbols into scope."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McsEngl.lagRust'use--used-keyword,
* McsEngl.lagRust-used-keyword.use,

used-keyword.where of lagRust

description::
"where: denote clauses that constrain a type."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McsEngl.lagRust'where--used-keyword,
* McsEngl.lagRust-used-keyword.where,

used-keyword.while of lagRust

description::
"while: loop conditionally based on the result of an expression."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McsEngl.lagRust'while--used-keyword,
* McsEngl.lagRust-used-keyword.while,

keyword.usedNo of lagRust

description::
· reserved-keyword of lagRust is a-keyword NOT used currently.

name::
* McsEngl.lagRust'reserved-keyword!⇒lagRust-usedNo-keyword,
* McsEngl.lagRust-keyword.reserved!⇒lagRust-usedNo-keyword,
* McsEngl.lagRust-usedNo-keyword,

usedNo-keyword.abstract of lagRust

description::
"abstract: reserved for potential future use."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McsEngl.lagRust'abstract--usedNo-keyword,
* McsEngl.lagRust-usedNo-keyword.abstract,

usedNo-keyword.async of lagRust

description::
"async: reserved for potential future use."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McsEngl.lagRust'async--usedNo-keyword,
* McsEngl.lagRust-usedNo-keyword.async,

usedNo-keyword.become of lagRust

description::
"become: reserved for potential future use."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McsEngl.lagRust'become--usedNo-keyword,
* McsEngl.lagRust-usedNo-keyword.become,

usedNo-keyword.box of lagRust

description::
"box: reserved for potential future use."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McsEngl.lagRust'box--usedNo-keyword,
* McsEngl.lagRust-usedNo-keyword.box,

usedNo-keyword.do of lagRust

description::
"do: reserved for potential future use."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McsEngl.lagRust'do--usedNo-keyword,
* McsEngl.lagRust-usedNo-keyword.do,

usedNo-keyword.final of lagRust

description::
"final: reserved for potential future use."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McsEngl.lagRust'final--usedNo-keyword,
* McsEngl.lagRust-usedNo-keyword.final,

usedNo-keyword.macro of lagRust

description::
"macro: reserved for potential future use."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McsEngl.lagRust'macro--usedNo-keyword,
* McsEngl.lagRust-usedNo-keyword.macro,

usedNo-keyword.override of lagRust

description::
"override: reserved for potential future use."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McsEngl.lagRust'override--usedNo-keyword,
* McsEngl.lagRust-usedNo-keyword.override,

usedNo-keyword.priv of lagRust

description::
"priv: reserved for potential future use."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McsEngl.lagRust'priv--usedNo-keyword,
* McsEngl.lagRust-usedNo-keyword.priv,

usedNo-keyword.try of lagRust

description::
"try: reserved for potential future use."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McsEngl.lagRust'try--usedNo-keyword,
* McsEngl.lagRust-usedNo-keyword.try,

usedNo-keyword.typeof of lagRust

description::
"typeof: reserved for potential future use."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McsEngl.lagRust'typeof--usedNo-keyword,
* McsEngl.lagRust-usedNo-keyword.typeof,

usedNo-keyword.unsized of lagRust

description::
"unsized: reserved for potential future use."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McsEngl.lagRust'unsized--usedNo-keyword,
* McsEngl.lagRust-usedNo-keyword.unsized,

usedNo-keyword.virtual of lagRust

description::
"virtual: reserved for potential future use."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McsEngl.lagRust'virtual--usedNo-keyword,
* McsEngl.lagRust-usedNo-keyword.virtual,

usedNo-keyword.yield of lagRust

description::
"yield: reserved for potential future use."
[https://doc.rust-lang.org/book/appendix-01-keywords.html]

name::
* McsEngl.lagRust'yield--usedNo-keyword,
* McsEngl.lagRust-usedNo-keyword.yield,

algo'semantic-unit of lagRust

description::
· source-semantic-unit of lagRust is a-lagSrc-Sunt that

name::
* McsEngl.lagRust'semantic-unit!⇒lagRust-Sunt,
* McsEngl.lagRust-algo'semantic-unit!⇒lagRust-Sunt,
* McsEngl.lagRust-Sunt,

generic-tree::
* sem-unit-of-Lsrc,

Sunt.SPECIFIC of lagRust

name::
* McsEngl.lagRust-Sunt.specific,

Sunt.specific-on-keyword

description::
* 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::
* McsEngl.lagRust-Sunt.specific-on-keyword,

Sunt.character (ch) of lagRust

description::
· 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::
* McsEngl.lagRust'character!⇒lagRust-ch,
* McsEngl.lagRust-Sunt.character!⇒lagRust-ch,
* McsEngl.lagRust-ch,

Sunt.string (s) of lagRust

description::
· string of lagRust is a-collection of characters.

name::
* McsEngl.lagRust'string!⇒lagRust-s,
* McsEngl.lagRust-Sunt.string!⇒lagRust-s,
* McsEngl.lagRust-s,

string.literal of lagRust

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

name::
* McsEngl.lagRust'literal-string,
* McsEngl.lagRust-literal.string,
* McsEngl.lagRust-s.literal,

string.String-type (link) of lagRust

Sunt.boolean (b) of lagRust

description::
· source-boolean of lagRust is any of the-two semantic-units true and false that denote the-same with the-same human-code.

name::
* McsEngl.lagRust'boolean,
* McsEngl.lagRust-b,

Sunt.number (n) of lagRust

description::
· source-number of lagRust is the-semantic-unit that denotes human-numbers.

name::
* McsEngl.lagRust'number,
* McsEngl.lagRust-n,

generic-tree::
* number-of-lagSrc,

lagRust-n.SPECIFIC

description::
* 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,

name::
* McsEngl.lagRust-n.specific,

lagRust-n.integer

description::
· integer is a-number that denotes whole quantities.

name::
* McsEngl.lagRust-n.integer!⇒lagRust-ni,

specific::
* linteral-integer,
* signed-integer,
* signedNo-integer,

lagRust-ni.literal

description::
· example:
* Decimal 98_222
* Hex 0xff
* Octal 0o77
* Binary 0b1111_0000
* Byte (u8 only) b'A'

name::
* McsEngl.lagRust-literal.ni,
* McsEngl.lagRust-ni.literal,

lagRust-ni.signed

description::
· 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::
* McsEngl.lagRust-ni.signed,

lagRust-ni.signedNo

description::
· 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::
* McsEngl.lagRust-ni.signedNo,
* McsEngl.lagRust-ni.unsigned,

lagRust-ni.i8

description::
·

name::
* McsEngl.lagRust'i8,
* McsEngl.lagRust-Sunt.i8,
* McsEngl.lagRust-ni.i8,

lagRust-ni.i16

description::
·

name::
* McsEngl.lagRust'i16,
* McsEngl.lagRust-Sunt.i16,
* McsEngl.lagRust-ni.i16,

lagRust-ni.i32

description::
·

name::
* McsEngl.lagRust'i32,
* McsEngl.lagRust-Sunt.i32,
* McsEngl.lagRust-ni.i32,

lagRust-ni.i64

description::
·

name::
* McsEngl.lagRust'i64,
* McsEngl.lagRust-Sunt.i64,
* McsEngl.lagRust-ni.i64,

lagRust-ni.i128

description::
·

name::
* McsEngl.lagRust'i128,
* McsEngl.lagRust-Sunt.i128,
* McsEngl.lagRust-ni.i128,

lagRust-ni.isize

description::
·

name::
* McsEngl.lagRust'isize,
* McsEngl.lagRust-Sunt.isize,
* McsEngl.lagRust-ni.isize,

lagRust-ni.u8

description::
· range: 0-(2^8-1) 256 numbers.

name::
* McsEngl.lagRust'u8,
* McsEngl.lagRust-Sunt.u8,
* McsEngl.lagRust-ni.u8,

lagRust-ni.u16

description::
· range: 0-(2^16-1) 65536 numbers.

name::
* McsEngl.lagRust'u16,
* McsEngl.lagRust-Sunt.u16,
* McsEngl.lagRust-ni.u16,

lagRust-ni.u32

description::
· range: 0-(2^32-1) 4294967296 numbers.

name::
* McsEngl.lagRust'u32,
* McsEngl.lagRust-Sunt.u32,
* McsEngl.lagRust-ni.u32,

lagRust-ni.u64

description::
· range: 0-(2^64-1) 18,446,744,073,709,551,616 numbers.

name::
* McsEngl.lagRust'u64,
* McsEngl.lagRust-Sunt.u64,
* McsEngl.lagRust-ni.u64,

lagRust-ni.u128

description::
· range: 0-(2^128-1) 3,4e+38 numbers.
· bin-code: 128 bit.

name::
* McsEngl.lagRust'u128,
* McsEngl.lagRust-Sunt.u128,
* McsEngl.lagRust-ni.u128,

lagRust-ni.usize

description::
"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::
* McsEngl.lagRust'usize,
* McsEngl.lagRust-Sunt.usize,
* McsEngl.lagRust-ni.usize,

lagRust-n.floating-point

description::
· floating-point is a-number that maps decimal-numbers.

name::
* McsEngl.lagRust-n.decimal!⇒lagRust-nf,
* McsEngl.lagRust-n.floating-point!⇒lagRust-nf,
* McsEngl.lagRust-n.integerNo!⇒lagRust-nf,

lagRust-nf.f32

description::
·

name::
* McsEngl.lagRust'f32,
* McsEngl.lagRust-Sunt.f32,
* McsEngl.lagRust-nf.f32,

lagRust-nf.f64

description::
"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::
* McsEngl.lagRust'f64,
* McsEngl.lagRust-Sunt.f64,
* McsEngl.lagRust-nf.f64,

Sunt.function (f) of lagRust

description::
· source-function of lagRust is a-semantic-unit that PROCESS information.

name::
* McsEngl.lagRust'function!⇒lagRust-f,
* McsEngl.lagRust-Sunt.function!⇒lagRust-f,
* McsEngl.lagRust-f,

generic-tree::
* source--semantic-unit---of-lagRust,
* source-function--of-lagSrc,

lagRust-f.SPECIFIC

description::
* main-function,
* operator,

name::
* McsEngl.lagRust-f.specific,

lagRust.operator

description::
· source-operator of lagRust is a-special function with syntax like math-operators.

name::
* McsEngl.lagRust'operator!⇒lagRust-opr,
* McsEngl.lagRust-Sunt.operator!⇒lagRust-opr,
* McsEngl.lagRust-opr,

generic-tree::
* lagSrc-operator,

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

overloading of opr of lagRust

description::
"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::
* McsEngl.lagRust-opr'overloading,

lagRust-opr.SPECIFIC

description::
* unary-operator,
* binary-operator,
* ternary-operator,

name::
* McsEngl.lagRust-opr.specific,

opr.!33 of lagRust

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

name::
* McsEngl.lagRust'!33--opr,
* McsEngl.lagRust-opr.!33,

opr.!=3361 of lagRust

description::
· 3361 (!=): var != expr: Nonequality comparison: PartialEq
[https://doc.rust-lang.org/book/appendix-02-operators.html]

name::
* McsEngl.lagRust'!=3361--opr,
* McsEngl.lagRust-opr.!=3361,

opr.%37 of lagRust

description::
· 37 (%): expr % expr: Arithmetic remainder: Rem
[https://doc.rust-lang.org/book/appendix-02-operators.html]

name::
* McsEngl.lagRust'%37--opr,
* McsEngl.lagRust-opr.%37,

opr.%=3761 of lagRust

description::
· 3761 (%=): var %= expr: Arithmetic remainder and assignment: RemAssign
[https://doc.rust-lang.org/book/appendix-02-operators.html]

name::
* McsEngl.lagRust'%=3761--opr,
* McsEngl.lagRust-opr.%=3761,

opr.&38 of lagRust

description::
· 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::
* McsEngl.lagRust'&38--opr,
* McsEngl.lagRust-opr.&38,

opr.&=3861 of lagRust

description::
· 3861 (&=): var &= expr: Bitwise AND and assignment: BitAndAssign
[https://doc.rust-lang.org/book/appendix-02-operators.html]

name::
* McsEngl.lagRust'&=3861--opr,
* McsEngl.lagRust-opr.&=3861,

opr.&&3838 of lagRust

description::
· 3838 (&&): expr && expr: Logical AND:
[https://doc.rust-lang.org/book/appendix-02-operators.html]

name::
* McsEngl.lagRust'&&3838--opr,
* McsEngl.lagRust-opr.&&3838,

opr.*42 of lagRust

description::
· 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::
* McsEngl.lagRust'*42--opr,
* McsEngl.lagRust-opr.*42,

opr.*=4261 of lagRust

description::
· 4261 (*=): var *= expr: Arithmetic multiplication and assignment: MulAssign
[https://doc.rust-lang.org/book/appendix-02-operators.html]

name::
* McsEngl.lagRust'*=4261--opr,
* McsEngl.lagRust-opr.*=4261,

opr.+43 of lagRust

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

name::
* McsEngl.lagRust'+43--opr,
* McsEngl.lagRust-opr.+43,

opr.+=4361 of lagRust

description::
· 4361 (+=): var += expr: Arithmetic addition and assignment: AddAssign
[https://doc.rust-lang.org/book/appendix-02-operators.html]

name::
* McsEngl.lagRust'+=4361--opr,
* McsEngl.lagRust-opr.+=4361,

opr.,44 of lagRust

description::
· 44 (,): expr, expr: Argument and element separator:
[https://doc.rust-lang.org/book/appendix-02-operators.html]

name::
* McsEngl.lagRust',44--opr,
* McsEngl.lagRust-opr.,44,

opr.-45 of lagRust

description::
· 45 (-): - expr: Arithmetic negation: Neg
: expr - expr: Arithmetic subtraction: Sub
[https://doc.rust-lang.org/book/appendix-02-operators.html]

name::
* McsEngl.lagRust'-45--opr,
* McsEngl.lagRust-opr.-45,

opr.=4561 of lagRust

description::
· 4561 (=): var -= expr: Arithmetic subtraction and assignment: SubAssign
[https://doc.rust-lang.org/book/appendix-02-operators.html]

name::
* McsEngl.lagRust'=4561--opr,
* McsEngl.lagRust-opr.=4561,

opr.->4562 of lagRust

description::
· 4562 (->): fn(...) -> type, |...| -> type: Function and closure return type:
[https://doc.rust-lang.org/book/appendix-02-operators.html]

name::
* McsEngl.lagRust'->4562--opr,
* McsEngl.lagRust-opr.->4562,

opr..46 of lagRust

description::
· 46 (.): expr.ident: Member access:
[https://doc.rust-lang.org/book/appendix-02-operators.html]

name::
* McsEngl.lagRust'.46--opr,
* McsEngl.lagRust-opr..46,

opr...4646 of lagRust

description::
· 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::
* McsEngl.lagRust'..4646--opr,
* McsEngl.lagRust-opr...4646,

opr...=464661 of lagRust

description::
· 464661 (..=): ..=expr, expr..=expr: Right-inclusive range literal:
[https://doc.rust-lang.org/book/appendix-02-operators.html]

name::
* McsEngl.lagRust'..=464661--opr,
* McsEngl.lagRust-opr...=464661,

opr....464646 of lagRust

description::
· 464646 (...): expr...expr: In a pattern: inclusive range pattern:
[https://doc.rust-lang.org/book/appendix-02-operators.html]

name::
* McsEngl.lagRust'...464646--opr,
* McsEngl.lagRust-opr....464646,

opr./47 of lagRust

description::
· 47 (/): expr / expr: Arithmetic division: Div
[https://doc.rust-lang.org/book/appendix-02-operators.html]

name::
* McsEngl.lagRust'/47--opr,
* McsEngl.lagRust-opr./47,

opr./=4761 of lagRust

description::
· 4761 (/=): var /= expr: Arithmetic division and assignment: DivAssign
[https://doc.rust-lang.org/book/appendix-02-operators.html]

name::
* McsEngl.lagRust'/=4761--opr,
* McsEngl.lagRust-opr./=4761,

opr.:58 of lagRust

description::
· 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::
* McsEngl.lagRust':58--opr,
* McsEngl.lagRust-opr.:58,

opr.;59 of lagRust

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

name::
* McsEngl.lagRust';59--opr,
* McsEngl.lagRust-opr.;59,

opr.;6060 of lagRust

description::
· 6060 (<<): expr << expr: Left-shift: Shl
[https://doc.rust-lang.org/book/appendix-02-operators.html]

name::
* McsEngl.lagRust';6060--opr,
* McsEngl.lagRust-opr.;6060,

opr.;606061 of lagRust

description::
· 606061 (<<=): var <<= expr: Left-shift and assignment: ShlAssign
[https://doc.rust-lang.org/book/appendix-02-operators.html]

name::
* McsEngl.lagRust';606061--opr,
* McsEngl.lagRust-opr.;606061,

opr.;60 of lagRust

description::
· 60 (<): expr < expr: Less than comparison: PartialOrd
[https://doc.rust-lang.org/book/appendix-02-operators.html]

name::
* McsEngl.lagRust';60--opr,
* McsEngl.lagRust-opr.;60,

opr.;6061 of lagRust

description::
· 6061 (<=): expr <= expr: Less than or equal to comparison: PartialOrd
[https://doc.rust-lang.org/book/appendix-02-operators.html]

name::
* McsEngl.lagRust';6061--opr,
* McsEngl.lagRust-opr.;6061,

opr.=61 of lagRust

description::
· 61 (=): var = expr, ident = type: Assignment/equivalence:
[https://doc.rust-lang.org/book/appendix-02-operators.html]

name::
* McsEngl.lagRust'=61--opr,
* McsEngl.lagRust-opr.=61,

opr.==6161 of lagRust

description::
· 6161 (==): expr == expr: Equality comparison: PartialEq
[https://doc.rust-lang.org/book/appendix-02-operators.html]

name::
* McsEngl.lagRust'==6161--opr,
* McsEngl.lagRust-opr.==6161,

opr.=>6162 of lagRust

description::
· 6162 (=>): pat => expr: Part of match arm syntax:
[https://doc.rust-lang.org/book/appendix-02-operators.html]

name::
* McsEngl.lagRust'=>6162--opr,
* McsEngl.lagRust-opr.=>6162,

opr.>62 of lagRust

description::
· 62 (>): expr > expr: Greater than comparison: PartialOrd
[https://doc.rust-lang.org/book/appendix-02-operators.html]

name::
* McsEngl.lagRust'>62--opr,
* McsEngl.lagRust-opr.>62,

opr.>=6261 of lagRust

description::
· 6261 (>=): expr >= expr: Greater than or equal to comparison: PartialOrd
[https://doc.rust-lang.org/book/appendix-02-operators.html]

name::
* McsEngl.lagRust'>=6261--opr,
* McsEngl.lagRust-opr.>=6261,

opr.>>6262 of lagRust

description::
· 6262 (>>): expr >> expr: Right-shift: Shr
[https://doc.rust-lang.org/book/appendix-02-operators.html]

name::
* McsEngl.lagRust'>>6262--opr,
* McsEngl.lagRust-opr.>>6262,

opr.>>=626261 of lagRust

description::
· 626261 (>>=): var >>= expr: Right-shift and assignment: ShrAssign
[https://doc.rust-lang.org/book/appendix-02-operators.html]

name::
* McsEngl.lagRust'>>=626261--opr,
* McsEngl.lagRust-opr.>>=626261,

opr.@64 of lagRust

description::
· 64 (@): ident @ pat: Pattern binding:
[https://doc.rust-lang.org/book/appendix-02-operators.html]

name::
* McsEngl.lagRust'@64--opr,
* McsEngl.lagRust-opr.@64,

opr.^94 of lagRust

description::
· 94 (^): expr ^ expr: Bitwise exclusive OR: BitXor
[https://doc.rust-lang.org/book/appendix-02-operators.html]

name::
* McsEngl.lagRust'^94--opr,
* McsEngl.lagRust-opr.^94,

opr.^=9461 of lagRust

description::
· 9461 (^=): var ^= expr: Bitwise exclusive OR and assignment: BitXorAssign
[https://doc.rust-lang.org/book/appendix-02-operators.html]

name::
* McsEngl.lagRust'^=9461--opr,
* McsEngl.lagRust-opr.^=9461,

opr.|124 of lagRust

description::
· 124 (|): pat | pat: Pattern alternatives:
: expr | expr: Bitwise OR: BitOr
[https://doc.rust-lang.org/book/appendix-02-operators.html]

name::
* McsEngl.lagRust'|124--opr,
* McsEngl.lagRust-opr.|124,

opr.|=12461 of lagRust

description::
· 12461 (|=): var |= expr: Bitwise OR and assignment: BitOrAssign
[https://doc.rust-lang.org/book/appendix-02-operators.html]

name::
* McsEngl.lagRust'|=12461--opr,
* McsEngl.lagRust-opr.|=12461,

opr.||124124 of lagRust

description::
· 124124 (||): expr || expr: Logical OR:
[https://doc.rust-lang.org/book/appendix-02-operators.html]

name::
* McsEngl.lagRust'||124124--opr,
* McsEngl.lagRust-opr.||124124,

opr.?63 of lagRust

description::
· 63 (?): expr?: Error propagation
[https://doc.rust-lang.org/book/appendix-02-operators.html]

name::
* McsEngl.lagRust'?63--opr,
* McsEngl.lagRust-opr.?63,

Sunt.array (a) of lagRust

description::
· source-array of lagRust is an-orderd-list of same type semantic-units with fixed length.
· let a = [1, 2, 3, 4, 5];

name::
* McsEngl.lagRust'array,
* McsEngl.lagRust-a,

Sunt.tuple () of lagRust

description::
· source-tuple of lagRust is an-orderd-list of different type semantic-units with fixed length.
· let t: (i32, f64, u8) = (500, 6.4, 1);

name::
* McsEngl.lagRust-Sunt.tuple,

Sunt.struct () of lagRust

description::
"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::
* McsEngl.lagRust-Sunt.struct!⇒lagRust-struct,
* McsEngl.lagRust-struct,

Sunt.enum () of lagRust

description::
· example:
enum IpAddrKind {
  V4,
  V6,
}

name::
* McsEngl.lagRust-Sunt.enum!⇒lagRust-enum,
* McsEngl.lagRust-enum,

Sunt.trait () of lagRust

description::
"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::
* McsEngl.lagRust'trait!⇒lagRust-trait,
* McsEngl.lagRust-Sunt.trait!⇒lagRust-trait,
* McsEngl.lagRust-trait,

Sunt.instance (literal) of lagRust

description::
· literal of lagRust is an-individual Sunt.

name::
* McsEngl.lagRust-Sunt.instance!⇒lagRust-literal,
* McsEngl.lagRust-literal,

Sunt.instanceNo (type) of lagRust

description::
· type of lagRust is a-generic Sunt.

name::
* McsEngl.lagRust'type!⇒lagRust-type,
* McsEngl.lagRust-Sunt.instanceNo!⇒lagRust-type,

Sunt.named of lagRust

description::
· named-Sunt of lagRust is a-semantic-unit associated with an-identifier.

name::
* McsEngl.lagRust'named-Sunt!⇒lagRust-named-Sunt,
* McsEngl.lagRust-Sunt.named!⇒lagRust-named-Sunt,
* McsEngl.lagRust-named-Sunt,

generic-tree::
* named-Sunt--of-Lsrc,

value of named-Sunt

description::
· value of lagRust is the-semantic-unit associated with an-identifier.

name::
* McsEngl.lagRust'value,
* McsEngl.lagRust-named-Sunt'value,

named-Sunt.variable

description::
· variable of lagRust is a-named-Sunt whose value is immutable but we can-make mutable.
· example:
let s = "hello";
let mut x = 5;

name::
* McsEngl.lagRust'variable!⇒lagRust-var,
* McsEngl.lagRust-named-Sunt.variable!⇒lagRust-var,
* McsEngl.lagRust-var,

named-Sunt.constant

description::
· 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::
* McsEngl.lagRust'constant!⇒lagRust-cnst,
* McsEngl.lagRust-named-Sunt.constant!⇒lagRust-cnst,
* McsEngl.lagRust-cnst,

Sunt.namedNo of lagRust

description::
· anonymous-Sunt is a-semantic-unit NOT associated with an-identifier.

name::
* McsEngl.lagRust'anonymous-Sunt!⇒lagRust-namedNo-Sunt,
* McsEngl.lagRust-namedNo-Sunt,
* McsEngl.lagRust-Sunt.namedNo!⇒lagRust-namedNo-Sunt,

Sunt.heap of lagRust

description::
· heap-Sunt is a-Sunt stored on heap.

name::
* McsEngl.lagRust-heap-Sunt,

pointer of heap-Sunt of lagRust

description::
· pointer of lagRust-heap-Sunt is the-address of the-location of the-Sunt on heap.

name::
* McsEngl.lagRust'pointer,
* McsEngl.lagRust-heap-Sunt'pointer,

length of heap-Sunt of lagRust

description::
· length is the-quantity in bytes, the-Sunt is-using in heap.

name::
* McsEngl.lagRust-heap-Sunt'length,

capacity of heap-Sunt of lagRust

description::
· capacity is the-total quantity in bytes, the-Sunt in heap has-received from the-operating-system.

name::
* McsEngl.lagRust-heap-Sunt'capacity,

Sunt.stack of lagRust

description::
· stack-Sunt is a-Sunt stored on stack.

name::
* McsEngl.lagRust-stack-Sunt,

Sunt.compound of lagRust

description::
"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::
* McsEngl.lagRust-Sunt.compound,

Sunt.compoundNo of lagRust

description::
"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::
* McsEngl.lagRust'scalar-type,
* McsEngl.lagRust-Sunt.compoundNo,
* McsEngl.lagRust-Sunt.primitive,
* McsEngl.lagRust-Sunt.scalar,

algo'phrase of lagRust

name::
* McsEngl.lagRust-algo'phrase,

generic-tree::
* phrase-of-Lsrc,

algo'sentence of lagRust

description::
· source-sentence of lagRust is a-structure of algo-nodes that denotes COMPLETE relations or processes ( 3 + 5 = 8 ).

name::
* McsEngl.lagRust-algo'sentence!⇒lagRust-sentence,
* McsEngl.lagRust-sentence,

generic-tree::
* sentence-of-Lsrc,

sentence.SPECIFIC of lagRust

description::
* assignment-sentence,
* definition-sentence,
* conditional-sentence,
* loop-sentence,
* use-sentence,

name::
* McsEngl.lagRust-sentence.specific,

sentence.loop-gnc of lagRust

description::
* for-sentence,
* loop-sentence,
* while-sentence,

name::
* McsEngl.lagRust'loop-gnc!⇒lagRust-loop-gnc,
* McsEngl.lagRust-loop-gnc,
* McsEngl.lagRust-sentence.loop-gnc!⇒lagRust-loop-gnc,

loop-gnc.for of lagRust

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

name::
* McsEngl.lagRust'for-sentence,
* McsEngl.lagRust-for,
* McsEngl.lagRust-loop-gnc.for,

loop-gnc.loop of lagRust

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

name::
* McsEngl.lagRust'loop-sentence,
* McsEngl.lagRust-loop,
* McsEngl.lagRust-loop-gnc.loop,

loop-gnc.while of lagRust

description::
· example:
let mut number = 3;
while number != 0 {
  println!("{}!", number);
  number -= 1;
}

name::
* McsEngl.lagRust'while-sentence,
* McsEngl.lagRust-while,
* McsEngl.lagRust-loop-gnc.while,

sentence.use of lagRust

description::
· 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::
* McsEngl.lagRust'use-sentence!⇒lagRust-use,
* McsEngl.lagRust-sentence.use!⇒lagRust-use,
* McsEngl.lagRust-use,

algo'section of lagRust

name::
* McsEngl.lagRust-algo'section,

generic-tree::
* section-of-Lsrc,

algo'titledNo-section of lagRust

algo'titled-section of lagRust

algo'root of lagRust

description::
· source-root of lagRust[a] is the-outermost structure of its[a] source-syntax-tree.

name::
* McsEngl.lagRust'root,
* McsEngl.lagRust-algo'root,

generic-tree::
* algo-root--of-lagSrc,

algo.SPECIFIC of lagRust

description::
* library,
* program,

name::
* McsEngl.lagRust-algo.specific,

algo.module of lagRust

description::
"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::
* McsEngl.lagRust'module!⇒lagRust-mod,
* McsEngl.lagRust-mod,

algo.crate of lagRust

description::
· source-crate of lagRust 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::
* McsEngl.lagRust'crate!⇒lagRust-crate,
* McsEngl.lagRust'library!⇒lagRust-crate,
* McsEngl.lagRust-algo.crate!⇒lagRust-crate,

main-module of crate of lagRust

description::
""

name::
* McsEngl.lagRust-crate'main-module,

crate.SPECIFIC of lagRust

description::
* package-registry: https://crates.io/,
===
* standard-library,

name::
* McsEngl.lagRust-crate.specific,

crate.standard of lagRust

description::
"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::
* McsEngl.Rust-Standard-Library!⇒lagRust-std,
* McsEngl.lagRust'standard-library!⇒lagRust-std,
* McsEngl.lagRust-std,

part of lagRust-std

description::
* structs,
* enums,
* unions,
* primitives,
* traits,
* macros,
* functions,
* typedefs,
* constants,
===
* re-exports,
* primitive-types,
* modules,
* macros,

name::
* McsEngl.lagRust-std'part,

module of lagRust-std

description::
·

name::
* McsEngl.lagRust-std'module,

info-resource of lagRust-std

name::
* McsEngl.lagRust-std'Infrsc,

addressWpg::
* https://doc.rust-lang.org/std/,

std::prelude of lagRust

description::
"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::
* McsEngl.lagRust'prelude-of-std!⇒lagRust-prelude,
* McsEngl.lagRust-prelude,
* McsEngl.lagRust-std::prelude!⇒lagRust-prelude,

part of prelude of lagRust

description::
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::
* McsEngl.lagRust-prelude'part,

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

description::
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::
* McsEngl.lagRust'String-struct!⇒lagRust-String,
* McsEngl.lagRust-String,
* McsEngl.lagRust-prelude'String-struct!⇒lagRust-String,
* McsEngl.lagRust-struct.String!⇒lagRust-String,

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

description::
"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::
* McsEngl.lagRust'Vec-struct!⇒lagRust-Vec,
* McsEngl.lagRust'vector!⇒lagRust-Vec,
* McsEngl.lagRust-Vec,
* McsEngl.lagRust-struct.Vec!⇒lagRust-Vec,

generic-tree::
* lagRust-struct,

algo.package of lagRust

description::
"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::
* McsEngl.lagRust'Cargo-package!⇒lagRust-pkg,
* McsEngl.lagRust'package!⇒lagRust-pkg,
* McsEngl.lagRust-pkg,

Cargo.toml-file of package of lagRust

description::
"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::
* McsEngl.lagRust-Cargo.toml,
* McsEngl.lagRust-pkg'Cargo.toml-file!⇒lagRust-Cargo.toml,
* McsEngl.lagRust-source-file.Cargo.toml-file!⇒lagRust-Cargo.toml,

algo.program of lagRust

description::
· source-program of lagRust is a-source-algo WITH an-executing-entry-point.

name::
* McsEngl.lagRust-algo.executable!⇒lagRust-pgm,
* McsEngl.lagRust-algo.program!⇒lagRust-pgm,
* McsEngl.lagRust-pgm,

program.command-line of lagRust

description::
·

name::
* McsEngl.lagRust-pgm.command-line!⇒lagRust-clip,
* McsEngl.lagRust-clip,

info-resource of clip of lagRust

addressWpg::
* https://doc.rust-lang.org/book/ch12-00-an-io-project.html,

program.command-line.no of lagRust

description::
·

name::
* McsEngl.lagRust-pgm.command-line.no!⇒lagRust-guip,
* McsEngl.lagRust-guip,

binary-algo of lagRust

description::
· Rust[a] is a-compiled-language.
· its[a]-algo, written by a-programer, is-compiled to a-binary-algo a-real-machine understands.

name::
* McsEngl.lagRust'binary-algo!⇒lagRust-bin-algo,
* McsEngl.lagRust-bin-algo,

bin-code of bin-algo of lagRust

description::
· bin-code of lagRust is any part of its bin-algo.

name::
* McsEngl.lagRust'bin-code,
* McsEngl.lagRust-bin-algo'code,

bin-algo.SPECIFIC of lagRust

description::
* bin-program,

name::
* McsEngl.lagRust-bin-algo.specific,

bin-algo.program of lagRust

description::
· executable of lagRust is a-bin-algo with an-executable-entry-point.

name::
* McsEngl.lagRust'bin-program!⇒lagRust-exe,
* McsEngl.lagRust'executable!⇒lagRust-exe,
* McsEngl.lagRust-bin-algo.program!⇒lagRust-exe,
* McsEngl.lagRust-exe,

evaluation of lagRust

name::
* McsEngl.lagRust'evaluation,

benefit of lagRust

benefitNo of lagRust

tool of lagRust

name::
* McsEngl.lagRust'tool!⇒lagRust-tool,
* McsEngl.lagRust-tool,

tool.SPECIFIC of lagRust

description::
* rustc,
* cargo,
===
* https://play.rust-lang.org/,

name::
* McsEngl.lagRust-tool.specific,

rustc of lagRust

description::
· rustc is a-lagPrgm-compiler.

name::
* McsEngl.lagRust'compiler!⇒lagRust-rustc,
* McsEngl.lagRust-rustc,
* McsEngl.lagRust-tool.compiler!⇒lagRust-rustc,
* McsEngl.Rust-compiler!⇒lagRust-rustc,

error of rustc

description::
· E0001 to E0725 are-recorded in docs.

name::
* McsEngl.lagRust-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

name::
* McsEngl.lagRust-rustc'Infrsc,

addressWpg::
* https://doc.rust-lang.org/rustc/index.html,
* https://blog.rust-lang.org/2016/04/19/MIR.html,

Cargo of lagRust

description::
· Cargo is Rust’s package-manager and build-tool.

name::
* McsEngl.Rust-Cargo!⇒lagRust-Cargo,
* McsEngl.lagRust'Cargo-tool!⇒lagRust-Cargo,
* McsEngl.lagRust-Cargo,
* McsEngl.lagRust-tool.Cargo!⇒lagRust-Cargo,

command of Cargo

description::
· Cargo is a-command-line tool, so it has many commands that do different things.

name::
* McsEngl.lagRust-Cargo'command!⇒lagRust-Cargo-cmd,
* McsEngl.lagRust-Cargo-cmd,

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

Cargo-cmd.bench of lagRust

description::
* bench: Execute all benchmarks of a local package

name::
* McsEngl.lagRust-Cargo-cmd.bench,

Cargo-cmd.build of lagRust

description::
* build: Compile a local package and all of its dependencies

name::
* McsEngl.lagRust-Cargo-cmd.build,

Cargo-cmd.check of lagRust

description::
* check: Check a local package and all of its dependencies for errors

name::
* McsEngl.lagRust-Cargo-cmd.check,

Cargo-cmd.clean of lagRust

description::
* clean: Remove artifacts that cargo has generated in the past

name::
* McsEngl.lagRust-Cargo-cmd.clean,

Cargo-cmd.clippy-preview of lagRust

description::
* clippy-preview: Checks a package to catch common mistakes and improve your Rust code,

name::
* McsEngl.lagRust-Cargo-cmd.clippy-preview,

Cargo-cmd.doc of lagRust

description::
* doc: Build a package's documentation

name::
* McsEngl.lagRust-Cargo-cmd.doc,

Cargo-cmd.fetch of lagRust

description::
* fetch: Fetch dependencies of a package from the network

name::
* McsEngl.lagRust-Cargo-cmd.fetch,

Cargo-cmd.fix of lagRust

description::
* fix: Automatically fix lint warnings reported by rustc

name::
* McsEngl.lagRust-Cargo-cmd.fix,

Cargo-cmd.generate-lockfile of lagRust

description::
* generate-lockfile: Generate the lockfile for a package

name::
* McsEngl.lagRust-Cargo-cmd.generate-lockfile,

Cargo-cmd.git-checkout of lagRust

description::
* git-checkout: Checkout a copy of a Git repository

name::
* McsEngl.lagRust-Cargo-cmd.git-checkout,

Cargo-cmd.init of lagRust

description::
* init: Create a new cargo package in an existing directory

name::
* McsEngl.lagRust-Cargo-cmd.init,

Cargo-cmd.install of lagRust

description::
* install: Install a Rust binary. Default location is $HOME/.cargo/bin

name::
* McsEngl.lagRust-Cargo-cmd.install,

Cargo-cmd.locate-project of lagRust

description::
* locate-project: Print a JSON representation of a Cargo.toml file's location

name::
* McsEngl.lagRust-Cargo-cmd.locate-project,

Cargo-cmd.login of lagRust

description::
* login: Save an api token from the registry locally. If token is not specified, it will be read from stdin,

name::
* McsEngl.lagRust-Cargo-cmd.login,

Cargo-cmd.metadata of lagRust

description::
* metadata: Output the resolved dependencies of a package, the concrete used versions including overrides, in machine-readable format

name::
* McsEngl.lagRust-Cargo-cmd.metadata,

Cargo-cmd.new of lagRust

description::
* creates a-new cargo-package at <path>
· $ cargo new  path>

name::
* McsEngl.lagRust-Cargo-cmd.new,

Cargo-cmd.owner of lagRust

description::
* owner: Manage the owners of a crate on the registry

name::
* McsEngl.lagRust-Cargo-cmd.owner,

Cargo-cmd.package of lagRust

description::
* package: Assemble the local package into a distributable tarball

name::
* McsEngl.lagRust-Cargo-cmd.package,

Cargo-cmd.pkgid of lagRust

description::
* pkgid: Print a fully qualified package specification

name::
* McsEngl.lagRust-Cargo-cmd.pkgid,

Cargo-cmd.publish of lagRust

description::
* publish: Upload a package to the registry

name::
* McsEngl.lagRust-Cargo-cmd.publish,

Cargo-cmd.read-manifest of lagRust

description::
* read-manifest: Print a JSON representation of a Cargo.toml manifest,

name::
* McsEngl.lagRust-Cargo-cmd.read-manifest,

Cargo-cmd.run of lagRust

description::
* run: Run a binary or example of the local package

name::
* McsEngl.lagRust-Cargo-cmd.run,

Cargo-cmd.rustc of lagRust

description::
* rustc: Compile a package and all of its dependencies

name::
* McsEngl.lagRust-Cargo-cmd.rustc,

Cargo-cmd.rustdoc of lagRust

description::
* rustdoc: Build a package's documentation, using specified custom flags,

name::
* McsEngl.lagRust-Cargo-cmd.rustdoc,

Cargo-cmd.search of lagRust

description::
* search: Search packages in crates.io

name::
* McsEngl.lagRust-Cargo-cmd.search,

Cargo-cmd.test of lagRust

description::
* test: Execute all unit and integration tests and build examples of a local package

name::
* McsEngl.lagRust-Cargo-cmd.test,

Cargo-cmd.uninstall of lagRust

description::
* uninstall: Remove a Rust binary

name::
* McsEngl.lagRust-Cargo-cmd.uninstall,

Cargo-cmd.update of lagRust

description::
* update: Update dependencies as recorded in the local lock file

name::
* McsEngl.lagRust-Cargo-cmd.update,

Cargo-cmd.verify-project of lagRust

description::
* verify-project: Check correctness of crate manifest

name::
* McsEngl.lagRust-Cargo-cmd.verify-project,

Cargo-cmd.version of lagRust

description::
* version: Show version information

name::
* McsEngl.lagRust-Cargo-cmd.version,

Cargo-cmd.yank of lagRust

description::
* yank: Remove a pushed crate from the index

name::
* McsEngl.lagRust-Cargo-cmd.yank,

Cargo-cmd.clippy of lagRust

description::
* clippy:

name::
* McsEngl.lagRust-Cargo-cmd.clippy,

Cargo-cmd.fmt of lagRust

description::
* fmt:

name::
* McsEngl.lagRust-Cargo-cmd.fmt,

Cargo-cmd.miri of lagRust

description::
* miri:

name::
* McsEngl.lagRust-Cargo-cmd.miri,

info-resource of Cargo

name::
* McsEngl.lagRust-Cargo'Infrsc,

addressWpg::
* https://doc.rust-lang.org/cargo/,
* https://doc.rust-lang.org/cargo/guide/,

rustup of lagRust

description::
· rustup doc opens local documentation in your browser.

name::
* McsEngl.lagRust'rustup,
* McsEngl.lagRust-tool.rustup,

human of lagRust

name::
* McsEngl.lagRust'human,

specific::
* creator,
* programer,

human.programer

name::
* McsEngl.lagRust'Rustacean,
* McsEngl.lagRust'programer,

info-resource of lagRust

name::
* McsEngl.lagRust'Infrsc,

addressWpg::
* 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,

ATTRIBUTE of lagRust

description::
· any attribute of lagRust.

name::
* McsEngl.lagRust'attribute!⇒lagRust-att,
* McsEngl.lagRust-att,

DOING of lagRust

name::
* McsEngl.lagRust'doing,

specific::
* main-functing,
* installing,
* updating,
* uninstalling,

main-functing of lagRust

description::
"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::
* McsEngl.lagRust'main-functing,

updating of lagRust

description::
· $ rustup update

name::
* McsEngl.lagRust'updating,

uninstalling of lagRust

description::
· $ rustup self uninstall

name::
* McsEngl.lagRust'unistalling,

EVOLUTING of lagRust

description::
"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::
* McsEngl.lagRust'evoluting,

release of lagRust

description::
"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::
* McsEngl.lagRust'release,

edition of lagRust

description::
"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::
* McsEngl.lagRust'edition,

GENERIC of lagRust

name::
* McsEngl.lagRust'generic,

generic-tree::
* compiled-language,
* statically-typed-language,
* programing-language,
* language,
...
* entity,

lagRust.SPECIFIC

name::
* McsEngl.lagRust.specific,

specific::

meta-info

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

page-wholepath: synagonism.net / worldviewSngo / dirTchInf / lagRust

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 'lagRust' 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:
 
• twitter: @synagonism

webpage-versions::
• version.last.dynamic: 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)