Rust — The Cheat Sheet

cheat sheet · rust

The Rust
Cheat Sheet

A systems language focused on safety, speed, and fearless concurrency — with no garbage collector. If it compiles, it usually works.

Hello, World

fn main() {
    println!("Hello, Rustacean!");
}

println! is a macro (note the !). Build & run with cargo run.

Variables & Mutability

let x = 5;            // immutable by default
let mut y = 10;       // mutable
y += 1;

const MAX: u32 = 100_000;

// shadowing: re-bind, even new type
let s = "   ";
let s = s.len();      // now a usize

Bindings are immutable unless marked mut. Shadowing creates a brand-new variable.

Basic Types

// scalar
i8 i16 i32 i64 i128 isize
u8 u16 u32 u64 u128 usize
f32 f64
bool   // true / false
char   // 'a' — 4 bytes, a Unicode scalar

// compound
let tup: (i32, f64) = (1, 2.0);
let (a, b) = tup;          // destructure
let arr: [i32; 3] = [1, 2, 3];

Integers default to i32, floats to f64. Arrays have a fixed length baked into the type.

Functions

fn add(a: i32, b: i32) -> i32 {
    a + b          // last expr, no `;` = return
}

fn greet(name: &str) {
    println!("hi {name}");
}

// early return
fn sign(n: i32) -> i32 {
    if n < 0 { return -1; }
    1
}

A trailing expression without a semicolon is the return value. Types are required on parameters.

⎇

Control Flow

// if is an expression
let n = if cond { 1 } else { 2 };

match x {
    1 => println!("one"),
    2 | 3 => println!("two or three"),
    4..=6 => println!("four to six"),
    _ => println!("anything else"),
}

match must be exhaustive — the compiler checks every case is covered. _ is the catch-all.

↻

Loops

loop {
    if done { break; }
}

// loop can return a value
let r = loop {
    c += 1;
    if c == 10 { break c * 2; }
};

while n < 100 { n *= 2; }

for i in 0..5 { ... }      // 0,1,2,3,4
for x in &vec { ... }      // borrow each

Three loop keywords: loop, while, for. Only loop can break with a value.

◆

Ownership

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

// Copy types are duplicated, not moved
let x = 5;
let y = x;            // both i32s still valid

Each value has one owner. When the owner goes out of scope, the value is dropped — no GC needed.

Borrowing & References

// &T = shared (read-only) borrow
fn len(s: &String) -> usize { s.len() }
let s = String::from("hi");
len(&s);              // s still usable

// &mut T = exclusive mutable borrow
fn grow(s: &mut String) { s.push('!'); }
let mut s = String::from("hi");
grow(&mut s);

The rule: any number of &T, OR exactly one &mut T — never both at once.

▦

Structs & impl

struct Point { x: i32, y: i32 }

let p = Point { x: 1, y: 2 };

struct Color(u8, u8, u8);  // tuple struct

impl Point {
    // associated fn (no self) — a constructor
    fn new(x: i32, y: i32) -> Self {
        Point { x, y }
    }
    // method (&self)
    fn sum(&self) -> i32 { self.x + self.y }
}
Point::new(1, 2).sum();

Methods live in impl blocks. :: calls associated functions; . calls methods.

⊕

Enums & Patterns

enum Shape {
    Circle(f64),
    Rect { w: f64, h: f64 },
    Unit,
}

let s = Shape::Circle(2.0);
match s {
    Shape::Circle(r) => r * r * 3.14,
    Shape::Rect { w, h } => w * h,
    Shape::Unit => 0.0,
};

Enum variants can carry data. match destructures them directly — the heart of Rust modeling.

Option & Result

// no null — absence is Option
enum Option<T> { Some(T), None }
// errors are Result, returned as values
enum Result<T, E> { Ok(T), Err(E) }

if let Some(v) = maybe { use_it(v); }

// `?` propagates the Err / None early
fn load() -> Result<String, io::Error> {
    let s = fs::read_to_string("f")?;
    Ok(s)
}
x.unwrap_or(0);  x.expect("msg");

