Rust

Quick Reference

Common Smart Pointers

// Heap allocation or recursive types
let data = Box::new(value);

// Shared ownership (single-threaded)
let shared = Rc::new(value);

// Shared ownership (multi-threaded)
let shared = Arc::new(value);

// Interior mutability (mutate behind immutable reference)
let cell = RefCell::new(value);
let mut borrowed = cell.borrow_mut();

Newtype Pattern

// Avoid primitive obsession
struct UserId(u32);
struct OrderId(u32);

fn get_user(id: UserId) { /* can't pass OrderId by mistake */ }

Error Handling

// Library: custom error types with thiserror
#[derive(thiserror::Error, Debug)]
enum MyError {
    #[error("IO error: {0}")]
    Io(#[from] std::io::Error),
    #[error("Invalid input: {0}")]
    Invalid(String),
}

// Application: anyhow for unified error handling
use anyhow::Result;

fn process() -> Result<()> {
    let data = read_file()?;
    let parsed = parse_data(data)?;
    Ok(())
}

Topics

Edition Updates

• 2024 Edition Features - Lifetime improvements, async support, enhanced safety, gen keyword

Development Practices

• Best Practices - Type system usage, ownership patterns, error handling, performance, tooling, project structure

Common Patterns

State Machine with Zero-Sized Types

struct Locked;
struct Unlocked;

struct Door<State> {
    _state: PhantomData<State>,
}

impl Door<Locked> {
    fn unlock(self) -> Door<Unlocked> {
        Door { _state: PhantomData }
    }
}

impl Door<Unlocked> {
    fn lock(self) -> Door<Locked> {
        Door { _state: PhantomData }
    }
}

Async Closures (2024 Edition)

// Native async closure syntax
let async_op = async || {
    fetch_data().await
};

// Future and IntoFuture are now in prelude (no manual import needed)

Essential Tooling

Resources

• The Rust Book
• Rust by Example
• Rust Edition Guide
• Clippy Lints