Immutable variables in Rust - Cheat Sheet & Quick Revision

Recall & Review

beginner

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

An immutable variable is one whose value cannot be changed after it is set. Once assigned, you cannot modify it.

beginner

How do you declare an immutable variable in Rust?

By default, variables declared with <code>let</code> are immutable. For example: <code>let x = 5;</code> creates an immutable variable <code>x</code>.

beginner

What happens if you try to change the value of an immutable variable in Rust?

The Rust compiler will give an error and prevent the program from compiling because immutable variables cannot be changed.

beginner

How can you make a variable mutable in Rust?

You add the keyword <code>mut</code> when declaring the variable, like <code>let mut x = 5;</code>. This allows you to change <code>x</code> later.

intermediate

Why does Rust use immutable variables by default?

Immutable variables help prevent bugs by avoiding accidental changes. They make code safer and easier to understand.

In Rust, what keyword do you use to declare a variable that can be changed?

A var

B let

C mut

D change

The keyword mut makes a variable mutable, allowing its value to be changed.

What will happen if you try to assign a new value to an immutable variable in Rust?

A The compiler will give an error.

B The old value will be kept and the new value ignored.

C The variable will automatically become mutable.

D The program will compile and run normally.

Rust's compiler prevents changing immutable variables by giving a compile-time error.

Which of these is the correct way to declare an immutable variable with value 10 in Rust?

A let mut x = 10;

B const x = 10;

C var x = 10;

D let x = 10;

By default, let declares an immutable variable.

Why does Rust prefer immutable variables by default?

A To make code run faster.

B To prevent accidental changes and bugs.

C Because mutable variables are not allowed.

D To save memory space.

Immutable variables help avoid bugs by preventing unintended changes.

What keyword is NOT used to declare variables in Rust?

A var

B mut

C let

D const

Rust does not use var; it uses let and const.

Explain what immutable variables are in Rust and how they affect your code.

Think about why Rust wants you to avoid changing variables unless you say so.

Describe how to declare a mutable variable in Rust and why you might want to do that.

Remember, mut means you can change the variable later.

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