Immutable variables in Rust - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare an immutable variable named x with value 5.

Rust

let [1] = 5;

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

Amut x

Blet mut x

Cvar x

Dx

Attempts:

3 left

💡 Hint

Common Mistakes

Adding mut makes the variable mutable, which is not what we want.

Using var is not valid syntax in Rust.

In Rust, variables are immutable by default. To declare an immutable variable named x, just write let x = 5;.

2fill in blank

medium

Complete the code to print the value of the immutable variable y.

Rust

let y = 10;
println!("[1]", y);

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

A"{}"

B"value"

C"y"

D"%d"

Attempts:

3 left

💡 Hint

Common Mistakes

Using quotes around the variable name inside the string prints the name, not the value.

Using %d is not valid in Rust's println! macro.

To print a variable's value in Rust, use println!("{}", variable);. The curly braces {} are placeholders for the variable.

3fill in blank

hard

Fix the error in the code by completing the blank to make the variable z immutable.

Rust

let [1] = 20;
z = 30; // This line causes an error

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

Amut z

Bz

Clet z

Dvar z

Attempts:

3 left

💡 Hint

Common Mistakes

Adding mut to fix the error changes the variable to mutable, which is not the goal.

Using var is invalid syntax in Rust.

The variable z is declared immutable by let z = 20;. Trying to assign a new value to z causes an error because immutable variables cannot be changed.

4fill in blank

hard

Fill both blanks to declare an immutable variable a with value 15 and print it.

Rust

let [1] = 15;
println!("[2]", a);

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

Aa

B"{}"

C"a"

Dmut a

Attempts:

3 left

💡 Hint

Common Mistakes

Using mut a makes the variable mutable, which is not needed.

Printing "a" prints the letter 'a', not the variable's value.

Declare a as immutable with let a = 15;. To print its value, use println!("{}", a);.

5fill in blank

hard

Fill all three blanks to declare an immutable variable name with value "Rust", then print it with a message.

Rust

let [1] = [2];
println!("Hello, [3]!");

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

Aname

B"Rust"

C{}

Dmut name

Attempts:

3 left

💡 Hint

Common Mistakes

Using mut name makes the variable mutable.

Forgetting to add the variable as an argument to println! causes errors.

Declare name as immutable with let name = "Rust";. To print it inside a message, use println!("Hello, {}!", name);.

Practice

1. What does it mean when a variable is immutable in Rust?

easy

A. It can be changed anytime during the program.

B. Its value cannot be changed after it is set.

C. It is only accessible inside a function.

D. It automatically becomes mutable after declaration.

Solution

1. Step 1: Understand Rust variable default behavior

   In Rust, variables are immutable by default, meaning their values cannot be changed once assigned.

2. Step 2: Interpret immutability meaning

   Immutability means the value is fixed and cannot be reassigned or modified after initialization.

3. Final Answer:

   Its value cannot be changed after it is set. -> Option B

4. Quick Check:

   Immutable means unchangeable = A [OK]

Hint: Immutable means no changes allowed after assignment [OK]

Common Mistakes:

• Thinking immutable means variable is hidden or local
• Confusing immutability with mutability
• Assuming variables change automatically

2. Which of the following is the correct way to declare a mutable variable named count with value 10 in Rust?

easy

A. let mut count = 10;

B. let count = 10;

C. mut let count = 10;

D. count mut = 10;

Solution

1. Step 1: Recall Rust syntax for mutable variables

   In Rust, to make a variable mutable, you write let mut variable_name = value;.

2. Step 2: Check each option

   let mut count = 10; uses the correct syntax. The other options use incorrect syntax.

3. Final Answer:

   let mut count = 10; -> Option A

4. Quick Check:

   Mutable variable syntax = let mut name = value [OK]

Hint: Use 'let mut' before variable name for mutability [OK]

Common Mistakes:

• Placing 'mut' after variable name
• Using 'mut let' instead of 'let mut'
• Omitting 'mut' for mutable variables

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

fn main() {
    let x = 5;
    // x = 10; // This line is commented out
    println!("{}", x);
}

medium

A. 10

B. Compilation error

C. Runtime error

D. 5

Solution

1. Step 1: Analyze variable declaration and assignment

   Variable x is declared as immutable with value 5. The reassignment line is commented out, so it does not execute.

2. Step 2: Understand the print statement

   The program prints the value of x, which remains 5.

3. Final Answer:

   5 -> Option D

4. Quick Check:

   Immutable variable unchanged prints original value = 5 [OK]

Hint: Commented reassignment means original value prints [OK]

Common Mistakes:

• Assuming reassignment happens despite comment
• Expecting compilation error due to reassignment line
• Confusing output with reassignment value

4. Identify the error in this Rust code snippet:

fn main() {
    let x = 3;
    x = 4;
    println!("{}", x);
}

medium

A. Cannot assign to immutable variable `x`

B. Variable `x` is not declared

C. println! macro syntax is incorrect

D. Missing semicolon after let statement

Solution

1. Step 1: Check variable mutability

   Variable x is declared immutable by default with let x = 3;.

2. Step 2: Identify reassignment error

   Trying to assign x = 4; causes a compile-time error because x is immutable.

3. Final Answer:

   Cannot assign to immutable variable `x` -> Option A

4. Quick Check:

   Immutable variables cannot be reassigned = D [OK]

Hint: Reassigning immutable variable causes compile error [OK]

Common Mistakes:

• Thinking semicolon is missing
• Assuming println! syntax error
• Ignoring immutability rules

5. You want to create a counter that increases by 1 each time a function is called. Which of these Rust code snippets correctly uses an immutable variable to achieve this behavior?

hard

A. Use let mut count = 0; and increment inside the function.

B. Use let count = 0; and reassign count = count + 1; inside the function.

C. Use let count = 0; and return count + 1 without changing count.

D. Use let mut count = 0; but never increment it.

Solution

1. Step 1: Understand immutability and counter logic

   An immutable variable cannot be changed, so you cannot increment it directly.

2. Step 2: Analyze options for correct usage

   Use let count = 0; and return count + 1 without changing count. uses an immutable variable count and returns count + 1 without changing count, which respects immutability and simulates increment.

3. Final Answer:

   Use let count = 0; and return count + 1 without changing count. -> Option C

4. Quick Check:

   Immutable means no change; return new value instead = A [OK]

Hint: Immutable vars can't change; return new value instead [OK]

Common Mistakes:

• Trying to reassign immutable variable
• Forgetting to declare variable mutable when needed
• Ignoring that immutable variables can't be incremented