Assignment operators in Rust - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the basic assignment operator in Rust?

The basic assignment operator in Rust is =. It assigns the value on the right to the variable on the left.

beginner

What does the operator += do in Rust?

The += operator adds the value on the right to the variable on the left and then assigns the result back to the variable.

beginner

How would you use the *= operator in Rust? Give an example.

The <code>*=</code> operator multiplies the variable by the value on the right and assigns the result back. Example: <code>let mut x = 5; x *= 3; // x is now 15</code>

intermediate

Can you chain assignment operators in Rust like x += y += z? Why or why not?

No, Rust does not support chaining assignment operators like x += y += z. Each assignment must be a separate statement because assignment operators return () (unit), not a value.

beginner

List some common compound assignment operators in Rust.

Common compound assignment operators in Rust include: +=, -=, *=, /=, %=, &=, |=, ^=, <<=, >>=.

What does the operator -= do in Rust?

A Divides the left variable by the right value

B Assigns the right value to the left variable without change

C Multiplies the left variable by the right value

D Subtracts the right value from the left variable and assigns the result to the variable

The -= operator subtracts the right value from the left variable and stores the result back in the variable.

Which of these is NOT a valid compound assignment operator in Rust?

A *=

B +=

C ++=

D &=

++= is not a valid operator in Rust. Rust does not have increment (++) operators.

What is the result of this code?
let mut a = 10; a /= 2;

A a is 5

B a is 20

C a is 2

D Compilation error

The /= operator divides a by 2 and assigns the result back, so a becomes 5.

Why can't you chain assignment operators like x += y += z in Rust?

A Because Rust does not allow multiple assignments

B Because assignment operators return unit type, not a value

C Because Rust only supports <code>=</code> operator

D Because variables must be immutable

Assignment operators in Rust return the unit type (), so chaining like x += y += z is not allowed.

Which operator would you use to perform a bitwise AND and assign the result to a variable?

A &=

B |=

C ^=

D &&=

The &= operator performs a bitwise AND on the variable and the right value, then assigns the result back.

Explain how compound assignment operators work in Rust and give examples.

Think about how you can combine an operation and assignment in one step.

Why does Rust not allow chaining of assignment operators like x += y += z? What does this tell you about the return type of assignment operators?

Consider what value an assignment expression produces in Rust.

Practice

1. What does the Rust assignment operator += do?

easy

A. Subtracts the right value from the left variable and stores the result in the variable

B. Adds the right value to the left variable and stores the result in the variable

C. Multiplies the right value with the left variable and stores the result in the variable

D. Divides the left variable by the right value and stores the result in the variable

Solution

1. Step 1: Understand the += operator

   The += operator adds the right-hand side value to the left-hand side variable.

2. Step 2: Effect on the variable

   The result of the addition is stored back into the same variable, updating its value.

3. Final Answer:

   Adds the right value to the left variable and stores the result in the variable -> Option B

4. Quick Check:

   += means add and assign [OK]

Hint: Think: add then store back in the same variable [OK]

Common Mistakes:

• Confusing += with subtraction or multiplication
• Forgetting that the variable must be mutable
• Thinking it creates a new variable instead of updating

2. Which of the following is the correct way to use the *= operator in Rust?

easy

A. let x = 5; x *= 2;

B. let mut x = 5; *= x 2;

C. let x = 5; mut x *= 2;

D. let mut x = 5; x *= 2;

Solution

1. Step 1: Check variable mutability

   In Rust, to change a variable's value, it must be declared with mut. So let mut x = 5; is correct.

2. Step 2: Correct operator usage

   The operator *= is used as x *= 2; to multiply and assign.

3. Final Answer:

   let mut x = 5; x *= 2; -> Option D

4. Quick Check:

   Mutable variable + operator syntax = correct [OK]

Hint: Declare variable mutable before using assignment operators [OK]

Common Mistakes:

• Not declaring variable as mutable
• Placing mut in wrong position
• Incorrect operator syntax like *= x 2

3. What is the output of the following Rust code?

let mut a = 10;
a += 5;
a *= 2;
println!("{}", a);

medium

A. 30

B. 25

C. 20

D. 15

Solution

1. Step 1: Perform a += 5;

   Starting with a = 10, adding 5 gives a = 15.

2. Step 2: Perform a *= 2;

   Multiplying 15 by 2 updates a = 30.

3. Final Answer:

   30 -> Option A

4. Quick Check:

   10 + 5 = 15; 15 * 2 = 30 [OK]

Hint: Calculate step-by-step updates to variable [OK]

Common Mistakes:

• Adding and multiplying in wrong order
• Forgetting variable is mutable
• Misreading operator effects

4. Identify the error in this Rust code snippet:

let x = 8;
x -= 3;
println!("{}", x);

medium

A. The println! macro is used incorrectly

B. The operator -= is not valid in Rust

C. Variable x is not mutable but is modified

D. Missing semicolon after println!

Solution

1. Step 1: Check variable mutability

   The variable x is declared without mut, so it is immutable.

2. Step 2: Check assignment operator usage

   The operator -= tries to subtract and assign a new value to x, which is not allowed for immutable variables.

3. Final Answer:

   Variable x is not mutable but is modified -> Option C

4. Quick Check:

   Immutable variable cannot be changed [OK]

Hint: Mutable variables needed for assignment operators [OK]

Common Mistakes:

• Assuming all variables are mutable by default
• Thinking operator syntax is wrong
• Ignoring Rust's immutability rules

5. Given the code below, what is the final value of result?

let mut result = 50;
let change = 7;
result %= change;
result += 3;
result *= 4;

hard

A. 16

B. 12

C. 28

D. 14

Solution

1. Step 1: Calculate result %= change;

   50 % 7 equals 1 because 7 * 7 = 49 and remainder is 1, so result = 1.

2. Step 2: Calculate result += 3;

   Add 3 to 1 gives result = 4.

3. Step 3: Calculate result *= 4;

   Multiply 4 by 4 gives result = 16.

4. Final Answer:

   16 -> Option A

5. Quick Check:

   50 % 7 = 1; 1 + 3 = 4; 4 * 4 = 16 [OK]

Hint: Apply each operator stepwise carefully [OK]

Common Mistakes:

• Miscomputing modulus operation
• Skipping steps or doing operations out of order
• Choosing wrong multiplication result