rust-pro

Rust Pro

"In Rust, the compiler is your strictest code reviewer and your most reliable safety net."

When to Use

• Writing new Rust code or modules
• Reviewing Rust code for idiomatic patterns
• Debugging ownership, borrowing, or lifetime errors
• Implementing async Rust with Tokio or async-std
• Designing concurrent systems with Rust's guarantees
• Choosing between Rust abstractions (trait objects vs. generics, Arc vs. Rc)

Ownership and Borrowing

Core Rules

1. Each value has exactly one owner
2. When the owner goes out of scope, the value is dropped
3. You can have either one mutable reference OR any number of immutable references (not both)

When to Clone vs. Borrow

• Borrow (&T or &mut T) by default; cloning is a last resort, not a first instinct
• Clone when you need independent ownership (e.g., sending data to another thread)
• Clone when the data is small and cheap to copy (small strings, numbers, small structs)
• Use Cow<'_, T> when you sometimes need to own and sometimes need to borrow

Common Ownership Patterns

// Transfer ownership
fn process(data: Vec<u8>) { /* owns data, dropped at end */ }

// Borrow immutably
fn analyze(data: &[u8]) -> usize { data.len() }

// Borrow mutably
fn transform(data: &mut Vec<u8>) { data.push(0); }

// Return owned data
fn create() -> Vec<u8> { vec![1, 2, 3] }

Avoiding Borrow Checker Fights

• Structure code so borrows have clear, non-overlapping scopes
• Split structs if one field's borrow conflicts with another's mutation
• Use indices instead of references into collections you need to mutate
• Consider interior mutability (RefCell, Mutex) when shared mutable state is truly needed

Lifetimes

When Annotations Are Needed

• Function signatures with references in both input and output
• Struct definitions that hold references
• Impl blocks for structs with lifetime parameters

Lifetime Elision Rules

1. Each input reference gets its own lifetime parameter
2. If there is exactly one input lifetime, it is assigned to all output lifetimes
3. If one input is &self or &mut self, its lifetime is assigned to all outputs