Rust: Operadores e expressões em Rust

fn main() {
    let price: f64 = 299.0;      // A piece of clothing 299 yuan
    let quantity: i32 = 3;        // Bought 3 items
    let is_member: bool = true;   // Is a member

    // Calculate all discounts with a single expression
    let total = (price * quantity as f64)           // Original Price
        * if quantity >= 3 { 0.7 } else { 0.9 }    // Volume Discount
        * if is_member { 0.95 } else { 1.0 };      // Member Discounts

    println!("Original Price: {:.2} yuan", price * quantity as f64);
    println!("Price after discount: {:.2} yuan", total);
    println!("Save: {:.2} yuan", price * quantity as f64 - total);
}

let a = 10;
let b = 20;
println!("{}", a == b);  // false
println!("{}", a != b);  // true
println!("{}", a < b);   // true

fn main() {
    let y = {
        let x = 3;
        x + 1       // No semicolons -- This is an expression, Returns 4
    };               // End of semicolon let Statement

    println!("y the value: {}", y);  // 4
}

let result = {
    let a = 2;
    let b = 3;
    a * b           // No semicolons, This expression returns 6
};

// ============================================
// Demonstration of Arithmetic Operators——Note: Truncation in integer division
// ============================================

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

    println!("Addition: {} + {} = {}", a, b, a + b);
    println!("Subtraction: {} - {} = {}", a, b, a - b);
    println!("Multiplication: {} * {} = {}", a, b, a * b);
    println!("Integer Division: {} / {} = {} (Truncation)", a, b, a / b);
    println!("Floating-Point Division: {} / {} = {:.2}", a as f64, b as f64, a as f64 / b as f64);
    println!("Modulo: {} % {} = {}", a, b, a % b);
}

Addition: 10 + 3 = 13
Subtraction: 10 - 3 = 7
Multiplication: 10 * 3 = 30
Integer Division: 10 / 3 = 3 (Truncation)
Floating-Point Division: 10 / 3 = 3.33
Modulo: 10 % 3 = 1

// ============================================
// Short-Circuit Evaluation of Logical Operators
// ============================================

fn main() {
    let age = 17;
    let has_id = true;

    // && Short Circuit: If the left is false, the right side is not executed
    let can_buy = age >= 18 && has_id;
    println!("Available for purchase (&&): {}", can_buy);  // false (Since the left side is already false)

    // || Short Circuit: If the left is true, the right side is not executed
    let is_ok = true || (expensive_check());
    println!("(|| Short Circuit, The right side will not be executed): {}", is_ok);
}

fn expensive_check() -> bool {
    println!("This function will not be executed!");
    true
}

Available for purchase (&&): false
(|| Short Circuit, The right side will not be executed): true

// ============================================
// Using Expression Blocks to Implement Concise Assignments with Complex Conditions
// ============================================

fn main() {
    let score = 85;

    let grade = {
        if score >= 90 {
            "A"
        } else if score >= 80 {
            "B"
        } else if score >= 70 {
            "C"
        } else if score >= 60 {
            "D"
        } else {
            "F"
        }
    };  // Note: The entire if-else chain is an expression, End with a semicolon let Statement

    println!("Score: {}, Level: {}", score, grade);

    // Alternatives to Ternary Operations: Use if Expression
    let is_pass = if score >= 60 { "passed" } else { "failed" };
    println!("Result: {}", is_pass);
}

Score: 85, Level: B
Result: passed

// ============================================
// Bitwise Operations in Practice:File Permissions and RGB Color Manipulation
// ============================================

