Rust Operators

An operator is a symbol that performs operations on values or variables. For example, - is an operator that performs subtraction between two values.

Rust programming provides various operators that can be categorized into the following major categories:

• Arithmetic Operators
• Compound Assignment Operators
• Logical Operators
• Comparison Operators

1. Arithmetic Operators in Rust

We use arithmetic operators to perform addition, subtraction, multiplication, and division.

Here's a list of various arithmetic operators available in Rust. We have used the variable names a and b in the example.

Example 1: Addition, Subtraction and Multiplication Operators

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

    // add two variables using + operator
    let x = a + b;
    println!("{} + {} = {}", a, b, x);

    // subtract two variables using - operator
    let y = a - b;
    println!("{} - {} = {}", a, b, y);

    // multiply two variables using * operator
    let z = a * b;
    println!("{} * {} = {}", a, b, z);
}

Output:

20 + 2 = 22
20 - 2 = 18
20 * 2 = 40

Example 2: Rust Division Operator

fn main() {
    let dividend = 21;
    let divisor = 8;

    // arithmetic division using / operator with integers
    let division = dividend / divisor;

    println!("{} / {} = {}", dividend, divisor, division);
}

Output:

21 / 8 = 2

In the above example, we use the / operator to divide two integers 21 and 8. The output of the operation is 2.

In standard calculation, 21 / 8 gives 2.625. However, in Rust, when the / operator is used with integer values, we get the quotient (integer) as the output.

If we want the actual result, we should use the / operator with floating-point values. For example,

fn main() {
    let dividend = 21.0;
    let divisor = 8.0;

    // arithmetic division using / operator with floating point values
    let division = dividend / divisor;

    println!("{} / {} = {}", dividend, divisor, division);
}

Output:

21 / 8 = 2.625

Here, both dividend and divisor variables are assigned floating point values. Thus, the division operation returns a floating point result of 2.625.

Example 3: Remainder Operator

fn main() {
    let dividend = 21;
    let divisor = 8;

    // arithmetic remainder using % operator
    let remainder = dividend % divisor;
  
    println!("{} % {} = {}", dividend, divisor, remainder);
}

Output:

21 % 8 = 5

Here, we use the remainder operator % with two integers: 21 and 8. The output of the operation is 5.

The remainder operator %, as the name suggests, always returns the remainder after division.

Assignment Operator

We use an assignment operator to assign a value to a variable. For example,

let x = 5;

Here, = is an assignment operator that assigns the value on the right 5 to the variable x on the left. The assignment operator is the most common operator in Rust.

Assignment Operators

In Rust, we use the assignment operator to assign a value to a variable. For example,

let mut x = 1;

Here, the = operator assigns the value on the right to the variable on the left.

Compound Assignment Operators

We can also use an assignment operator and an arithmetic operator, known as a compound assignment operator. For example,

let mut x = 1;

// compound assignment operators
x += 3;

Here, += is a compound assignment operator known as an addition assignment. It first adds 3 to the value of x (1) and assigns the final result (4) to x.

Here's a list of various compound assignment operators in Rust.

Example: Compound Assignment Operator

fn main() {
    let mut a = 2;
  
    // arithmetic addition and assignment
    a += 3;

    println!("a = {}", a);
}

Output:

a = 5

Comparison Operators

We use comparison operators to compare two values or variables. For example,

6 > 5

Here, the relational operator > (greater than) checks if 6 is greater than 5.

A relational operator returns:

• true if the relation between two values is correct
• false if the relation is incorrect

Note: Comparison operators are also known as relational operators.

Here's a list of comparison operators available in Rust.

Example: Comparison Operators

fn main() {
    let a = 7;
    let b = 3;
    
    // use of comparison operators
    let c = a > b;
    let d = a < b;
    let e = a == b;
    
    println!("{} >= {} is {}", a, b, c);
    println!("{} <= {} is {}", a, b, d);
    println!("{} == {} is {}", a, b, e);
}

Output:

7 > 3 is true
7 < 3 is false
7 == 3 is false

Logical Operators

We use logical operators to perform logical decisions or operations. A logical operation returns either true or false depending on the conditions. For example,

(5 < 6) && (7 > 4)

Here, && is the logical AND operator that returns true if both conditions are true. In our example, both conditions are true. Hence the expression is true.

There are mainly 3 logical operators in Rust.

Example: Logical Operators

fn main() {
    let a = true;
    let b = false;
    
    // logical AND operation
    let c = a && b;

    // logical OR operation
    let d = a || b;

    // logical NOT operation
    let e = !a;
    
    println!("{} && {} = {}", a, b, c);
    println!("{} || {} = {}", a, b, d);
    println!("!{} = {}", a, e);
}

Output:

true && false = false
true || false = true
!true = false

false || true || false