Cheat sheets 📋

Variables

let x = 5;            // immutable
let mut y = 5;        // mutable
y += 1;               // ok, y is mut
const MAX: u32 = 100; // constant
let x = x * 2;        // shadowing

Functions

fn add(a: i32, b: i32) -> i32 {
    a + b   // last expression = return
}

fn greet(name: &str) {  // no return
    println!("Hi, {name}!");
}

Control flow

if x > 5 { ... } else { ... }

let label = if x > 5 { "big" } else { "small" };

for i in 0..10 { ... }      // 0 to 9
for item in &my_vec { ... } // borrow items
while x < 100 { ... }
loop { break; }             // forever, until break

Printing

println!("plain text");
println!("value: {x}");        // inline var
println!("sum: {}", a + b);    // expression
println!("debug: {:?}", vec);  // Debug view
println!("pretty: {:#?}", s);  // multi-line
eprintln!("to stderr");

The three ownership rules

• Every value has exactly one owner.
• When the owner goes out of scope, the value is dropped (freed).
• Assigning or passing a heap value moves ownership (unless you .clone()).

let s1 = String::from("hi");
let s2 = s1;        // s1 MOVED into s2
// println!("{s1}"); // ❌ error: s1 is gone
let s3 = s2.clone(); // deep copy, both valid

The two borrowing rules

• Any number of shared borrows &T, or exactly one mutable borrow &mut T.
• No reference may outlive the data it points to.

fn shout(msg: &String) { ... }      // reads
fn extend(msg: &mut String) { ... } // edits

let mut s = String::from("hi");
shout(&s);        // lend it (read-only)
extend(&mut s);   // lend it (writable)
// s is still ours afterwards ✅

match

match number {
    0 => println!("zero"),
    1 | 2 => println!("one or two"),
    3..=9 => println!("3 through 9"),
    n if n < 0 => println!("negative"),
    _ => println!("something else"),
}

Option & Result patterns

match find_user(id) {
    Some(user) => greet(&user),
    None => println!("no such user"),
}

if let Some(user) = find_user(id) {
    greet(&user);   // only-one-case shortcut
}

let n: i32 = "42".parse()?;  // ? bubbles Err up
let n = "42".parse().unwrap_or(0);

Vec: a growable list

let mut v = vec![1, 2, 3];
v.push(4);                 // add to end
let last = v.pop();        // Option<i32>
let first = v.first();     // Option<&i32>
let n = v[0];              // panics if empty!
let n = v.get(0);          // safe: Option
for x in &v { ... }        // iterate borrowed
v.len();  v.is_empty();  v.contains(&2);

String: owned text

let mut s = String::from("Hello");
s.push_str(", world");     // append &str
s.push('!');               // append char
let joined = format!("{s} x{n}");
s.to_uppercase();  s.trim();  s.len();
for word in s.split(' ') { ... }
let num: i32 = "42".parse().unwrap();

HashMap: key → value

use std::collections::HashMap;

let mut scores = HashMap::new();
scores.insert("ferris", 100);
let s = scores.get("ferris"); // Option<&i32>
*scores.entry("crab").or_insert(0) += 1;
for (name, score) in &scores { ... }

Iterator one-liners

let doubled: Vec<i32> =
    v.iter().map(|x| x * 2).collect();

let evens: Vec<i32> =
    v.iter().filter(|x| *x % 2 == 0)
            .cloned().collect();

let total: i32 = v.iter().sum();
let biggest = v.iter().max();   // Option
v.iter().count();  v.iter().rev();
v.iter().enumerate();  // (index, item)

The toolbox

result.unwrap();      // crash on Err 😬
result.expect("msg"); // crash with message
result.unwrap_or(0);  // fallback value
result.is_ok();       // just checking
result?               // pass Err to caller
option.ok_or("gone")? // Option → Result

Propagating with ?

use std::fs;

fn read_config() -> Result<String, std::io::Error> {
    let text = fs::read_to_string("cfg.txt")?;
    Ok(text.trim().to_string())
}
// caller decides what a missing file means