📖 Guide
Rust — Complete Reference
Comprehensive Rust language cheat sheet covering ownership, traits, pattern matching, concurrency, and more.
137 commands across 12 categories
BasicsOwnership & BorrowingStructs & EnumsPattern MatchingError HandlingTraits & GenericsCollectionsIterators & ClosuresModules & CratesConcurrencyMacrosCommon Std Library
Basics
| Command | Description |
|---|---|
let x = 5; | Immutable variable binding |
let mut x = 5; | Mutable variable binding |
const MAX: u32 = 100; | Compile-time constant (must be type-annotated) |
static GLOBAL: &str = "hi"; | Static variable with 'static lifetime |
let x: i32 = 42; | Explicit type annotation |
let (x, y) = (1, 2); | Destructuring assignment |
let x = { let y = 5; y + 1 }; | Block expression (last expression is the value) |
fn add(a: i32, b: i32) -> i32 { a + b } | Function definition with return type |
let s = String::from("hello"); | Create owned String from string literal |
println!("x = {x}, y = {}", y); | Print with inline and positional formatting |
type Km = i32; | Type alias |
let _ = expensive_call(); | Discard a value (suppress unused warnings) |
Ownership & Borrowing
| Command | Description |
|---|---|
let s2 = s1; | Move ownership — s1 is no longer valid |
let s2 = s1.clone(); | Deep copy — both s1 and s2 are valid |
fn foo(s: &String) | Immutable borrow (shared reference) |
fn foo(s: &mut String) | Mutable borrow (exclusive reference) |
let r = &x; | Create an immutable reference |
let r = &mut x; | Create a mutable reference (x must be mut) |
fn first(s: &str) -> &str | Lifetime elision — compiler infers lifetimes |
fn foo<'a>(x: &'a str) -> &'a str | Explicit lifetime annotation |
struct Foo<'a> { part: &'a str } | Struct holding a reference needs a lifetime parameter |
'statice.g. let s: &'static str = "hello"; | Lifetime that lives for the entire program duration |
Structs & Enums
| Command | Description |
|---|---|
struct Point { x: f64, y: f64 } | Named-field struct |
struct Color(u8, u8, u8); | Tuple struct |
struct Unit; | Unit struct (zero-sized) |
let p = Point { x: 1.0, y: 2.0 }; | Struct instantiation |
let p2 = Point { x: 3.0, ..p }; | Struct update syntax (copy remaining fields) |
impl Point { fn dist(&self) -> f64 { ... } } | Method definition with impl block |
enum Direction { Up, Down, Left, Right } | Simple enum |
enum Option<T> { Some(T), None } | Enum with data (generic) |
enum Message { Quit, Move { x: i32, y: i32 }, Write(String) } | Enum variants can hold different types of data |
#[derive(Debug, Clone, PartialEq)] | Auto-derive common traits for structs/enums |
Pattern Matching
| Command | Description |
|---|---|
match value { pattern => expr } | Match expression — must be exhaustive |
match x { 1 => "one", 2 => "two", _ => "other" } | Match with wildcard catch-all |
match pair { (0, y) => println!("y={y}"), _ => {} } | Destructure tuples in match |
match opt { Some(x) => x, None => 0 } | Match on Option |
match x { 1..=5 => "small", _ => "big" } | Range pattern (inclusive) |
match x { n if n < 0 => "neg", _ => "pos" } | Match guard (extra condition) |
match s { Point { x, y: 0 } => ... } | Destructure struct fields in match |
if let Some(v) = optional { ... } | if let — match single pattern, ignore rest |
while let Some(v) = stack.pop() { ... } | while let — loop while pattern matches |
let (a, b, ..) = (1, 2, 3, 4); | Rest pattern — ignore remaining fields |
match x { val @ 1..=5 => println!("{val}"), _ => {} } | @ binding — bind matched value to a name |
Error Handling
| Command | Description |
|---|---|
Result<T, E> | Type for recoverable errors: Ok(T) or Err(E) |
Option<T> | Type for optional values: Some(T) or None |
let f = File::open("a.txt")?; | ? operator — propagate error to caller |
.unwrap() | Get inner value or panic if Err/None |
.expect("msg") | Like unwrap but with a custom panic message |
.unwrap_or(default) | Get inner value or use provided default |
.unwrap_or_else(|| compute()) | Get inner value or compute default lazily |
panic!("crash") | Unrecoverable error — unwind and abort |
.map_err(|e| MyError::from(e)) | Transform the error type of a Result |
impl From<io::Error> for MyError { ... } | Enable automatic error conversion with ? |
Box<dyn std::error::Error> | Trait object for any error type (quick prototyping) |
Traits & Generics
| Command | Description |
|---|---|
trait Summary { fn summarize(&self) -> String; } | Define a trait with a required method |
impl Summary for Article { fn summarize(&self) -> String { ... } } | Implement a trait for a type |
trait Summary { fn summarize(&self) -> String { String::from("...") } } | Trait with a default method implementation |
fn notify(item: &impl Summary) | impl Trait syntax — accept any type implementing Summary |
fn notify<T: Summary>(item: &T) | Trait bound syntax (equivalent to impl Trait) |
fn foo<T: Clone + Debug>(x: T) | Multiple trait bounds with + |
fn foo<T>(x: T) where T: Clone + Debug | where clause for cleaner bounds |
fn largest<T: PartialOrd>(list: &[T]) -> &T | Generic function with trait bound |
struct Wrapper<T> { value: T } | Generic struct |
impl<T: Display> ToString for T { ... } | Blanket implementation |
fn returns() -> impl Summary | Return an opaque type implementing a trait |
dyn Traite.g. Box<dyn Summary> | Trait object for dynamic dispatch |
Collections
| Command | Description |
|---|---|
let v: Vec<i32> = Vec::new(); | Create empty vector |
let v = vec![1, 2, 3]; | Create vector with macro |
v.push(4); | Append element to vector |
v.pop() | Remove and return last element (Option<T>) |
&v[0] / v.get(0) | Index access (panics) vs safe access (returns Option) |
let mut map = HashMap::new(); | Create empty HashMap |
map.insert(key, value); | Insert or overwrite entry |
map.entry(key).or_insert(default) | Insert only if key doesn't exist |
map.get(&key) | Look up value (returns Option<&V>) |
let set: HashSet<i32> = HashSet::new(); | Create empty HashSet |
let vd: VecDeque<i32> = VecDeque::new(); | Double-ended queue |
let bmap: BTreeMap<K, V> = BTreeMap::new(); | Sorted map (keys implement Ord) |
Iterators & Closures
| Command | Description |
|---|---|
let add = |a, b| a + b; | Closure (anonymous function) |
let add = |a: i32, b: i32| -> i32 { a + b }; | Closure with explicit type annotations |
move || { println!("{x}"); } | move closure — takes ownership of captured variables |
.iter() | Iterate over immutable references (&T) |
.iter_mut() | Iterate over mutable references (&mut T) |
.into_iter() | Iterate by consuming (takes ownership) |
.map(|x| x * 2) | Transform each element |
.filter(|x| x > &5) | Keep elements matching predicate |
.collect::<Vec<_>>() | Consume iterator into a collection |
.fold(0, |acc, x| acc + x) | Reduce to single value with accumulator |
.enumerate() | Yield (index, value) pairs |
.zip(other) | Pair elements from two iterators |
.flat_map(|x| x.chars()) | Map then flatten nested iterators |
.any(|x| x > 5) / .all(|x| x > 0) | Short-circuit boolean checks |
Modules & Crates
| Command | Description |
|---|---|
mod my_module; | Declare module (loads from my_module.rs or my_module/mod.rs) |
mod inner { pub fn hello() {} } | Inline module definition |
pub fn / pub struct / pub enum | Make items public (private by default) |
pub(crate) fn internal() | Visible within the crate only |
use std::collections::HashMap; | Bring item into scope |
use std::io::{self, Read, Write}; | Import multiple items from same path |
use crate::utils::helper; | Absolute path from crate root |
use super::parent_fn; | Relative path to parent module |
pub use crate::inner::Thing; | Re-export — expose item at a different path |
extern crate serde; | Link external crate (rarely needed in edition 2021+) |
Concurrency
| Command | Description |
|---|---|
std::thread::spawn(|| { ... }) | Spawn a new OS thread |
handle.join().unwrap() | Wait for thread to finish |
let (tx, rx) = mpsc::channel(); | Create message-passing channel |
tx.send(val).unwrap() | Send value through channel (moves ownership) |
rx.recv().unwrap() | Blocking receive from channel |
Arc::new(data) | Atomic reference counted pointer (thread-safe Rc) |
Arc::clone(&arc) | Clone Arc (increments reference count) |
Mutex::new(data) | Mutual exclusion lock |
let val = mutex.lock().unwrap(); | Acquire mutex lock (blocks until available) |
RwLock::new(data) | Reader-writer lock (multiple readers OR one writer) |
async fn fetch() -> Result<()> { ... } | Async function (returns a Future) |
value.await | Await a Future inside an async context |
Macros
| Command | Description |
|---|---|
println!("Hello, {name}!"); | Print to stdout with newline |
eprintln!("error: {e}"); | Print to stderr |
format!("x = {x}") | Format string into String (no I/O) |
dbg!(&value) | Debug print with file/line info (returns value) |
todo!() | Placeholder — compiles but panics at runtime |
unimplemented!() | Placeholder for code not yet written — panics at runtime |
assert!(condition); | Panic if condition is false |
assert_eq!(a, b); | Panic if a != b (shows both values) |
vec![1, 2, 3] | Create Vec from literal values |
cfg!(target_os = "linux") | Compile-time configuration check (returns bool) |
#[cfg(test)] mod tests { ... } | Conditional compilation — only in test builds |
Common Std Library
| Command | Description |
|---|---|
String::from("hello") / "hello".to_string() | Create owned String from &str |
s.as_str() / &s | Borrow String as &str |
s.contains("world") | Check if string contains substring |
s.split(',').collect::<Vec<&str>>() | Split string by delimiter |
s.trim() / s.trim_start() / s.trim_end() | Remove whitespace |
s.replace("old", "new") | Replace all occurrences in string |
fs::read_to_string("file.txt")? | Read entire file to String |
fs::write("file.txt", contents)? | Write string to file (creates/overwrites) |
Path::new("/tmp/foo.txt").exists() | Check if path exists |
std::env::args().collect::<Vec<String>>() | Get command-line arguments |
std::time::Instant::now() | High-precision monotonic clock |
duration.as_secs() / .as_millis() | Convert Duration to numeric |
📖 Free, searchable command reference. Bookmark this page for quick access.