Rust Cheat Sheet

By Bogdan Sandu · Updated August 19, 2026

What Rust Is

Rust is a compiled systems programming language built around one idea: memory safety without a garbage collector. The compiler proves that your references are valid before the program ever runs, so an entire class of bugs never reaches production.

Graydon Hoare started it as a personal project in 2006, Mozilla sponsored it from 2009, and version 1.0 shipped in May 2015. The Rust Foundation has stewarded the language since 2021, with members including AWS, Google, Microsoft, and Huawei.

It now runs in the Linux kernel, in Windows, in Android, in Firefox, in Cloudflare's edge network, and inside AWS Firecracker. Developers have voted it the most admired language in the Stack Overflow survey every year since 2016.

The trade is simple. You spend more time convincing the compiler up front, and in exchange you get C-level performance with none of the null pointer dereferences, use-after-free bugs, buffer overflows, or data races.

Rust Syntax Basics

Rust reads like a curly-brace language with a functional accent. Most constructs are expressions, semicolons matter, and types appear after the name.

Variables and mutability

Every binding is immutable unless you write mut. This is the reverse of most languages and it is deliberate: shared mutable state is where concurrency bugs come from.

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

const MAX: u32 = 100_000;   // compile-time constant, type required

Shadowing lets you reuse a name with a different type, which is common when parsing input.

let input = "42";
let input: i32 = input.parse().unwrap();

Functions and expressions

A function body's last expression is its return value when you leave off the semicolon. Adding that semicolon turns the expression into a statement that evaluates to unit, which is the single most common compile error for newcomers.

fn add(a: i32, b: i32) -> i32 {
    a + b       // returned
}

fn add_wrong(a: i32, b: i32) -> i32 {
    a + b;      // error: expected i32, found ()
}

Control flow

There is no ternary operator because if is already an expression. Both branches must have the same type.

let label = if n % 2 == 0 { "even" } else { "odd" };

for i in 0..5 { }           // 0 to 4
for item in &collection { } // borrow each item
while let Some(x) = stack.pop() { }

Ownership, Borrowing, and Lifetimes

This is the part that makes Rust different from every mainstream language, and it is the part worth understanding properly before anything else.

The ownership model

Three rules cover it. Each value has exactly one owner. There is only one owner at a time. When the owner goes out of scope, the value is dropped and its memory is released.

let a = String::from("hello");
let b = a;              // ownership moves to b
// println!("{a}");     // error: value borrowed after move

Nothing was copied there. The pointer, length, and capacity moved into b, and a was invalidated so the same heap buffer can never be freed twice. Types that are cheap to duplicate, such as integers and bool, implement Copy and are duplicated instead of moved.

Borrowing

Passing ownership everywhere would be exhausting, so you borrow instead. A borrow is a reference that does not take ownership.

fn length(s: &String) -> usize { s.len() }   // shared borrow
fn shout(s: &mut String) { s.push_str("!"); } // exclusive borrow

The rule is short: you may have any number of shared references, or exactly one mutable reference, never both at once. That single invariant is what eliminates data races at compile time.

Lifetimes

Lifetime annotations describe how long references remain valid. They never change runtime behaviour, they only give the compiler enough information to check what you already meant.

fn longest<'a>(a: &'a str, b: &'a str) -> &'a str {
    if a.len() > b.len() { a } else { b }
}

Thanks to elision rules, most functions need no annotations at all. You mainly write them when a function returns a reference derived from more than one input, or when a struct stores a reference.

Types and Data Modelling

Rust models data with structs for "this and that" and enums for "this or that". Enums carry data, which makes them far more useful than in C or Java.

Structs

struct User { name: String, age: u32 }

impl User {
    fn new(name: &str) -> Self {
        Self { name: name.to_string(), age: 0 }
    }
    fn birthday(&mut self) { self.age += 1; }
}

Enums and pattern matching

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

let area = match shape {
    Shape::Circle(r) => 3.14159 * r * r,
    Shape::Rect { w, h } => w * h,
};

match is exhaustive. If you add a variant later, every match on that enum stops compiling until you handle the new case. That is not an inconvenience, it is a refactoring safety net.

No null, no exceptions

Rust has neither. Absence is modelled by Option<T> and failure by Result<T, E>, both ordinary enums from the standard library. The compiler forces you to acknowledge both possibilities.

Error Handling in Practice

The ? operator is the workhorse. It unwraps on the success path and returns early on the failure path, converting the error type through the From trait as it goes.

fn load(path: &str) -> Result<Config, ConfigError> {
    let text = std::fs::read_to_string(path)?;
    let cfg: Config = toml::from_str(&text)?;
    cfg.validate()?;
    Ok(cfg)
}

Two crates dominate real projects. Use thiserror in libraries, where callers need to match on specific error variants. Use anyhow in applications, where you mostly want context strings and a readable report at the top level.

Reserve unwrap() for tests, prototypes, and cases where a failure genuinely means a bug in your own code. In anything long lived, prefer expect() with a message that explains the violated assumption.

Traits, Generics, and Zero-Cost Abstraction

