language-rust

Rust

Ownership in one paragraph

Every value has one owner. Passing by value moves; borrow with & (shared, many) or &mut (exclusive, one). Shared and mutable references cannot coexist. Most "fights with the borrow checker" are a design smell — the data model mixed ownership and sharing.

Borrowing rules of thumb

• &T when you only read.
• &mut T when you mutate in place.
• T (by value) when you consume — builders, transforming constructors.
• Return owned types unless the caller clearly benefits from a borrow tied to a parameter's lifetime.

Lifetimes

• Start without annotations; add them when the compiler asks.
• 'static does not mean "lives forever" — it means "no non-static references inside". Prefer owned types over 'static juggling.
• If a struct needs many lifetimes, consider owned data or Arc instead.

Error handling

• Return Result<T, E>; use ? to propagate.
• Library code: custom enum with thiserror.
• Application code: anyhow::Error for ergonomics; add context with .with_context(|| "doing X").
• Reserve panic! for invariant violations the caller cannot recover from.

#[derive(thiserror::Error, Debug)]
pub enum LoadError {
    #[error("io: {0}")] Io(#[from] std::io::Error),
    #[error("bad format: {0}")] Format(String),
}

Traits

• Design around capability, not identity (Read, not IsFile).
• Default methods let traits evolve without breaking implementors.
• impl Trait in arguments → static dispatch, monomorphized, fast.
• dyn Trait behind Box/& → dynamic dispatch, smaller binary, one code path.
• Choose dyn for open-ended type sets or heterogeneous collections.

Iterators

Prefer iterator chains over indexed loops — usually faster, always clearer.

let total: u32 = orders.iter()
    .filter(|o| o.is_paid())
    .map(|o| o.total)
    .sum();

• collect::<Vec<_>>() only when you need to materialize.
• iter() borrows; into_iter() consumes; iter_mut() mutates in place.