Mutable variables in Rust - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does it mean when a variable is mutable in Rust?

A mutable variable in Rust means you can change its value after it is first set. You declare it with mut before the variable name.

beginner

How do you declare a mutable variable named count with the value 5 in Rust?

You write: <code>let mut count = 5;</code> This means <code>count</code> can be changed later.

beginner

What happens if you try to change a variable that is not mutable in Rust?

Rust will give a compile-time error because variables are immutable by default. You must declare them as mutable to change their value.

intermediate

Why does Rust make variables immutable by default?

Immutability helps prevent bugs by avoiding unexpected changes. It makes programs safer and easier to understand.

beginner

Show an example of changing a mutable variable's value in Rust.

Example:<br><code>let mut score = 10;<br>score = 20;<br>println!("Score is {}", score);</code><br>This prints: <code>Score is 20</code>

How do you declare a mutable variable in Rust?

A var variable_name = value;

B let mut variable_name = value;

C mutable variable_name = value;

D let variable_name = mut value;

In Rust, you use let mut to declare a mutable variable.

What is the default mutability of variables in Rust?

A Mutable

B Depends on the type

C Immutable

D Mutable only for integers

Variables are immutable by default in Rust unless declared with mut.

What error occurs if you try to change an immutable variable?

A Compile-time error

B Warning only

C No error, it works fine

D Runtime error

Rust prevents changing immutable variables at compile time, so you get a compile-time error.

Why is immutability preferred by default in Rust?

A To prevent unexpected changes and bugs

B To make code run faster

C Because mutable variables are not supported

D To save memory

Immutability helps keep code safe and easier to understand by avoiding unexpected changes.

Which of the following is a correct way to change a mutable variable's value?

A let x = mut 5; x = 10;

B let x = 5; x = 10;

C let mut x = 5; mut x = 10;

D let mut x = 5; x = 10;

You must declare the variable as mutable with mut and then you can assign a new value.

Explain what mutable variables are in Rust and how to declare them.

Think about how you can change a variable's value after setting it.

Describe why Rust makes variables immutable by default and the benefits of this choice.

Consider how fixing values helps avoid mistakes.

Practice

1. What keyword do you use in Rust to make a variable mutable?

easy

A. let

B. var

C. change

D. mut

Solution

1. Step 1: Understand variable declaration in Rust

   Rust uses let to declare variables, but by default they are immutable.

2. Step 2: Identify how to make variables mutable

   Adding mut after let makes the variable mutable.

3. Final Answer:

   mut -> Option D

4. Quick Check:

   Use let mut for mutable variables [OK]

Hint: Remember: let mut makes variables changeable [OK]

Common Mistakes:

• Using 'var' instead of 'mut'
• Forgetting 'mut' and expecting change
• Using 'let' alone for mutable variables

2. Which of the following is the correct syntax to declare a mutable integer variable named x with value 5 in Rust?

easy

A. let mut x = 5;

B. var mut x = 5;

C. mut let x = 5;

D. let x = 5;

Solution

1. Step 1: Recall correct order of keywords

   In Rust, let comes first, then mut to mark mutability.

2. Step 2: Check each option's syntax

   let mut x = 5; uses let mut x = 5; which is correct. Others have wrong order or invalid keywords.

3. Final Answer:

   let mut x = 5; -> Option A

4. Quick Check:

   Correct syntax is let mut variable = value; [OK]

Hint: Always write let mut in that order [OK]

Common Mistakes:

• Swapping 'mut' and 'let'
• Using 'var' instead of 'let'
• Omitting 'mut' when variable changes

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

fn main() {
    let mut count = 1;
    count = count + 2;
    println!("{}", count);
}

medium

A. 3

B. 2

C. 1

D. Compilation error

Solution

1. Step 1: Understand variable initialization and mutation

   The variable count starts at 1 and is mutable.

2. Step 2: Calculate the new value after addition

   Adding 2 to 1 gives 3, so count becomes 3.

3. Final Answer:

   3 -> Option A

4. Quick Check:

   Mutable variable updated correctly outputs 3 [OK]

Hint: Mutable lets you add and update variable values [OK]

Common Mistakes:

• Expecting original value without mutation
• Thinking code causes error without 'mut'
• Confusing output with variable name

4. Identify the error in this Rust code snippet:

fn main() {
    let x = 10;
    x = 20;
    println!("{}", x);
}

medium

A. Missing semicolon after println!

B. Variable x is not declared

C. Cannot assign twice to immutable variable x

D. Incorrect println! syntax

Solution

1. Step 1: Check variable mutability

   Variable x is declared without mut, so it is immutable.

2. Step 2: Analyze reassignment attempt

   Assigning x = 20; tries to change an immutable variable, causing a compile error.

3. Final Answer:

   Cannot assign twice to immutable variable x -> Option C

4. Quick Check:

   Immutable variables cannot be reassigned [OK]

Hint: Add mut to allow variable reassignment [OK]

Common Mistakes:

• Ignoring need for 'mut' to reassign
• Thinking println! needs semicolon error
• Assuming variable is undeclared

5. You want to create a counter that increases by 1 every time a function is called. Which Rust code correctly uses a mutable variable to achieve this?

fn main() {
    let mut counter = 0;
    increment(&mut counter);
    increment(&mut counter);
    println!("{}", counter);
}

fn increment(count: &mut i32) {
    *count += 1;
}

hard

A. Code fails because counter is immutable

B. Code compiles and prints 2

C. Code prints 0 because counter is not updated

D. Code fails due to wrong function signature

Solution

1. Step 1: Check mutability of counter

   Counter is declared mutable with let mut counter = 0;.

2. Step 2: Understand function parameter and mutation

   Function increment takes a mutable reference and increases the value by 1 each call.

3. Step 3: Count increments and final output

   Called twice, counter increases from 0 to 2, then printed.

4. Final Answer:

   Code compiles and prints 2 -> Option B

5. Quick Check:

   Mutable variable with mutable reference updates correctly [OK]

Hint: Use let mut and mutable references to update variables [OK]

Common Mistakes:

• Forgetting 'mut' on variable or reference
• Passing immutable reference to function
• Expecting counter to update without mutable reference