The borrow checker in practice

What the borrow checker does

The borrow checker reads your code and tracks every reference: where it is created, where it is last used, and what it points to. If any path breaks the rules, the program does not compile. This feels strict at first, but each error it reports is a real bug you would otherwise find later, maybe in production.

A borrow ends at its last use

Modern Rust uses non-lexical lifetimes (NLL): a reference is "alive" only from where it is created to where it is last used. It does not have to wait for the closing brace. That is why this code is fine:

let mut list = vec![1, 2, 3];
let first = &list[0];       // shared borrow starts
println!("{first}");        // ...and ends here (last use)
list.push(4);               // mutable borrow: OK, no shared borrow is alive

E0382: use of a moved value

let s = String::from("hi");
let t = s;
println!("{s}");
// error[E0382]: borrow of moved value: `s`

E0499: two mutable borrows at once

let mut name = String::from("Ana");
let a = &mut name;
let b = &mut name;
a.push('!');
// error[E0499]: cannot borrow `name` as mutable more than once at a time

let mut name = String::from("Ana");
{
    let a = &mut name;
    a.push('!');
}                       // a is done
let b = &mut name;
b.push('?');
println!("{name}");     // Ana!?

E0502: mutable borrow while a shared borrow is still used

let mut v = vec![10, 20, 30];
let first = &v[0];
v.push(40);
println!("{first}");
// error[E0502]: cannot borrow `v` as mutable because it is also borrowed as immutable

Why is this dangerous? push may need more capacity. Then the Vec allocates a bigger block of heap memory, copies the items and frees the old block. first would still point to the old, freed block: a dangling reference. In C++ this exact bug (iterator invalidation) is common. Fix: copy the value out before pushing (let first = v[0]; works because i32 is Copy), or use first before the push.

before push:  v.ptr --> [10][20][30]          first --> [10] (old block)
after push:   v.ptr --> [10][20][30][40]      old block FREED, first would dangle

E0106 and E0597: references that would dangle

fn make() -> &String {          // error[E0106]: missing lifetime specifier
    let s = String::from("temp");
    &s                          // s is dropped at the end of make
}

let r;
{
    let x = 5;
    r = &x;
}                               // x is dropped here
println!("{r}");
// error[E0597]: `x` does not live long enough

A strategy list for borrow errors

1. Read the whole error. It shows where each borrow starts and where it is used later.
2. Shorten the borrow: use the reference earlier, or put it in a smaller block.
3. Copy or clone small values out instead of holding a reference (let price = cart[0];).
4. Restructure: do all the reading first, collect what you need, then do the writing.
5. Store indexes instead of references when you need to remember a position in a Vec.
6. If the function returns a reference to local data, return the owned value instead.