In this article, we are going to understand **Operators** **in** **Rust** with their usages in detail, along with examples.

**Operators in Rust can be classified as:**

## Arithmetic Operators

### Basic Arithmetic Operators:

Rust provides the following basic arithmetic operators:

- Addition (
`+`

) - Subtraction (
`-`

) - Multiplication (
`*`

) - Division (
`/`

) - Remainder (modulus) (
`%`

)

These operators can be used with integer and floating-point number types. Here’s an example of how to use them:

```
fn main() {
let a: i32 = 10;
let b: i32 = 3;
let addition = a + b;
let subtraction = a - b;
let multiplication = a * b;
let division = a / b;
let remainder = a % b;
println!("a + b = {}", addition);
println!("a - b = {}", subtraction);
println!("a * b = {}", multiplication);
println!("a / b = {}", division);
println!("a % b = {}", remainder);
}
```

### Compound Assignment Operators:

Rust also supports compound assignment operators that combine arithmetic operations with assignment. These operators are useful for updating a variable’s value while applying an arithmetic operation. The compound assignment operators include:

: Addition and assignment**+=**

: Subtraction and assignment**-=**

: Multiplication and assignment***=**

: Division and assignment**/=**

: Remainder (modulus) and assignment**%=**

Here’s an example using compound assignment operators:

```
fn main() {
let mut a: i32 = 10;
let b: i32 = 3;
a += b; // Equivalent to a = a + b
println!("a += b; a = {}", a);
a -= b; // Equivalent to a = a - b
println!("a -= b; a = {}", a);
a *= b; // Equivalent to a = a * b
println!("a *= b; a = {}", a);
a /= b; // Equivalent to a = a / b
println!("a /= b; a = {}", a);
a %= b; // Equivalent to a = a % b
println!("a %= b; a = {}", a);
}
```

### Unary Negation Operator:

Rust includes the unary negation operator (`-`

), which negates the value of a number. This operator can be used with both integers and floating-point numbers. Here’s an example:

```
fn main() {
let a: i32 = 10;
let negation = -a;
println!("-a = {}", negation);
}
```

### Numeric Type Casting:

While Rust’s arithmetic operators work seamlessly within the same numeric type, you may need to perform operations on values of different types. In such cases, Rust requires explicit type casting. You can use the `as`

keyword to cast a value from one numeric type to another:

```
fn main() {
let a: i32 = 10;
let b: f64 = 3.5;
let multiplication = a as f64 * b;
println!("a * b = {}", multiplication);
}
```

In this example, we cast the integer `a`

to a `f64`

floating-point number before performing the multiplication.

## Comparison Operators

Comparison operators are essential in programming languages as they allow developers to compare values and make decisions based on the outcome of the comparison. Rust offers a variety of comparison operators for working with numeric, boolean, and other comparable types.

### Basic Comparison Operators:

Rust provides the following basic comparison operators:

- Equal to (

)**==** - Not equal to (

)**!=** - Less than (

)**<** - Greater than (

)**>** - Less than or equal to (

)**<=** - Greater than or equal to (

)**>=**

These operators can be used with integer and floating-point number types, characters, and other types implementing the

or **PartialOrd**

traits. Here’s an example of using comparison operators with numbers:**Ord**

```
fn main() {
let a: i32 = 10;
let b: i32 = 5;
println!("a == b: {}", a == b);
println!("a != b: {}", a != b);
println!("a < b: {}", a < b);
println!("a > b: {}", a > b);
println!("a <= b: {}", a <= b);
println!("a >= b: {}", a >= b);
}
```

### Comparing Floating-Point Numbers:

When comparing floating-point numbers, keep in mind that due to the nature of their representation, some values may not be exactly equal. Therefore, it’s better to compare them within a certain range, known as an epsilon, to avoid unexpected results. Here’s an example:

```
fn main() {
let a: f64 = 0.1 + 0.2;
let b: f64 = 0.3;
let epsilon: f64 = 1e-9;
println!("a == b: {}", (a - b).abs() < epsilon);
}
```

### Comparing Custom Types:

To use comparison operators with custom types, you need to implement the

or **PartialOrd**

traits. The **Ord**

trait provides support for partial ordering, where some values might not have a defined order (e.g., floating-point numbers with NaN values). The **PartialOrd**

trait requires a total ordering, meaning that any two values of the type can be compared.**Ord**

Here’s an example of implementing the

and **PartialOrd**

traits for a custom type:**Ord**

**Example 1:**

```
#[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
struct Point {
x: i32,
y: i32,
}
fn main() {
let p1 = Point { x: 1, y: 2 };
let p2 = Point { x: 2, y: 1 };
println!("p1 == p2: {}", p1 == p2);
println!("p1 != p2: {}", p1 != p2);
println!("p1 < p2: {}", p1 < p2);
println!("p1 > p2: {}", p1 > p2);
println!("p1 <= p2: {}", p1 <= p2);
println!("p1 >= p2: {}", p1 >= p2);
}
```

