RUSTY YELLOW PAGES

/

Conversations Articles Crates More

Syntax

const false fn let mut true

break continue else for if if let in loop match return while

move ref

as enum struct type union

Self dyn impl self trait where

crate extern crate mod pub super use

async await

extern static unsafe

macro_rules!

abstract become box do final gen override priv try typeof unsized virtual yield

% %= * *= + += - -= / /=

!= < <= == > >=

! && ||

& &= << <<= >> >>= ^ ^= | |=

=

&raw const / &raw mut

Type<Ident = Type>

::

?

'a (named lifetime) 'static for<'a> Type

Binary integer literal Byte literal Byte string literal C string literal Character literal Decimal integer literal Digit separator (_) Escape sequences Float suffixes Floating-point literal Hexadecimal integer literal Integer suffixes Octal integer literal Raw C string literal Raw byte string literal Raw string literal String literal

( ) , -> . .. / ..= / ... : ; => @ Reserved syntax & edition gotchas [ ] _ { }

/* */ (block comment) /*! */ (inner block doc comment) /** */ (outer block doc comment) // (line comment) //! (inner line doc comment) /// (outer line doc comment)

#[meta] / #![meta]

#[cfg(...)] #[cfg_attr(...)]

#[ignore] #[should_panic] #[test]

#[allow(...)] / #[warn(...)] / #[deny(...)] / #[forbid(...)] #[deprecated] #[diagnostic::on_unimplemented] / #[diagnostic::do_not_recommend] #[expect(...)] #[must_use]

#[doc = "..."]

#[automatically_derived] #[derive(...)]

#[macro_export] / #[macro_use] #[proc_macro] / #[proc_macro_derive(...)] / #[proc_macro_attribute]

#[non_exhaustive] #[repr(...)]

#[path = "..."]

#[crate_type = "..."] / #[crate_name = "..."] #[naked] #[no_builtins] #[no_main] #[no_mangle] / #[link(...)] / #[link_name] / #[link_ordinal] / #[link_section] / #[no_link] / #[export_name] #[target_feature(...)] / #[instruction_set(...)] #[used] #[windows_subsystem = "..."]

#![no_std] #[global_allocator] #[no_implicit_prelude] #[panic_handler]

#![feature(...)] #[cold] #[debugger_visualizer(...)] / #[collapse_debuginfo] #[recursion_limit = "N"] / #[type_length_limit = "N"] #[track_caller]

$(...)… $ident $ident:kind ident!(...) / ident!{...} / ident![...]

format! println! / print! / eprintln! / eprint! write! / writeln!

vec!

assert! / assert_eq! / assert_ne! matches! panic! todo! / unimplemented! / unreachable!

cfg! concat! / stringify! / line! / column! / file! / module_path! env! / option_env! include! / include_str! / include_bytes!

Concepts

Borrowing (shared references) Copy vs Clone Deref & DerefMut coercion Immutability by default Interior mutability (Cell & RefCell) Lifetime elision Lifetimes Move semantics Mutable borrowing Ownership RAII & the Drop trait Shared ownership (Rc & Arc) Smart pointers (Box<T>) Stack vs heap allocation The borrow checker Weak references (Weak<T>)

Arrays vs Vec Associated types Const generics Enums (algebraic data types) Generics Numeric types & overflow behavior Recursive types (via Box<T>) Slices Structs The newtype pattern Tuple structs Type aliases Type inference Unit structs Zero-sized types & PhantomData

Blanket implementations Default trait methods Dependency injection via traits/generics Derivable traits (Debug, Clone, PartialEq, …) Marker traits (Send, Sync, Sized, Copy) Operator overloading (std::ops traits) Static dispatch & monomorphization Supertraits The orphan rule & coherence Trait bounds Trait objects & dynamic dispatch (dyn Trait) Traits Type erasure (dyn Any & downcasting)

Closures & capturing Expression-oriented language Fn / FnMut / FnOnce Function pointers (fn types) Functions Higher-order functions

Custom iterators FromIterator & collect targets IntoIterator (iter/iter_mut/into_iter) Iterator adaptors Iterator consumers Lazy evaluation The Iterator trait

Custom error types Option<T> Panic & unwinding Result<T, E> The ? operator (concept angle) The Error trait

Destructuring Exhaustiveness checking Match guards if let / while let match expressions

Cargo & Cargo.toml Crates Dependency management & semver Modules Visibility & privacy (pub and friends) Workspaces

Async runtimes Async/await Futures Message passing (channels / mpsc) Send & Sync Shared-state concurrency (Mutex, RwLock) Threads (std::thread)

FFI (foreign function interface) Memory layout & repr Raw pointers (*const T / *mut T) The undefined-behavior boundary Unsafe Rust

Attribute-like macros Declarative macros (macro_rules!) Derive macros Function-like macros Procedural macros

BTreeMap & BTreeSet HashMap & HashSet String formatting (Display, Debug, format!) String vs &str Vec<T>

Benchmarking Clippy & rustfmt Doc tests Integration tests Serialization (the serde ecosystem) Unit tests

The builder pattern The command pattern The strategy pattern The typestate pattern The visitor pattern

Compose structs Composition over inheritance Constructor functions (new() convention) Contain unsafety in small modules On-stack dynamic dispatch Prefer small crates Privacy for extensibility Return consumed argument on error Temporary mutability The Default trait as idiom mem::take / mem::replace

Anti-pattern: #[deny(warnings)] Anti-pattern: Deref polymorphism (faking inheritance) Anti-pattern: cloning to satisfy the borrow checker

"Make invalid states unrepresentable" Fearless concurrency Memory safety without a garbage collector The edition system Zero-cost abstractions

Home› More

More

Reference material about the site itself, and about how Rust is presented here.

LangColorMap

The colour assigned to each role in Rust syntax, and what each one covers.

Rusty Yellow Pages · a free, open-source Rust reference