ownership-borrowing

Rust Ownership and Borrowing

Understand and apply Rust's ownership system to write memory-safe code without a garbage collector. Master borrowing rules, lifetimes, and smart pointers.

When to Use

• Encountering borrow checker errors ("cannot borrow as mutable")
• Deciding between references, cloning, and moving
• Adding lifetime annotations to structs or functions
• Choosing between Box, Rc, Arc for heap allocation and sharing
• Understanding when to derive Clone vs Copy

Core Patterns

Pattern 1: Ownership Rules

Three rules govern all Rust memory:

1. Each value has exactly one owner.
2. When the owner goes out of scope, the value is dropped.
3. Ownership can be transferred (moved) but not duplicated (unless Copy).

fn main() {
    let name = String::from("Alice"); // name owns the String
    let greeting = greet(name);       // ownership moves to greet
    // println!("{name}");            // ERROR: name was moved
    println!("{greeting}");
}

fn greet(name: String) -> String {    // takes ownership
    format!("Hello, {name}!")         // returns a new owned String
}

Pattern 2: Borrowing -- Shared and Mutable References

Borrow data without taking ownership. Two rules:

• Any number of shared references (&T) OR exactly one mutable reference (&mut T).
• References must always be valid (no dangling pointers).

fn analyze(data: &[i32]) -> (i32, i32) {
    // Shared borrow: can read, cannot modify
    let sum: i32 = data.iter().sum();
    let count = data.len() as i32;
    (sum, count)
}

fn normalize(data: &mut Vec<f64>) {
    // Mutable borrow: can read and modify
    let max = data.iter().cloned().fold(f64::NEG_INFINITY, f64::max);
    if max != 0.0 {
        for val in data.iter_mut() {
            *val /= max;
        }
    }
}

fn main() {
    let mut values = vec![1.0, 2.0, 3.0];
    normalize(&mut values);     // mutable borrow
    let (sum, _) = analyze(&[1, 2, 3]); // shared borrow
    println!("{sum}");
}

Pattern 3: Lifetimes