> ## Documentation Index > Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt > Use this file to discover all available pages before exploring further. # Rust Inequality The `!=` (not equal to) operator is a binary comparison operator that evaluates to `true` if its two operands are not equivalent, and `false` otherwise. It serves as syntactic sugar for the `ne` method defined in the `std::cmp::PartialEq` trait. ```rust theme={"dark"} fn main() { let a = 5; let b = 10; let is_not_equal = a != b; // Evaluates to true } ``` ## Trait Resolution and Desugaring In Rust, operators are backed by the trait system. The `!=` operator requires the left-hand operand's type to implement `PartialEq`, where `Rhs` is the type of the right-hand operand. When the compiler encounters the `!=` operator, it implicitly borrows both operands and desugars the expression into a method call: ```rust theme={"dark"} fn main() { let a = 5; let b = 10; // Standard syntax let result_standard = a != b; // Desugared compiler equivalent let result_desugared = std::cmp::PartialEq::ne(&a, &b); } ``` ## The `PartialEq` Trait Mechanics The behavior of `!=` is dictated by the `PartialEq` trait definition in the standard library: ```rust theme={"dark"} pub trait PartialEq where Rhs: ?Sized, { fn eq(&self, other: &Rhs) -> bool; // Default implementation for != fn ne(&self, other: &Rhs) -> bool { !self.eq(other) } } ``` Because `ne` provides a default implementation that strictly returns the logical negation of `eq`, custom types typically only need to implement the `eq` method. The `!=` operator will then automatically utilize this default `ne` method implementation without requiring any procedural macro derivation or manual implementation of the inequality logic. ## Technical Characteristics * **Ownership and Borrowing:** The `!=` operator evaluates operands by reference (`&self` and `&other`). It does not consume, move, or mutate the underlying values. * **Type Coercion:** Rust does not perform implicit type coercion during comparison. Attempting to use `!=` on variables of different types will result in a compile-time type error, unless a specific `PartialEq` implementation exists for `TypeA`. * **Floating-Point Behavior:** Because floating-point numbers (`f32`, `f64`) implement `PartialEq` rather than `Eq` (due to IEEE 754 standards), comparing `f32::NAN != f32::NAN` evaluates to `true`. This occurs because `NaN` lacks the reflexive property (`f32::NAN == f32::NAN` is `false`), and the `ne` method strictly negates the result of `eq`.

Tired of Poor Rust Skills? Fix That With Deep Grasping! Learn More