Ownership rules in Rust - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare a mutable String variable.

Rust

let [1] = String::from("hello");

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

Amut s

Bs

Cmut

Dlet s

Attempts:

3 left

💡 Hint

Common Mistakes

Forgetting to add mut when you want to change the variable later.

Writing let mut without a variable name.

In Rust, to make a variable mutable, you add mut before the variable name. So let mut s declares a mutable variable s.

2fill in blank

medium

Complete the code to transfer ownership of the String to the function.

Rust

fn take_ownership(s: String) {
    println!("{}", s);
}

fn main() {
    let s1 = String::from("hello");
    [1](s1);
}

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

Aprint

Bborrow

Cclone

Dtake_ownership

Attempts:

3 left

💡 Hint

Common Mistakes

Trying to call a function that does not exist.

Using clone instead of calling the function.

The function take_ownership takes ownership of the String. Calling take_ownership(s1) moves ownership from s1 to the function.

3fill in blank

hard

Fix the error by completing the code to borrow the String instead of moving ownership.

Rust

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

fn main() {
    let s1 = String::from("hello");
    let len = calculate_length([1]);
    println!("Length: {}", len);
}

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

A&s1

Bs1

C*s1

Ds1.clone()

Attempts:

3 left

💡 Hint

Common Mistakes

Passing s1 directly, which moves ownership.

Using *s1 which tries to dereference a value.

To borrow a String without taking ownership, you pass a reference using &. So &s1 borrows s1 for the function.

4fill in blank

hard

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

Rust

fn change(s: [1] String) {
    s.push_str(" world");
}

fn main() {
    let mut s = String::from("hello");
    change([2] s);
    println!("{}", s);
}

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

A&mut

B&

Cmut

DString

Attempts:

3 left

💡 Hint

Common Mistakes

Using immutable references & when trying to modify.

Passing ownership instead of a reference.

To modify a String through a reference, you need a mutable reference. So the function parameter is &mut String and you pass &mut s when calling.

5fill in blank

hard

Fill all three blanks to create a dictionary comprehension that filters words by length.

Rust

fn main() {
    let words = vec!["apple", "bat", "car", "dog"];
    let lengths = [1]: [2] for word in words.iter() if word.len() [3] 3;
    println!("{:?}", lengths);
}

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

Aword

Bword.len()

C>

D<=

Attempts:

3 left

💡 Hint

Common Mistakes

Using the wrong comparison operator in the condition.

Mixing up key and value in the comprehension.

This Rust code uses an iterator and a filter to create a map of words and their lengths where the length is greater than 3. The blanks fill the key, value, and condition respectively.

Practice

1. What happens when ownership of a variable is moved to another variable in Rust?

easy

A. The original variable becomes invalid and cannot be used.

B. Both variables can be used independently without restrictions.

C. The data is copied and both variables own separate copies.

D. The original variable automatically deletes the data.

Solution

1. Step 1: Understand ownership move

   When ownership moves, the original variable loses its right to access the data.

2. Step 2: Effect on original variable

   The original variable becomes invalid and cannot be used to prevent double free errors.

3. Final Answer:

   The original variable becomes invalid and cannot be used. -> Option A

4. Quick Check:

   Ownership move invalidates old owner = A [OK]

Hint: Ownership move disables old variable usage [OK]

Common Mistakes:

• Thinking ownership move copies data
• Assuming both variables remain valid
• Confusing move with borrowing

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

easy

A. let ref x = value;

B. let x = value;

C. let x = *value;

D. let x = &value;

Solution

1. Step 1: Identify borrowing syntax

   Immutable borrowing uses the & symbol before the variable.

2. Step 2: Match correct syntax

   let x = &value; correctly borrows value immutably.

3. Final Answer:

   let x = &value; -> Option D

4. Quick Check:

   Immutable borrow uses & = B [OK]

Hint: Use & to borrow immutably [OK]

Common Mistakes:

• Using * for borrowing instead of dereferencing
• Missing & symbol for borrowing
• Confusing mutable and immutable borrow syntax

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

let s1 = String::from("hello");
let s2 = s1;
println!("{}", s1);

medium

A. Runtime error

B. hello

C. Compilation error

D. Empty string

Solution

1. Step 1: Analyze ownership move

   Assigning s1 to s2 moves ownership, invalidating s1.

2. Step 2: Using invalidated variable

   Printing s1 after move causes a compile-time error because s1 is no longer valid.

3. Final Answer:

   Compilation error -> Option C

4. Quick Check:

   Using moved variable causes compile error = A [OK]

Hint: Using moved variable causes compile error [OK]

Common Mistakes:

• Expecting s1 to print after move
• Confusing move with copy
• Thinking runtime error occurs instead

4. Identify the error in this Rust code snippet:

let 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 mutable because it is already borrowed as immutable.

C. String::from is not a valid function.

D. Cannot print two variables in one println! macro.

Solution

1. Step 1: Check borrowing rules

   Rust forbids mutable borrow if immutable borrow exists simultaneously.

2. Step 2: Identify conflict

   r1 is an immutable borrow; r2 tries mutable borrow causing error.

3. Final Answer:

   Cannot borrow s as mutable because it is already borrowed as immutable. -> Option B

4. Quick Check:

   Mutable borrow conflicts with existing immutable borrow = D [OK]

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

Common Mistakes:

• Ignoring borrow rules and expecting code to run
• Thinking multiple mutable borrows allowed
• Misunderstanding println! macro usage

5. Given this Rust function:

fn take_ownership(s: String) {
    println!("{}", s);
}

fn main() {
    let s = String::from("hello");
    take_ownership(s);
    println!("{}", s);
}

What is the correct way to fix the error without cloning the string?

hard

A. Change the function parameter to borrow the string: fn take_ownership(s: &String)

B. Remove the println! after the function call.

C. Declare s as mutable in main.

D. Use let s = &String::from("hello"); in main.

Solution

1. Step 1: Understand ownership transfer

   Passing s to take_ownership moves ownership, invalidating s in main.

2. Step 2: Use borrowing to avoid move

   Changing parameter to &String borrows s, so ownership stays with main.

3. Step 3: Adjust function call

   Call take_ownership(&s) to pass reference matching new parameter.

4. Final Answer:

   Change the function parameter to borrow the string: fn take_ownership(s: &String) -> Option A

5. Quick Check:

   Borrow parameter to keep ownership in caller = C [OK]

Hint: Borrow in function parameter to keep ownership [OK]

Common Mistakes:

• Trying to use s after move without borrowing
• Removing code instead of fixing ownership
• Confusing mutability with ownership