Rust Ownership & Borrowing Practice: Move Semantics & Borrow Rules

The most common ownership error. You used a value after ownership was transferred:

// WRONG: using a value after move
let s1 = String::from("hello");
let s2 = s1;
// println!("{s1}"); // error[E0382]: borrow of moved value

// RIGHT Option 1: borrow instead of move
let s1 = String::from("hello");
let s2 = &s1;
println!("{s1}"); // OK: s1 was only borrowed
println!("{s2}");

// RIGHT Option 2: clone if you need independent ownership
let s1 = String::from("hello");
let s2 = s1.clone();
println!("{s1} {s2}"); // both valid

Moves also happen when passing to functions. If you only need to read, take &T instead of T:

// WRONG: takes ownership unnecessarily
// fn print_len(s: String) { println!("{}", s.len()); }

// RIGHT: borrows — caller keeps ownership
fn print_len(s: &str) { println!("{}", s.len()); }

An active & reference exists while you try to take &mut:

// WRONG: mutable borrow while immutable borrow is active
let mut v = vec![1, 2, 3];
let first = &v[0];
// v.push(4); // error[E0502]: cannot borrow v as mutable
// println!("{first}");

// RIGHT: end the immutable borrow before mutating
let mut v = vec![1, 2, 3];
let first = v[0]; // Copy the value instead of borrowing
v.push(4);        // no conflict, no active borrow
println!("{first}");

The rule: at any point, you can have either one &mut T or any number of &T, never both simultaneously.

Something still holds a reference, so ownership cannot transfer:

// WRONG: moving while borrowed
let s = String::from("hello");
let r = &s;
// let s2 = s;  // error[E0505]: cannot move out of s because it is borrowed
// println!("{r}");

// RIGHT: scope the borrow before moving
let s = String::from("hello");
{
    let r = &s;
    println!("{r}");
}  // r's borrow ends here
let s2 = s;  // move is fine now

A function creates a value and tries to return a reference to it. The value is dropped when the function returns, leaving a dangling pointer:

// WRONG: returning a reference to a local
// fn make_greeting() -> &str {
//     let s = String::from("hello");
//     &s  // error[E0515]: s is dropped here
// }

// RIGHT: return the owned value
fn make_greeting() -> String {
    String::from("hello")
}

If the function creates the data, it must return the owned value. References only work for data that outlives the function call (e.g., passed in by the caller). When references do need explicit lifetime annotations, the references and lifetimes guide covers the syntax.

A common source of confusion: borrows don't last until the end of the block. Since Rust 2018, the compiler ends a borrow at its last use, not at the closing }:

let mut v = vec![1, 2, 3];
let first = &v[0];
println!("{first}");  // last use of first — borrow ends here
v.push(4);            // OK! no active borrow

This is called non-lexical lifetimes (NLL). If you get E0502, check whether you can move the last use of the immutable reference above the mutation.

let a = 5;
let b = a;         // Copy: a is still valid
println!("{a}");

let s1 = String::from("hi");
let s2 = s1;       // Move: s1 is now invalid
let s3 = s2.clone(); // Clone: s2 is still valid
println!("{s2} {s3}");

Clone calls arbitrary code — for String it allocates a new heap buffer, but for Rc it just increments a counter. "Clone = deep copy" is not always true.

• Use &T to read without taking ownership.
• Use &mut T to mutate without taking ownership.
• Prefer &str over &String — it accepts both String and string literals.

// Prefer &str for read-only string access
fn word_count(s: &str) -> usize {
    s.split_whitespace().count()
}

fn push_excl(s: &mut String) {
    s.push('!');
}

let owned = String::from("hello world");
word_count(&owned);     // &String coerces to &str
word_count("literal");  // &str directly

Slices (&str, &[T]) are references to a contiguous sequence within owned data:

let s = String::from("hello world");
let first_word: &str = &s[..5];    // "hello"
println!("{first_word}");

let nums = [1, 2, 3, 4, 5];
let middle: &[i32] = &nums[1..4];  // [2, 3, 4]
println!("{middle:?}");

Slices borrow the original data, so the same borrow rules apply — you cannot mutate the owned value while a slice is active. The Rust strings guide dives deeper into &str slices specifically.

You cannot move a field out of a borrowed struct. Use std::mem::take or std::mem::replace to swap in a default:

use std::mem;

struct Config {
    name: String,
    retries: u32,
}

let mut config = Config { name: "prod".into(), retries: 3 };
// Take name out, leaving String::default() ("") in its place
let name = mem::take(&mut config.name);
println!("{name}");        // "prod"
println!("{}", config.name); // ""

This is common in builders, state machines, and any pattern where you need to extract an owned value from a mutable reference. For a printable quick-reference of these patterns, see the ownership and borrowing cheat sheet.

• The Rust Book: Ownership — move semantics, scope, drop
• The Rust Book: References and Borrowing — & vs &mut rules
• The Rust Book: The Slice Type — &str and &[T]
• Rust Blog: Non-Lexical Lifetimes — borrows end at last use