Creates a comparator using the sequence of functions to calculate a result of comparison. The functions are called sequentially, receive the given values a and b and return Comparable objects. As soon as the Comparable instances returned by a function for a and b values do not compare as equal, the result of that comparison is returned from the Comparator.

fun <T> compareBy(
    vararg selectors: (T) -> Comparable<*>?
): Comparator<T>

Creates a comparator using the function to transform value to a Comparable instance for comparison.

fun <T> compareBy(
    selector: (T) -> Comparable<*>?
): Comparator<T>

Creates a comparator using the selector function to transform values being compared and then applying the specified comparator to compare transformed values.

fun <T, K> compareBy(
    comparator: Comparator<in K>, 
    selector: (T) -> K
): Comparator<T>

Creates a descending comparator using the function to transform value to a Comparable instance for comparison.

fun <T> compareByDescending(
    selector: (T) -> Comparable<*>?
): Comparator<T>

Creates a descending comparator using the selector function to transform values being compared and then applying the specified comparator to compare transformed values.

fun <T, K> compareByDescending(
    comparator: Comparator<in K>, 
    selector: (T) -> K
): Comparator<T>

Compares two nullable Comparable values. Null is considered less than any value.

fun <T : Comparable<*>> compareValues(a: T?, b: T?): Int

Compares two values using the specified functions selectors to calculate the result of the comparison. The functions are called sequentially, receive the given values a and b and return Comparable objects. As soon as the Comparable instances returned by a function for a and b values do not compare as equal, the result of that comparison is returned.

fun <T> compareValuesBy(
    a: T, 
    b: T, 
    vararg selectors: (T) -> Comparable<*>?
): Int

Compares two values using the specified selector function to calculate the result of the comparison. The function is applied to the given values a and b and return Comparable objects. The result of comparison of these Comparable instances is returned.

fun <T> compareValuesBy(
    a: T, 
    b: T, 
    selector: (T) -> Comparable<*>?
): Int

Compares two values using the specified selector function to calculate the result of the comparison. The function is applied to the given values a and b and return objects of type K which are then being compared with the given comparator.

fun <T, K> compareValuesBy(
    a: T, 
    b: T, 
    comparator: Comparator<in K>, 
    selector: (T) -> K
): Int

Returns the greater of three values according to the order specified by the given comparator.

fun <T> maxOf(
    a: T, 
    b: T, 
    c: T, 
    comparator: Comparator<in T>
): T

Returns the greater of two values according to the order specified by the given comparator. If values are equal, returns the first one.

fun <T> maxOf(a: T, b: T, comparator: Comparator<in T>): T

Returns the greater of two values.

fun maxOf(a: UInt, b: UInt): UInt

fun maxOf(a: ULong, b: ULong): ULong

fun maxOf(a: UByte, b: UByte): UByte

fun maxOf(a: UShort, b: UShort): UShort

fun maxOf(a: Byte, b: Byte): Byte

fun maxOf(a: Short, b: Short): Short

fun maxOf(a: Int, b: Int): Int

fun maxOf(a: Long, b: Long): Long

fun maxOf(a: Float, b: Float): Float

fun maxOf(a: Double, b: Double): Double

Returns the greater of three values.

fun maxOf(a: UInt, b: UInt, c: UInt): UInt

fun maxOf(a: ULong, b: ULong, c: ULong): ULong

fun maxOf(a: UByte, b: UByte, c: UByte): UByte

fun maxOf(a: UShort, b: UShort, c: UShort): UShort

fun <T : Comparable<T>> maxOf(a: T, b: T, c: T): T

fun maxOf(a: Byte, b: Byte, c: Byte): Byte

fun maxOf(a: Short, b: Short, c: Short): Short

fun maxOf(a: Int, b: Int, c: Int): Int

fun maxOf(a: Long, b: Long, c: Long): Long

fun maxOf(a: Float, b: Float, c: Float): Float

fun maxOf(a: Double, b: Double, c: Double): Double

Returns the greater of two values. If values are equal, returns the first one.

fun <T : Comparable<T>> maxOf(a: T, b: T): T

Returns the smaller of three values according to the order specified by the given comparator.

fun <T> minOf(
    a: T, 
    b: T, 
    c: T, 
    comparator: Comparator<in T>
): T

