Rust is well known for memory safety without requiring a garbage collector. One of the most important ideas that makes this possible is borrowing and references.
If you are new to Rust, borrowing can feel confusing at first because it is closely connected to Rust’s ownership system. But once you understand the basic rule—you can use a value without taking ownership of it—the concept becomes much easier.
In this guide, you’ll learn what references are, what borrowing means, how immutable and mutable references work, what dangling references are, and the most important borrowing rules every beginner should know.
What Is Borrowing in Rust?
Borrowing means temporarily using a value without taking ownership of it.
Instead of giving ownership of a value to another function, Rust allows you to pass a reference to that value.
A reference points to a value but does not own it.
Consider this example:
fn main() {
let name = String::from("Rust");
print_name(&name);
println!("{}", name);
}
fn print_name(name: &String) {
println!("{}", name);
}
Output:
Rust
Rust
Here, name is passed to the function using:
&name
This creates a reference to name.
The function receives:
name: &String
Because the function only borrows the value, ownership stays with main().
That means name can still be used after the function call.
Why Does Rust Need Borrowing?
Without borrowing, passing values such as String into functions can transfer ownership.
Example:
fn main() {
let name = String::from("Rust");
print_name(name);
println!("{}", name);
}
fn print_name(name: String) {
println!("{}", name);
}
This code will not compile.
Why?
Because ownership of name moves into print_name().
After that function call, the original name variable can no longer be used.
Borrowing solves this problem.
Instead of:
print_name(name);
you can use:
print_name(&name);
and update the function parameter:
fn print_name(name: &String)
Now the function borrows the value rather than taking ownership.
What Is a Reference in Rust?
A reference is a way to access a value without owning it.
References are created using the & symbol.
Example:
fn main() {
let number = 10;
let reference = &number;
println!("{}", reference);
}
Output:
10
Here:
&number
creates a reference to number.
The variable:
reference
stores that reference.
You can think of a reference as permission to access another value without becoming its owner.
Borrowing with Function Parameters
One of the most common uses of references is passing data to functions.
Example:
fn main() {
let message = String::from("Hello Rust");
show_message(&message);
println!("{}", message);
}
fn show_message(message: &String) {
println!("{}", message);
}
Output:
Hello Rust
Hello Rust
The function parameter:
message: &String
means:
This function accepts a reference to a
String.
The function can use the String, but it does not own it.
When the function finishes, the reference disappears, while the original value remains available.
Borrowing vs Ownership Transfer
Consider these two examples.
Ownership Transfer
fn display(text: String) {
println!("{}", text);
}
fn main() {
let message = String::from("Hello");
display(message);
}
Ownership moves into display().
You cannot safely use:
message
afterward.
Borrowing
fn display(text: &String) {
println!("{}", text);
}
fn main() {
let message = String::from("Hello");
display(&message);
println!("{}", message);
}
Now ownership stays inside main().
The function only borrows the String.
This is one of the biggest reasons references are so useful in Rust.
Immutable References
By default, references in Rust are immutable.
Example:
fn main() {
let name = String::from("Rust");
let reference = &name;
println!("{}", reference);
}
The reference can read the value but cannot change it.
This type of reference is written as:
&String
or more generally:
&T
where T is some type.
For example:
&i32
&String
&Vec<i32>
&bool
are all immutable references.
Multiple Immutable References
Rust allows multiple immutable references to the same value at the same time.
Example:
fn main() {
let name = String::from("Rust");
let r1 = &name;
let r2 = &name;
let r3 = &name;
println!("{}", r1);
println!("{}", r2);
println!("{}", r3);
}
Output:
Rust
Rust
Rust
This is safe because none of those references can modify the value.
They only read it.
Mutable References
Sometimes you want a function to borrow a value and modify it.
For this, Rust provides mutable references.
A mutable reference uses:
&mut
Example:
fn main() {
let mut message = String::from("Hello");
add_text(&mut message);
println!("{}", message);
}
fn add_text(message: &mut String) {
message.push_str(" Rust");
}
Output:
Hello Rust
Notice two important things.
The original variable must be mutable:
let mut message
And the reference must also be mutable:
&mut message
The function parameter becomes:
message: &mut String
This gives the function permission to modify the borrowed value.
Why Must the Original Variable Be Mutable?
This will not work:
fn main() {
let message = String::from("Hello");
add_text(&mut message);
}
The variable was created with:
let message
which makes it immutable.
To create a mutable reference, the original value must be declared with mut.
Correct:
let mut message = String::from("Hello");
Then:
add_text(&mut message);
can borrow it mutably.
Only One Mutable Reference at a Time
Rust normally allows only one active mutable reference to a particular value at a time.
Example:
fn main() {
let mut text = String::from("Hello");
let r1 = &mut text;
let r2 = &mut text;
println!("{}", r1);
println!("{}", r2);
}
This will not compile because both references could potentially change the same value.
Rust prevents this situation to reduce problems such as data races and unexpected simultaneous modification.
A correct version could be:
fn main() {
let mut text = String::from("Hello");
{
let r1 = &mut text;
r1.push_str(" Rust");
}
let r2 = &mut text;
r2.push_str("!");
println!("{}", text);
}
Output:
Hello Rust!
The first mutable reference is no longer active when the second one is created.
Immutable and Mutable References Together
Rust also prevents you from using an active mutable reference together with active immutable references in conflicting ways.
Example:
fn main() {
let mut text = String::from("Hello");
let r1 = &text;
let r2 = &mut text;
println!("{}", r1);
println!("{}", r2);
}
This causes a borrowing conflict.
Why?
Because r1 assumes the value will not change while it is being read, while r2 has permission to modify it.
Rust prevents this unsafe situation.
The Main Borrowing Rules
The most important borrowing rules are:
- You can have multiple immutable references to a value.
- You can have one mutable reference to a value.
- You cannot have conflicting mutable and immutable references active at the same time.
- References must always point to valid data.
These rules are enforced by Rust’s compiler.
The Borrow Checker
Rust uses something called the borrow checker.
The borrow checker is part of the compiler that checks whether references are used safely.
For example, it ensures that:
&value
does not remain valid after value has been destroyed.
It also checks whether mutable references conflict with other references.
You do not manually run the borrow checker.
It automatically runs when Rust compiles your program.
If your borrowing rules are incorrect, the compiler gives you an error.
Dereferencing a Reference
Sometimes you need to access the value behind a reference.
This is called dereferencing.
Rust uses the * operator for dereferencing.
Example:
fn main() {
let number = 10;
let reference = &number;
println!("{}", *reference);
}
Output:
10
Here:
reference
is a reference to number.
And:
*reference
accesses the value behind the reference.
Reference and Dereference Example
Consider:
fn main() {
let x = 5;
let y = &x;
println!("x = {}", x);
println!("y = {}", y);
println!("*y = {}", *y);
}
Output:
x = 5
y = 5
*y = 5
Although y is a reference, Rust often automatically dereferences references in common situations, which makes code easier to write.
Mutable Reference Example with Numbers
Mutable references are not limited to strings.
Example:
fn increase(number: &mut i32) {
*number += 1;
}
fn main() {
let mut value = 10;
increase(&mut value);
println!("{}", value);
}
Output:
11
Inside the function:
*number += 1;
dereferences the reference and changes the original value.
Borrowing a String Without Changing It
Here is a simple function that calculates the length of a String.
fn calculate_length(text: &String) -> usize {
text.len()
}
fn main() {
let message = String::from("Hello Rust");
let length = calculate_length(&message);
println!("Length: {}", length);
println!("Message: {}", message);
}
Output:
Length: 10
Message: Hello Rust
The function only needs to read the string, so an immutable reference is enough.
Borrowing a String and Changing It
If the function must modify the string, use a mutable reference.
fn add_exclamation(text: &mut String) {
text.push('!');
}
fn main() {
let mut message = String::from("Hello Rust");
add_exclamation(&mut message);
println!("{}", message);
}
Output:
Hello Rust!
The function changes the original String directly.
References with Vectors
Borrowing works with collections too.
Example:
fn print_numbers(numbers: &Vec<i32>) {
println!("{:?}", numbers);
}
fn main() {
let numbers = vec![10, 20, 30];
print_numbers(&numbers);
println!("{:?}", numbers);
}
Output:
[10, 20, 30]
[10, 20, 30]
Because the function only borrows the vector, ownership remains in main().
Mutable References with Vectors
You can also modify a vector through a mutable reference.
fn add_number(numbers: &mut Vec<i32>) {
numbers.push(40);
}
fn main() {
let mut numbers = vec![10, 20, 30];
add_number(&mut numbers);
println!("{:?}", numbers);
}
Output:
[10, 20, 30, 40]
The vector remains owned by main(), but the function temporarily receives permission to modify it.
Borrowing with &str
When working with text, functions often accept &str instead of &String.
Example:
fn greet(name: &str) {
println!("Hello, {}", name);
}
fn main() {
let name = String::from("Alex");
greet(&name);
greet("Rust Developer");
}
Output:
Hello, Alex
Hello, Rust Developer
Using &str is flexible because it can work with both string literals and borrowed String values.
For functions that only need to read text, &str is often preferred over &String.
Borrowing Only Part of a Value
Rust can also borrow part of a value.
For example, you can borrow a slice of a string.
fn main() {
let text = String::from("Hello Rust");
let hello = &text[0..5];
println!("{}", hello);
}
Output:
Hello
The variable hello does not own a new string.
It refers to part of the original string.
This is called a string slice.
Borrowing Array Slices
The same idea works with arrays.
fn main() {
let numbers = [10, 20, 30, 40, 50];
let slice = &numbers[1..4];
println!("{:?}", slice);
}
Output:
[20, 30, 40]
The slice is a reference to part of the array.
It does not copy the entire array.
What Is a Dangling Reference?
A dangling reference is a reference that points to data that no longer exists.
Rust prevents dangling references at compile time.
Consider:
fn create_reference() -> &String {
let text = String::from("Hello");
&text
}
This code will not compile.
Why?
Because text is created inside the function.
When the function finishes, text is destroyed.
Returning a reference to it would create a reference to invalid memory.
Rust prevents this.
Correct Way to Return the Value
Instead of returning a reference to a local String, return the String itself.
fn create_text() -> String {
let text = String::from("Hello");
text
}
fn main() {
let message = create_text();
println!("{}", message);
}
Output:
Hello
Ownership of text moves out of the function safely.
Non-Lexical Lifetimes and Reference Usage
Modern Rust is smart about determining when a reference is no longer being used.
For example:
fn main() {
let mut text = String::from("Hello");
let r1 = &text;
let r2 = &text;
println!("{} {}", r1, r2);
let r3 = &mut text;
r3.push_str(" Rust");
println!("{}", r3);
}
This can work because the immutable references r1 and r2 are no longer used after the first println!.
Rust recognizes that their active borrowing period has ended.
Then a mutable reference can safely be created.
Borrowing in Loops
References are also common when looping through collections.
Example:
fn main() {
let numbers = vec![10, 20, 30];
for number in &numbers {
println!("{}", number);
}
println!("{:?}", numbers);
}
Output:
10
20
30
[10, 20, 30]
Using:
&numbers
allows the loop to borrow the vector rather than consume it.
Because of that, numbers can still be used afterward.
Mutable Borrowing in Loops
You can also modify every element by borrowing the vector mutably.
fn main() {
let mut numbers = vec![10, 20, 30];
for number in &mut numbers {
*number += 5;
}
println!("{:?}", numbers);
}
Output:
[15, 25, 35]
Each number is a mutable reference to an element.
The expression:
*number += 5;
changes the actual element.
Practical Example: Update a User Name
fn update_name(name: &mut String) {
name.push_str(" Kumar");
}
fn main() {
let mut name = String::from("Ankit");
update_name(&mut name);
println!("{}", name);
}
Output:
Ankit Kumar
The function does not own the String.
It temporarily borrows it mutably and changes the original value.
Practical Example: Calculate Total Without Taking Ownership
fn calculate_total(prices: &Vec<f64>) -> f64 {
let mut total = 0.0;
for price in prices {
total += price;
}
total
}
fn main() {
let prices = vec![100.0, 250.0, 50.0];
let total = calculate_total(&prices);
println!("Total: {}", total);
println!("Prices: {:?}", prices);
}
Output:
Total: 400
Prices: [100.0, 250.0, 50.0]
The function only reads the vector, so borrowing is better than transferring ownership.
Common Borrowing Mistakes
Mistake 1: Passing Ownership When You Only Need to Read
Less suitable:
fn print_name(name: String) {
println!("{}", name);
}
If the function does not need ownership, borrow instead:
fn print_name(name: &String) {
println!("{}", name);
}
Or, for text-reading functions, often prefer:
fn print_name(name: &str) {
println!("{}", name);
}
Mistake 2: Forgetting mut
Incorrect:
let name = String::from("Rust");
change_name(&mut name);
Correct:
let mut name = String::from("Rust");
change_name(&mut name);
Mistake 3: Creating Conflicting Mutable References
Incorrect:
let mut value = 10;
let r1 = &mut value;
let r2 = &mut value;
Rust does not allow two overlapping mutable borrows of the same value.
Mistake 4: Mixing Active Mutable and Immutable Borrows
Incorrect:
let mut text = String::from("Hello");
let r1 = &text;
let r2 = &mut text;
println!("{}", r1);
The immutable borrow is still needed while the mutable borrow exists.
Rust prevents this conflict.
Mistake 5: Returning a Reference to Local Data
Incorrect:
fn get_name() -> &String {
let name = String::from("Rust");
&name
}
The local String will be destroyed when the function ends.
Return the owned value instead:
fn get_name() -> String {
String::from("Rust")
}
Ownership vs Borrowing vs Mutable Borrowing
Here is the basic difference.
| Concept | Syntax | Can Read? | Can Modify? | Takes Ownership? |
|---|---|---|---|---|
| Ownership | String | Yes | If mutable | Yes |
| Immutable Borrow | &String | Yes | No | No |
| Mutable Borrow | &mut String | Yes | Yes | No |
For text-focused function parameters, you will also commonly see:
&str
instead of:
&String
Rust Reference Syntax Cheat Sheet
Immutable reference:
let reference = &value;
Mutable reference:
let reference = &mut value;
Function accepting immutable reference:
fn show(value: &String) {
}
Function accepting mutable reference:
fn change(value: &mut String) {
}
Dereference:
*reference
Borrow a vector:
&numbers
Mutably borrow a vector:
&mut numbers
Borrow a string slice:
&text[0..5]
Best Practices for Borrowing and References
When writing beginner-level Rust code, keep these practices in mind:
- Borrow values when a function does not need ownership.
- Use immutable references when you only need to read data.
- Use mutable references only when modification is necessary.
- Prefer
&strinstead of&Stringwhen a function only needs to read text. - Avoid creating unnecessary mutable references.
- Keep borrowing scopes as small and clear as possible.
- Return owned values instead of references to local variables.
- Read compiler borrowing errors carefully because Rust often explains exactly which references conflict.
Frequently Asked Questions
What does & mean in Rust?
The & symbol creates a reference to a value.
Example:
let reference = &value;
What does borrowing mean?
Borrowing means accessing a value through a reference without taking ownership of it.
What is &mut?
&mut creates a mutable reference.
Example:
let reference = &mut value;
It allows the borrowed value to be modified.
Can Rust have multiple references?
Yes.
Multiple immutable references are generally allowed:
let r1 = &value;
let r2 = &value;
But overlapping mutable access is restricted.
Why does Rust restrict mutable references?
The restriction prevents multiple parts of the program from unexpectedly changing the same value at the same time and helps Rust guarantee memory safety.
What does * mean with references?
The * operator dereferences a reference, giving access to the value behind it.
Example:
*reference
Does borrowing copy the value?
No.
Borrowing creates a reference to the existing value rather than copying or transferring ownership of that value.
Does borrowing transfer ownership?
No.
The original owner keeps ownership while another part of the program temporarily uses the value through a reference.
Conclusion
Borrowing and references are fundamental Rust concepts that allow you to use data without transferring ownership.
An immutable reference looks like this:
let reference = &value;
It allows you to read the value without owning it.
A mutable reference looks like this:
let reference = &mut value;
It allows temporary modification without transferring ownership.
The most important rules to remember are simple: multiple immutable references are allowed, mutable references require stricter exclusive access, and references must always point to valid data.
Once you understand these rules, Rust’s ownership system becomes much easier to work with. Borrowing lets you reuse data efficiently while Rust’s compiler protects your program from many common memory-related mistakes before the program even runs.
