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.

clear

abstract fun clear()

Removes all elements from this collection.

contains

abstract operator fun contains(p0: T?): Boolean

Checks whether this collection contains an element equal to element.

contains

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

Checks whether this iterable has an element equal to element.

containsAll

abstract fun containsAll(p0: Collection<*>?): Boolean

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.

get

abstract operator fun get(index: Int): T

Returns the element at index.

getOrNull

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

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

indexOf

abstract fun indexOf(element: T): Int

Returns the index of the first element equal to element.

indexOf

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

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

isEmpty

abstract fun isEmpty(): Boolean

Checks whether this collection has no elements.

isNotEmpty

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

Checks whether this collection contains at least one element.

iterator

abstract operator fun iterator(): MutableIterator<T>

Returns an iterator that can remove the most recently returned element.

lastIndexOf

abstract fun lastIndexOf(element: T): Int

Returns the index of the last element equal to element.

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.

listIterator

abstract fun listIterator(): ListIterator<T?>?

abstract fun listIterator(p0: Int): ListIterator<T?>?

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.

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.

remove

abstract fun remove(element: T): Boolean

Removes one element equal to element, if one exists.

removeAll

abstract fun removeAll(p0: Collection<*>?): Boolean

removeAt

abstract fun removeAt(index: Int): T

Removes the element at index, shifting following elements to the left.

retainAll

abstract fun retainAll(p0: Collection<*>?): Boolean

set

abstract operator fun set(index: Int, element: T): T

Replaces the element at index without changing the list's size.

subList

abstract fun subList(p0: Int, p1: Int): List<T?>?

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.

MutableList

Type Parameters

See also

Inheritors

Properties

Functions