Expression evaluation in Rust

Introduction

Expression evaluation means calculating the result of a math or logic statement in code. It helps the computer decide what value to use next.

When you want to add, subtract, multiply, or divide numbers.

When you need to compare two values to make decisions.

When you want to combine values using logical operations like AND or OR.

When you want to store the result of a calculation in a variable.

When you want to print the result of a calculation to the screen.

Syntax

Rust

let result = expression;

An expression can be a math operation like 5 + 3 or a comparison like 4 > 2.

The result of the expression is stored in a variable using let.

Examples

Adds 5 and 3, then stores 8 in sum.

Rust

let sum = 5 + 3;

Checks if 10 is greater than 7, stores true in is_greater.

Rust

let is_greater = 10 > 7;

First adds 4 and 2, then multiplies the result by 3, stores 18 in combined.

Rust

let combined = (4 + 2) * 3;

Sample Program

This program calculates and prints the sum, difference, product, and quotient of two numbers. It also checks if one number is greater than the other.

Rust

fn main() {
    let a = 10;
    let b = 5;
    let sum = a + b;
    let difference = a - b;
    let product = a * b;
    let quotient = a / b;
    let is_a_greater = a > b;

    println!("Sum: {}", sum);
    println!("Difference: {}", difference);
    println!("Product: {}", product);
    println!("Quotient: {}", quotient);
    println!("Is a greater than b? {}", is_a_greater);
}

Important Notes

Rust follows the usual math order: multiplication and division happen before addition and subtraction.

Division between integers gives an integer result (no decimals).

Boolean expressions like comparisons return true or false.

Summary

Expressions calculate values using math or logic.

Use let to save the result of an expression in a variable.

Expressions can be combined and used to make decisions or print results.

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