Glossary

This is a list of words which both new and less new Rustaceans might not know the meaning of. Not all words here are Rust-specific.

Words which take only a couple of sentences to explain belong here.

See also Rust Tropes.

CommunityEdit

URLOEdit

Short for users.rust-lang.org. This is the official forum for users of Rust.

IRLOEdit

Short for internals.rust-lang.org. This is the official forum for discussing the design and implementation of Rust.

RustaceanEdit

Rustacean is a term that is used to refer to rust programmers. It is a play on the word "crustacean".

RIIREdit

An acronym for "Rewrite It In Rust". Rustaceans notoriously try to rewrite everything in Rust.

RESFEdit

Short for "Rust Evangelism Strike Force", used to mockingly refer to members of the Rust community who constantly promote Rust and demonize all other languages.

WGEdit

Short for "Working Group" - a group of people who work to improve Rust in some way. See the official list of WGs.

RFCEdit

An acronym for "Request For Comments". Completely separate from the IETF's RFCs, but with a similar concept.

RFCs can be looked up in the RFC book. Active RFCs are listed on rfcbot.rs.

MSRVEdit

Acronym for "Minimum Supported Rust Version". Many crates choose to support older versions of Rust, and so they set an MSRV.

Language conceptsEdit

UBEdit

Main article: Undefined Behavior

Undefined behavior; writing code in a certain way allows the compiler to output any code it wants, and often causes memory safety bugs. Safe Rust can never cause UB, but unsafe code can.

ZSTEdit

A zero-sized type.

DSTEdit

Main article: Dynamically Sized Type

A dynamically-sized type, i.e. a type whose size is not known at compile time.

RAIIEdit

An acronym for "Resource Acquisition Is Initialization", a concept where all data types you have access to are initialized on creation and freed on destruction, so that no values are ever invalid. Idiomatic Rust code uses this extensively. Also common in the C++ world.

HKTsEdit

An acronym for "Higher Kinded Types", a feature of Rust that is yet to be implemented, but has been discussed for many years. These 4 articles explain what they are used for, and what they might look like in Rust in the future:

HRTBEdit

An acronym for "Higher Ranked Trait Bounds" - see Higher Ranked Trait Bounds for more info.

GATEdit

An acronym for "Generic Associated Types", an upcoming feature in Rust.

NLLEdit

An acronym for "Non-lexical lifetimes", which use the MIR to make borrow checking more accurate and permissive. NLL were introduced in Rust 1.31 with the 2018 edition and backported to the 2015 edition in Rust 1.36.

ADTEdit

An algebraic data type, i.e. a sum type (e.g. an enum) or a product type (e.g. a struct or tuple).

Syntactic sugarEdit

A form of syntax that the compiler substitutes with a more general syntax. For example, if let is a syntactic sugar for match. The substitution of syntactic sugar to the most general form is called desugaring.

Compiler internalsEdit

ASTEdit

An acronym for the "Abstract Syntax Tree". The AST is created by parsing Rust code and expanding the macros.

HIREdit

An acronym for "High-level Intermediate Representation". The HIR resembles the AST, except that syntax sugar such as if let is already desugared in the HIR. The HIR is used for type checking.

MIREdit

An acronym for "Mid-level Intermediate Representation". When converting the HIR to the MIR, complex expressions are lowered to a sequence of instructions. The MIR is used for borrow checking. In the first Rust versions, the MIR didn't exist, so the borrow checker used the AST in older Rust versions.

BorrowckEdit

The borrow checker. This part of the compiler validates lifetimes to ensure safety. For example, the borrow checker prevents use-after-free bugs and data races.

LLVMEdit

LLVM is a modular compiler back end that handles code generation in Rust. The name is short for "Low Level Virtual Machine". LLVM was built originally for use in the Clang compiler. The current version used by Rust is LLVM 10.

LLVM IREdit

An acronym for the Intermediate Representation of LLVM. The LLVM IR is generated from the MIR.