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.

component1

operator fun <K, V> Map.Entry<K, V>.component1(): K

Returns this entry's key for destructuring.

component2

operator fun <K, V> Map.Entry<K, V>.component2(): V

Returns this entry's current value for destructuring.

contains

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

Checks whether this iterable has an element equal to element.

operator fun <K, V> Map<K, V>.contains(key: K): Boolean

Checks key membership using key in map syntax.

copyInto

external fun <T> Array<out T>.copyInto(destination: Array<T>, destinationOffset: Int = 0, startIndex: Int = 0, endIndex: Int = size): Array<T>

external fun BooleanArray.copyInto(destination: BooleanArray, destinationOffset: Int = 0, startIndex: Int = 0, endIndex: Int = size): BooleanArray

external fun ByteArray.copyInto(destination: ByteArray, destinationOffset: Int = 0, startIndex: Int = 0, endIndex: Int = size): ByteArray

external fun CharArray.copyInto(destination: CharArray, destinationOffset: Int = 0, startIndex: Int = 0, endIndex: Int = size): CharArray

external fun DoubleArray.copyInto(destination: DoubleArray, destinationOffset: Int = 0, startIndex: Int = 0, endIndex: Int = size): DoubleArray

external fun FloatArray.copyInto(destination: FloatArray, destinationOffset: Int = 0, startIndex: Int = 0, endIndex: Int = size): FloatArray

external fun IntArray.copyInto(destination: IntArray, destinationOffset: Int = 0, startIndex: Int = 0, endIndex: Int = size): IntArray

external fun LongArray.copyInto(destination: LongArray, destinationOffset: Int = 0, startIndex: Int = 0, endIndex: Int = size): LongArray

external fun ShortArray.copyInto(destination: ShortArray, destinationOffset: Int = 0, startIndex: Int = 0, endIndex: Int = size): ShortArray

external fun UByteArray.copyInto(destination: UByteArray, destinationOffset: Int = 0, startIndex: Int = 0, endIndex: Int = size): UByteArray

external fun UIntArray.copyInto(destination: UIntArray, destinationOffset: Int = 0, startIndex: Int = 0, endIndex: Int = size): UIntArray

external fun ULongArray.copyInto(destination: ULongArray, destinationOffset: Int = 0, startIndex: Int = 0, endIndex: Int = size): ULongArray

external fun UShortArray.copyInto(destination: UShortArray, destinationOffset: Int = 0, startIndex: Int = 0, endIndex: Int = size): UShortArray

Copies this range into destination, supporting overlapping ranges, and returns it.

copyOf

external fun <T> Array<T>.copyOf(): Array<T>

external fun BooleanArray.copyOf(): BooleanArray

external fun ByteArray.copyOf(): ByteArray

external fun CharArray.copyOf(): CharArray

external fun DoubleArray.copyOf(): DoubleArray

external fun FloatArray.copyOf(): FloatArray

external fun IntArray.copyOf(): IntArray

external fun LongArray.copyOf(): LongArray

external fun ShortArray.copyOf(): ShortArray

external fun UByteArray.copyOf(): UByteArray

external fun UIntArray.copyOf(): UIntArray

external fun ULongArray.copyOf(): ULongArray

external fun UShortArray.copyOf(): UShortArray

Returns a new array containing the same elements.

external fun <T> Array<T>.copyOf(newSize: Int): Array<T?>

Returns a resized copy, padding extra elements with null.

external fun BooleanArray.copyOf(newSize: Int): BooleanArray

Returns a resized copy, padding extra elements with false.

external fun ByteArray.copyOf(newSize: Int): ByteArray

external fun DoubleArray.copyOf(newSize: Int): DoubleArray

external fun FloatArray.copyOf(newSize: Int): FloatArray

external fun IntArray.copyOf(newSize: Int): IntArray

external fun LongArray.copyOf(newSize: Int): LongArray

external fun ShortArray.copyOf(newSize: Int): ShortArray

external fun UByteArray.copyOf(newSize: Int): UByteArray

external fun UIntArray.copyOf(newSize: Int): UIntArray

external fun ULongArray.copyOf(newSize: Int): ULongArray

external fun UShortArray.copyOf(newSize: Int): UShortArray

Returns a resized copy, padding extra elements with zero.

external fun CharArray.copyOf(newSize: Int): CharArray

Returns a resized copy, padding extra elements with zero characters.

copyOfRange

external fun <T> Array<T>.copyOfRange(fromIndex: Int, toIndex: Int): Array<T>

Returns a new array containing elements from fromIndex up to, but excluding, toIndex.

emptyList

external fun <T> emptyList(): List<T>

Creates a fresh empty ArrayList exposed through the read-only List interface.

emptyMap

fun <K, V> emptyMap(): Map<K, V>

Creates a fresh empty HashMap exposed through the read-only Map interface.

emptySet

fun <T> emptySet(): Set<T>

Creates a fresh empty HashSet exposed through the read-only Set interface.

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.

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

Returns the first element, or null when this list 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.

getOrNull

fun <T> List<T>.getOrNull(index: Int): T?

Returns the element at index, or null when the index is outside this list.

getOrPut

inline fun <K, V> MutableMap<K, V>.getOrPut(key: K, defaultValue: () -> V): V

Returns a non-null value for key, or computes and stores a default value.

indexOf

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

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

isNotEmpty

fun <T> Collection<T>.isNotEmpty(): Boolean

Checks whether this collection contains at least one element.

fun <K, V> Map<K, V>.isNotEmpty(): Boolean

Checks whether this map contains at least one association.

iterator

operator fun <K, V> Map<K, V>.iterator(): Iterator<Map.Entry<K, V>>

Returns an iterator over this map's entries, enabling for ((key, value) in map).

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.

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

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

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

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

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

Returns the last element satisfying predicate, or null when no element matches.

listOf

external fun <T> listOf(vararg elements: T): List<T>

Creates a new list containing elements in argument order, including duplicates and nulls.

map

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

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.

mapOf

external fun <K, V> mapOf(vararg pairs: Pair<K, V>): Map<K, V>

Creates a fresh read-only map containing the supplied key-value pairs.

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.

mutableMapOf

external fun <K, V> mutableMapOf(vararg pairs: Pair<K, V>): MutableMap<K, V>

Creates a fresh mutable HashMap containing the supplied key-value pairs.

mutableSetOf

external fun <T> mutableSetOf(vararg elements: T): MutableSet<T>

Creates a fresh mutable HashSet containing the distinct supplied elements.

none

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

Returns true when no element matches predicate.

set

operator fun <K, V> MutableMap<K, V>.set(key: K, value: V)

Associates key with value using indexed assignment, discarding the previous value.

setOf

external fun <T> setOf(vararg elements: T): Set<T>

Creates a fresh read-only set containing the distinct supplied elements.

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.