The Basic Rules of Ownership

Working Code

Start by running this code in the Rust Playground.

fn main() {
    let name = String::from("Alice");
    let greeting = format!("Hello, {name}!");
    println!("{greeting}");
    println!("Name: {name}");
}

Works fine, right? Now change it slightly:

fn main() {
    let name = String::from("Alice");
    let name2 = name;           // assign name to name2
    println!("Name: {name}");   // error!
}

error[E0382]: borrow of moved value: `name`
 --> src/main.rs:4:24
  |
2 |     let name = String::from("Alice");
  |         ---- move occurs because `name` has type `String`
3 |     let name2 = name;
  |                 ---- value moved here
4 |     println!("Name: {name}");
  |                      ^^^^ value borrowed here after move

Try It Yourself

1. In the broken code, change {name} to {name2} in the println!. Does the error go away?
2. Replace let name2 = name; with let name2 = name.clone();. Can you now use both name and name2?

"Why?" — The Three Rules of Ownership

Rust's ownership rules boil down to three statements:

1. Every value has an owner
2. There can be only one owner at a time
3. When the owner goes out of scope, the value is dropped

Think about it with the "owner of an item" analogy:

• Your laptop has one owner (rule 2)
• If you give your laptop to a friend (move), your friend is now the owner. You can no longer use it
• When the owner leaves the room (scope ends), the laptop is cleaned up (rule 3)

Move — Like Shipping a Package

When you assign heap data like a String to another variable, the value moves. It's like shipping a package — once you ship it, you no longer have it.

fn main() {
    let original = String::from("package contents");
    let moved = original;  // shipped!

    // original is now empty-handed
    // moved is the new owner
    println!("{moved}");
}

Remember the error in Lesson 06 when you passed a vector to a function and tried to use it again? You fixed it with clone(). Now you can see why that error happened.

fn print_fruits(fruits: Vec<&str>) {
    for f in fruits {
        println!("{f}");
    }
}

fn main() {
    let fruits = vec!["apple", "banana"];
    print_fruits(fruits);       // ownership of fruits moves to the function!
    // println!("{:?}", fruits); // error! already moved
}

Passing a value to a function is also a move. The owner of fruits changed from main to the print_fruits function parameter.

Copy Types — Values That Get Copied

Integers and bool behave differently.

fn main() {
    let x = 42;
    let y = x;     // copied! (not moved)
    println!("x = {x}, y = {y}");  // both usable!
}

No error! Why?

Small values stored on the stack are cheap to copy. Rust gives these types the Copy trait so they are copied instead of moved.

| Copy types (copied) | Non-Copy types (moved) | | ---------------------------- | -------------------------- | | i32, f64, bool, char | String, Vec, HashMap | | Stack-stored, fixed size | Heap data, variable size |

fn main() {
    // Cloning 10,000 numbers — expensive!
    let big_data = vec![0; 10_000];
    let copy = big_data.clone();
    println!("Original: {}, Copy: {}", big_data.len(), copy.len());
}

fn main() {
    {
        let s = String::from("temporary!");
        println!("{s}");
    } // <- s is dropped here. Memory freed automatically!

    // println!("{s}"); // error! s is already gone
}

fn main() {
    let message = String::from("hello");
    let message2 = message;
    println!("{message}");
}

fn main() {
    let a = 10;
    let b = a;
    println!("a = {a}, b = {b}");
}

fn main() {
    let s1 = String::from("hello");
    let s2 = s1;
    println!("{s2}");
}