Kotlin Less Than

val a = 5
val b = 10

// Standard operator syntax
val isLessStandard = a < b

// Compile-time desugared equivalent
val isLessDesugared = a.compareTo(b) < 0

​

The compareTo Contract

• A negative integer (< 0) indicates the left operand is less than the right operand.
• Zero (0) indicates equality in terms of ordering.
• A positive integer (> 0) indicates the left operand is greater than the right operand.

​

Custom Implementation Syntax

class Magnitude(val scalar: Int) : Comparable<Magnitude> {
    // The 'operator' modifier is inherited from Comparable<Magnitude>,
    // which implicitly binds the < operator to this function.
    override fun compareTo(other: Magnitude): Int {
        return this.scalar.compareTo(other.scalar)
    }
}

class CustomValue(val value: Int) {
    // When not implementing Comparable, the 'operator' keyword 
    // is strictly required to bind the < operator.
    operator fun compareTo(other: CustomValue): Int {
        return this.value.compareTo(other.value)
    }
}

​

Type Constraints and Nullability

• Type Safety: The < operator is statically typed. The compiler enforces that the right-hand operand matches the parameter type defined in the left-hand operand’s compareTo signature.
• Nullability: The standard < operator cannot be invoked directly on nullable types (T?). Operands must be non-null, or explicitly unwrapped, because the desugared compareTo call requires a non-null receiver.
• Primitive Optimization: For primitive types like Int, Float, and Double, the < operator does not incur the overhead of a method call. The compiler optimizes the expression directly into the corresponding JVM bytecode comparison instructions (e.g., if_icmplt, fcmpg), adhering to IEEE 754 standards for floating-point numbers.