> ## 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 Greater Than Or Equal To The `>=` (greater-than-or-equal-to) operator is a relational operator used to evaluate the structural or numerical order of two operands. In Kotlin, relational operators are not strictly primitive operations; rather, `>=` acts as syntactic sugar that delegates to the `compareTo` method, which is typically provided by implementing the `Comparable` interface. When the Kotlin compiler encounters the `>=` operator, it translates the expression into a method call that evaluates the integer result of `compareTo` against zero. ```kotlin theme={"dark"} // Operator syntax val result = a >= b // Desugared equivalent val result = a.compareTo(b) >= 0 ``` ## The `compareTo` Contract For the `>=` operator to function on a given type, the left-hand operand (the receiver) must possess a `compareTo` function that accepts the right-hand operand's type and returns an `Int`. The returned integer dictates the relational outcome: * **Positive (`> 0`):** The left operand is greater than the right. * **Zero (`== 0`):** Both operands are equal in order. * **Negative (`< 0`):** The left operand is less than the right. The `>=` operator evaluates to `true` if the underlying `compareTo` call yields a positive integer or zero. ## Operator Overloading To enable the `>=` operator for custom classes, the class must either implement the `Comparable` interface or define a custom `compareTo` function explicitly marked with the `operator` keyword. ```kotlin theme={"dark"} class CustomValue(val magnitude: Int) : Comparable { // The 'operator' modifier is implicitly applied via the Comparable interface override fun compareTo(other: CustomValue): Int { return this.magnitude.compareTo(other.magnitude) } } // Alternatively, as a standalone operator function without the interface: class AnotherValue(val magnitude: Int) { operator fun compareTo(other: AnotherValue): Int { return this.magnitude.compareTo(other.magnitude) } } ``` ## Type Resolution and Nullability * **Type Safety:** The Kotlin compiler enforces type safety during the desugaring process. The type of the right-hand operand must be compatible with the parameter type expected by the left-hand operand's `compareTo` function. * **Nullability:** The `>=` operator cannot be used directly on nullable types (`T?`) because the standard library `Comparable` interface requires non-null receivers and parameters. Attempting to use `>=` on a nullable type results in a compilation error unless a custom extension function (e.g., `operator fun T?.compareTo(other: T?): Int`) is explicitly defined in the scope. * **Floating-Point Behavior:** When used with statically typed `Float` or `Double` primitives, the `>=` operator adheres strictly to IEEE 754 standards (e.g., `NaN >= NaN` evaluates to `false`). However, if the operands are boxed and compared generically via `Comparable` or `Comparable`, the comparison falls back to total order behavior, where `NaN` is considered equal to itself and greater than `POSITIVE_INFINITY`.

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