fn main() {
    let read_perm: u8    = 0b100;   // 4
    let write_perm: u8   = 0b010;   // 2
    let exec_perm: u8    = 0b001;   // 1

    let user_perm = read_perm | write_perm;
    println!("User Permissions: {:03b} (Read+Write)", user_perm);

    let full_perm = read_perm | write_perm | exec_perm;
    println!("Full Permissions: {:03b} (Read+Write+Execute)", full_perm);

    let can_read = (user_perm & read_perm) != 0;
    let can_exec = (user_perm & exec_perm) != 0;
    println!("User-readable: {}, Executable: {}", can_read, can_exec);

    let no_write = user_perm & !write_perm;
    println!("Remove Write Permissions: {:03b}", no_write);

    let toggled = user_perm ^ exec_perm;
    println!("Toggle the execution bit: {:03b}", toggled);

    let red: u32   = 0xFF0000;
    let green: u32 = 0x00FF00;
    let blue: u32  = 0x0000FF;
    let yellow = red | green;
    let white = red | green | blue;
    println!("\nRed: {:06X}", red);
    println!("Yellow (Red|Green): {:06X}", yellow);
    println!("White (Red|Green|Blue): {:06X}", white);

    let pixel: u32 = 0xFF8040;
    let r = (pixel >> 16) & 0xFF;
    let g = (pixel >> 8)  & 0xFF;
    let b = pixel & 0xFF;
    println!("\nPixel #FF8040 → R={}, G={}, B={}", r, g, b);

    let shift_val: u8 = 1;
    println!("\n1 << 0 = {}", shift_val << 0);
    println!("1 << 1 = {}", shift_val << 1);
    println!("1 << 2 = {}", shift_val << 2);
    println!("1 << 3 = {}", shift_val << 3);
}

User Permissions: 110 (Read+Write)
Full Permissions: 111 (Read+Write+Execute)
User-readable: true, Executable: false
Remove Write Permissions: 100
Toggle the execution bit: 111

Red: FF0000
Yellow (Red|Green): FFFF00
White (Red|Green|Blue): FFFFFF

Pixel #FF8040 → R=255, G=128, B=64

1 << 0 = 1
1 << 1 = 2
1 << 2 = 4
1 << 3 = 8

// ============================================
// Operator Precedence in Practice + Compound Assignment Operator
// ============================================

fn main() {
    println!("=== Operator Precedence ===");
    let a = 2 + 3 * 4;
    println!("2 + 3 * 4 = {} (Multiply First, Then Add)", a);

    let b = (2 + 3) * 4;
    println!("(2 + 3) * 4 = {} (Parentheses Take Precedence)", b);

    let c = 10 - 6 / 2;
    println!("10 - 6 / 2 = {} (Multiply First, Then Subtract)", c);

    let d = true && false || true;
    println!("true && false || true = {} (&& Take precedence over ||)", d);

    let e = true || false && false;
    println!("true || false && false = {} (&& Take precedence over ||)", e);

    println!("\n=== Compound Assignment Operator ===");
    let mut score: i32 = 100;
    score += 20;
    println!("score += 20 → {}", score);
    score -= 30;
    println!("score -= 30 → {}", score);
    score *= 2;
    println!("score *= 2 → {}", score);
    score /= 7;
    println!("score /= 7 → {}", score);
    score %= 3;
    println!("score %= 3 → {}", score);

    println!("\n=== Chain Comparison(Using logical operators)===");
    let x = 50;
    let in_range = x >= 0 && x <= 100;
    let out_range = x < 0 || x > 100;
    println!("x={}, in [0,100]: {}, Out of range: {}", x, in_range, out_range);

    let charlie_score = 75;
    let bob_score = 88;
    let both_passed = charlie_score >= 60 && bob_score >= 60;
    let any_excellent = charlie_score >= 90 || bob_score >= 90;
    println!("Both passed: {}, Someone excellent: {}", both_passed, any_excellent);
}

=== Operator Precedence ===
2 + 3 * 4 = 14 (Multiply First, Then Add)
(2 + 3) * 4 = 20 (Parentheses Take Precedence)
10 - 6 / 2 = 7 (Multiply First, Then Subtract)
true && false || true = true (&& Take precedence over ||)
true || false && false = true (&& Take precedence over ||)

=== Compound Assignment Operator ===
score += 20 → 120
score -= 30 → 90
score *= 2 → 180
score /= 7 → 25
score %= 3 → 1

=== Chain Comparison(Using logical operators)===
x=50, in [0,100]: true, Out of range: false
Both passed: true, Someone excellent: false