Borrowing & References

Borrowing lets code use data without taking ownership. Shared references (&T) allow concurrent readers. Mutable references (&mut T) grant exclusive write access.

Recipe

fn push_char(s: &mut String, c: char) {
    s.push(c);
}
 
fn display(s: &str) {
    println!("{s}");
}
 
fn main() {
    let mut msg = String::from("hi");
    display(&msg);
    push_char(&mut msg, '!');
    display(&msg);
}

When to reach for this: Read-mostly APIs with &T, builders and mutation with &mut T, avoiding ownership transfer.

Working Example

fn split_at_mut<T>(slice: &mut [T], mid: usize) -> (&mut [T], &mut [T]) {
    slice.split_at_mut(mid)
}
 
fn main() {
    let mut data = vec![1, 2, 3, 4];
    let (left, right) = split_at_mut(&mut data, 2);
    left[0] = 10;
    right[0] = 40;
    println!("{:?}", data);
}

What this demonstrates:

• Exclusive &mut for mutation
• split_at_mut creates two non-overlapping &mut slices safely
• Borrow ends when left/right go out of scope
• &str/&[T] follow same rules

Deep Dive

Aliasing Rules

1. Any number of &T or exactly one &mut T
2. References must always be valid (no dangling)
3. Reference scope ends at last use (NLL) - see dedicated page

Reborrowing

let mut s = String::from("a");
let r1 = &mut s;
let r2 = &*r1; // reborrow shared while mutable loan active in subset
println!("{r2}");

& Coercion

&String -> &str, &Vec<T> -> &[T] via Deref.

Gotchas

• Two &mut to same variable - Compile error. Fix: Scope splits, split_at_mut, or interior mutability.
• Read while &mut active - Forbidden. Fix: End mutable borrow before shared read.
• Returning & to local data - Dangling reference. Fix: Return owned value or tie lifetime to input.
• Mutable borrow across function calls holding &mut - Extends loan. Fix: Limit borrow scope with blocks.
• Iterating with &mut collection while pushing - Iterator invalidation. Fix: Collect indices first or use drain.

Alternatives

FAQs

Related

• The Borrow Checker - compiler reasoning
• Lifetimes Explained - why 'a exists
• Non-Lexical Lifetimes & Reborrows - modern behavior
• References & Slices - slice basics

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+.