CharProgression

open class CharProgression : Iterable<Char>

A progression of values of type Char.

CharRange

class CharRange : CharProgression, ClosedRange<Char>

A range of values of type Char.

ClosedFloatingPointRange

interface ClosedFloatingPointRange<T : Comparable<T>> : 
    ClosedRange<T>

Represents a range of floating point numbers. Extends ClosedRange interface providing custom operation lessThanOrEquals for comparing values of range domain type.

ClosedRange

interface ClosedRange<T : Comparable<T>>

Represents a range of values (for example, numbers or characters). See the Kotlin language documentation for more information.

IntProgression

open class IntProgression : Iterable<Int>

A progression of values of type Int.

IntRange

class IntRange : IntProgression, ClosedRange<Int>

A range of values of type Int.

LongProgression

open class LongProgression : Iterable<Long>

A progression of values of type Long.

LongRange

class LongRange : LongProgression, ClosedRange<Long>

A range of values of type Long.

coerceAtLeast

fun <T : Comparable<T>> T.coerceAtLeast(minimumValue: T): T

fun Byte.coerceAtLeast(minimumValue: Byte): Byte

fun Short.coerceAtLeast(minimumValue: Short): Short

fun Int.coerceAtLeast(minimumValue: Int): Int

fun Long.coerceAtLeast(minimumValue: Long): Long

fun Float.coerceAtLeast(minimumValue: Float): Float

fun Double.coerceAtLeast(minimumValue: Double): Double

Ensures that this value is not less than the specified minimumValue.

coerceAtMost

fun <T : Comparable<T>> T.coerceAtMost(maximumValue: T): T

fun Byte.coerceAtMost(maximumValue: Byte): Byte

fun Short.coerceAtMost(maximumValue: Short): Short

fun Int.coerceAtMost(maximumValue: Int): Int

fun Long.coerceAtMost(maximumValue: Long): Long

fun Float.coerceAtMost(maximumValue: Float): Float

fun Double.coerceAtMost(maximumValue: Double): Double

Ensures that this value is not greater than the specified maximumValue.

coerceIn

fun <T : Comparable<T>> T.coerceIn(
    minimumValue: T?, 
    maximumValue: T?
): T

fun Byte.coerceIn(
    minimumValue: Byte, 
    maximumValue: Byte
): Byte

fun Short.coerceIn(
    minimumValue: Short, 
    maximumValue: Short
): Short

fun Int.coerceIn(minimumValue: Int, maximumValue: Int): Int

fun Long.coerceIn(
    minimumValue: Long, 
    maximumValue: Long
): Long

fun Float.coerceIn(
    minimumValue: Float, 
    maximumValue: Float
): Float

fun Double.coerceIn(
    minimumValue: Double, 
    maximumValue: Double
): Double

Ensures that this value lies in the specified range minimumValue..maximumValue.

fun <T : Comparable<T>> T.coerceIn(
    range: ClosedFloatingPointRange<T>
): T

fun <T : Comparable<T>> T.coerceIn(range: ClosedRange<T>): T

fun Int.coerceIn(range: ClosedRange<Int>): Int

fun Long.coerceIn(range: ClosedRange<Long>): Long

Ensures that this value lies in the specified range.

contains

operator fun ClosedRange<Int>.contains(value: Byte): Boolean

operator fun ClosedRange<Long>.contains(value: Byte): Boolean

operator fun ClosedRange<Short>.contains(
    value: Byte
): Boolean

operator fun ClosedRange<Double>.contains(
    value: Byte
): Boolean

operator fun ClosedRange<Float>.contains(
    value: Byte
): Boolean

operator fun ClosedRange<Int>.contains(
    value: Double
): Boolean

operator fun ClosedRange<Long>.contains(
    value: Double
): Boolean

operator fun ClosedRange<Byte>.contains(
    value: Double
): Boolean

operator fun ClosedRange<Short>.contains(
    value: Double
): Boolean

operator fun ClosedRange<Float>.contains(
    value: Double
): Boolean

operator fun ClosedRange<Int>.contains(value: Float): Boolean

operator fun ClosedRange<Long>.contains(
    value: Float
): Boolean

