Why borrowing is required in Rust - Challenge Your Understanding

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Rust code involving borrowing?

Consider the following Rust code. What will it print when run?

Rust

fn main() {
    let s = String::from("hello");
    let len = calculate_length(&s);
    println!("The length of '{}' is {}.", s, len);
}

fn calculate_length(s: &String) -> usize {
    s.len()
}

A The length of 'hello' is 5.

B The length of 'hello' is 0.

C Compile error: cannot borrow `s` as immutable because it is also borrowed as mutable

D Runtime error: use of moved value `s`

💡 Hint

Look at how the function borrows the string without taking ownership.

The function `calculate_length` borrows `s` immutably using `&s`. This means ownership is not moved, so `s` can still be used after the function call. The length of 'hello' is 5, so the output prints correctly.

❓ Predict Output

intermediate

What error does this Rust code produce without borrowing?

What error will this Rust code produce when compiled?

Rust

fn main() {
    let s = String::from("hello");
    let len = calculate_length(s);
    println!("The length of '{}' is {}.", s, len);
}

fn calculate_length(s: String) -> usize {
    s.len()
}

A Runtime error: null pointer dereference

B The length of 'hello' is 5.

C Compile error: cannot borrow `s` as mutable because it is also borrowed as immutable

D Compile error: use of moved value `s`

💡 Hint

Passing `s` by value moves ownership, so `s` cannot be used after.

The function `calculate_length` takes ownership of `s`. After the call, `s` is moved and cannot be used in `println!`. This causes a compile-time error about use of moved value.

🔧 Debug

advanced

Why does this Rust code fail to compile?

Identify the reason this Rust code does not compile.

Rust

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

A Cannot borrow `s` as immutable because it is already borrowed as mutable

B Cannot borrow `s` as mutable because it is already borrowed as immutable

C Use of moved value `s`

D No error, prints 'hello and hello'

💡 Hint

Rust enforces only one mutable reference or multiple immutable references at a time.

The code tries to create an immutable reference `r1` and a mutable reference `r2` to `s` at the same time. Rust forbids this to prevent data races, so it causes a compile error.

🧠 Conceptual

advanced

Why is borrowing important in Rust?

Which of the following best explains why borrowing is required in Rust?

A To allow multiple parts of code to access data without taking ownership, preventing data races and enabling safe concurrency.

B To make the code run faster by copying data multiple times.

C To allow variables to be used after they have been moved without restrictions.

D To enable garbage collection automatically in Rust programs.

💡 Hint

Think about how Rust prevents bugs related to memory safety.

Borrowing lets Rust let multiple parts of code read or write data safely without transferring ownership. This prevents bugs like data races and dangling pointers without needing a garbage collector.

❓ Predict Output

expert

What is the output of this Rust code demonstrating borrowing rules?

Analyze the code and select the correct output or error message.

Rust

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

A

hello and hello
hello

B

hello and hello
hello, world

C Compile error: cannot borrow `s` as mutable because it is also borrowed as immutable

D Runtime error: simultaneous mutable and immutable borrow

💡 Hint

Rust does not allow mutable borrow while immutable borrows are active.

The code tries to create two immutable references `r1` and `r2` and then a mutable reference `r3` before the immutable references go out of scope. Rust forbids this and produces a compile error.

Practice

1. Why does Rust require borrowing when accessing data instead of always transferring ownership?

easy

A. To allow multiple parts of code to read data without copying it

B. To make the code run slower for safety

C. To force programmers to write more code

D. To prevent any data from being changed

Solution

1. Step 1: Understand ownership and borrowing

   Ownership means one variable controls the data. Borrowing lets others use data without owning it.

2. Step 2: Why borrowing is useful

   Borrowing allows multiple parts of code to read data safely without making copies or moving ownership.

3. Final Answer:

   To allow multiple parts of code to read data without copying it -> Option A

4. Quick Check:

   Borrowing = safe shared access [OK]

Hint: Borrowing means sharing data without moving ownership [OK]

Common Mistakes:

• Thinking borrowing slows down code
• Believing borrowing prevents all data changes
• Confusing borrowing with copying data

2. Which of the following is the correct syntax to borrow a variable immutably in Rust?

easy

A. let x = ref value;

B. let x = &value;

C. let &x = value;

D. let mut x = &mut value;

Solution

1. Step 1: Identify borrowing syntax

   In Rust, borrowing immutably uses the ampersand before the variable: &value.

2. Step 2: Match correct syntax

   The correct way to bind a reference is let x = &value;. Other options are invalid or mean something else.

3. Final Answer:

   let x = &value; -> Option B

4. Quick Check:

   Immutable borrow = &value [OK]

Hint: Use & before variable to borrow immutably [OK]

Common Mistakes:

• Using let x = ref value; invalid syntax
• Confusing &x with &value
• Using mutable borrow (&mut) for immutable access

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

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

medium

A. hello and hello

B. Compilation error due to multiple mutable borrows

C. hello and error

D. Runtime error

Solution

1. Step 1: Analyze borrowing in code

   Two immutable references r1 and r2 borrow s simultaneously, which is allowed.

2. Step 2: Check output of println!

   Both references print the string "hello", so output is "hello and hello".

3. Final Answer:

   hello and hello -> Option A

4. Quick Check:

   Multiple immutable borrows print values [OK]

Hint: Multiple immutable borrows allowed, prints values [OK]

Common Mistakes:

• Thinking multiple immutable borrows cause errors
• Confusing mutable and immutable borrow rules
• Expecting runtime errors for borrowing

4. Identify the error in this Rust code and why borrowing is required:

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

medium

A. No error, code runs fine

B. Cannot borrow `s` as immutable because it is mutable

C. Cannot borrow `s` as mutable because it is already borrowed as immutable

D. Cannot print two variables in println!

Solution

1. Step 1: Check borrowing rules

   Rust forbids mutable borrow while immutable borrow exists to prevent data races.

2. Step 2: Identify error cause

   Here, r1 immutably borrows s, then r2 tries mutable borrow, causing compile error.

3. Final Answer:

   Cannot borrow `s` as mutable because it is already borrowed as immutable -> Option C

4. Quick Check:

   Mutable borrow blocked by existing immutable borrow [OK]

Hint: Mutable borrow blocked if immutable borrow exists [OK]

Common Mistakes:

• Thinking mutable borrow is allowed with immutable borrow
• Ignoring borrow checker errors
• Assuming println! causes error

5. You want to write a function that changes a string passed to it without taking ownership. Which borrowing type should you use and why?

hard

A. Immutable borrow (&) because it allows reading the string safely

B. Copy the string inside the function to modify it

C. Ownership transfer because borrowing is not needed for modification

D. Mutable borrow (&mut) because it allows modifying the string without ownership

Solution

1. Step 1: Understand function parameter needs

   To modify data inside a function without taking ownership, you must borrow it mutably.

2. Step 2: Choose correct borrow type

   Mutable borrow &mut allows changing the original data safely without moving ownership.

3. Final Answer:

   Mutable borrow (&mut) because it allows modifying the string without ownership -> Option D

4. Quick Check:

   Modify data = use &mut borrow [OK]

Hint: Use &mut to change data without ownership transfer [OK]

Common Mistakes:

• Using immutable borrow when modification is needed
• Transferring ownership unnecessarily
• Copying data instead of borrowing