The ownership rules and moves

The three rules

1. Each value in Rust has an owner: the variable that holds it.
2. There can only be one owner at a time.
3. When the owner goes out of scope, the value is dropped (its memory is freed).

Scope is the part of the code where a variable is valid: from the line where it is declared to the closing curly brace of its block. Drop means "clean up": for a String, the heap bytes are freed. Rust calls a special function named drop for you automatically at the closing brace.

{                                   // s is not valid yet
    let s = String::from("chai");   // s is valid from here
    println!("{s}");                // use s
}                                   // scope ends: s is dropped, heap memory freed

What happens on assignment: a move

Now the key question. What does let s2 = s1; do when s1 is a String? Rust copies only the stack part (pointer, length, capacity). Both variables would then point to the same heap bytes.

let s1 = String::from("dosa");
let s2 = s1;

  STACK                         HEAP
  s1: ptr --+  (no longer valid)
      len 4  \
      cap 4   \              +---+---+---+---+
               +----------> | d | o | s | a |
  s2: ptr ----/              +---+---+---+---+
      len 4
      cap 4

If both s1 and s2 were valid, then at the end of the scope both would be dropped, and the same heap memory would be freed twice: a double free. Rust prevents this simply: after let s2 = s1;, the value has moved to s2, and s1 is no longer usable. Only s2 will drop the memory.

let s1 = String::from("dosa");
let s2 = s1;
println!("{s1}");
// error[E0382]: borrow of moved value: `s1`
//   value moved here: let s2 = s1;
//   value borrowed here after move

Moves are cheap

A move copies only 24 bytes (three numbers on a 64-bit machine), no matter whether the string has 4 letters or 4 million. The heap data is never copied by a move. So Rust is both safe and fast here.

Moves happen in many places

• Assignment: let b = a;
• Passing to a function: takes_it(a); (next topic but one)
• Returning from a function: the value moves to the caller.
• Putting into a collection: list.push(a); moves a into the list.
• A for loop over a collection by value: for x in list moves each item out, and list is used up.

Assigning a new value drops the old one

let mut s = String::from("old");
s = String::from("new");   // "old" is dropped right here
println!("{s}");           // new

Drop runs in reverse order

When several variables go out of scope at the same brace, they are dropped in the reverse order of creation: the last one created is dropped first. This matters later, when one value refers to another.

Common mistakes and fixes

• Using a variable after moving it (E0382). Fix: use the new owner; or borrow with & instead of moving (module 4); or call .clone() if you really need two copies.
• Moving inside a loop: for i in 0..3 { send(msg); } moves msg on the first round. Fix: send(&msg) if the function can borrow, or msg.clone() if it must own.
• Thinking a move copies the heap data. It does not; it only transfers ownership.