Ownership and Borrowing

Ownership is Rust's most distinctive feature and the key to its memory safety guarantees. Understanding ownership, moves, references, and borrowing is essential for writing Rust programs.

---

The Ownership Rules

Rust enforces three ownership rules at compile time:

1. Each value has exactly one owner (a variable)
2. There can only be one owner at a time
3. When the owner goes out of scope, the value is dropped (freed)

{
    let s = String::from("hello"); // s owns the String
    // s is valid here
} // s goes out of scope — the String is dropped (freed)

---

Moves

When you assign a heap-allocated value to another variable, ownership moves:

let s1 = String::from("hello");
let s2 = s1; // s1 is MOVED to s2

println!("{s1}"); // ERROR: s1 is no longer valid
println!("{s2}"); // OK: s2 owns the String

This prevents double free errors — only one variable can free the memory.

Copy Types

Types that are small and live on the stack implement the Copy trait. Assignment copies instead of moves:

let x = 5;
let y = x; // x is COPIED, not moved

println!("{x}"); // OK — integers implement Copy
println!("{y}"); // OK

Copy types	Non-Copy types (move semantics)
All integers (i32, u64, etc.)	String
Floating-point (f32, f64)	Vec<T>
bool	Box<T>
char	Any type with heap data
Tuples of Copy types	Structs (unless they derive Copy)

Clone

To explicitly duplicate heap data, use .clone():

let s1 = String::from("hello");
let s2 = s1.clone(); // Deep copy

println!("{s1}"); // OK — s1 is still valid
println!("{s2}"); // OK — s2 is an independent copy

---

References and Borrowing

Instead of transferring ownership, you can borrow a value using references:

Immutable References (&T)

fn calculate_length(s: &String) -> usize {
    s.len()
} // s goes out of scope, but it does not own the String — nothing is dropped

let s1 = String::from("hello");
let len = calculate_length(&s1); // borrow s1
println!("{s1} has length {len}"); // s1 is still valid

Mutable References (&mut T)

fn add_world(s: &mut String) {
    s.push_str(", world!");
}

let mut s = String::from("hello");
add_world(&mut s);
println!("{s}"); // "hello, world!"

---

The Borrowing Rules

Rust enforces two critical borrowing rules at compile time:

1. You can have either one mutable reference OR any number of immutable references (but not both at the same time)
2. References must always be valid (no dangling references)

let mut s = String::from("hello");