Mutable variables in Rust - Step-by-Step Execution

Concept Flow - Mutable variables

Declare variable with mut

↓

Assign initial value

↓

Use variable

↓

Change value

↓

Use updated variable

↓

End

This flow shows how a mutable variable is declared, assigned, used, changed, and used again in Rust.

Execution Sample

Rust

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

This code declares a mutable variable x, prints it, changes its value, and prints it again.

Execution Table

Step	Action	Variable x	Output
1	Declare mutable variable x with value 5	5
2	Print x	5	x = 5
3	Change x to 10	10
4	Print x	10	x = 10
5	End of program	10

💡 Program ends after printing updated value of x.

Variable Tracker

Variable	Start	After Step 1	After Step 3	Final
x	undefined	5	10	10

Key Moments - 2 Insights

Why do we need to write 'mut' before the variable name?

In Rust, variables are immutable by default. Writing 'mut' allows the variable to be changed later, as shown in steps 1 and 3 of the execution_table.

What happens if we try to change x without 'mut'?

Without 'mut', Rust will give a compile error when trying to assign a new value to x, because variables are immutable by default. This is why step 3 requires 'mut' in step 1.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of x after step 3?

A 10

B undefined

C 5

D 0

💡 Hint

Check the 'Variable x' column at step 3 in the execution_table.

At which step is the first time x is printed?

A Step 3

B Step 1

C Step 2

D Step 4

💡 Hint

Look at the 'Output' column in the execution_table to find when x is printed first.

If we remove 'mut' from the declaration, what will happen at step 3?

A x changes to 10 successfully

B Compile error occurs

C x remains 5 silently

D Program prints an error at runtime

💡 Hint

Refer to key_moments about mutability and step 3 in the execution_table.

Concept Snapshot

Mutable variables in Rust:
- Declare with 'let mut variable = value;'
- Allows changing the variable's value later
- Variables are immutable by default
- Changing without 'mut' causes compile error
- Use println! to see variable values

Full Transcript

This example shows how to use mutable variables in Rust. First, we declare a variable x with 'let mut x = 5;'. This means x can be changed later. We print x, which shows 5. Then we change x to 10 and print it again, showing 10. Without 'mut', Rust would not allow changing x. This teaches that variables are immutable by default and 'mut' is needed to make them mutable.

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