Rust Borrowing and References: &T, &mut T, Borrow Rules and Dangling References article illustrationContents
Ownership keeps Rust memory-safe, but moving every value into every function would be inconvenient. Borrowing solves that problem.
A reference lets code access a value without becoming its owner. This is one of the most important Rust skills because well-designed Rust programs borrow data whenever ownership does not need to change.
What is a reference?
A reference refers to a value owned somewhere else. You create an immutable reference using &:
bash
fn main() { let message = String::from("Hello Rust"); let len = calculate_length(&message); println!("{message} has {len} bytes"); } fn calculate_length(text: &String) -> usize { text.len() }
calculate_length can read the String, but it does not own it. When the function returns, the original message remains available.
bash
Owner message ──────────> String heap data │ └── &message ──> borrowed reference no ownership transfer
What is borrowing?
Creating a reference is called borrowing. Think of it as temporary access:
The owner remains responsible for the value.
The borrower can use the value according to the reference's permissions.
The compiler ensures the reference cannot outlive the value it refers to.
Immutable references: &T
bash
fn print_name(name: &String) { println!("Name: {name}"); } fn main() { let name = String::from("Melochip"); print_name(&name); print_name(&name); println!("Owner still has: {name}"); }
Immutable references are read-only. Rust can allow multiple immutable references because none can modify the shared value.
At a given time, Rust's borrowing model enforces an important rule:
You may have multiple immutable references to a value, or
you may have a mutable reference that requires exclusive mutable access for the relevant borrow period.
This prevents data races and iterator/reference invalidation problems from appearing unchecked.
Multiple immutable references
bash
let text = String::from("Rust"); let r1 = &text; let r2 = &text; println!("{r1} {r2}");
This is safe because both references only read.
Conflicting mutable references
bash
let mut text = String::from("Rust"); let r1 = &mut text; let r2 = &mut text; println!("{r1} {r2}");
If the two mutable borrows overlap in use, the compiler rejects the code because concurrent mutation through multiple aliases could be unsafe.
Mutable and immutable borrows cannot conflict
bash
let mut text = String::from("Rust"); let reader = &text; let writer = &mut text; println!("{reader} {writer}");
If these borrows overlap, Rust prevents the mutable reference from coexisting with active immutable references.
Non-lexical lifetimes: borrow ends after its last use
Modern Rust often recognizes that a reference is no longer needed before the closing brace:
bash
let mut text = String::from("Rust"); let r1 = &text; let r2 = &text; println!("{r1} {r2}"); // last use of immutable borrows let r3 = &mut text; r3.push_str(" language"); println!("{r3}");
This works because the immutable borrows are no longer used when the mutable borrow begins.
Dereferencing with *
The * operator accesses the value behind a reference:
bash
fn main() { let number = 10; let reference = &number; assert_eq!(10, number); assert_eq!(10, *reference); }
For method calls and field access, Rust often performs convenient automatic referencing/dereferencing, so explicit * is not always necessary.
Borrowing is not copying
Operation
Ownership
Typical syntax
Move
Transfers ownership
let b = a; for non-Copy owned values
Clone
Creates another owned value
a.clone()
Borrow
Owner stays the same
&a
Mutable borrow
Owner stays the same; temporary write access
&mut a
Prefer &str over &String for read-only string parameters
When a function only needs to read text, a string slice is often more flexible:
The read-only function borrows with &Config; the update function borrows with &mut Config. Neither function takes ownership.
Common borrowing errors
Cannot borrow as mutable
bash
let message = String::from("hello"); message.push_str(" world");
Fix the owner:
bash
let mut message = String::from("hello"); message.push_str(" world");
Cannot borrow as mutable because it is also borrowed as immutable
Look for an immutable reference that is still used after you attempt the mutable borrow. Often the correct fix is to shorten the immutable borrow's usage rather than cloning the value.
Reference may outlive borrowed value
Make sure the owner lives long enough, or return/move ownership instead of trying to return a reference to a local temporary value.
Hands-on mini lab
bash
cargo new borrowing_lab cd borrowing_lab
Write a function accepting &String and returning its length.
Change it to accept &str .
Create a function accepting &mut String that appends text.
Try two simultaneous active mutable borrows and read the compiler message.
Try returning a reference to a locally created String and understand why Rust rejects it.
bash
cargo fmt cargo clippy cargo run
Borrowing checklist
Does the function need ownership? If not, borrow.
Does it only read? Prefer an immutable reference.
Does it modify? Use a mutable owner plus &mut .
For text-only read parameters, consider &str .
Do not reach for clone() automatically when the compiler reports a move problem.
Next chapter
Now that references make sense, continue with Chapter 8: Rust Strings and Slices to understand String, &str, UTF-8 and safe slicing.
No comments yet. Start the discussion.