Why Borrowing rules in Rust? - Purpose & Use Cases

The Big Idea

What if your program could automatically stop you from making dangerous mistakes with data sharing?

The Scenario

Imagine you are sharing a book with your friends. If everyone tries to write notes in the book at the same time, the pages get messy and confusing. Without clear rules, it's hard to keep track of who can read or write the book safely.

The Problem

Manually tracking who can use data and when is slow and error-prone. You might accidentally change something while someone else is reading it, causing bugs or crashes. It's like trying to share a single pen among many people without any order.

The Solution

Borrowing rules in Rust act like clear sharing guidelines. They let multiple people read the book at once, but only one person can write at a time. This keeps data safe and prevents mistakes, all checked automatically by the compiler.

Before vs After

✗ Before

let mut data = vec![1, 2, 3];
let r1 = &data;
let r2 = &mut data; // Oops! Mutable borrow while immutable borrow exists

✓ After

let mut data = vec![1, 2, 3];
let r1 = &data; // Immutable borrow
// let r2 = &mut data; // Error prevented by borrowing rules

What It Enables

It enables safe and efficient sharing of data without crashes or confusing bugs, making your programs reliable and easy to understand.

Real Life Example

Think of a library where many people can read the same book at the same time, but only one person can take it home to write notes. Borrowing rules make sure everyone follows this system smoothly.

Key Takeaways

Borrowing rules prevent data conflicts by controlling who can read or write.

They help catch mistakes early, before the program runs.

This leads to safer and more reliable code.

Practice

1. What does borrowing in Rust allow you to do?

easy

A. Copy data to a new variable

B. Use data without taking ownership

C. Delete data immediately

D. Create multiple owners of data

Solution

1. Step 1: Understand borrowing concept

   Borrowing means using data without taking ownership, so the original owner keeps control.

2. Step 2: Compare options

   Copying or deleting data changes ownership or data state, which borrowing does not do.

3. Final Answer:

   Use data without taking ownership -> Option B

4. Quick Check:

   Borrowing = Use without ownership [OK]

Hint: Borrowing means using data without owning it [OK]

Common Mistakes:

• Confusing borrowing with copying
• Thinking borrowing deletes data
• Assuming borrowing creates multiple owners

2. Which of the following is the correct syntax to create an immutable borrow of a variable x in Rust?

easy

A. let y = &x;

B. let y = *x;

C. let y = &mut x;

D. let y = x;

Solution

1. Step 1: Identify immutable borrow syntax

   Immutable borrow uses &x to create a reference without allowing changes.

2. Step 2: Check other options

   &mut x is mutable borrow, *x dereferences, and x moves ownership.

3. Final Answer:

   let y = &x; -> Option A

4. Quick Check:

   Immutable borrow = &x [OK]

Hint: Immutable borrow uses & before variable [OK]

Common Mistakes:

• Using &mut for immutable borrow
• Dereferencing instead of borrowing
• Assigning ownership instead of reference

3. What will be the output of this Rust code?

let mut s = String::from("hello");
let r1 = &s;
let r2 = &s;
println!("{} and {}", r1, r2);
let r3 = &mut s;
println!("{}", r3);

medium

A. hello and hello\nerror at runtime

B. hello and hello\nhello

C. Compile error due to mutable borrow while immutable borrows exist

D. hello\nhello and hello

Solution

1. Step 1: Analyze immutable borrows

   Two immutable borrows r1 and r2 are allowed simultaneously.

2. Step 2: Check mutable borrow after immutable borrows

   Trying to create mutable borrow r3 while immutable borrows exist causes compile error.

3. Final Answer:

   Compile error due to mutable borrow while immutable borrows exist -> Option C

4. Quick Check:

   Mutable borrow disallowed with active immutable borrows [OK]

Hint: No mutable borrow allowed if immutable borrows exist [OK]

Common Mistakes:

• Assuming mutable borrow works after immutable borrows
• Expecting runtime error instead of compile error
• Confusing output with allowed borrows

4. Identify the error in this Rust code snippet:

let mut data = vec![1, 2, 3];
let r1 = &mut data;
let r2 = &data;
r1.push(4);
println!("{:?}", r2);

medium

A. No error, code runs fine

B. Cannot push to vector inside mutable borrow

C. Cannot print vector with {:?}

D. Cannot borrow data as immutable while mutable borrow exists

Solution

1. Step 1: Check borrows

   Variable r1 is a mutable borrow, r2 is an immutable borrow of the same data.

2. Step 2: Understand borrowing rules

   Rust forbids immutable borrow while mutable borrow is active, causing a compile error.

3. Final Answer:

   Cannot borrow data as immutable while mutable borrow exists -> Option D

4. Quick Check:

   Immutable borrow disallowed during mutable borrow [OK]

Hint: No immutable borrow allowed during mutable borrow [OK]

Common Mistakes:

• Thinking push is invalid inside mutable borrow
• Ignoring borrow conflict between r1 and r2
• Assuming printing with {:?} causes error

5. You want to write a function that takes a mutable reference to a vector and appends a number, but also returns the length of the vector after appending. Which function signature and usage follow Rust's borrowing rules correctly?

hard

A. fn add_and_len(v: &mut Vec<i32>, n: i32) -> usize { v.push(n); v.len() }
let mut nums = vec![1,2];
let length = add_and_len(&mut nums, 3);

B. fn add_and_len(v: &Vec<i32>, n: i32) -> usize { v.push(n); v.len() }
let mut nums = vec![1,2];
let length = add_and_len(&nums, 3);

C. fn add_and_len(v: Vec<i32>, n: i32) -> usize { v.push(n); v.len() }
let nums = vec![1,2];
let length = add_and_len(nums, 3);

D. fn add_and_len(v: &mut Vec<i32>, n: i32) -> usize { v.len(); v.push(n) }
let mut nums = vec![1,2];
let length = add_and_len(&mut nums, 3);

Solution

1. Step 1: Check function signature for mutable borrow

   Function needs &mut Vec<i32> to modify vector by pushing a number.

2. Step 2: Verify function body and usage

   fn add_and_len(v: &mut Vec<i32>, n: i32) -> usize { v.push(n); v.len() } let mut nums = vec![1,2]; let length = add_and_len(&mut nums, 3); pushes number then returns length correctly; usage passes mutable reference.

3. Step 3: Analyze other options

   fn add_and_len(v: &Vec<i32>, n: i32) -> usize { v.push(n); v.len() } let mut nums = vec![1,2]; let length = add_and_len(&nums, 3); uses immutable borrow but tries to push (not allowed). fn add_and_len(v: Vec<i32>, n: i32) -> usize { v.push(n); v.len() } let nums = vec![1,2]; let length = add_and_len(nums, 3); takes ownership, not borrow. fn add_and_len(v: &mut Vec<i32>, n: i32) -> usize { v.len(); v.push(n) } let mut nums = vec![1,2]; let length = add_and_len(&mut nums, 3); returns length before push, so length is old value.

4. Final Answer:

   fn add_and_len(v: &mut Vec<i32>, n: i32) -> usize { v.push(n); v.len() } let mut nums = vec![1,2]; let length = add_and_len(&mut nums, 3); -> Option A

5. Quick Check:

   Mutable borrow needed to modify vector [OK]

Hint: Use &mut to modify data inside function [OK]

Common Mistakes:

• Using immutable borrow when modifying data
• Taking ownership instead of borrowing
• Returning length before modification