https://DevOpsCloud.io -- Cloud Monk Losang Jinpa, Ph.D., MCSE/MCT, GitOps DevOps Engineer

Rust Official Glossary

19. The Rust runtime

20. Rust Appendices
20.1. Rust Macro Follow-Set Ambiguity Formal Specification
20.2. Rust Influences
20.3. Rust Glossary

The Rust Reference

Rust Glossary

Rust Abstract syntax tree - “An ‘abstract syntax tree’, or ‘AST’, is an intermediate representation of the structure of the program when the compiler is compiling it.” (doc.rust-lang.org)

Rust Alignment - “The alignment of a value specifies what addresses values are preferred to start at. Always a power of two. References to a value must be aligned. More.

Rust Arity - “Arity refers to the number of arguments a function or operator takes. For some examples, f(2, 3) and g(4, 6) have arity 2, while h(8, 2, 6) has arity 3. The ! operator has arity 1.

Rust Array - “An array, sometimes also called a fixed-size array or an inline array, is a value describing a collection of elements, each selected by an index that can be computed at run time by the program. It occupies a contiguous region of memory.

Rust Associated item - “An associated item is an item that is associated with another item. Associated items are defined in implementations and declared in traits. Only functions, constants, and type aliases can be associated. Contrast to a free item.

Rust Blanket implementation - “Any implementation where a type appears uncovered. impl<T> Foo for T, impl<T> Bar<T> for T, impl<T> Bar<Vec<T» for T, and impl<T> Bar<T> for Vec<T> are considered blanket impls. However, impl<T> Bar<Vec<T» for Vec<T> is not a blanket impl, as all instances of T which appear in this impl are covered by Vec.

Rust Bound - “Bounds are constraints on a type or trait. For example, if a bound is placed on the argument a function takes, types passed to that function must abide by that constraint.

Rust Combinator - “Combinators are higher-order functions that apply only functions and earlier defined combinators to provide a result from its arguments. They can be used to manage control flow in a modular fashion.

Rust Crate - “A crate is the unit of compilation and linking. There are different types of crates, such as libraries or executables. Crates may link and refer to other library crates, called external crates. A crate has a self-contained tree of modules, starting from an unnamed root module called the crate root. Items may be made visible to other crates by marking them as public in the crate root, including through paths of public modules. More.

Rust Dispatch - “Dispatch is the mechanism to determine which specific version of code is actually run when it involves polymorphism. Two major forms of dispatch are static dispatch and dynamic dispatch. While Rust favors static dispatch, it also supports dynamic dispatch through a mechanism called ‘trait objects’.

Rust Dynamically sized type - “A dynamically sized type (DST) is a type without a statically known size or alignment.

Rust Entity - “An entity is a language construct that can be referred to in some way within the source program, usually via a path. Entities include types, items, generic parameters, variable bindings, loop labels, lifetimes, fields, attributes, and lints.

Rust Expression - “An expression is a combination of values, constants, variables, operators and functions that evaluate to a single value, with or without side-effects.

For example, 2 + (3 * 4) is an expression that returns the value 14.

Rust Free item - “An item that is not a member of an implementation, such as a free function or a free const. Contrast to an associated item.

Rust Fundamental traits - “A fundamental trait is one where adding an impl of it for an existing type is a breaking change. The Fn traits and Sized are fundamental.

Rust Fundamental type constructors - “A fundamental type constructor is a type where implementing a blanket implementation over it is a breaking change. &, &mut, Box, and Pin are fundamental.

Any time a type T is considered local, &T, &mut T, Box<T>, and Pin<T> are also considered local. Fundamental type constructors cannot cover other types. Any time the term “covered type” is used, the T in &T, &mut T, Box<T>, and Pin<T> is not considered covered.

Rust Inhabited - “A type is inhabited if it has constructors and therefore can be instantiated. An inhabited type is not “empty” in the sense that there can be values of the type. Opposite of Uninhabited.

Rust Inherent implementation - “An implementation that applies to a nominal type, not to a trait-type pair. More.

Rust Inherent method - “A method defined in an inherent implementation, not in a trait implementation.

Rust Initialized - “A variable is initialized if it has been assigned a value and hasn't since been moved from. All other memory locations are assumed to be uninitialized. Only unsafe Rust can create a memory location without initializing it.

Rust Local trait - “A trait which was defined in the current crate. A trait definition is local or not independent of applied type arguments. Given trait Foo<T, U>, Foo is always local, regardless of the types substituted for T and U.

Rust Local type - “A struct, enum, or union which was defined in the current crate. This is not affected by applied type arguments. struct Foo is considered local, but Vec<Foo> is not. LocalType<ForeignType> is local. Type aliases do not affect locality.

Rust Module - “A module is a container for zero or more items. Modules are organized in a tree, starting from an unnamed module at the root called the crate root or the root module. Paths may be used to refer to items from other modules, which may be restricted by visibility rules. More

Rust Name - “A name is an identifier or lifetime or loop label that refers to an entity. A name binding is when an entity declaration introduces an identifier or label associated with that entity. Paths, identifiers, and labels are used to refer to an entity.

Rust Name resolution - “Name resolution is the compile-time process of tying paths, identifiers, and labels to entity declarations.

