Immutable variables in Rust - Step-by-Step Execution

Concept Flow - Immutable variables

Declare variable with let

↓

Variable is immutable by default

↓

Try to change variable value

↓

Compiler error: cannot assign to immutable variable

↓

Use variable as is or declare mutable with let mut

In Rust, variables declared with let are immutable by default. Trying to change their value causes a compile error. To change a variable, declare it mutable with let mut.

Execution Sample

Rust

fn main() {
    let x = 5;
    // x = 6; // error: cannot assign to immutable variable
    println!("x = {}", x);
}

This code declares an immutable variable x with value 5 and prints it. Trying to assign a new value to x causes a compile error.

Execution Table

Step	Action	Variable	Value	Result/Output
1	Declare x with let x = 5;	x	5	x is set to 5
2	Attempt to assign x = 6;	x	5	Compile error: cannot assign to immutable variable
3	Print x	x	5	Output: x = 5

💡 Execution stops at compile error on step 2 because x is immutable

Variable Tracker

Variable	Start	After Step 1	After Step 2	Final
x	undefined	5	5 (unchanged, assignment failed)	5

Key Moments - 2 Insights

Why can't we assign a new value to x after declaring it with let?

Because variables declared with let are immutable by default in Rust, so the compiler prevents changing their value as shown in step 2 of the execution_table.

How can we make a variable mutable so we can change its value?

By declaring it with let mut instead of let, which tells Rust the variable can be changed.

Visual Quiz - 3 Questions

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

A undefined

B 6

C 5

D 0

💡 Hint

Check the 'Value' column for step 1 in the execution_table

At which step does the compiler error occur?

A Step 1

B Step 2

C Step 3

D No error

💡 Hint

Look at the 'Result/Output' column in the execution_table for the error message

If we change 'let x = 5;' to 'let mut x = 5;', what happens at step 2?

A x changes to 6 successfully

B Program crashes

C Compile error remains

D x remains 5

💡 Hint

Recall that 'let mut' allows variable reassignment, so step 2 assignment succeeds

Concept Snapshot

Rust variables declared with let are immutable by default.
Trying to assign a new value causes a compile error.
Use let mut to declare mutable variables.
Immutable variables help prevent bugs by avoiding unintended changes.

Full Transcript

In Rust, when you declare a variable with let, it is immutable by default. This means you cannot change its value later. For example, if you write let x = 5;, x holds the value 5 and cannot be changed. If you try to assign x = 6;, the compiler will give an error and stop the program from compiling. To allow changing a variable's value, you must declare it mutable using let mut x = 5;. Then you can assign new values to x. This behavior helps keep your code safe and predictable by preventing accidental changes to variables.

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