In this example, we define a `Point`

struct with `x`

and `y`

fields, and we use the `derive`

attribute to automatically implement the `PartialEq`

, `Eq`

, `PartialOrd`

, and `Ord`

traits.

**Example 2:**

```
use std::cmp::Ordering;
#[derive(Debug, PartialEq, Eq)]
struct MyType {
value: i32,
}
impl PartialOrd for MyType {
fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
Some(self.cmp(other))
}
}
impl Ord for MyType {
fn cmp(&self, other: &Self) -> Ordering {
self.value.cmp(&other.value)
}
}
fn main() {
let a = MyType { value: 10 };
let b = MyType { value: 5 };
println!("a > b: {}", a > b);
}
```

## Logical Operators

Logical operators are crucial in programming languages as they enable developers to perform operations on boolean values and create more complex conditions. Rust provides several logical operators for working with boolean values, which are helpful in control flow statements like

, **if**

, and **else if**

. In this article, we will examine Rust’s logical operators in detail and provide examples to demonstrate their usage.**while**

### Basic Logical Operators:

Rust provides the following basic logical operators:

- Logical AND (

)**&&** - Logical OR (

)**||** - Logical NOT (

)**!**

These operators work with boolean values (

or **true**

) and return a boolean result. Here’s an example of how to use them:**false**

```
fn main() {
let a: bool = true;
let b: bool = false;
println!("a && b: {}", a && b);
println!("a || b: {}", a || b);
println!("!a: {}", !a);
}
```

### Short-circuit Evaluation:

Rust’s logical AND and logical OR operators use short-circuit evaluation, meaning that they only evaluate the second operand if necessary. This can be particularly useful in scenarios where evaluating the second operand might cause an error or be computationally expensive. Here’s an example:

```
fn main() {
let a = true;
let b = false;
let expensive_operation = || {
println!("Expensive operation called");
true
};
println!("Using AND operator");
if a && expensive_operation() {
println!("Both conditions are true");
}
println!("Using OR operator");
if a || expensive_operation() {
println!("At least one condition is true");
}
}
```

In this example, the

function is only called when necessary.**expensive_operation**

### Combining Logical Operators:

You can combine logical operators to create more complex conditions. Here’s an example:

```
fn main() {
let a: i32 = 10;
let b: i32 = 5;
let c: i32 = 7;
if a > b && a > c {
println!("a is the largest number");
} else if b > a && b > c {
println!("b is the largest number");
} else {
println!("c is the largest number");
}
}
```

### Using Logical Operators with Non-Boolean Types:

Although Rust’s logical operators are primarily designed for boolean values, you can also use them with non-boolean types by leveraging the

method from the **bool**

trait. However, this requires an explicit conversion to a boolean value. Here’s an example:**From**

```
fn main() {
let a: i32 = 10;
let b: i32 = 0;
if bool::from(a != 0) && bool::from(b != 0) {
println!("Both a and b are non-zero");
} else {
println!("At least one of a and b is zero");
}
}
```

Note that using logical operators with non-boolean types directly is not idiomatic Rust, and it’s better to use boolean expressions in most cases.

## Bitwise Operators

Bitwise operators allow developers to perform operations at the bit level, which can be helpful for low-level programming, optimization, and working with binary data. Rust provides several bitwise operators for working with integers.

Rust provides the following basic bitwise operators:

- Bitwise AND (

)**&** - Bitwise OR (

)**|** - Bitwise XOR (

)**^** - Bitwise NOT (

)**!** - Left shift (

)**<<** - Right shift (

)**>>**

**Bitwise AND (&):**

The bitwise AND operator (&) compares each bit of the first integer with the corresponding bit of the second integer. If both bits are 1, the corresponding result bit is set to 1; otherwise, the result bit is set to 0.

**Example:**

```
fn main() {
let a: u8 = 0b10110011;
let b: u8 = 0b11001010;
let result = a & b;
println!("a: {:08b}, b: {:08b}, a & b: {:08b}", a, b, result);
}
```

**Output:**

a: 10110011, b: 11001010, a & b: 10000010

**Bitwise OR (|):**

The bitwise OR operator (|) compares each bit of the first integer with the corresponding bit of the second integer. If either bit is 1, the corresponding result bit is set to 1; otherwise, the result bit is set to 0.

**Example:**

```
fn main() {
let a: u8 = 0b10110011;
let b: u8 = 0b11001010;
let result = a | b;
println!("a: {:08b}, b: {:08b}, a | b: {:08b}", a, b, result);
}
```

**Output:**

a: 10110011, b: 11001010, a | b: 11111011

