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.