In Rust, operators are essential elements for performing various computations and operations on values. They encompass a range of functionalities, including arithmetic, assignment, comparison, and logical operations. This article provides a comprehensive overview of these operators, along with examples to illustrate their usage and behavior.

Arithmetic Operators

Arithmetic operators such as addition (+), subtraction (-), multiplication (*), division (/), and remainder (%) are used for basic mathematical calculations. It's important to note that when dividing integers, the result is also an integer, discarding any remainder.

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

    println!("Addition: {}", a + b); // 13
    println!("Subtraction: {}", a - b); // 7
    println!("Multiplication: {}", a * b); // 30
    println!("Division: {}", a / b); // 3
    println!("Remainder: {}", a % b); // 1
}

Assignment Operators

Assignment operators (=, +=, -= , *= , /=, %=) are used to assign values to variables and perform arithmetic operations simultaneously. These operators are convenient for concise and readable code.

• = (Assignment)
• += (Add and assign)
• -= (Subtract and assign)
• *= (Multiply and assign)
• /= (Divide and assign)
• %= (Remainder and assign)

fn main() {
    let mut a = 5;

    a += 2; // equivalent to a = a + 2;
    println!("After addition: {}", a); // 7

    a *= 3; // equivalent to a = a * 3;
    println!("After multiplication: {}", a); // 21
}

Comparison Operators

Comparison operators (==, !=, <, >, <=, >=) are used to compare values and determine their relationship. These operators return a boolean value (true or false) based on the comparison result.

• == (Equal to)
• != (Not equal to)
• < (Less than)
• > (Greater than)
• <= (Less than or equal to)
• >= (Greater than or equal to)

fn main() {
    let x = 5;
    let y = 7;

    println!("Equal: {}", x == y); // false
    println!("Not equal: {}", x != y); // true
    println!("Less than: {}", x < y); // true
    println!("Greater than: {}", x > y); // false
    println!("Less than or equal to: {}", x <= y); // true
    println!("Greater than or equal to: {}", x >= y); // false
}

Logical Operators

Logical operators (&&, ||, !) are used to perform logical operations on boolean values. && represents logical AND, || represents logical OR, and ! represents logical NOT. These operators are often used in conditional statements and loops.

fn main() {
    let a = true;
    let b = false;

    println!("Logical AND: {}", a && b); // false
    println!("Logical OR: {}", a || b); // true
    println!("Logical NOT: {}", !a); // false
}

Understanding and mastering these operators are fundamental to writing efficient and effective Rust code. They provide the building blocks for complex algorithms and logic in Rust programs.