**Bitwise XOR (^):**

The bitwise XOR operator (^) compares each bit of the first integer with the corresponding bit of the second integer. If the bits are different, the corresponding result bit is set to 1; otherwise, the result bit is set to 0.

```
fn main() {
let a: u8 = 0b10110011;
let b: u8 = 0b11001010;
let result = a ^ b;
println!("a: {:08b}, b: {:08b}, a ^ b: {:08b}", a, b, result);
}
```

**Output:**

a: 10110011, b: 11001010, a ^ b: 01111001

**Bitwise NOT (!):**

The bitwise NOT operator (!) inverts each bit of an integer. If a bit is 1, it becomes 0; if a bit is 0, it becomes 1.

**Example:**

```
fn main() {
let a: u8 = 0b10110011;
let result = !a;
println!("a: {:08b}, !a: {:08b}", a, result);
}
```

**Output:**

a: 10110011, !a: 01001100

**Left Shift Operator (<<):**

The left shift operator (<<) shifts the bits of an integer to the left by a specified number of positions. Any bits that are shifted beyond the leftmost position are discarded, while new bits are filled with zeros on the right.

**Example:**

```
fn main() {
let a: u8 = 0b10110011;
let shift_amount = 2;
let result = a << shift_amount;
println!("a: {:08b}, a << {}: {:08b}", a, shift_amount, result);
}
```

**Output:**

a: 10110011, a << 2: 11001100

**Right Shift Operator (>>):**

The right shift operator (>>) shifts the bits of an integer to the right by a specified number of positions. Any bits that are shifted beyond the rightmost position are discarded, while new bits are filled with zeros on the left side for unsigned integers or with the sign bit (0 for positive and 1 for negative) for signed integers.

**Example (unsigned integer):**

```
fn main() {
let a: u8 = 0b10110011;
let shift_amount = 2;
let result = a >> shift_amount;
println!("a: {:08b}, a >> {}: {:08b}", a, shift_amount, result);
}
```

**Output:**

a: 10110011, a >> 2: 00101100

In the example above, the bits of the unsigned integer ‘a’ are shifted two positions to the right. The two rightmost bits (11) are discarded, and two zeros are added on the left side.

**Example (signed integer):**

```
fn main() {
let a: i8 = -0b10110011;
let shift_amount = 2;
let result = a >> shift_amount;
println!("a: {:08b}, a >> {}: {:08b}", a, shift_amount, result);
}
```

**Output:**

a: 10110011, a >> 2: 11101100

In this example, the bits of the signed integer ‘a’ are shifted two positions to the right. The two rightmost bits (11) are discarded, and the sign bit (1) is used to fill the new bits on the left side.

Keep in mind that the shift amount must be less than the number of bits in the integer type. If the shift amount is equal to or greater than the number of bits, the behavior is undefined. To avoid this, you can use the wrapping_shr method provided by Rust integer types:

**Example:**

```
fn main() {
let a: u8 = 0b10110011;
let shift_amount = 10; // This value is greater than 8, the number of bits in u8.
let result = a.wrapping_shr(shift_amount);
println!("a: {:08b}, a.wrapping_shr({}): {:08b}", a, shift_amount, result);
}
```

**Output:**

a: 10110011, a.wrapping_shr(10): 00101100

In this example, the wrapping_shr method is used, which wraps the shift amount to fit the number of bits in the integer type. It calculates the shift amount as shift_amount % number_of_bits (10 % 8 = 2), and the result is the same as in the first example.

### Compound Bitwise Assignment Operators:

Rust also supports compound bitwise assignment operators that combine bitwise operations with assignment. These operators are useful for updating a variable’s value while applying a bitwise operation. The compound bitwise assignment operators include:

: Bitwise AND and assignment**&=**

: Bitwise OR and assignment**|=**

: Bitwise XOR and assignment**^=**

: Left shift and assignment**<<=**

: Right shift and assignment**>>=**

Here’s an example using compound bitwise assignment operators:

```
fn main() {
let mut a: u8 = 0b1010_1010;
let b: u8 = 0b0101_0101;
a &= b; // Equivalent to a = a & b
println!("a &= b; a = {:08b}", a);
a |= b; // Equivalent to a = a | b
println!("a |= b; a = {:08b}", a);
a ^= b; // Equivalent to a = a ^ b
println!("a ^= b; a = {:08b}", a);
a <<= 2; // Equivalent to a = a << 2
println!("a <<= 2; a = {:08b}", a);
a >>= 2; // Equivalent to a = a >> 2
println!("a >>= 2; a = {:08b}", a);
}
```

**To check more Go related articles. Pls click given below link:**

https://en.wikipedia.org/wiki/Rust_(programming_language)

https://www.techieindoor.com/rust-constant-in-rust/