Ownership Preview

Ownership is Rust's core memory model: one owner per value, moves transfer responsibility, and borrows allow temporary access under compile-time rules. This page previews the ideas before the Ownership section.

Recipe

fn main() {
    let s = String::from("hello");
    let t = s; // move
    // println!("{s}"); // error: moved
 
    let len = measure(&t);
    println!("{t} has length {len}");
}
 
fn measure(text: &String) -> usize {
    text.len()
}

When to reach for this: Whenever you pass data between functions, store it in structs, or share it across threads - ownership rules apply everywhere.

Working Example

fn append(mut s: String, suffix: &str) -> String {
    s.push_str(suffix);
    s
}
 
fn print_both(first: &str, second: &str) {
    println!("{first} {second}");
}
 
fn main() {
    let greeting = String::from("Hello");
    let full = append(greeting, ", Rust!");
    let slice: &str = &full;
    print_both(slice, "welcome.");
}

What this demonstrates:

• append takes ownership of greeting and returns updated String
• &str borrows string data without owning it
• String coerces to &str via Deref (deref coercion)
• Functions signal ownership transfer in their signatures

Deep Dive

How It Works

• Stack data with Copy duplicates on assignment (i32, bool, char)
• Heap-owning types (String, Vec) move on assignment
• When an owner goes out of scope, drop runs automatically
• References (&T, &mut T) are borrowed views with lifetime limits

Move vs Copy

let a = 5;
let b = a; // Copy - both valid
 
let v1 = vec![1, 2];
let v2 = v1; // Move - v1 invalid

Borrowing Rules (Summary)

• Any number of &T or exactly one &mut T at a time
• References must not outlive the owner
• Data races are prevented at compile time

Stack vs Heap (Preview)

let x = 42;              // stack
let s = String::from("x"); // pointer + capacity + len on stack, bytes on heap

Gotchas

• Using a value after move - Classic beginner error with String. Fix: Clone (s.clone()) if you need a duplicate, or borrow instead.
• Taking ownership when borrowing suffices - fn print(s: String) forces callers to give up the string. Fix: Use &str or &String.
• Multiple &mut to the same data - Compile error. Fix: Restructure scopes, use RefCell in single-threaded interior mutability, or split fields.
• Returning reference to local - fn bad() -> &String cannot work. Fix: Return owned value or take input by reference with lifetime tied to input.
• Cloning to silence the borrow checker - Works but hides design issues. Fix: Refactor API to borrow or use Cow.

Alternatives

FAQs

Related

• References & Slices - borrowing mechanics
• Ownership Basics - deep dive
• Move Semantics & Copy - Copy/Clone
• Borrowing & References - & vs &mut

Stack versions: This page was written for Rust 1.97.0 (edition 2024), Tokio 1.x, Axum 0.8, serde 1.0, sqlx 0.8, clap 4, and Polars 0.46+.