Operators and Expressions in Rust

# CHAPTER 5

Operators and Expressions in Rust #

1. Chapter Introduction #

2. Learning Objectives #

• Perform basic math using Arithmetic Operators.

• Compare values using Comparison Operators.

• Chain logic using Logical Operators.

• Understand what a Statement is (does not return a value).

• Understand what an Expression is (returns a value).

3. Arithmetic Operators #

fn main() {
    let sum = 5 + 10;          // Addition
    let difference = 95.5 - 4.3; // Subtraction
    let product = 4 * 30;      // Multiplication
    let quotient = 56.0 / 32.2;  // Division
    let remainder = 43 % 5;    // Modulo (Returns the remainder, which is 3)
}

4. Comparison Operators #

fn main() {
    let a = 10;
    let b = 20;

    println!("Is a equal to b? {}", a == b);   // false
    println!("Is a not equal to b? {}", a != b); // true
    println!("Is a greater than b? {}", a > b);  // false
    println!("Is a less than or equal? {}", a <= b); // true
}

5. Logical Operators #

• && (Logical AND): True if BOTH sides are true.

• || (Logical OR): True if AT LEAST ONE side is true.

• ! (Logical NOT): Reverses the boolean value.

fn main() {
    let is_adult = true;
    let has_ticket = false;

    // Both must be true
    let can_enter = is_adult && has_ticket; // false
    
    // Reverse the value
    let is_minor = !is_adult; // false
}

6. Statements vs Expressions (CRITICAL CONCEPT) #

A. Statements Statements are instructions that perform some action but do not return a value.

• Variable declarations are statements: let y = 6;

• Function definitions are statements: fn main() {}

• Because let y = 6; does not return a value, you cannot do this in Rust: let x = (let y = 6); (This works in C, but causes an error in Rust).

B. Expressions Expressions evaluate to a resulting value.

• Math is an expression: 5 + 6 evaluates to 11.

• Calling a function is an expression.

• A new scope block {} is an expression!

Look closely at this example:

fn main() {
    let x = 5;

    // This entire block is an expression.
    // It calculates a value and assigns it to 'y'
    let y = {
        let x_squared = x * x;
        let x_cubed = x_squared * x;
        
        // Notice there is NO SEMICOLON at the end of this line!
        // Expressions do not include ending semicolons. 
        // If you add a semicolon, it becomes a statement and returns nothing '()'.
        x_cubed + 1 
    };

    println!("The value of y is: {}", y); // Output: 126
}

7. Common Mistakes #

• Type Mismatch in Math: Attempting let sum = 5 + 3.2;. The compiler will panic. You must explicitly cast the integer to a float using the as keyword: let sum = 5 as f64 + 3.2;.

• Accidental Semicolons in Expressions: If you write xcubed + 1; with a semicolon inside a block assigned to a variable, the block will return an empty tuple () instead of the integer value.

1. 1. Create two variables, price and taxrate. Calculate the total_cost.

1. 2. Write an expression block {} that calculates the area of a circle ($Area = 3.14 * r * r$) and returns it to a variable area. Remember not to use a semicolon on the last line!

10. MCQs with Answers #

11. Interview Questions #

• Q: Explain the difference between a Statement and an Expression in Rust.

• Q: Why does adding a semicolon to the end of a block change its behavior?

12. FAQs #

• Why are there no increment operators (++) in Rust? Rust does not have x++ or x-- because they can lead to subtle bugs regarding order of evaluation (e.g., x++ vs ++x). Instead, explicitly use x += 1.

13. Summary #

14. Next Chapter Recommendation #