Compukters Core/kotlin.ranges/IntProgression

IntProgression

open class IntProgression(val first: Int, endInclusive: Int, val step: Int) : Iterable<Int> (source)

An ordered progression of Int values with a nonzero, signed step.

Positive steps move upwards; negative steps move downwards. The inclusive last is adjusted to align with first and step, so it may differ from endInclusive. A progression is empty when its bounds run against the step direction.

Parameters

first

the starting value.

endInclusive

the requested inclusive bound in the direction of traversal.

step

the signed difference between successive elements.

Throws

IllegalArgumentException

if step is zero or Int.MIN_VALUE.

Inheritors

IntRange

Constructors

IntProgression

constructor(first: Int, endInclusive: Int, step: Int)

creates a progression with an aligned final element.

Properties

first

val first: Int

The starting value; an empty progression does not yield it.

last

val last: Int

The inclusive final element of a nonempty progression, aligned with first and step.

step

val step: Int

The signed difference between successive elements; positive for ascending traversal.

Functions

all

inline fun <T> Iterable<T>.all(predicate: (T) -> Boolean): Boolean

Returns true when every element matches predicate.

any

inline fun <T> Iterable<T>.any(predicate: (T) -> Boolean): Boolean

Returns true when at least one element matches predicate.

asSequence

fun <T> Iterable<T>.asSequence(): Sequence<T>

Borrows this iterable as a lazy sequence without traversing or copying it. Each traversal requests a new source iterator; later mutations and invalidation follow the iterable's own contract. Wrappers and iterators use ordinary managed heap quotas.

contains

operator fun <T> Iterable<T>.contains(element: T): Boolean

Checks whether this iterable has an element equal to element.

filter

inline fun <T> Iterable<T>.filter(predicate: (T) -> Boolean): List<T>

Returns a list containing elements matching predicate, in their original iteration order.

filterNotNull

fun <T : Any> Iterable<T?>.filterNotNull(): List<T>

Returns a list of non-null elements in their original iteration order.

filterTo

inline fun <T, C : MutableCollection<in T>> Iterable<T>.filterTo(destination: C, predicate: (T) -> Boolean): C

Appends matching elements to destination in iteration order.

find

inline fun <T> Iterable<T>.find(predicate: (T) -> Boolean): T?

Returns the first matching element, or null when no element matches predicate.

first

fun <T> Iterable<T>.first(): T

Returns the first element, throwing NoSuchElementException when empty.

inline fun <T> Iterable<T>.first(predicate: (T) -> Boolean): T

Returns the first matching element, throwing NoSuchElementException when no element matches.

firstOrNull

fun <T> Iterable<T>.firstOrNull(): T?

Returns the first element, or null when this iterable is empty.

inline fun <T> Iterable<T>.firstOrNull(predicate: (T) -> Boolean): T?

Returns the first matching element, or null when no element matches predicate.

fold

inline fun <T, R> Iterable<T>.fold(initial: R, operation: (R, T) -> R): R

Accumulates elements in iteration order.

forEach

inline fun <T> Iterable<T>.forEach(action: (T) -> Unit)

Calls action for each element in iteration order.

forEachIndexed

inline fun <T> Iterable<T>.forEachIndexed(action: (Int, T) -> Unit)

Calls action for each element and its zero-based index in iteration order.

indexOf

fun <T> Iterable<T>.indexOf(element: T): Int

Returns the index of the first equal element, or -1 when no element matches.

isEmpty

open fun isEmpty(): Boolean

Returns whether this progression contains no elements.

iterator

open operator override fun iterator(): Iterator<Int>

Creates an independent iterator over this progression in step order.

lastIndexOf

fun <T> Iterable<T>.lastIndexOf(element: T): Int

Returns the index of the last equal element, or -1 when no element matches.

lastOrNull

fun <T> Iterable<T>.lastOrNull(): T?

Returns the last element, or null when this iterable is empty.

inline fun <T> Iterable<T>.lastOrNull(predicate: (T) -> Boolean): T?

Returns the last matching element after traversing this iterable in iteration order.

map

inline fun <T, R> Iterable<T>.map(transform: (T) -> R): List<R>

Returns a list containing transform applied once to each element in iteration order.

mapNotNull

inline fun <T, R : Any> Iterable<T>.mapNotNull(transform: (T) -> R?): List<R>

Applies transform once per element in iteration order and retains only non-null results.

mapNotNullTo

inline fun <T, R : Any, C : MutableCollection<in R>> Iterable<T>.mapNotNullTo(destination: C, transform: (T) -> R?): C

Appends non-null transformed elements to destination in iteration order.

mapTo

inline fun <T, R, C : MutableCollection<in R>> Iterable<T>.mapTo(destination: C, transform: (T) -> R): C

Appends transformed elements to destination in iteration order.

none

inline fun <T> Iterable<T>.none(predicate: (T) -> Boolean): Boolean

Returns true when no element matches predicate.

step

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

Creates a progression with the same direction and a new positive step magnitude.

sum

fun Iterable<Byte>.sum(): Int

Numeric accumulation traverses once in iteration order without an intermediate collection. Empty iterables return positive numeric zero. Integer arithmetic wraps at the result width; Float/Double addition retains ordinary rounding, infinities and NaN. Byte/Short widen to Int; UByte/UShort widen to UInt. Iterator failures propagate unchanged.

fun Iterable<Double>.sum(): Double

fun Iterable<Float>.sum(): Float

fun Iterable<Int>.sum(): Int

fun Iterable<Long>.sum(): Long

fun Iterable<Short>.sum(): Int

fun Iterable<UByte>.sum(): UInt

fun Iterable<UInt>.sum(): UInt

fun Iterable<ULong>.sum(): ULong

fun Iterable<UShort>.sum(): UInt

sumOf

inline fun <T> Iterable<T>.sumOf(selector: (T) -> Double): Double

Sums selector once per element in iteration order, returning Double zero when empty. No collection is allocated; selector/iterator exceptions and inline non-local returns propagate. Addition retains ordinary Double rounding, infinities and NaN.

inline fun <T> Iterable<T>.sumOf(selector: (T) -> Int): Int

Sums selector once per element in iteration order, returning Int zero when empty. No collection is allocated; selector/iterator exceptions and inline non-local returns propagate. Addition uses ordinary wrapping Int arithmetic.

inline fun <T> Iterable<T>.sumOf(selector: (T) -> Long): Long

Sums selector once per element in iteration order, returning Long zero when empty. No collection is allocated; selector/iterator exceptions and inline non-local returns propagate. Addition uses ordinary wrapping Long arithmetic.

inline fun <T> Iterable<T>.sumOf(selector: (T) -> UInt): UInt

Sums selector once per element in iteration order, returning UInt zero when empty. No collection is allocated; selector/iterator exceptions and inline non-local returns propagate. Addition uses ordinary wrapping UInt arithmetic.

inline fun <T> Iterable<T>.sumOf(selector: (T) -> ULong): ULong

Sums selector once per element in iteration order, returning ULong zero when empty. No collection is allocated; selector/iterator exceptions and inline non-local returns propagate. Addition uses ordinary wrapping ULong arithmetic.