The lexicon
60 terms. Each has a plain definition and a sentence showing it in real use — because recognising a word and being able to say it in a design review are different skills.
Where a term is hard to pronounce or is usually abbreviated in speech, that is noted too. See 6.1 for the register and the overclaims to avoid.
Two meanings. &'static T is a reference valid for the whole program. T: 'static is a bound meaning T contains no borrowed data.
"Spawn needs 'static — it doesn't mean forever, it means the future can't borrow from this frame."
A single owner (usually a Vec) holding all nodes, with elements referring to each other by index rather than by pointer.
"Use an arena with indices — you don't want Rc<RefCell<>> for a graph."
A trait the compiler implements automatically and structurally, based on a type's fields. Send, Sync, Unpin.
"Send is an auto trait, so one non-Send field makes the whole struct non-Send."
An implementation covering every type satisfying some bound, e.g. impl<T: Display> ToString for T.
"You get to_string from the blanket impl — just implement Display."
Taking a reference to a value without taking ownership. Shared (&T) or exclusive (&mut T).
"Just borrow it instead of taking it by value — the caller probably still needs it."
The compiler pass that verifies references obey the shared-XOR-exclusive rule and never outlive what they point at.
"It compiles fine until you add the second closure — then borrowck complains."
Whether a future can be dropped part-way through without losing data or leaving state inconsistent. Matters because select! drops losing branches.
"That read isn't cancellation-safe — you'll lose bytes every time the timeout fires."
The official linter. Around 700 lints, many of which teach idiom rather than catching bugs.
"Clippy will tell you to use if let there."
The guarantee that a given trait/type pair has exactly one implementation across the entire program.
"That would break coherence — two crates could each define a different impl."
A compilation unit — either a library or a binary. The unit of dependency and of coherence.
"Split it into two crates so the proc-macro doesn't rebuild every time."
Unsynchronised concurrent access to one location where at least one access is a write. This is what Rust prevents at compile time.
"Rust eliminates data races, not race conditions — those are still on us."
Automatic conversion of &T to &U when T: Deref<Target = U>. Turns &String into &str, &Vec<T> into &[T].
"Take &str — deref coercion means String callers still work."
A hidden runtime boolean tracking whether a conditionally-moved value still needs dropping.
"Conditional moves need a drop flag — it's about the only runtime cost ownership has."
The compiler-generated code that recursively drops a value's fields after its own Drop::drop runs.
"There's no explicit Drop impl, but there's still drop glue for the fields."
A type whose size is unknown at compile time — [T], str, dyn Trait. Can only exist behind a pointer.
"You need ?Sized on that bound if you want it to accept DSTs."
Whether a trait can be used as dyn Trait. Requires a fixed vtable layout, so no generic methods, no Self returns. Called "object safety" before Rust 1.84.
"That trait isn't dyn-compatible because clone returns Self."
An opt-in language dialect (2015, 2018, 2021, 2024) allowing breaking syntax changes without splitting the ecosystem. Crates of different editions interoperate.
"We're on the 2021 edition — migrating to 2024 mostly means explicit unsafe blocks in unsafe fns."
The rules that let you omit lifetime annotations in common cases. Three rules; if none determines the output lifetime, you must write it.
"Elision ties the output to &self here, but you actually want it tied to the input."
The thing that polls futures. Not in std — you choose tokio, smol, embassy, or another.
"Which runtime? That decides half the dependency tree."
A trait implemented for foreign types purely to add methods to them. Imported for its methods, never named again.
"sorted comes from the Itertools extension trait — check the imports."
A two-word pointer. &[T] and &str carry a length; &dyn Trait carries a vtable pointer.
"&dyn Error is a fat pointer, which is why it's sixteen bytes."
The marketing phrase for compile-time data-race prevention. Accurate only in that narrow sense.
"Fearless concurrency means no data races. It doesn't mean no deadlocks."
Cargo enables the union of all features requested for a crate across the dependency graph — which can surprise you when one dependency turns on a feature another did not want.
"That's feature unification — something upstream enabled std on it."
The problem that async-ness propagates up through callers, since an async fn can only be awaited from an async context.
"Making that async colours the whole call stack — it's a bigger change than it looks."
An index carrying a generation counter, so a stale index into a reused slot fails to resolve instead of silently pointing at the wrong element.
"Slotmap gives you generational indices, so removals don't create dangling handles."
A bound quantified over all lifetimes, written for<'a>. The callee supplies the lifetime, not the caller.
"You need an HRTB there — the closure has to work for any lifetime the iterator hands it."
Mutating data through a shared reference, via Cell, RefCell, Mutex and friends — all built on UnsafeCell.
"It takes &self but mutates — interior mutability, so there's a RefCell inside."
A region of code — a set of program points over which a reference must stay valid. Inferred by the compiler, not a duration of time.
"The lifetime here is tied to self, which is why the return value can't outlive the struct."
Default binding modes: matching a reference against a non-reference pattern binds by reference automatically.
"Match ergonomics means s is a &String there, not a move."
An interpreter that detects undefined behaviour at run time. cargo +nightly miri test.
"Does it run under Miri in CI? That tells me more than reading the unsafe."
Generating a separate concrete copy of a generic function for every set of type arguments it is used with, at compile time.
"The build got slow because that generic is monomorphised for forty different types."
Transferring ownership of a value from one place to another. The source becomes unusable. Mechanically a shallow byte copy plus a compile-time mark.
"You moved it into the closure, so it isn't available afterwards."
Minimum Supported Rust Version. The oldest toolchain a crate promises to build on.
"Bumping MSRV is semver-minor by convention, but check — some maintainers treat it as major."
An attribute making it a warning to discard a value. Result and iterators carry it.
"There's a let _ = silencing a must_use — is that deliberate?"
A single-field tuple struct wrapping another type, for orphan-rule reasons or type safety. Zero runtime cost.
"Wrap it in a newtype so you can implement Display for it."
An invalid bit pattern in a type that the compiler can reuse to encode an enum variant, avoiding a separate tag.
"Option is free here — the null pointer is the niche."
Non-lexical lifetimes. The change (Rust 2018) that made a borrow end at its last use rather than at the end of its enclosing block.
"That would have needed an explicit scope before NLL. It's fine now."
A crate that does not depend on the standard library, so it works on embedded targets. core always available; alloc optional.
"It's no_std compatible, so we can share it with the firmware."
To write impl Trait for Type, at least one of the trait or the type must be defined in your crate. Enforces coherence locally.
"Orphan rule — you'll need a newtype wrapper."
A zero-sized marker field making the compiler treat a type as though it contained a T — for typestate, variance, or opting out of auto traits.
"The PhantomData is there to make it !Send deliberately."
Pin promises a value will not move in memory, which is what makes self-referential async state machines sound. Unpin types are exempt.
"Box::pin it — the future isn't Unpin."
A Mutex whose holder panicked is marked poisoned; subsequent lock() calls return Err, since the data may be inconsistent.
"The unwrap on lock is for poisoning — it only fails if another thread panicked holding it."
A logical bug where correctness depends on timing. Distinct from a data race, and NOT prevented by Rust.
"That's a race condition, not a data race — check-then-act across two locks."
Resource Acquisition Is Initialisation: tying resource release to a value's destructor, so cleanup cannot be forgotten.
"It's an RAII guard — the lock is released when it goes out of scope."
An implicit shorter-lived &mut *r created when you pass a &mut somewhere. It is why passing a &mut does not consume it.
"That's a reborrow, so the original is usable again after the call returns."
A public API that cannot cause UB however it is used, built on internal unsafe. Vec and Mutex are examples.
"The unsafe is fine — it's confined behind a safe abstraction with SAFETY comments."
A public trait with a private supertrait, preventing outside crates from implementing it.
"It's sealed, so they can add methods without a breaking change."
Send: a value can be moved to another thread. Sync: &T can be shared between threads. T: Sync if and only if &T: Send.
"It's Send but not Sync — you can move it across threads, just not share it."
A safe API is sound if no safe use of it can cause UB. An unsound API is a bug even if nobody has triggered it.
"That's a soundness hole — safe code can construct an invalid value."
? — unwraps Ok/Some, or returns early converting the error via From.
"Add a question mark and a From impl — you don't need the match."
Two error crates by the same author. thiserror derives concrete error enums for libraries; anyhow provides one opaque error type for binaries.
"thiserror in the library, anyhow in the binary — callers need to match, main just reports."
A value of type dyn Trait, accessed through a fat pointer carrying a data pointer and a vtable pointer.
"Store them as trait objects — you can't have a Vec of different concrete types."
The ::<T> syntax for supplying type arguments explicitly, e.g. collect::<Vec<_>>().
"Add a turbofish or annotate the binding — inference can't pick the type."
Encoding an object's state in its type so invalid operations do not compile.
"It's a typestate builder — send only exists once you've set a body."
Undefined behaviour. The program has no defined meaning, and the compiler may optimise assuming the situation cannot occur.
"That's UB even though it works today — it'll break on the next compiler bump."
The only primitive permitting mutation through a shared reference. Every safe interior-mutability type is built on it.
"At the bottom it's an UnsafeCell, like everything in std::cell."
Whether a longer lifetime may substitute for a shorter one. &'a T is covariant; &'a mut T is invariant in T.
"You can't pass that — &mut is invariant in its contents."
A table of function pointers used to dispatch trait methods dynamically. The second word of a dyn Trait pointer.
"It's one extra indirection through the vtable, so it can't inline."
A scheduler where idle worker threads take tasks from busy ones. Tokio's default; requires Send on tasks.
"It's work-stealing, so the task can resume on a different thread — hence the Send bound."
An abstraction that compiles to code no worse than the hand-written equivalent. Iterator chains and Option<&T> are the canonical examples.
"Iterator chains are genuinely zero-cost here — it compiles to the same loop."
Nothing matches that filter.