Expression evaluation in Rust - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is an expression in Rust?

An expression in Rust is any piece of code that returns a value. For example, 5 + 3 is an expression that evaluates to 8.

beginner

How does Rust evaluate the expression 2 * (3 + 4)?

Rust first evaluates the expression inside the parentheses (3 + 4), which is 7, then multiplies it by 2, resulting in 14.

intermediate

What is the difference between an expression and a statement in Rust?

An expression returns a value and can be part of a larger expression. A statement performs an action but does not return a value. For example, <code>let x = 5;</code> is a statement, while <code>5 + 3</code> is an expression.

beginner

How does Rust handle boolean expressions like 5 > 3 && 2 < 4?

Rust evaluates each comparison: 5 > 3 is true, 2 < 4 is true, then combines them with && (and), resulting in true.

intermediate

What is the role of the match expression in Rust?

The match expression lets you compare a value against patterns and execute code based on which pattern matches. It always returns a value, making it a powerful expression for decision-making.

What does the Rust expression 3 + 4 * 2 evaluate to?

A 11

B 14

C 10

D 7

Rust follows order of operations: multiplication first (4 * 2 = 8), then addition (3 + 8 = 11).

Which of the following is a statement in Rust?

A <code>let x = 10;</code>

B <code>3 * 4</code>

C <code>5 + 3</code>

D <code>7 - 2</code>

let x = 10; is a statement because it declares a variable and does not return a value.

What is the result of true || false && false in Rust?

A false

B true

C error

D none

Rust evaluates && before ||. So false && false is false, then true || false is true.

Which expression correctly uses match to return a value?

A match num { 1 => 10; _ => 20; };

B match num { 1 => println!("One") };

C let x = match num { 1 => 10, _ => 20 };

D let x = if num == 1 { 10 } else { 20 };

Option C uses match as an expression that returns a value assigned to x.

What type of value does an expression in Rust always produce?

A Only integers

B No value

C Only booleans

D A value or unit type <code>()</code>

Every expression in Rust produces a value. If no meaningful value, it produces the unit type ().

Explain how Rust evaluates the expression 4 + 3 * 2 step-by-step.

Think about which part Rust calculates first.

Describe the difference between an expression and a statement in Rust with examples.

Consider what each piece of code produces or does.

Practice

1. What does the following Rust expression do?
let result = 5 + 3 * 2;
Choose the correct description.

easy

A. Calculates 3 times 2, then adds 5

B. Multiplies 5 by 3, then adds 2

C. Calculates 5 plus 3, then multiplies by 2

D. Adds 5, 3, and 2 together

Solution

1. Step 1: Understand operator precedence in Rust

   Multiplication (*) has higher precedence than addition (+), so 3 * 2 is calculated first.

2. Step 2: Calculate the expression step-by-step

   3 * 2 = 6, then 5 + 6 = 11.

3. Final Answer:

   Calculates 3 times 2, then adds 5 -> Option A

4. Quick Check:

   5 + (3 * 2) = 11 [OK]

Hint: Remember multiplication before addition in expressions [OK]

Common Mistakes:

• Adding numbers left to right ignoring precedence
• Multiplying after addition
• Confusing operator precedence

2. Which of the following is the correct way to assign the result of 4 + 7 to a variable named sum in Rust?

easy

A. let sum : 4 + 7;

B. sum = let 4 + 7;

C. let sum = 4 + 7;

D. let sum == 4 + 7;

Solution

1. Step 1: Recall Rust variable assignment syntax

   In Rust, use let variable = expression; to assign a value.

2. Step 2: Check each option for correct syntax

   let sum = 4 + 7; uses correct syntax: let sum = 4 + 7;. Others have syntax errors.

3. Final Answer:

   let sum = 4 + 7; -> Option C

4. Quick Check:

   Correct Rust assignment syntax [OK]

Hint: Use 'let var = expression;' to assign values [OK]

Common Mistakes:

• Using '==' instead of '=' for assignment
• Placing 'let' after variable name
• Using ':' instead of '=' for assignment

3. What is the output of this Rust code?

fn main() {
    let x = 10;
    let y = 3;
    let result = x / y + x % y;
    println!("{}", result);
}

medium

A. 13

B. 3

C. 1

D. 4

Solution

1. Step 1: Calculate integer division and remainder

   10 / 3 = 3 (integer division), 10 % 3 = 1 (remainder).

2. Step 2: Add the results

   3 + 1 = 4.

3. Final Answer:

   4 -> Option D

4. Quick Check:

   10 / 3 + 10 % 3 = 4 [OK]

Hint: Remember integer division drops decimals, % gives remainder [OK]

Common Mistakes:

• Treating division as float division
• Confusing remainder with division result
• Adding operands incorrectly

4. Identify the error in this Rust code snippet:

fn main() {
    let a = 5;
    let b = 0;
    let c = a / b;
    println!("{}", c);
}

medium

A. Division by zero causes a runtime panic

B. Variable 'c' is not declared properly

C. Missing semicolon after 'let b = 0'

D. println! macro syntax is incorrect

Solution

1. Step 1: Analyze the division operation

   The code divides 'a' by 'b', where 'b' is zero.

2. Step 2: Understand Rust runtime behavior

   Dividing by zero in Rust causes a runtime panic (crash), not a compile error.

3. Final Answer:

   Division by zero causes a runtime panic -> Option A

4. Quick Check:

   Division by zero panics in Rust [OK]

Hint: Check for zero divisor before division to avoid panic [OK]

Common Mistakes:

• Thinking division by zero is a compile error
• Ignoring runtime panics
• Assuming variable declaration errors

5. Given a list of numbers, which Rust expression correctly calculates the sum of all even numbers?

let numbers = [1, 2, 3, 4, 5, 6];
let sum_even = /* fill here */;
println!("{}", sum_even);

Choose the correct expression to replace /* fill here */.

hard

A. numbers.iter().map(|x| x * 2).sum::<i32>()

B. numbers.iter().filter(|&&x| x % 2 == 0).sum::<i32>()

C. numbers.iter().filter(|&x| x % 2 != 0).sum::<i32>()

D. numbers.iter().sum::<i32>()

Solution

1. Step 1: Understand the goal

   We want to sum only even numbers from the list.

2. Step 2: Analyze each option

   numbers.iter().filter(|&&x| x % 2 == 0).sum::<i32>() filters even numbers (x % 2 == 0) and sums them. numbers.iter().map(|x| x * 2).sum::<i32>() doubles all numbers then sums (wrong). numbers.iter().filter(|&x| x % 2 != 0).sum::<i32>() sums odd numbers (wrong). numbers.iter().sum::<i32>() sums all numbers (wrong).

3. Final Answer:

   numbers.iter().filter(|&&x| x % 2 == 0).sum::<i32>() -> Option B

4. Quick Check:

   Filter evens then sum [OK]

Hint: Filter even numbers before summing with iterator methods [OK]

Common Mistakes:

• Summing all numbers without filtering
• Filtering odd numbers instead of even
• Mapping values incorrectly before sum