Borrowing

Moving a value every time you want to use it is a pain. Borrowing lets code use a value without taking ownership.

Shared references

&x makes a shared reference to x. The reference can read the value, but the owner keeps it. You can have as many shared references as you like.

1fn len(s: &String) -> usize {2    s.len()3}4let word = String::from("hi");5let n = len(&word); // word is borrowed6println!("{word} {n}"); // still usable

Mutable references

&mut x makes a mutable reference, which can change the value. The variable itself must be declared with mut, or you get error E0596.

1let mut n = 1;2let r = &mut n;3*r += 1;            // n is now 2

One &mut at a time

Only one mutable reference to a value can be live at once. Two at the same time is error E0499. This stops two parts of the code from changing the same thing at once.

No & with &mut

You can't hold a shared reference while a mutable one is live, or the other way round. That is error E0502. Changing a value while it is borrowed is also not allowed (E0506).

1let mut v = vec![1];2let first = &v[0];3v.push(2);          // E0502: v is borrowed4println!("{first}");

Borrows end at last use

A borrow ends after its last use, not at the end of the block. So this is fine:

1let mut s = String::from("hi");2let r = &s;3println!("{r}");    // last use of r4s.push('!');        // ok now

Remember

• Many & or one &mut, never both at once.
• &mut needs a mut variable (E0596).
• E0499: two &mut. E0502: & and &mut mixed.
• A borrow ends at its last use.