Skip to main content

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.

The < (less-than) operator is a binary comparison operator that evaluates whether the left-hand operand is strictly less than the right-hand operand, returning a bool. At the compiler level, the < operator is syntactic sugar for the lt method provided by the std::cmp::PartialOrd trait. 
let a = 1;
let b = 2;

// Standard syntax
let result = a < b;

// Desugared equivalent
let result = std::cmp::PartialOrd::lt(&a, &b);

​
Trait Implementation

To use the < operator with a specific type, that type must implement PartialOrd. Because PartialOrd has a supertrait bound on PartialEq, any type supporting < must also support the == operator. 
use std::cmp::Ordering;

pub trait PartialOrd<Rhs = Self>: PartialEq<Rhs>
where
    Rhs: ?Sized,
{
    fn partial_cmp(&self, other: &Rhs) -> Option<Ordering>;

    // The `<` operator directly invokes this provided method
    #[inline]
    fn lt(&self, other: &Rhs) -> bool {
        matches!(self.partial_cmp(other), Some(Ordering::Less))
    }
}

​
Evaluation Mechanics

  1. Delegation to partial_cmp: The default implementation of lt calls partial_cmp, which returns an Option<std::cmp::Ordering>.
  2. Strict Evaluation: The < operator evaluates to true only if partial_cmp returns Some(Ordering::Less).
  3. Incomparable Values: If partial_cmp returns None (which occurs with incomparable values, such as floating-point NaN), the < operator evaluates to false.
  4. Borrowing: The operator implicitly takes immutable references to both operands (&self and &Rhs). It does not consume or move the values being compared.

​
Type Constraints

Rust enforces strict type safety during comparison. The < operator does not perform implicit type coercion. Both operands must resolve to the same type, or the left-hand type must explicitly implement PartialOrd<Rhs> where Rhs is the type of the right-hand operand. 
// Valid: Same types
let valid = 5_i32 < 10_i32;

// Invalid: Compilation error due to mismatched types (i32 vs f64)
// let invalid = 5_i32 < 10.0_f64;

​
Derivation

For custom structs and enums, the compiler can automatically generate the < operator logic using #[derive(PartialOrd)]. Because of the supertrait bound, #[derive(PartialEq)] is also strictly required; attempting to derive PartialOrd without deriving PartialEq results in a compilation error. When derived:
  • Structs: Evaluates fields lexicographically, top-to-bottom.
  • Enums: Evaluates based on the discriminant (the declared order of variants), followed by lexicographical comparison of any data contained within the variants.
Master Rust with Deep Grasping Methodology!Learn More