Rust Namespace - “A namespace is a logical grouping of declared names based on the kind of entity the name refers to. Namespaces allow the occurrence of a name in one namespace to not conflict with the same name in another namespace.

Within a namespace, names are organized in a hierarchy, where each level of the hierarchy has its own collection of named entities.

Rust Nominal types - “Types that can be referred to by a path directly. Specifically enums, structs, unions, and trait objects.

Rust Object safe traits - “Traits that can be used as trait objects. Only traits that follow specific rules are object safe.

Rust Path - “A path is a sequence of one or more path segments used to refer to an entity in the current scope or other levels of a namespace hierarchy.

Rust Prelude - “Prelude, or The Rust Prelude, is a small collection of items - mostly traits - that are imported into every module of every crate. The traits in the prelude are pervasive.

Rust Scope - “A scope is the region of source text where a named entity may be referenced with that name.

Rust Scrutinee - “A scrutinee is the expression that is matched on in match expressions and similar pattern matching constructs. For example, in match x { A ⇒ 1, B ⇒ 2 }, the expression x is the scrutinee.

Rust Size - “The size of a value has two definitions.

The first is that it is how much memory must be allocated to store that value.

The second is that it is the offset in bytes between successive elements in an array with that item type.

It is a multiple of the alignment, including zero. The size can change depending on compiler version (as new optimizations are made) and target platform (similar to how usize varies per-platform).

More.

Rust Slice - “A slice is dynamically-sized view into a contiguous sequence, written as [T].

It is often seen in its borrowed forms, either mutable or shared. The shared slice type is &[T], while the mutable slice type is &mut [T], where T represents the element type.

Rust Statement - “A statement is the smallest standalone element of a programming language that commands a computer to perform an action.

Rust String literal - “A string literal is a string stored directly in the final binary, and so will be valid for the 'static duration.

Its type is 'static duration borrowed string slice, &'static str.

Rust String slice - “A string slice is the most primitive string type in Rust, written as str. It is often seen in its borrowed forms, either mutable or shared. The shared string slice type is &str, while the mutable string slice type is &mut str.

Strings slices are always valid UTF-8.

Rust Trait - “A trait is a language item that is used for describing the functionalities a type must provide. It allows a type to make certain promises about its behavior.

Generic functions and generic structs can use traits to constrain, or bound, the types they accept.

Rust Turbofish - “Paths with generic parameters in expressions must prefix the opening brackets with a ::. Combined with the angular brackets for generics, this looks like a fish ::<>. As such, this syntax is colloquially referred to as turbofish syntax.

Examples:

let ok_num = Ok::<_, ()>(5); let vec = [1, 2, 3].iter().map(|n| n * 2).collect::<Vec<_»(); This :: prefix is required to disambiguate generic paths with multiple comparisons in a comma-separate list. See the bastion of the turbofish for an example where not having the prefix would be ambiguous.

Rust Uncovered type - “A type which does not appear as an argument to another type. For example, T is uncovered, but the T in Vec<T> is covered. This is only relevant for type arguments.

Rust Undefined behavior - “Compile-time or run-time behavior that is not specified. This may result in, but is not limited to: process termination or corruption; improper, incorrect, or unintended computation; or platform-specific results. More.

Rust Uninhabited - “A type is uninhabited if it has no constructors and therefore can never be instantiated. An uninhabited type is “empty” in the sense that there are no values of the type. The canonical example of an uninhabited type is the never type !, or an enum with no variants enum Never { }. Opposite of Inhabited.”

Fair Use Sources

Fair Use Sources:

https://doc.rust-lang.org/reference/glossary.html

Rust Vocabulary List (Sorted by Popularity)

GPT o1 Pro mode:

