> ## 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.
# Swift 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.
```swift theme={"dark"}
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`.
```swift theme={"dark"}
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 (`<`, `<=`, `>`, `>=`).
```swift theme={"dark"}
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.
Tired of Poor Swift Skills? Fix That With Deep Grasping!
Learn More