operator fun ClosedRange<Byte>.contains(
    value: Float
): Boolean

operator fun ClosedRange<Short>.contains(
    value: Float
): Boolean

operator fun ClosedRange<Double>.contains(
    value: Float
): Boolean

operator fun ClosedRange<Long>.contains(value: Int): Boolean

operator fun ClosedRange<Byte>.contains(value: Int): Boolean

operator fun ClosedRange<Short>.contains(value: Int): Boolean

operator fun ClosedRange<Double>.contains(
    value: Int
): Boolean

operator fun ClosedRange<Float>.contains(value: Int): Boolean

operator fun ClosedRange<Int>.contains(value: Long): Boolean

operator fun ClosedRange<Byte>.contains(value: Long): Boolean

operator fun ClosedRange<Short>.contains(
    value: Long
): Boolean

operator fun ClosedRange<Double>.contains(
    value: Long
): Boolean

operator fun ClosedRange<Float>.contains(
    value: Long
): Boolean

operator fun ClosedRange<Int>.contains(value: Short): Boolean

operator fun ClosedRange<Long>.contains(
    value: Short
): Boolean

operator fun ClosedRange<Byte>.contains(
    value: Short
): Boolean

operator fun ClosedRange<Double>.contains(
    value: Short
): Boolean

operator fun ClosedRange<Float>.contains(
    value: Short
): Boolean

Checks if the specified value belongs to this range.

downTo

infix fun Int.downTo(to: Byte): IntProgression

infix fun Long.downTo(to: Byte): LongProgression

infix fun Byte.downTo(to: Byte): IntProgression

infix fun Short.downTo(to: Byte): IntProgression

infix fun Char.downTo(to: Char): CharProgression

infix fun Int.downTo(to: Int): IntProgression

infix fun Long.downTo(to: Int): LongProgression

infix fun Byte.downTo(to: Int): IntProgression

infix fun Short.downTo(to: Int): IntProgression

infix fun Int.downTo(to: Long): LongProgression

infix fun Long.downTo(to: Long): LongProgression

infix fun Byte.downTo(to: Long): LongProgression

infix fun Short.downTo(to: Long): LongProgression

infix fun Int.downTo(to: Short): IntProgression

infix fun Long.downTo(to: Short): LongProgression

infix fun Byte.downTo(to: Short): IntProgression

infix fun Short.downTo(to: Short): IntProgression

Returns a progression from this value down to the specified to value with the step -1.

rangeTo

operator fun <T : Comparable<T>> T.rangeTo(
    that: T
): ClosedRange<T>

Creates a range from this Comparable value to the specified that value.

operator fun Double.rangeTo(
    that: Double
): ClosedFloatingPointRange<Double>

Creates a range from this Double value to the specified other value.

operator fun Float.rangeTo(
    that: Float
): ClosedFloatingPointRange<Float>

Creates a range from this Float value to the specified other value.

reversed

fun IntProgression.reversed(): IntProgression

fun LongProgression.reversed(): LongProgression

fun CharProgression.reversed(): CharProgression

Returns a progression that goes over the same range in the opposite direction with the same step.

step

infix fun IntProgression.step(step: Int): IntProgression

infix fun LongProgression.step(step: Long): LongProgression

infix fun CharProgression.step(step: Int): CharProgression

Returns a progression that goes over the same range with the given step.

until

infix fun Int.until(to: Byte): IntRange

infix fun Long.until(to: Byte): LongRange

infix fun Byte.until(to: Byte): IntRange

infix fun Short.until(to: Byte): IntRange

infix fun Char.until(to: Char): CharRange

infix fun Int.until(to: Int): IntRange

infix fun Long.until(to: Int): LongRange

infix fun Byte.until(to: Int): IntRange

infix fun Short.until(to: Int): IntRange

infix fun Int.until(to: Long): LongRange

infix fun Long.until(to: Long): LongRange

infix fun Byte.until(to: Long): LongRange

infix fun Short.until(to: Long): LongRange

infix fun Int.until(to: Short): IntRange

infix fun Long.until(to: Short): LongRange

infix fun Byte.until(to: Short): IntRange

infix fun Short.until(to: Short): IntRange

Returns a range from this value up to but excluding the specified to value.