Returns the smaller of two values according to the order specified by the given comparator. If values are equal, returns the first one.

fun <T> minOf(a: T, b: T, comparator: Comparator<in T>): T

Returns the smaller of two values.

fun minOf(a: UInt, b: UInt): UInt

fun minOf(a: ULong, b: ULong): ULong

fun minOf(a: UByte, b: UByte): UByte

fun minOf(a: UShort, b: UShort): UShort

fun minOf(a: Byte, b: Byte): Byte

fun minOf(a: Short, b: Short): Short

fun minOf(a: Int, b: Int): Int

fun minOf(a: Long, b: Long): Long

fun minOf(a: Float, b: Float): Float

fun minOf(a: Double, b: Double): Double

Returns the smaller of three values.

fun minOf(a: UInt, b: UInt, c: UInt): UInt

fun minOf(a: ULong, b: ULong, c: ULong): ULong

fun minOf(a: UByte, b: UByte, c: UByte): UByte

fun minOf(a: UShort, b: UShort, c: UShort): UShort

fun <T : Comparable<T>> minOf(a: T, b: T, c: T): T

fun minOf(a: Byte, b: Byte, c: Byte): Byte

fun minOf(a: Short, b: Short, c: Short): Short

fun minOf(a: Int, b: Int, c: Int): Int

fun minOf(a: Long, b: Long, c: Long): Long

fun minOf(a: Float, b: Float, c: Float): Float

fun minOf(a: Double, b: Double, c: Double): Double

Returns the smaller of two values. If values are equal, returns the first one.

fun <T : Comparable<T>> minOf(a: T, b: T): T

Returns a comparator that compares Comparable objects in natural order.

fun <T : Comparable<T>> naturalOrder(): Comparator<T>

Extends the given comparator of non-nullable values to a comparator of nullable values considering null value less than any other value.

fun <T : Any> nullsFirst(
    comparator: Comparator<in T>
): Comparator<T?>

Provides a comparator of nullable Comparable values considering null value less than any other value.

fun <T : Comparable<T>> nullsFirst(): Comparator<T?>

Extends the given comparator of non-nullable values to a comparator of nullable values considering null value greater than any other value.

fun <T : Any> nullsLast(
    comparator: Comparator<in T>
): Comparator<T?>

Provides a comparator of nullable Comparable values considering null value greater than any other value.

fun <T : Comparable<T>> nullsLast(): Comparator<T?>

Returns a comparator that imposes the reverse ordering of this comparator.

fun <T> Comparator<T>.reversed(): Comparator<T>

Returns a comparator that compares Comparable objects in reversed natural order.

fun <T : Comparable<T>> reverseOrder(): Comparator<T>

Combines this comparator and the given comparator such that the latter is applied only when the former considered values equal.

infix fun <T> Comparator<T>.then(
    comparator: Comparator<in T>
): Comparator<T>

Creates a comparator comparing values after the primary comparator defined them equal. It uses the function to transform value to a Comparable instance for comparison.

fun <T> Comparator<T>.thenBy(
    selector: (T) -> Comparable<*>?
): Comparator<T>

Creates a comparator comparing values after the primary comparator defined them equal. It uses the selector function to transform values and then compares them with the given comparator.

fun <T, K> Comparator<T>.thenBy(
    comparator: Comparator<in K>, 
    selector: (T) -> K
): Comparator<T>

Creates a descending comparator using the primary comparator and the function to transform value to a Comparable instance for comparison.

fun <T> Comparator<T>.thenByDescending(
    selector: (T) -> Comparable<*>?
): Comparator<T>

Creates a descending comparator comparing values after the primary comparator defined them equal. It uses the selector function to transform values and then compares them with the given comparator.

fun <T, K> Comparator<T>.thenByDescending(
    comparator: Comparator<in K>, 
    selector: (T) -> K
): Comparator<T>

Creates a comparator using the primary comparator and function to calculate a result of comparison.

fun <T> Comparator<T>.thenComparator(
    comparison: (a: T, b: T) -> Int
): Comparator<T>

Combines this comparator and the given comparator such that the latter is applied only when the former considered values equal.

infix fun <T> Comparator<T>.thenDescending(
    comparator: Comparator<in T>
): Comparator<T>