There is no null. The ? operator is the idiomatic way to bubble errors up.

[ ]

Vec & HashMap

let mut v: Vec<i32> = Vec::new();
v.push(1);
let v = vec![1, 2, 3];
v[0];   v.len();   v.get(0); // Option

use std::collections::HashMap;
let mut m = HashMap::new();
m.insert("a", 1);
m.get("a");              // Option<&i32>
*m.entry("a").or_insert(0) += 1;

vec![] is the quick builder. Indexing panics out of bounds; .get() returns an Option.

Strings

let a: &str = "borrowed slice";
let mut s = String::from("hi"); // owned
s.push_str(" there");
s.push('!');

let joined = format!("{} {}", a, s);
let n = s.len();        // bytes, not chars!
for ch in s.chars() { ... }
s.split(' ');  s.trim();  s.to_uppercase();

&str is a borrowed view; String is owned and growable. .len() counts bytes — iterate .chars() for characters.

⌘

Traits

trait Area {
    fn area(&self) -> f64;
    fn name(&self) -> &str {  // default
        "shape"
    }
}

impl Area for Circle {
    fn area(&self) -> f64 { 3.14 * self.r * self.r }
}

// accept anything that implements Area
fn show(x: &impl Area) { x.area(); }

Traits are Rust's shared behavior (like interfaces). Derive common ones: #[derive(Debug, Clone)].

<T>

Generics

// T must support comparison
fn largest<T: PartialOrd>(list: &[T]) -> &T {
    let mut max = &list[0];
    for item in list {
        if item > max { max = item; }
    }
    max
}

struct Wrapper<T> { value: T }

// where-clause for readability
fn f<T>(t: T) where T: Clone + Debug { ... }

Generics are monomorphized — zero runtime cost. Trait bounds say what a type must be able to do.

⟜

Closures & Iterators

let add = |a, b| a + b;
let inc = |x: i32| x + 1;

let v = vec![1, 2, 3, 4];
let sum: i32 = v.iter().sum();

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

Iterators are lazy — nothing runs until a consumer like collect, sum, or for drives them.

Lifetimes

// 'a ties the output to the inputs
fn longest<'a>(x: &'a str, y: &'a str)
    -> &'a str
{
    if x.len() > y.len() { x } else { y }
}

// a struct that holds a reference
struct Holder<'a> {
    part: &'a str,
}

Lifetimes are annotations, not runtime cost — they tell the borrow checker how long references stay valid.

⫶

Concurrency

use std::thread;
let h = thread::spawn(|| {
    println!("from a thread");
});
h.join().unwrap();

// shared state: Arc + Mutex
use std::sync::{Arc, Mutex};
let data = Arc::new(Mutex::new(0));
let d = Arc::clone(&data);
*d.lock().unwrap() += 1;

// channels
let (tx, rx) = mpsc::channel();
tx.send(42).unwrap();
rx.recv().unwrap();

Fearless concurrency: the type system rejects data races at compile time. Share with Arc<Mutex<T>>.

□

Smart Pointers

Box<T>      // heap value, single owner
Rc<T>       // shared owners, single-thread
Arc<T>      // shared owners, thread-safe
RefCell<T>  // interior mutability (runtime check)

let b = Box::new(5);
let shared = Rc::new(vec![1, 2]);
let also = Rc::clone(&shared);  // +1 ref

Reach for Box for recursion/heap, Rc/Arc for shared ownership, RefCell for interior mutability.

⌗

Cargo (CLI)

cargo new myapp          # scaffold a project
cargo run               # build + run (debug)
cargo build --release   # optimized binary
cargo check             # fast type-check only
cargo test              # run tests
cargo fmt               # format code
cargo clippy            # lints & suggestions
cargo add serde         # add a dependency
cargo doc --open        # build & view docs

Dependencies live in Cargo.toml. Tests are #[test] functions; run the whole suite with cargo test.

Satyam Kumar Das Founder & Solutions Architect · AppScale LLP

satyam@appscale.in
linkedin.com/in/satyamkumar