Rust Programming Language, Rust Compiler, Rust Cargo Build Tool, Rust Ownership System, Rust Borrow Checker, Rust Lifetime, Rust Crate, Rust Module, Rust Package, Rust Trait, Rust Struct, Rust Enum, Rust Function, Rust Macro, Rust Pattern Matching, Rust Closure, Rust Iterator, Rust Result Type, Rust Option Type, Rust Error Handling, Rust Vec Type, Rust String Type, Rust Slice Type, Rust Reference, Rust Mutable Reference, Rust Immutable Reference, Rust Smart Pointer, Rust Box Type, Rust Rc Type, Rust Arc Type, Rust Cell Type, Rust RefCell Type, Rust Mutex Type, Rust RwLock Type, Rust Atomic Types, Rust PhantomData, Rust Drop Trait, Rust From Trait, Rust Into Trait, Rust AsRef Trait, Rust AsMut Trait, Rust PartialEq Trait, Rust Eq Trait, Rust PartialOrd Trait, Rust Ord Trait, Rust Hash Trait, Rust Clone Trait, Rust Copy Trait, Rust Default Trait, Rust Debug Trait, Rust Display Trait, Rust ToString Trait, Rust Iterator Trait, Rust DoubleEndedIterator Trait, Rust ExactSizeIterator Trait, Rust FusedIterator Trait, Rust Extend Trait, Rust FromIterator Trait, Rust IntoIterator Trait, Rust Borrow Trait, Rust BorrowMut Trait, Rust Deref Trait, Rust DerefMut Trait, Rust Fn Trait, Rust FnMut Trait, Rust FnOnce Trait, Rust Send Marker Trait, Rust Sync Marker Trait, Rust Unpin Marker Trait, Rust Sized Marker Trait, Rust Unsized Trait, Rust Marker Traits, Rust dyn Trait, Rust Generic Type Parameter, Rust Generic Lifetime Parameter, Rust Generic Associated Type, Rust Generic Constraints, Rust Associated Type, Rust Associated Function, Rust Inherent Implementation, Rust Trait Implementation, Rust Trait Bounds, Rust Trait Object, Rust Impl Keyword, Rust Self Keyword, Rust Super Keyword, Rust Use Keyword, Rust mod Keyword, Rust pub Keyword, Rust crate Keyword, Rust extern Keyword, Rust const Keyword, Rust static Keyword, Rust async Keyword, Rust await Keyword, Rust match Keyword, Rust if let Expression, Rust while let Expression, Rust loop Keyword, Rust for Keyword, Rust break Keyword, Rust continue Keyword, Rust return Keyword, Rust move Keyword, Rust ref Keyword, Rust in Keyword, Rust Box Smart Pointer, Rust Rc Smart Pointer, Rust Arc Smart Pointer, Rust RefCell Interior Mutability, Rust Cell Interior Mutability, Rust Mutex Synchronization, Rust RwLock Synchronization, Rust AtomicBool, Rust AtomicIsize, Rust AtomicUsize, Rust AtomicPtr, Rust NonNull Pointer, Rust ManuallyDrop, Rust MaybeUninit, Rust Pin Type, Rust PhantomPinned, Rust std Library, Rust core Library, Rust alloc Library, io Module, fs Module, net Module, sync Module, thread Module, time Module, mem Module, ptr Module, slice Module, string Module, vec Module, env Module, process Module, collections Module, hash Module, fmt Module, error Module, option Module, result Module, mpsc Channel, atomic Operations, path Module, ffi Module, os Module, task Module, future Module, pin Module, marker Module, any Module, cmp Module, iter Module, ops Module, str Module, num Module, rc Module, Duration, sleep, spawn, args, var, set_var, swap, replace, take, null, null_mut, from_raw_parts, from_raw_parts_mut, from_utf8, Option, Result, Error Trait, Formatter, Display, Debug, Write Trait, Hasher, Hash, HashMap, HashSet, BTreeMap, BTreeSet, VecDeque, BinaryHeap, Iterator, IntoIterator, FromIterator, Add, Sub, Mul, Div, Rem, BitAnd, BitOr, BitXor, Not, Shl, Shr, Deref, DerefMut, Drop, Index, IndexMut, Range, RangeInclusive, RangeFrom, RangeTo, RangeFull, ControlFlow, Wrapping, NonZeroUsize, NonZeroIsize, NonZeroU8, NonZeroU16, NonZeroU32, NonZeroU64, NonZeroU128, NonZeroI8, NonZeroI16, NonZeroI32, NonZeroI64, NonZeroI128, Rust Memory Safety, Rust Zero-Cost Abstractions, Rust Ownership Rules, Rust Move Semantics, Rust Clone Semantics, Rust Copy Semantics, Rust Partial Move, Rust Pattern Destructuring, Rust Type Inference, Rust Sized Type, Rust Unsized Type, Rust Coercion, Rust DST (Dynamically Sized Type), Rust FFI (Foreign Function Interface), Rust C ABI, Rust extern Function, Rust extern Block, [repr(C)], [derive(...)] Attribute, [cfg(...)] Attribute, [test] Attribute, [macro_use] Attribute, [no_mangle] Attribute, [inline] Attribute, [inline(always)] Attribute, [inline(never)] Attribute, [cold] Attribute, [must_use] Attribute, [deny(...)] Attribute, [allow(...)] Attribute, [warn(...)] Attribute, [forbid(...)] Attribute, [non_exhaustive] Attribute, [global_allocator] Attribute, [panic_handler] Attribute, [no_std] Attribute, [no_main] Attribute, [repr(transparent)] Attribute, [repr(packed)] Attribute, [repr(align(...))] Attribute, [export_name(...)] Attribute, [link(...)] Attribute, [used] Attribute, [no_coverage] Attribute, [track_caller] Attribute, Rust Cargo, Rust cargo build, Rust cargo run, Rust cargo test, Rust cargo bench, Rust cargo doc, Rust cargo fmt, Rust cargo clippy, Rust cargo clean, Rust cargo update, Rust cargo publish, Rust cargo login, Rust cargo yank, Rust cargo install, Rust cargo uninstall, Rust cargo tree, Rust cargo metadata, Rust cargo package, Rust cargo fix, Rust cargo generate-lockfile, Rust cargo vendor, Rust cargo +nightly Command, Rust cargo workspace, Rust Cargo.toml, Rust Cargo.lock, Rust crate-type, Rust crate-name, Rust edition (2015), Rust edition (2018), Rust edition (2021), Rust edition (2024 Proposed), Rust rustc Compiler, Rust rustdoc Tool, Rust rustfmt Tool, Rust clippy Linter, Rust miri Interpreter, Rust RLS (Rust Language Server), Rust rust-analyzer, Rust cargo-make, Rust cargo-tarpaulin, Rust cargo-audit, Rust cargo-outdated, Rust cargo-expand, Rust crates.io Registry, Rust Rustup Tool, Rust rustup default, Rust rustup toolchain, Rust rustup component add, Rust rustup target add, Rust stable Channel, Rust beta Channel, Rust nightly Channel, Rust LTS (Hypothetical), Rust MSRV (Minimum Supported Rust Version), Rust RFC (Request For Comments), Rust Edition Guide, Rust The Rustonomicon, Rust The Book (The Rust Programming Language), Rust unsafe Code, Rust unsafe Block, Rust unsafe Fn, Rust unsafe Trait, Rust raw Pointer, Rust *const T, Rust *mut T, Rust Dereferencing Raw Pointer, read, write, replace, transmute, forget, align_of, size_of, zeroed, MaybeUninit, Rust Union Type, Rust extern Crate (Legacy), Rust Edition Imports (no extern keyword), Rust pub(crate) Visibility, Rust pub(super) Visibility, Rust pub(in path) Visibility, Rust pub use Re-export, Rust glob import (*), Rust underscore import (_), Rust name Mangling, Rust LTO (Link Time Optimization), Rust ThinLTO, Rust Profile-Guided Optimization (PGO), Rust Codegen Units, Rust Incremental Compilation, arch Intrinsics, Rust simd Feature, Rust specialization (nightly), Rust const fn, Rust const generics (nightly), Rust async/await, Rust Future Trait, Rust Pin<P> Type, Rust poll Function, Rust Waker, Rust Context (in async), Rust async fn, Rust async move, Rust .await Operator, Rust async Streams (nightly), Rust Generator State, Rust Generator Trait, Rust yield Keyword (nightly), Rust proc_macro Crate, Rust proc_macro_derive Macro, Rust custom_derive Macro, Rust custom_attribute Macro (deprecated), Rust attribute Macro, Rust function-like Macro, Rust declarative Macro, Rust macro_rules! Macro, Rust macro Expansion, Rust Hygiene in Macros, Rust edition macros changes, Rust procedural Macro expansion, Rust Testing Framework, [test] Function, [bench] (deprecated), [should_panic] Attribute, Rust cargo test -- --nocapture, Rust doc Tests, Rust integration Tests directory (tests), Rust benches Directory, Rust examples Directory, Rust microbenchmarking (Criterion crate), Rust fuzz Testing (cargo-fuzz), Rust Miri Testing, Rust code coverage (LLVM), Rust Crate Features (Cargo), Rust optional Dependencies, Rust dev-dependencies, Rust build-dependencies, Rust cargo features, Rust feature flags in Cargo.toml, Rust unstable features (nightly), Rust [patch] section in Cargo.toml, Rust Path dependencies, Rust Git dependencies, Rust HTTP dependencies, Rust local Registries, Rust workspaces in Cargo, Rust crates.io Publishing, Rust crates.io yank, Rust crates.io owners, Rust Documentation Comments ///, ![doc(...)], Rust Documenting Modules, Rust Documenting Struct Fields, Rust Documenting Enum Variants, Rust Documenting Functions, Rust Documenting Traits, Rust Documenting Implementations, Rust Documenting Macros, Rust Documenting Constants, Rust Doc hidden, Rust Doc no_inline, Rust Doc cfg Attributes, Rust Code Examples in Docs, Rust doctest in Documentation, Rust Cross-Compilation, Rust Targets (e.g. wasm32-unknown-unknown), Rust wasm-bindgen Integration, Rust wasm-pack Tool, Rust wasm32-wasi Target, Rust Embedded Development, Rust no_std Environments, Rust alloc Crate in no_std, Rust Core Crate in no_std, [panic_handler], [alloc_error_handler], Rust Naked functions (nightly), Rust inline Assembly (asm! Macro), Rust Linker Arguments in Cargo, Rust build scripts (build.rs), Rust env! Macro, Rust option_env! Macro, Rust include! Macro, Rust include_str! Macro, Rust include_bytes! Macro, Rust concat! Macro, Rust line! Macro, Rust column! Macro, Rust file! Macro, Rust cfg! Macro, Rust stringify! Macro, Rust format! Macro, Rust println! Macro, Rust print! Macro, Rust eprintln! Macro, Rust eprint! Macro, Rust dbg! Macro, Rust panic! Macro, Rust unreachable! Macro, Rust unimplemented! Macro, Rust todo! Macro, Rust assert! Macro, Rust assert_eq! Macro, Rust assert_ne! Macro, Rust compile_error! Macro, Rust concat_idents! Macro (nightly), Rust global_asm! Macro (nightly), Rust log crates Integration, Rust serde Crate Integration, Rust serde_derive Macro, Rust anyhow Crate for Error Handling, Rust thiserror Crate for Error Derives, Rust clap Crate for CLI Arguments, Rust structopt Crate (deprecated in favor of clap), Rust tokio Crate (Async Runtime), Rust async-std Crate, Rust futures Crate, executor, channel, stream, sink, select! Macro, Rust pin_utils Crate, Rust lazy_static Crate (deprecated in favor of once_cell), Rust once_cell Crate, Rust crossbeam Crate, Rust rayon Crate (Data Parallelism), Rust nom Crate (Parsing), Rust regex Crate, Rust hyper Crate (HTTP), Rust reqwest Crate (HTTP Client), Rust warp Crate (Web Framework), Rust rocket Crate (Web Framework), Rust actix-web Crate, Rust axum Crate, Rust tonic Crate (gRPC), Rust prost Crate (Protocol Buffers), Rust capnproto-rust Crate, Rust diesel Crate (ORM), Rust sqlx Crate (Async SQL), Rust rusqlite Crate, Rust mongodb Crate, Rust redis Crate, Rust log Crate, Rust env_logger Crate, Rust tracing Crate, Rust tracing_subscriber Crate, Rust slog Crate, Rust sloggers Crate, Rust structopt Crate, Rust clap_derive Crate, Result, Error, Error Derive, Serialize, Deserialize, Rust serde_json Crate, Rust toml Crate, Rust yaml-rust Crate, Rust bincode Crate, Rust byteorder Crate, Rust rand Crate, Rng Trait, thread_rng, StdRng, SliceRandom, Rust chrono Crate, Utc, DateTime, NaiveDate, App Builder, Arg Builder, StructOpt Derive, main Macro, spawn, select! Macro, mpsc, oneshot, Mutex, RwLock, fs, net, time, Future Trait, Stream Trait, Sink Trait, join! Macro, try_join! Macro, select_biased! Macro, Rust pin_project Crate, pin_project Macro, Rust cfg_if Crate, Rust lazy_static! Macro, Lazy, Lazy, spawn, join, scope, parallel_iterator, prelude, IResult, complete, sequence, branch, combinator, multi, character, Regex, Captures, Server, Request, Response, Body, make_service_fn, service_fn, Client, Response, Error, Filter, Reply, path, query, body, header, Rocket, ignite (Deprecated), build, routes Macro, get Macro, post Macro, State, App, HttpServer, HttpRequest, HttpResponse, Router, routing, extract, Server, Request, Response, Status, Message Trait, EncodeError, DecodeError, prelude, Connection, Queryable Derive, Insertable Derive, Pool, query, query_as, Executor, Connection, params! Macro, Client, Collection, bson, Client, Commands Trait, Rust memory Safety Guarantee, Rust fearless Concurrency, Rust RAII (Resource Acquisition Is Initialization), Rust Zero-cost Interruptions, Rust Minimal Runtime Overhead, Rust Pattern Exhaustiveness, Rust match Guards, Rust let Binding Patterns, Rust destructuring assignment (nightly), Rust never Type (!), Rust Infallible Type, TryFrom, TryInto, FromStr, parse Method, Rust borrowing &T, Rust mutable borrowing &mut T, Rust Deref coercion, Rust Slice Patterns, Rust associated consts, Rust array Types, Rust tuple Types, Rust unit Type (), Rust underscore Lifetimes, Rust underscore Import `_`, Rust underscore Variable `_var`, Rust pub(crate), Rust pub(super), Rust inline Modules mod keyword, Rust nested Modules, item, Rust crate root, Rust crate level attributes, Rust doc tests, Rust doc hidden Items, Rust doc(cfg) attribute, Rust doc include attributes, Rust doc alias attributes, Rust doc comment triple slash ///, Rust doc inline code block, Rust doc code fencing ```, Rust doctest ignore, Rust doctest no_run, Rust doctest compile_fail, Rust doctest should_panic, Rust Benchmarking (nightly), [bench] attribute (deprecated), Rust Criterion Benchmarking, Rust cross compilation with cargo, Rust rustup target list, Rust rustup target add wasm32-unknown-unknown, Rust wasm32-unknown-emscripten Target, Rust cdylib Crate Type, Rust staticlib Crate Type, Rust bin Crate Type, Rust proc-macro Crate Type, [no_main], Rust link Sections, Rust extern crate (deprecated in 2018), identifier, Rust macro 2.0 (procedural macros), Rust macro hygiene improvements, Rust macro pattern matching, Rust macro pattern repetitions, Rust macro capture variables, Rust macro scoping rules, Rust macro modularization, Rust edition idioms, Rust edition linting, Rust Rustfix Tool, Rust cargo fix --edition, Rust lint warnings, Rust deny warnings policy, Rust forbid unsafe code policy, Rust cargo deny Crate, Rust cargo crev Crate (Code Review), Rust cargo geiger (count unsafe)