Traits are Rust's answer to interfaces, and generics are how one function serves many types. Together they give abstraction that costs nothing at runtime.

trait Area {
    fn area(&self) -> f64;
    fn describe(&self) -> String {
        format!("area is {:.2}", self.area())
    }
}

fn total<T: Area>(items: &[T]) -> f64 {
    items.iter().map(|i| i.area()).sum()
}

When you call a generic function, the compiler generates a specialised copy for each concrete type used. This is called monomorphisation, and it means the generic version runs exactly as fast as a hand-written one.

When you need different concrete types in the same collection, switch to a trait object with Box<dyn Trait>. That costs one pointer indirection per call and prevents inlining, so use it when you need the flexibility rather than by default.

Iterators

Iterator chains are lazy and compile down to the same machine code as an equivalent loop. Nothing executes until a consuming adapter such as collect, sum, or for pulls values through.

let names: Vec<String> = users
    .iter()
    .filter(|u| u.active)
    .map(|u| u.name.to_uppercase())
    .collect();

Concurrency Without Data Races

Two marker traits carry the whole model. Send means a value can be moved to another thread. Sync means a reference to it can be shared with another thread. The compiler derives both automatically and rejects any code that would violate them.

use std::sync::{Arc, Mutex};
use std::thread;

let counter = Arc::new(Mutex::new(0));
let mut handles = vec![];

for _ in 0..8 {
    let c = Arc::clone(&counter);
    handles.push(thread::spawn(move || { *c.lock().unwrap() += 1; }));
}
for h in handles { h.join().unwrap(); }

Try to share a plain Rc between threads and the code will not compile, because Rc is not Send. The mistake is caught at build time rather than as an intermittent production failure.

For asynchronous work, Rust ships the async and await syntax but no runtime. Tokio is the default choice for network services, and async-std or smol serve narrower needs.

Cargo, the Reason Rust Tooling Feels Good

Cargo is the build system, package manager, test runner, documentation generator, and publisher in one binary. There is no separate build file format to learn and no plugin ecosystem to assemble.

Doc comments are written in Markdown, and any fenced code block inside them is compiled and run by cargo test, so your examples cannot silently rot.

cargo check deserves a special mention. It performs the full type and borrow analysis without generating machine code, so it returns in a fraction of the time of a build. Most Rust developers keep it running on save.

When Rust Is the Right Choice

Rust is not a universal replacement. It earns its keep in specific situations.

• Systems and infrastructure: operating system components, drivers, embedded firmware, databases, and network proxies where predictable latency matters.
• Performance-critical services: request handlers, parsers, and pipelines where garbage collection pauses are unacceptable.
• WebAssembly: Rust produces some of the smallest and fastest wasm modules, which is why it dominates that space.
• CLI tools: single static binaries with no runtime dependency, which is why ripgrep, fd, bat, and uv are written in Rust.
• Replacing C or C++ selectively: rewriting the memory-unsafe core of an existing codebase while leaving the rest in place.

The surrounding toolchain is ordinary. Pattern matching on text uses the regex crate with the syntax in our regex cheat sheet, database work with sqlx expects the same SQL you already write, and a release binary drops into a scratch Docker image with no runtime to install.

It is a weaker fit for quick data exploration scripts, for teams with no appetite for a learning curve, or for problems where an existing library ecosystem in another language already solves everything.

How Rust compares

Learning Path That Actually Works

The order matters more than the material, because the borrow checker punishes anyone who skips ahead.

• Week one: syntax, ownership, borrowing, and the standard collections. Do not fight lifetimes yet, and clone freely while you learn.
• Week two: enums, pattern matching, Option, Result, and the ? operator. Build a small command line tool.
• Week three: traits, generics, and iterators. This is where the language starts to feel productive rather than restrictive.
• Week four: lifetimes properly, smart pointers, and then either threads or async depending on what you are building.
• Ongoing: read the compiler errors slowly. Rust's diagnostics usually name the exact fix, which is a genuine advantage over most toolchains.

If you are arriving from another stack, the fastest way in is to translate what you already do. Our Python cheat sheet and JavaScript cheat sheet line up well against the translation tables in the tool above, and the Git cheat sheet covers the version control side of any Rust workspace.

The canonical free resources are The Rust Programming Language, Rust by Example, and Rustlings for hands-on exercises. Crate documentation lives on docs.rs, and packages are published to crates.io.

Common Beginner Mistakes

• Fighting the borrow checker instead of restructuring: if a function needs a value in two places, the answer is usually a different data layout, not a cleverer set of references.
• Reaching for Rc and RefCell too early: they are tools for genuine shared ownership, not a way to silence the compiler.
• Using String where &str would do: take &str in parameters and return String only when the caller needs ownership.
• Sprinkling unwrap through production code: every unwrap is a potential panic with no context attached.
• Ignoring clippy: it catches non-idiomatic patterns that compile fine but read badly, and it explains each one.
• Writing unsafe to avoid a design problem: unsafe should be a small, documented, audited core, never a shortcut.

Frequently Asked Questions