> ## 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 The `>` (greater than) operator is a relational operator used to evaluate strict upper-bound inequality between two operands. In Kotlin, it functions as syntactic sugar that the compiler translates into a method call to the `compareTo` function. When the compiler encounters `a > b`, it desugars the expression to evaluate whether the integer returned by `compareTo` is strictly greater than zero. ```kotlin theme={"dark"} val a = 10 val b = 5 // Standard operator syntax val isGreater = a > b // Compiler-translated equivalent val isGreaterTranslated = a.compareTo(b) > 0 ``` ## Type Requirements For the `>` operator to be valid on a given type, the left-hand operand must provide an `operator fun compareTo` that accepts the right-hand operand's type and returns an `Int`. This is structurally achieved in two ways: 1. Implementing the `Comparable` interface (which inherently provides the `operator` modifier). 2. Defining a standalone `operator fun compareTo` as a member or extension function. ```kotlin theme={"dark"} // Method 1: Implementing Comparable class Measure(val magnitude: Int) : Comparable { override fun compareTo(other: Measure): Int { return this.magnitude.compareTo(other.magnitude) } } // Method 2: Standalone operator function class Weight(val kg: Double) { operator fun compareTo(other: Weight): Int { return this.kg.compareTo(other.kg) } } ``` ## Return Value Contract The underlying `compareTo` function must adhere to a strict mathematical contract, returning: * A positive integer (`> 0`) if the receiver object is strictly greater than the argument. * Zero (`0`) if the objects are equal. * A negative integer (`< 0`) if the receiver object is less than the argument. ## Floating-Point Behavior When the `>` operator is used with statically typed `Float` or `Double` primitives, the compiler generates JVM bytecodes (`fcmpg`, `dcmpg`) that strictly adhere to IEEE 754 floating-point comparison rules. Under these rules, any comparison involving `NaN` evaluates to `false`, and `-0.0` is evaluated as exactly equal to `0.0`. However, if the operands are boxed or evaluated generically via the `Comparable` interface, Kotlin delegates to the `Float.compareTo` and `Double.compareTo` methods. These methods deviate from IEEE 754 to establish a total order: * `NaN` is considered equal to itself and strictly greater than `POSITIVE_INFINITY`. * `0.0` is considered strictly greater than `-0.0`. ```kotlin theme={"dark"} // IEEE 754 primitive comparison val primitiveNanGreater = Float.NaN > Float.POSITIVE_INFINITY // Evaluates to false val primitiveZeroGreater = 0.0 > -0.0 // Evaluates to false // Generic Comparable comparison val genericNan: Comparable = Float.NaN val genericZero: Comparable = 0.0 val genericNanGreater = genericNan > Float.POSITIVE_INFINITY // Evaluates to true val genericZeroGreater = genericZero > -0.0 // Evaluates to true ```

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