Rust Cheatsheet

Power user.

Overview

Rust is a systems language with memory safety enforced at compile time and zero-cost abstractions for performance. The cheatsheet captures the small set of patterns operators reach for daily.

• Ownership and borrowing. Memory safety enforced at compile time. Whole classes of C-family bugs are unrepresentable.
• Result and Option. Error and absence are first-class types. No null-pointer dereference; no silent error swallowing.
• Pattern matching. match expressions are exhaustive. Missing cases fail the compile, not production.
• Cargo and async runtime. Cargo unifies build, test, and dependencies; tokio provides the standard async runtime for IO-bound work.

The approach

Three habits separate fluent Rust from beginner Rust: Result everywhere, iterator chains over imperative loops, and clippy in CI.

• Result<T, E>. Explicit error handling for any operation that can fail. Panics belong in tests, not production paths.
• The ? operator. Concise error propagation. Reads like try-catch without the ceremony.
• Iterator chains. .map(), .filter(), .collect(). Most loops should be iterator chains; the compiler optimises them aggressively.
• cargo clippy and cargo fmt. Lint and format in CI. Style debates and anti-patterns disappear at the same time.

Why this compounds

Rust fluency compounds because the same idioms apply across every Rust service the team writes. The compiler does the teaching; engineers internalise the patterns within a few months.

• Stronger safety. Memory safety at compile time eliminates whole bug categories from the production failure surface.
• Predictable performance. Zero-cost abstractions mean idiomatic code is also fast. The trade-off curve is friendly.
• Operational simplicity. Single binary deploys with no runtime to install. Container images stay tiny.
• Year-one investment, year-two habit. The first Rust service is heavy lift while the team learns the borrow checker. The third is routine.