Rust Operators

Operators are symbols that perform operations on values or variables (operands) which are crucial for instructing compilers and interpreters on specific mathematical or logical operations. Rust categorizes operators by their precedence and associativity, understanding the precedence and associativity of operators make it possible to write clear and predictable code, as operations are performed in the intended order.

Operator precedence dictates the order in which operations in an expression are evaluated. Operators with higher precedence are evaluated before those with lower precedence. In an instance, multiplication takes precedence over addition. Therefore this expression 3 + 2 × 3 is calculated as 3 + (2 × 3) = 9 not (3 + 2) × 3 = 15.

Below is a table of rust operators precedence, operators are listed top to bottom, in descending order:

Operators with higher precedence are evaluated before operators with lower precedence but when operators have the same precedence, the associativity of the operators determines the order in which the operation is performed. Below is a table showing the associativity of rust operators:

Types of Operators

Example

Here is a simple code block that demonstrates the use of various operators in rust:

fn main() {
  let mut x = 8;
  let mut y = 4;
  let mut z = 10;

// Arithmetic Operators
  println!("x = {}, y = {}, z = {}\n", x, y, z);

  let result_add = x + y;
  println!("x + y = {}", result_add);

  let result_sub = x - y;
  println!("x - y = {}", result_sub);

  let result_mul = x * y;
  println!("x * y = {}", result_mul);

  let result_div = x / y;
  println!("x / y = {}", result_div);

  let result_modulo = x % y;
   println!("x % y = {}\n", result_modulo);

// Comparison Operators
  let is_equal = x == y;
  println!("{} == {} is {}", x, y, is_equal);

  let is_not_equal = x != y;
  println!("{} != {} is {}", x, y, is_not_equal);

  let is_greater = x > y;
  println!("{} > {} is {}", x, y, is_greater);

  let is_less = x < y;
  println!("{} < {} is {}", x, y, is_less);

  let is_greater_or_equal = x >= y;
  println!("{} >= {} is {}", x, y, is_greater_or_equal);

  let is_less_or_equal = x <= y;
  println!("{} <= {} is {}\n", x, y, is_less_or_equal);

// Logical Operators
  let result_1 = x < y && y < z;  // true
  println!("Result_1: {}", result_1);

  let result_2 = x > y || y > z;
  println!("Result_2: {}", result_2);

  let result_3 = x != y;
  println!("Result_3: {}\n", result_3);

// Bitwise Operators
  let result_and = x & y;
  println!("{} & {} = {}", x, y, result_and);

  let result_or = x | y;
  println!("{} | {} = {}", x, y, result_or);

  let result_xor = x ^ y;
  println!("{} ^ {} = {}", x, y, result_xor);

  let result_not = !x;
  println!("!{} = {}", x, result_not);

  let result_left_shift = x << 2;
  println!("{} << 2 = {}", x, result_left_shift);

  let result_right_shift = x >> 2;
   println!("{} >> 2 = {}\n", x, result_right_shift);

// Compound Assignment Operators
  x += y;
  println!("x += y: {}", x);

  x -= y;
  println!("x -= y: {}", x);

  x *= y;
  println!("x *= y: {}", x);

  x /= y;
  println!("x /= y: {}", x);

  x %= y;
  println!("x %= y: {}\n", x);

  // Reset x and y for bitwise operations
  x = 0b1010; // 10 in binary
  y = 0b1100; // 12 in binary

  x &= y;
  println!("x &= y: {:b}", x);
}

to clipboard
Copy to clipboard

Here is the output of the above code:

x = 8, y = 4, z = 10

x + y = 12
x - y = 4
x * y = 32
x / y = 2
x % y = 0

8 == 4 is false
8 != 4 is true
8 > 4 is true
8 < 4 is false
8 >= 4 is true
8 <= 4 is false

Result_1: true
Result_2: false
Result_3: true

8 & 4 = 0
8 | 4 = 12
8 ^ 4 = 12
!8 = 0
8 << 2 = 32
8 >> 2 = 2

x += y: 12
x -= y: 8
x *= y: 32
x /= y: 8
x %= y: 0

x &= y: 0b1000