Ownership and scope in Rust - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a new String and assign it to variable s.

Rust

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

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

Afrom

Bnew

Cto_string

Dclone

Attempts:

3 left

💡 Hint

Common Mistakes

Using String::new() which creates an empty string, not from a literal.

Using to_string() directly on String:: which is incorrect syntax.

The String::from function creates a new String from a string literal.

2fill in blank

medium

Complete the code to transfer ownership of s1 to s2.

Rust

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

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

As1.clone()

B&s1

Cs1

DString::from("hello")

Attempts:

3 left

💡 Hint

Common Mistakes

Using clone() which copies instead of moving ownership.

Using a reference &s1 which borrows, not moves.

Assigning s1 to s2 moves ownership, so s1 is no longer valid.

3fill in blank

hard

Fix the error by completing the code to borrow s1 immutably.

Rust

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

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

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

As1

Bs1.clone()

C*s1

D&s1

Attempts:

3 left

💡 Hint

Common Mistakes

Passing s1 directly causes move error.

Dereferencing with *s1 is invalid here.

Passing &s1 borrows s1 immutably, matching the function parameter.

4fill in blank

hard

Fill both blanks to create a mutable String and append text to it.

Rust

let mut s = String::[1]("hello");
s.[2](" world");

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

Afrom

Bnew

Cpush_str

Dappend

Attempts:

3 left

💡 Hint

Common Mistakes

Using new creates an empty string, not from literal.

Using append is not a valid String method.

String::from creates the string, and push_str appends text to it.

5fill in blank

hard

Fill all three blanks to create a function that takes ownership and returns the String.

Rust

fn takes_and_returns_[1](s: [2]) -> [3] {
    s
}

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

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

Astring

BString

C&String

Dstr

Attempts:

3 left

💡 Hint

Common Mistakes

Using &String causes borrowing, not ownership transfer.

Using lowercase string or str is incorrect type.

The function takes ownership of a String and returns it, so parameter and return types are String.

Practice

1. What does ownership in Rust primarily ensure?

easy

A. Ownership is not related to variable scope

B. Multiple variables can own the same value simultaneously

C. Variables can share ownership without restrictions

D. Only one variable owns a value at a time

Solution

1. Step 1: Understand ownership concept

   Ownership means a value has exactly one owner variable at any time.

2. Step 2: Compare options with ownership rule

   Only one variable owns a value at a time states single ownership, others allow multiple owners or unrelated concepts.

3. Final Answer:

   Only one variable owns a value at a time -> Option D

4. Quick Check:

   Ownership = single owner [OK]

Hint: Ownership means one owner per value, no sharing [OK]

Common Mistakes:

• Thinking multiple variables can own the same value
• Confusing ownership with borrowing
• Ignoring the role of scope in ownership

2. Which of the following is the correct way to declare a variable with ownership in Rust?

easy

A. let x = String::from("hello");

B. var x = "hello";

C. int x = 5;

D. let x := "hello";

Solution

1. Step 1: Identify Rust variable declaration syntax

   Rust uses 'let' keyword and type inference or explicit types.

2. Step 2: Check each option for Rust syntax

   let x = String::from("hello"); uses 'let' and String::from correctly; others use invalid syntax for Rust.

3. Final Answer:

   let x = String::from("hello"); -> Option A

4. Quick Check:

   Rust variables start with let [OK]

Hint: Rust variables start with 'let' keyword [OK]

Common Mistakes:

• Using 'var' instead of 'let'
• Using ':=' which is not Rust syntax
• Declaring types like 'int' which is not Rust

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

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

medium

A. hello

B. Runtime error

C. Compile-time error

D. hellohello

Solution

1. Step 1: Understand ownership move in assignment

   Assigning s1 to s2 moves ownership; s1 is no longer valid.

2. Step 2: Check usage of s1 after move

   Using s1 in println! after move causes compile-time error due to invalid ownership.

3. Final Answer:

   Compile-time error -> Option C

4. Quick Check:

   Using moved value = compile error [OK]

Hint: Using moved variable causes compile error [OK]

Common Mistakes:

• Assuming s1 still owns the value after move
• Expecting runtime error instead of compile error
• Thinking both s1 and s2 own the value

4. Identify the error in this Rust code snippet:

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

fn takes_ownership(some_string: String) {
    println!("{}", some_string);
}

medium

A. Using s after ownership moved to function

B. Missing semicolon after println!

C. Function takes_ownership should return String

D. String::from is invalid syntax

Solution

1. Step 1: Analyze ownership transfer to function

   Passing s to takes_ownership moves ownership to function parameter.

2. Step 2: Check usage of s after function call

   Using s in println! after move causes compile-time error because s is invalid.

3. Final Answer:

   Using s after ownership moved to function -> Option A

4. Quick Check:

   Use after move = error [OK]

Hint: Ownership moves into function, original variable invalid after [OK]

Common Mistakes:

• Thinking function parameter borrows instead of takes ownership
• Expecting runtime error instead of compile-time
• Ignoring ownership rules with function calls

5. Given this Rust code, what is the correct way to allow main to use s after passing it to takes_ownership?

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

fn takes_ownership(some_string: String) {
    println!("{}", some_string);
}

hard

A. Return the String from takes_ownership and assign back in main

B. All of the above

C. Clone s before passing: takes_ownership(s.clone())

D. Change takes_ownership to borrow: fn takes_ownership(some_string: &String)

Solution

1. Step 1: Understand ownership transfer problem

   Passing s moves ownership, so s is invalid after call.

2. Step 2: Review options to keep s usable

   Change takes_ownership to borrow: fn takes_ownership(some_string: &String) borrows s, so ownership not moved. Return the String from takes_ownership and assign back in main returns ownership back. Clone s before passing: takes_ownership(s.clone()) clones s to keep original.

3. Step 3: Confirm all options fix the problem

   All three approaches prevent use-after-move error, so all are correct.

4. Final Answer:

   All of the above -> Option B

5. Quick Check:

   Borrow, return, or clone fixes ownership [OK]

Hint: Borrow, return ownership, or clone to keep variable usable [OK]

Common Mistakes:

• Thinking only borrowing works
• Ignoring cloning as a solution
• Not returning ownership from function