rust_partialeq_vs_eq.md

Eq vs. PartialEq in Rust

In Rust, PartialEq and Eq are traits that define how types compare for equality, but they differ in strictness:

1. PartialEq:

   • Provides the == and != operators.
   • Must define a partial equivalence relation, but it does not require every value to be equal to itself in all cases.
   • For example, floating-point numbers (f64) implement PartialEq but not Eq, because NaN is considered not equal to itself.

2. Eq:

   • A marker trait that extends PartialEq.
   • Implies a total reflexive relation: for any value x, x == x must always be true.
   • If your type can guarantee that every instance is equal to itself (no exceptions like NaN), then you implement Eq.
   • Most simple data types (integers, fixed-size arrays, enums without special behavior) implement Eq.

When to Use Them

• Use PartialEq:
  • For custom types that need equality comparison but might have special rules (e.g., ignoring certain fields), or for types that can’t always be equal to themselves (like floats).
  • Almost any comparison in Rust requires at least PartialEq.
• Add Eq if:
  • Your type’s equality is always reflexive.
  • You want to use your type in places requiring a total equality relationship (e.g., some data structures or derived traits might depend on that guarantee).

In practice, you often derive both:

#[derive(PartialEq, Eq)]
struct Point {
    x: i32,
    y: i32,
}

But if your type has non-reflexive behavior or can’t fulfill Eq’s stricter requirements (like floating-point fields), you might omit Eq.