GPT 4o:

ABI Compatibility, Abstract Data Types, Abstract Syntax Tree, Access Modifiers, Accumulator Idiom, AddAssign Trait, Addition Operator Overloading, Address Sanitizer, Advanced Macros, Affine Types, Alias Types, Alignment, Allocator API, Allocators, Alphanumeric Identifiers, Anonymized Lifetimes, Arc Type, Array Initialization, Array Slices, As Keyword, Async/Await Syntax, Async Functions, Atomic Operations, Atomic Reference Counting, Attribute Macros, Attributes, Await Operator, Backtrace Support, Bare Metal Programming, Beginner Errors, Benchmarking, Binary Crates, Binary Operators, Binding Modes, Bit Manipulation, Bitfields, Bitflags Crate, Bitwise Operators, Block Expressions, Box Smart Pointer, Box Type, Boxed Closures, Boxed Trait Objects, Borrow Checker, Borrow Mutability, Borrowed Pointers, Borrowed Types, Borrowing, Bounds Checking, Break Expressions, Build Automation, Build Dependencies, Build Profiles, Build Scripts, Byte Order, Byte Strings, Bytecode, C ABI Compatibility, C FFI Integration, Cargo Bench Command, Cargo Binaries, Cargo Build Command, Cargo Build Scripts, Cargo Check Command, Cargo Clean Command, Cargo Clippy, Cargo Commands, Cargo Crates, Cargo Doc Command, Cargo Features, Cargo Install Command, Cargo Integration, Cargo Lock File, Cargo Metadata, Cargo New Command, Cargo Package Manager, Cargo Publish Command, Cargo Run Command, Cargo Scripts, Cargo Semver, Cargo Subcommands, Cargo Test Command, Cargo.toml File, Casting Between Types, Cell Type, Character Encoding, Character Literals, Closures as Arguments, Closures, Coercions, Collection Types, Combined Traits, Command Line Arguments, Command Line Parsing, Comment Syntax, Common Lifetime Errors, Common Traits, Compile Time Assertions, Compile Time Errors, Compile Time Function Evaluation, Compile-Time Functions, Compiler Hints, Compiler Internals, Compiler Options, Compiler Plugins, Compiler Warnings, Complex Number Types, Complex Types, Concurrency, Conditional Compilation, Conditional Expressions, Configuration Macros, Configuration Options, Const Context, Const Evaluator, Const Expressions, Const Functions, Const Generics, Const Trait Implementations, Constant Evaluation, Constant Generics, Constant Panic, Constant Promotion, Constructors, Container Types, Content Security Policies, Contextual Keywords, Continue Expressions, Copy Elision, Copy Trait, Covariance, Crate Attributes, Crate Dependencies, Crate Documentation, Crate Export, Crate Features, Crate Graph, Crate Import, Crate Level Attributes, Crate Manifest, Crate Metadata, Crate Registry, Crate Roots, Crate Types, Crate Visibility, Crates, Cross Compilation, Cross-Crate Inlining, Custom Allocators, Custom Attributes, Custom Derive Macros, Custom DSTs, Custom Lints, Custom Macros, Custom Smart Pointers, Custom Test Frameworks, Data Alignment, Data Ownership, Data Races, Data Structures, Data Types, Dead Code Elimination, Debug Trait, Debugging Rust Code, Debugging Symbols, Decimal Literal Suffixes, Default Generic Parameters, Default Implementations, Default Keyword, Default Trait, Deferred Initialization, Deref Coercion, Deref Trait, Derived Traits, Destructuring, Destructor, Deterministic Behavior, Developing Libraries, Diagnostic Messages, Diverging Functions, Doctests, Documentation Comments, Documentation Generation, Double Borrowing, Double-Free Errors, Downcasting, Drop Check, Drop Flag, Drop Glue, Drop Implementation, Drop Trait, Dynamic Dispatch, Dynamic Linking, Dynamic Polymorphism, Dynamic Sized Types, Dyn Trait Syntax, Elided Lifetimes, Else If Expressions, Embedded Development, Encapsulation, Enums with Data, Enum Discriminants, Enum Matching, Enum Variants, Enums, Error Handling in Rust, Error Messages, Error Trait, Escape Analysis, Escape Sequences, Exclusive Borrowing, Existential Types, Exhaustive Matching, Explicit Lifetimes, Expression Lifetimes, Expression Macros, Expressions, Extensible Enums, Extension Traits, Extern Crate, External Crates, External Macros, Extern Function Declarations, Extern Keyword, F32 Type, F64 Type, Fat Pointers, Feature Gates, Field Initializers, Field Offsets, Field Shorthands, Field Visibility, File Inclusion, Final Variables, Finalizers, Fixed Size Arrays, Flag Enums, Float Literal Suffixes, Floating Point Types, Fn Trait, FnMut Trait, FnOnce Trait, For Loop Syntax, Foreign Function Interface, Format Macros, Format Specifiers, Format Strings, Formatting Guidelines, Formatting Traits, Formatters, Forwarding Implementations, Futures, Future Combinators, Future Trait, Garbage Collection in Rust, Generic Associated Types, Generic Bounds, Generic Constraints, Generic Functions, Generic Lifetimes, Generic Parameters, Generic Trait Implementations, Generic Traits, Generics, Global Allocator, Global State, Global Variables, Graphical User Interfaces, Guaranteed Initialization, Hash Map Type, Hash Trait, Hashable Types, Hashing Algorithms, HashSet Type, Heap Allocation, Helper Macros, Higher Kinded Types, Higher Rank Trait Bounds, Higher-Rank Lifetimes, Hir (High-Level Intermediate Representation), Hygiene in Macros, Identifier Hygiene, Identifier Resolution, If Let Expressions, If Let Syntax, If Statements, Immutability, Implementation Blocks, Implicit Conversions, Implicit Lifetimes, Import Declarations, Import Paths, Indexed Access, Index Trait, IndexMut Trait, Infinite Loops, Inferable Types, Inherent Implementations, Inherent Methods, Initialization, Inline Assembly in Rust, Inline Attributes, Inline Functions, Inner Attributes, Input Streams, Integer Casting, Integer Literals, Integer Overflow, Integer Promotions, Integer Types, Integral Types, Integration Tests, Interior Mutability, Interoperability with C, Interoperability with C++, IntoIterator Trait, Into Trait, Intrinsic Functions, Invariant Lifetimes, IO Handling, IO Traits, Irrefutable Patterns, Iterator Adapters, Iterator Combinators, Iterator Trait, Iterators in Rust, Iterator Types, Key-Value Collections, Key-Value Store, Keyword Restrictions, Language Keywords, Labeled Breaks, Labeled Continue, Labeled Loops, Lambda Expressions, Lambdas, Lazy Evaluation, Lazy Static Initialization, Lexical Lifetimes, Lexical Scoping, Lifetime Annotations, Lifetime Bounds, Lifetime Elision Rules, Lifetime Elision, Lifetime Parameters, Lifetime Subtyping, Lifetime Variance, Lifetimes in Closures, Lifetimes, Line Comments, Linked Crates, Linked Lists, Linkage in Rust, Link Time Optimization, Lint Attributes, Linting, Literal Patterns, Literal Suffixes, Literals, Local Crates, Local Variables, Loop Expressions, Loop Labels, Loop Constructs, Macro Expansion, Macro Hygiene, Macro Invocation, Macros By Example, Macros in Rust, Main Function, Manually Drop Type, Manually Implemented Traits, Map Type, Match Arms, Match Expressions, Match Guards, Match Patterns, Match Statement, Memory Allocation, Memory Barriers, Memory Leaks, Memory Management, Memory Safety in Rust, Memory Safety, Meta Variables, Method Chaining, Method Dispatch, Method Overriding, Method Resolution, Methods, Mir (Mid-level Intermediate Representation), Module Attributes, Module Crates, Module Declarations, Module Imports, Module Level Attributes, Module Path, Module Privacy, Module Resolution, Module System, Modules, Monomorphization, Move Semantics, Mutable Aliases, Mutable Bindings, Mutable Borrowing, Mutable References, Mutable Variables, Mutability, Mutex Type, Name Mangling, Namespacing, Nested Closures, Nested Modules, New Type Idiom, Newtype Pattern, Nightly Builds, No Mangle Attribute, Non-Lexical Lifetimes, NonNull References, NonNull Type, Non-Copy Types, Non-Sized Types, Null Pointer Optimization, Null References, Number Literals, Numeric Traits, Object Safety, Object-Oriented Features, Offset Of Macro, Operators Overloading, Option and Result Types, Option Type, Order of Evaluation, Ord Trait, Orphan Rules, OsString Type, Outlives Syntax, Owned Types, Ownership and Borrowing, Ownership Rules, Ownership, Packed Structs, Panicking Behavior, Panic Macro, Panic Safety, Panic Unwind, Parallel Iterators, Parameter Lifetimes, Parameterized Types, Parentheses in Patterns, Partial Eq Trait, Partial Moves, Partial Ord Trait, Pattern Binding Modes, Pattern Guards in Match, Pattern Guards, Pattern Matching, PhantomData Type, Phantom Type Parameters, Pin API, Pinning, Placement New, Platform Abstraction, Platform-Specific Code, Pointer Types, Pointers, Polymorphic Code, Polymorphism, Postfix Macros, Powerful Enumerations, Precedence of Operators, Prefixed Literals, Prelude, Primitive Traits, Primitive Types, Privacy and Visibility, Privacy Rules, Proc Macro Attributes, Proc Macro Crates, Proc Macros, Process Crates, Process Management, Project Layout, Project Module, Promotable Constants, Pub Crate Visibility, Pub Keyword, Pub Restricted Visibility, Public Interfaces, Public Items, Qualified Paths, Question Mark Operator, Raw Identifiers, Raw Literals, Raw Pointers, Rc Type, Reborrowing References, Receiver Types, Re-exports, RefCell Type, Reference Counting, References, Reflexive Traits, Refutable Patterns, Regex Crate, Regression Testing, Regular Expressions, Release Channels, Release Profiles, Repeat Expressions, Repr Attributes, Reserved Keywords, Resource Management, Result Type, Return Type Notation, Return Type Polymorphism, Rewriting, Rust Analyzer, Rust Borrow Checker, Rust Build System, Rust Cargo, Rust Compiler, Rust Crates, Rust Design Patterns, Rust Documentation, Rust Edition, Rust Error Messages, Rust Formatting Tool, Rust Language Server, Rust Macros, Rust Playground, Rust Project, Rust RFCs, Rust Standard Library, Rust Style Guide, Rust Toolchain, Rust Traits, Rust Type System, Rustfmt, Rustlings Exercises, Rustup, Safety Checks, Safety in Rust, Safe Code in Rust, Safe Abstractions, Scoped Threads, Scope of Variables, Semver Compatibility, Send Trait, Shadowing Variables, Shared Libraries, Shared Ownership, Shared References, Shorthand Struct Initialization, Side Effects, Signal Handling, Sized Trait, Sizedness, Slice Patterns, Slice Type, Slices, Smart Pointer Implementations, Smart Pointer Types, Smart Pointers, Soft Keywords, Split Borrowing, Stack Allocation, Stack Memory, Standard Input and Output, Standard Library, State Machine, Static Assertions, Static Dispatch, Static Items, Static Keyword, Static Lifetimes, Static Methods, Static Variables, Statically Sized Types, String Formatting, String Literals, String Manipulation, String Slices, String Type, Strings in Rust, Strong Typing, Struct Definitions, Struct Embedding, Struct Expressions, Struct Fields, Struct Initialization, Struct Patterns in Match, Struct Patterns, Struct Update Syntax, Structs, Structured Concurrency, Submodules, Subtyping in Rust, Subtyping, Supertraits, Synchronization Primitives, Sync Trait, System Programming, Tail Call Optimization, Target Architecture, Target Specifications, Target Triple, Task Management, Task Spawning, Temporary Lifetimes, Temporary Variables, Thread Local Storage, Thread Safety, Thread Safety in Rust, Threads, Time Measurement, To Owned Trait, To String Trait, Toolchains, Trait Aliases, Trait Bounds in Generics, Trait Bounds in Rust, Trait Bounds, Trait Implementations in Rust, Trait Implementations, Trait Objects in Rust, Trait Objects, Trait Parameters, Trait Syntax, Trait Upcasting, Traits, Transitive Dependencies, Transmute Function, Transmute Unsafe, Type Aliases in Rust, Type Aliases, Type Annotations, Type Ascription, Type Checking, Type Coercion, Type Constraints, Type Conversion, Type Erasure in Rust, Type Erasure, Type Families, Type Inference in Rust, Type Inference, Type Layout, Type Lifetimes, Type Mismatch, Type Parameters in Traits, Type Parameters, Type Placeholder, Type Promotion, Type Safety, Type System in Rust, Type System, Type Variance in Rust, Type Variance, Typed Constants, Type-Safe Programming, Typeid Function, Unchecked Indexing, Unchecked Operations, Undefined Behavior, Underscore Imports, Underscore Lifetimes, Underscore Placeholder, Uninitialized Memory, Unit Structs, Universal Function Call Syntax, Unpin Trait, Unreachable Code, Unsafe Blocks, Unsafe Code in Rust, Unsafe Code, Unsafe Functions, Unsafe Trait Implementations, Unsafe Traits in Rust, Unsized Coercions, Unsized Trait, Unsized Types, Untyped Constants, Unused Code Warnings, Unused Import Warnings, Unused Variables, Upcasting in Rust, Use Declarations in Rust, Use Declarations, User-Defined Macros, UTF-8 Encoding, Variable Binding in Rust, Variable Binding, Variable Lifetimes, Variable Scope, Variadic Functions, Variance of Lifetimes, Variance of Types, Vec Deque Type, Vec Type, Vector Type, Vectors in Rust, Visibility in Rust, Visibility Modifiers in Rust, Visibility Modifiers, Volatile Access, Volatile Reads and Writes, Wait Groups, Weak Pointers, Weak Type, WebAssembly Support, WebAssembly Target, While Let Expressions, While Loops in Rust, Wrapping Arithmetic, Yield Expressions, Zero Overhead Abstraction, Zero Sized Types, Zero-Cost Abstractions, Zero-Sized Structs, Zero-Sized Types in Rust, Zero-Sized Types

