Rust

Immutable binding by default — you can't reassign x.

Mutable binding — x can be reassigned.

Shadowing — rebind the same name, even to a new type.

Compile-time constant — type required, always immutable.

Static — a single fixed memory location, 'static lifetime.

Destructuring a tuple in a binding.

`_` discards a value (suppresses the unused warning).

Each value has one owner; assigning a non-Copy value moves it.

Small stack-only types implement Copy — assignment duplicates instead of moving.

Passing a value by value moves it into the function (callee owns it).

Deep copy — explicit, potentially expensive, gives you a second owner.

Drop a value early; runs its Drop impl and frees resources now.

Returning a value moves ownership out to the caller.

Borrow a value to read it without taking ownership.

A single mutable borrow — exclusive access to mutate in place.

Dereference a reference to read or write the pointed-to value.

Prefer &str over &String in parameters — accepts both, via deref coercion.

Owned heap allocation; single owner, for recursive types or large values.

Shared ownership via reference counting (Arc is thread-safe / atomic).

Generic lifetime — ties the output reference's validity to the inputs.

A struct that holds a reference must name that reference's lifetime.

Lives for the whole program — string literals, leaked/global data.

Lifetime elision — compiler infers obvious cases, no annotation needed.

A named-field struct grouping related data.

Enums model 'one of several variants', each able to carry different data.

Tuple struct — fields accessed by position (.0, .1).

Unit struct — no data; useful as a marker or for trait impls.

Struct update syntax — fill remaining fields from another instance.

Auto-implement common traits for a type.

Inherent impl block — define methods and associated functions.

Exhaustive pattern matching — the compiler forces you to handle every case.

Match one pattern concisely, ignoring the rest — great for Option/Result.

Loop while a pattern keeps matching (e.g. draining a stack).

Or-patterns (`|`) and inclusive ranges (`..=`).

Destructure structs/tuples/enums directly in the pattern.

Match guard — an extra boolean condition on an arm.

@ binding — capture the matched value while also testing it.

Models 'a value or nothing' — Rust's safe replacement for null.

Models success-or-failure — Rust's recoverable error type.

The ? operator — propagate the error/None, or unwrap the success value.

Provide a fallback for None/Err without panicking.

Transform / chain fallible computations on Option/Result.

Unwrap, but panic with a custom message on failure (use in tests/setup).

Convert Result<T,E> to Option<T> / Option<E>, discarding the other side.

Define shared behavior; types `impl` the trait to gain it.

Generic function with a trait bound — works for any T that satisfies the bound.

`impl Trait` in argument position — accept any type implementing the trait (static dispatch).

where-clause — readable home for long/complex trait bounds.

Trait object — dynamic dispatch for heterogeneous values (Vec<Box<dyn Draw>>).

Provide a default value; call with T::default().

Convert between types; Into is auto-derived from From.

Growable vector, borrowed slice, fixed-size array.

Owned, growable UTF-8 string vs a borrowed string slice.

Hash map; .entry(k).or_insert(v) for insert-or-update; keys need Eq + Hash.

Iterate by &T / &mut T / by value (consuming the collection).

Slice a range out of a Vec/array/String (half-open: start..end).

Lazy iterator pipelines — compose adapters, then consume once.

An anonymous function that can capture its environment.

Pair items with their index / pair two iterators together.

Reduce a sequence to one value with an accumulator.

First matching element / its index (returns Option).

Let main return Result so `?` works at the top level.

Panic for unrecoverable bugs; Result for expected, recoverable failures.

Cargo — Rust's build tool, package manager, and test runner.

Ergonomic errors: anyhow for apps (one error type), thiserror for libs (derive custom errors).

Unit test — run with `cargo test`.

You used a value after it was moved into something else.

Tried to borrow as mutable while an immutable borrow is still live.

Two mutable borrows of the same value are alive simultaneously.

Returning &local fails — the local is dropped at function end; return an owned value.

A type lacks a required trait (e.g. used `==` without PartialEq); add the bound or derive the trait.