# 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.

Operator Example
`+` (Addition) `a + b`
`-` (Subtraction) `a - b`
`*` (Multiplication) `a * b`
`/` (Division) `a / b`
`%` (Remainder) `a % b`

### 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.

Operator Example Equivalent To
`+=` (addition assignment) `a += b` `a = a + b`
`-=` (subtraction assignment) `a -= b` `a = a - b`
`*=` (multiplication assignment) `a *= b` `a = a * b`
`/=` (division assignment) `a /= b` `a = a / b`
`%=` (remainder assignment) `a %= b` `a = a % b`

### Example: Compound Assignment Operator

``````fn main() {
let mut a = 2;

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.

Operator Example Description
`>` (Greater than) `a > b` `true` if `a` is greater than `b`
`<` (Less than) `a < b` `true` if `a` is less than `b`
`>=` (Greater than or equal to) `a >= b` `true` if `a` is greater than or equal to `b`
`<=` (Less than or equal to) `a <= b` `true` if `a` is less than or equal to `b`
`==` (Equal to) `a == b` `true` if `a` is equal to `b`
`!=` (Not equal to) `a != b` `true` if `a` is not equal to `b`

### 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.

Operator Example Description
`&&` (Logical AND) `exp1 && exp2` returns `true` if both `exp1` and `exp2` are `true`
`||` (Logical OR) `exp1 || exp2` returns `true` if any one of the expressions is `true`
`!` (Logical NOT) `!exp` returns `true` if the expression is `false` and returns `false`, if it is `true`

### 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```

Note: The logical `AND` and `OR` operators are also called short-circuiting logical operators because these operators don't evaluate the whole expression in cases they don't need to. For example, in this expression

``false || true || false``

The `||` operator evaluates to `true` because once the compiler sees a single `true` expression, it skips the evaluation and returns `true` directly.