Less Than Or Equal To

The <= (less than or equal to) operator is a binary comparison operator that evaluates whether the value of its left-hand operand is strictly less than or equivalent to the value of its right-hand operand. It returns a Bool indicating the result of the evaluation.

lhs <= rhs

Protocol Requirements

For the <= operator to be available, both the left-hand side (lhs) and right-hand side (rhs) operands must be of the exact same type, and that type must conform to the Comparable protocol.

Evaluation Mechanics

The expression yields true if lhs precedes rhs in the type’s defined sorting order, or if lhs and rhs are identical in value. Otherwise, it yields false.

let a: Int = 5
let b: Int = 10
let c: Int = 5

let result1: Bool = (a <= b) // true
let result2: Bool = (b <= a) // false
let result3: Bool = (a <= c) // true

Standard Library Implementation

In Swift, developers do not typically implement the <= operator directly when creating custom types. The Comparable protocol inherits from Equatable and only strictly requires the implementation of the < (less than) and == (equal to) operators.

The Swift standard library provides a default implementation for <= as an extension on Comparable. Under the hood, Swift evaluates lhs <= rhs by negating the greater-than logic, effectively computing !(rhs < lhs). This minimizes boilerplate code while ensuring mathematical consistency across all comparison operators (<, <=, >, >=).

struct Metric: Comparable {
    let magnitude: Double
    
    // Only < and == are required.
    // <= is automatically synthesized by the standard library.
    static func < (lhs: Metric, rhs: Metric) -> Bool {
        return lhs.magnitude < rhs.magnitude
    }
    
    static func == (lhs: Metric, rhs: Metric) -> Bool {
        return lhs.magnitude == rhs.magnitude
    }
}

let m1 = Metric(magnitude: 1.0)
let m2 = Metric(magnitude: 2.0)
let evaluation = m1 <= m2 // true, resolved via default Comparable extension

Operator Precedence

The <= operator belongs to the ComparisonPrecedence group. It has a lower precedence than addition/subtraction operators (AdditionPrecedence) but a higher precedence than logical conjunction operators (LogicalConjunctionPrecedence). It is non-associative, meaning multiple <= operators cannot be chained together in a single expression without explicit parentheses.

Master Swift with Deep Grasping Methodology!

Learn More