In Rust, the if statement is used for conditional execution of code. It evaluates a condition, and if the condition is true, the associated block of code is executed. Rust's if statements are versatile and integrate seamlessly with the language's emphasis on safety and expressions.

---

Syntax of if

The basic structure of an if statement in Rust is:

if condition {
    // Code to execute if the condition is true
}

Example:

fn main() {
    let number = 10;

    if number > 5 {
        println!("The number is greater than 5.");
    }
}

---

if-else Statement

You can include an else block to execute code when the condition is false.

fn main() {
    let number = 3;

    if number % 2 == 0 {
        println!("The number is even.");
    } else {
        println!("The number is odd.");
    }
}

---

if-else if Ladder

For multiple conditions, you can chain if-else if statements:

fn main() {
    let number = 0;

    if number > 0 {
        println!("The number is positive.");
    } else if number < 0 {
        println!("The number is negative.");
    } else {
        println!("The number is zero.");
    }
}

---

if as an Expression

In Rust, if can be used as an expression, meaning it can return a value. This makes it possible to assign the result of an if block to a variable.

Example:

fn main() {
    let number = 10;

    let result = if number % 2 == 0 {
        "even"
    } else {
        "odd"
    };

    println!("The number is {}.", result);
}

Key Notes:

• Both branches of the if must return the same type, as Rust is statically typed.
• If mismatched types are provided, it will result in a compilation error.

---

Combining Conditions with Logical Operators

Rust supports logical operators (&&, ||, !) for combining conditions.

Example:

fn main() {
    let age = 20;

    if age >= 18 && age <= 65 {
        println!("You are an adult.");
    } else {
        println!("You are either a minor or a senior.");
    }
}

• && is the logical AND operator.
• || is the logical OR operator.
• ! is the logical NOT operator.

---

Pattern Matching with if let

Rust offers the if let syntax for concise pattern matching, especially useful with enums.

Example:

fn main() {
    let value = Some(42);

    if let Some(x) = value {
        println!("The value is {}", x);
    } else {
        println!("No value found.");
    }
}

Explanation:

• if let matches a pattern (e.g., Some(x)) against a value.
• The else block handles cases where the pattern does not match.

---

Comparison with Other Languages

Feature	Rust if	Traditional if in Other Languages
Expression-Based	Returns a value	Often statement-based
Safety	Requires boolean conditions	May allow implicit truthiness checks
Static Typing	Enforces type consistency	May allow mixed types

---

Summary

• Basic Use: Conditional branching of code.
• Versatility: Can return values when used as an expression.
• Safety: Conditions must evaluate to a bool, preventing common bugs.
• Advanced Use: Works seamlessly with pattern matching (if let) and logical operators.

Rust’s if construct is both powerful and straightforward, aligning well with the language's focus on reliability and clarity.