Expression evaluation in Rust - Step-by-Step Execution

Concept Flow - Expression evaluation

Start

↓

Parse expression

↓

Evaluate operands

↓

Apply operator

↓

Get result

↓

End

The program reads an expression, evaluates each part, applies the operator, and produces the final result.

Execution Sample

Rust

fn main() {
    let result = 3 + 4 * 2;
    println!("{}", result);
}

This code calculates 3 plus 4 times 2 and prints the result.

Execution Table

Step	Action	Evaluation	Result
1	Evaluate 4 * 2	4 * 2	8
2	Evaluate 3 + 8	3 + 8	11
3	Print result	println!("{}", result)	11

💡 Expression fully evaluated and result printed.

Variable Tracker

Variable	Start	After Step 1	After Step 2	Final
result	uninitialized	uninitialized	11	11

Key Moments - 2 Insights

Why is 4 * 2 evaluated before adding 3?

Because multiplication has higher priority than addition, so step 1 evaluates 4 * 2 first as shown in execution_table row 1.

Why does the variable 'result' change only after step 2?

The variable 'result' gets its value after the full expression is evaluated, which happens at step 2 in the execution_table.

Visual Quiz - 3 Questions

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

A 11

B 6

C 8

D 7

💡 Hint

Check the 'Result' column in execution_table row 1.

At which step is the variable 'result' assigned a value?

A Step 1

B Step 2

C Step 3

D Before Step 1

💡 Hint

Look at variable_tracker row for 'result' and see when it changes from uninitialized.

If the expression was changed to (3 + 4) * 2, what would be the result after step 2?

A 14

B 10

C 11

D 7

💡 Hint

Parentheses change evaluation order; check how execution_table would change.

Concept Snapshot

Expression evaluation in Rust:
- Operators follow precedence (e.g., * before +)
- Evaluate operands first
- Apply operator to operands
- Store result in variable
- Print or use result
Example: let result = 3 + 4 * 2; // result is 11

Full Transcript

This example shows how Rust evaluates an expression step-by-step. First, it calculates 4 times 2, getting 8. Then it adds 3 to 8, resulting in 11. The variable 'result' is assigned this value. Finally, the program prints 11. Multiplication happens before addition because of operator precedence. Changing the expression with parentheses changes the order of evaluation and the final result.

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