Ownership & Borrowing

Introduction

Ownership is the single feature that makes Rust different from almost every other language. It is a set of rules, checked entirely at compile time, that lets Rust guarantee memory safety without a garbage collector and without manual `free()` calls.

This is the most important lesson in the course — take your time here. Every later lesson, from structs to error handling, assumes you understand how ownership and borrowing work.

The Three Ownership Rules

Rust's entire memory model rests on three simple rules, enforced by the compiler at compile time, not at runtime.

Move Semantics

For heap-allocated types like `String`, assigning one variable to another does not copy the data — it moves ownership. After a move, the original variable is no longer valid, and the compiler will refuse to let you use it.

fn main() {
    let s1 = String::from("hello");
    let s2 = s1; // s1's data is moved into s2; s1 is no longer valid here

    println!("{}", s2);
}

If you uncommented a line trying to print `s1` after this move, the compiler would reject the program with a "value borrowed after move" error. This is not a runtime crash — it's a compile-time guarantee that you can never accidentally use invalidated data.

The Copy and Clone Traits

Not everything moves. Simple, fixed-size, stack-only types like integers, `bool`, `char`, and `f64` implement the `Copy` trait, meaning assignment copies the value instead of moving it — both variables remain valid afterward, since duplicating them is cheap and has no ownership implications.

For heap-allocated types, you can explicitly opt into a deep copy using `.clone()`. This duplicates the actual data, giving you two fully independent owners — at the cost of extra memory allocation and CPU time, which is why Rust never does it implicitly.

Borrowing with References

Constantly moving or cloning values just to pass them to a function would be exhausting. Instead, Rust lets you "borrow" a value with a reference (`&`), giving a function temporary access without transferring ownership.

fn main() {
    let s1 = String::from("hello");
    let len = calculate_length(&s1);

    println!("The length of '{}' is {}.", s1, len);
}

fn calculate_length(s: &String) -> usize {
    s.len()
}

Because `calculate_length` receives `&s1` (a reference) instead of `s1` itself, ownership never leaves `main`. `s1` is still perfectly valid to use after the function call — something that would be impossible if we had passed `s1` by value.

Mutable References

A regular `&` reference is read-only. To let a borrowed function modify the original value, you use a mutable reference, `&mut`.

fn main() {
    let mut s = String::from("hello");
    change(&mut s);
    println!("{}", s);
}

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

Note that `s` itself must be declared `mut` for you to be able to create a mutable reference to it in the first place — mutability has to be explicit all the way through.

The Borrow Checker's Rules

The borrow checker enforces one central rule for every value, within any given scope: you may have either any number of immutable references (`&T`), or exactly one mutable reference (`&mut T`) — never both kinds at the same time. This rule alone is what makes Rust's "fearless concurrency" possible: it is the same rule the compiler uses to rule out data races between threads.

The borrow checker also guarantees references are always valid — Rust will refuse to compile a function that tries to return a reference to a value created inside that function, because the value would be dropped (and the reference left dangling) the moment the function returns.

Move vs Borrow vs Clone

Common Mistakes

Best Practices

Frequently Asked Questions

Key Takeaways

Summary

You've now covered Rust's single most important concept: ownership, moves, cloning, and borrowing. Everything else in this course builds on this foundation. Next, you'll use structs to model your own data types, and see ownership and borrowing in action with methods.