Mutable variables in Rust

Introduction

Mutable variables let you change the value stored in them after you create them. This helps when you want to update information as your program runs.

When you want to keep track of a score that changes during a game.

When you need to update a counter in a loop.

When you want to store user input that can change.

When you want to modify a value based on conditions.

When you want to build a value step-by-step.

Syntax

Rust

let mut variable_name = initial_value;

Use mut right after let to make a variable mutable.

Without mut, variables are read-only and cannot be changed.

Examples

This creates a mutable variable count starting at 0, then changes it to 5.

Rust

let mut count = 0;
count = 5;

This variable name is not mutable, so trying to change it will cause an error.

Rust

let name = "Alice";
// name = "Bob"; // This will cause an error because name is not mutable

Here, temperature starts at 20 and then increases by 5.

Rust

let mut temperature = 20;
temperature = temperature + 5;

Sample Program

This program shows a mutable variable score starting at 0, then changing to 10, printing both values.

Rust

fn main() {
    let mut score = 0;
    println!("Initial score: {}", score);
    score = 10;
    println!("Updated score: {}", score);
}

Important Notes

Remember to use mut only when you need to change the variable.

Rust helps prevent bugs by making variables immutable by default.

Summary

Mutable variables let you change values after creating them.

Use let mut to declare a mutable variable.

Without mut, variables cannot be changed.

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