Borrowing rules in Rust - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to borrow a reference to the variable name.

Rust

let name = String::from("Alice");
let name_ref = &[1];
println!("{}", name_ref);

Drag options to blanks, or click blank then click option'

AAlice

Bname_ref

CString

Dname

Attempts:

3 left

💡 Hint

Common Mistakes

Using the value directly without borrowing causes ownership transfer.

Trying to borrow a reference to a string literal instead of the variable.

Using &name borrows a reference to the variable name without taking ownership.

2fill in blank

medium

Complete the code to create a mutable reference to count.

Rust

let mut count = 5;
let count_ref = &[1] count;
*count_ref += 1;
println!("{}", count);

Drag options to blanks, or click blank then click option'

Amut

Bref

Clet

Dconst

Attempts:

3 left

💡 Hint

Common Mistakes

Using &count which creates an immutable reference.

Forgetting to declare the variable as mutable.

Using &mut count creates a mutable reference allowing modification through the reference.

3fill in blank

hard

Fix the error by choosing the correct way to borrow data immutably.

Rust

let data = vec![1, 2, 3];
let first = [1] data.get(0).unwrap();
println!("{}", first);

Drag options to blanks, or click blank then click option'

A&

B*

C&mut

Dref

Attempts:

3 left

💡 Hint

Common Mistakes

Using &mut causing mutable borrow error.

Using dereference operator * incorrectly.

Using &data.get(0).unwrap() borrows an immutable reference to the first element.

4fill in blank

hard

Fill both blanks to create a mutable reference and modify the value.

Rust

let mut value = 10;
let val_ref = &[1] value;
*val_ref [2] 5;
println!("{}", value);

Drag options to blanks, or click blank then click option'

Amut

B+=

C-=

D*

Attempts:

3 left

💡 Hint

Common Mistakes

Using immutable borrow & and trying to modify value.

Using wrong operator like -= or *.

Use &mut to borrow mutably and += to add 5 to the value through the reference.

5fill in blank

hard

Fill all three blanks to borrow immutably and print the length of the string.

Rust

let text = String::from("hello");
let text_ref = &[1];
let length = text_ref.[2]();
println!("Length: {}", [3]);

Drag options to blanks, or click blank then click option'

Atext

Blen

Clength

Dtext_ref

Attempts:

3 left

💡 Hint

Common Mistakes

Trying to call len() on the original variable without borrowing.

Printing the wrong variable.

Borrow text immutably, call len() on the reference, and print the reference variable text_ref length.

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