> ## 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. # Kotlin Less Than Or Equal To The `<=` (less than or equal to) operator is a relational operator that evaluates whether the left operand is less than or equal to the right operand, based on their natural or custom semantic ordering. For object types, this operator acts as syntactic sugar that delegates to the `compareTo` method. However, for built-in primitive types (such as `Int`, `Float`, and `Double`), the Kotlin compiler explicitly optimizes the operator down to native, hardcoded primitive bytecode instructions to avoid function call and boxing overhead. When the Kotlin compiler encounters the `<=` operator on object types, it translates the expression into a method call comparing the returned integer against zero. ```kotlin theme={"dark"} // Source expression a <= b // Compiler translation (for object types) a.compareTo(b) <= 0 ``` ## Type Constraints and `Comparable` For the `<=` operator to compile on non-primitive types, the left operand (`a`) must provide an `operator fun compareTo` that accepts the right operand (`b`) as its argument. This is typically achieved by implementing the `Comparable` interface. The `compareTo` function must return an `Int` adhering to the following contract: * **Negative integer (`< 0`):** The receiver object is less than the argument. * **Zero (`== 0`):** The receiver object is equal to the argument. * **Positive integer (`> 0`):** The receiver object is greater than the argument. Because `<=` checks if the result is `<= 0`, it evaluates to `true` for both the negative integer and zero conditions. ## Operator Overloading You can enable the `<=` operator for custom types by overriding the `compareTo` function and marking it with the `operator` modifier. If the class implements `Comparable`, the `operator` modifier is implicitly inherited from the interface's `compareTo` function and does not need to be explicitly declared. ```kotlin theme={"dark"} class Metric(val value: Int) : Comparable { // The 'operator' modifier is implicitly inherited from Comparable override fun compareTo(other: Metric): Int { return this.value.compareTo(other.value) } } ``` Alternatively, the operator can be provided via an extension function if modifying the original class is not possible: ```kotlin theme={"dark"} operator fun ExternalType.compareTo(other: ExternalType): Int { return this.internalValue.compareTo(other.internalValue) } ``` ## Null Safety Mechanics The `<=` operator does not inherently handle nullable types. If a nullable type (`T?`) is used, compilation fails for one of two distinct reasons depending on the operand's position: * **Left operand is nullable:** The compiler rejects the expression because the `compareTo` function cannot be safely invoked on a potentially null receiver. * **Right operand is nullable:** The compiler rejects the expression due to a parameter type mismatch, as the standard `compareTo` function expects a strictly non-null argument. To use `<=` with nullable types, you must explicitly unwrap the values or provide a custom `compareTo` extension function that accepts nullable receivers or arguments. ## Floating-Point Resolution When using `<=` with statically typed `Float` or `Double` operands, Kotlin uses the IEEE 754 standard for floating-point comparison. However, if the operands are boxed—such as when typed as `Comparable`, `Comparable`, `Number`, `Any`, or their nullable counterparts (e.g., `Double?`)—Kotlin falls back to the `compareTo` implementation of the wrapper classes. This creates a strict mechanical distinction: * **IEEE 754 (`Float` / `Double`):** `NaN <= NaN` evaluates to `false`. `0.0 <= -0.0` evaluates to `true` (because `0.0` and `-0.0` are considered equal). * **Boxed `Comparable`:** `NaN <= NaN` evaluates to `true` (`NaN` is considered equal to itself and greater than any other value). `0.0 <= -0.0` evaluates to `false` (because `0.0` is considered strictly greater than `-0.0`).

Tired of Poor Kotlin Skills? Fix That With Deep Grasping! Learn More