Rust: Rust Best Practices, Rust Anti-Patterns, Rust Fundamentals, Rust Inventor: Rust Language Designer: Graydon Hoare on July 7, 2010; Cloud Native Rust https://CloudRust.rs, Rust Wasm - Rust WebAssembly https://WebAssembly.rs, Rust in the Cloud https://CloudRust.io, Rust RFCs https://github.com/rust-lang/rfcs, Rust Scripting, Rust Keywords, Rust Built-In Data Types, Rust Data Structures - Rust Algorithms, Rust Syntax, Rust OOP - Rust Design Patterns https://DesignPatterns.rs https://rust-unofficial.github.io/patterns/rust-design-patterns.pdf, Rust Package Manager (cargo-crates.io - Rust Crates - Rust Cargo), Rust Virtualization, Rust Interpreter, Rust REPL, Rust IDEs (JetBrains RustRover, IntelliJ - CLion with JetBrains Rust Plugins, Visual Studio Code), Rust Development Tools, Rust Linter, Rustaceans https://Rustaceans.rs Rust Users - Rust Programmers, List of Rust Software, Rust Popularity, Rust Compiler (rustc), Rust Transpiler, Rust DevOps - Rust SRE, Rust Data Science - Rust DataOps, Rust Machine Learning, Rust Deep Learning, Functional Rust, Rust Concurrency - Rust Parallel Programming - Async Rust, Rust Standard Library, Rust Testing, Rust Libraries, Rust Frameworks, Rust History, Rust Bibliography, Manning Rust Series, Rust Glossary - Rust Official Glossary - Glossaire de Rust - French, Rust Topics, Rust Courses, Rust Research, Rust GitHub, Written in Rust, Rust Awesome List. (navbar_rust - see also navbar_rust_domains)

SYI LU SENG E MU CHYWE YE. NAN. WEI LA YE. WEI LA YE. SA WA HE.

Table of Contents

Rust Official Glossary

Fair Use Sources

Rust Vocabulary List (Sorted by Popularity)