Skip to main content
The <= (less than or equal to) operator is a binary relational operator that evaluates whether the left-hand operand is strictly less than or mathematically equivalent to the right-hand operand, returning a bool. In Rust, <= is syntactic sugar for the le method provided by the std::cmp::PartialOrd trait. To use this operator, both operands must implement PartialOrd. The operator directly invokes the le method. While le provides a default implementation that calls partial_cmp, types can (and frequently do) override le directly to optimize performance. 
let left_operand = 1;
let right_operand = 2;

// Standard operator syntax
let result = left_operand <= right_operand;

// Desugared trait method equivalent
let desugared_result = std::cmp::PartialOrd::le(&left_operand, &right_operand);

​
Trait Mechanics and Evaluation

When a type relies on the default implementation of le, the operator’s behavior is determined by the Option<std::cmp::Ordering> returned by the required partial_cmp method. The default le implementation evaluates these variants as follows:
  • Some(Ordering::Less) evaluates to true.
  • Some(Ordering::Equal) evaluates to true.
  • Some(Ordering::Greater) evaluates to false.
  • None evaluates to false.
The None variant is specifically designed to handle values that lack a total mathematical order, such as floating-point NaN (Not-a-Number) values. If either operand is NaN, <= strictly evaluates to false.

​
Type Constraints

Rust enforces strict type safety during comparison. The <= operator does not perform implicit type coercion. By default, both operands must be of the exact same type T. Cross-type comparisons using <= are only permitted if the left operand’s type implements PartialOrd<Rhs>, where Rhs is the type of the right operand. 
use std::cmp::Ordering;

// Signature of the underlying trait
trait PartialOrd<Rhs = Self>: PartialEq<Rhs> {
    fn partial_cmp(&self, other: &Rhs) -> Option<Ordering>;

    // The <= operator directly invokes this method.
    // Types may override this default implementation for performance.
    fn le(&self, other: &Rhs) -> bool {
        matches!(self.partial_cmp(other), Some(Ordering::Less | Ordering::Equal))
    }
}

​
Memory and Ownership Behavior

The <= operator evaluates its operands by reference. As seen in the PartialOrd signature, the le method takes &self and &Rhs. Consequently, evaluating a <= b borrows a and b immutably. The operator does not consume, move, or mutate the operands, allowing them to be safely accessed after the comparison is evaluated.
Tired of Poor Rust Skills? Fix That With Deep Grasping!Learn More