inline fun <T, K, V> KoneIterable<T>.associate(keyEquality: Equality<K> = Equality.defaultFor(), keyHashing: Hashing<K>? = null, keyOrder: Order<K>? = null, transform: (T) -> KoneMapEntry<K, V>, resolve: (key: K, currentValue: V, newValue: V) -> V): KoneMap<K, V>

associateBy

inline fun <Element, Key> KoneIterable<Element>.associateBy(keyEquality: Equality<Key> = Equality.defaultFor(), keyHashing: Hashing<Key>? = null, keyOrder: Order<Key>? = null, keySelector: (Element) -> Key): KoneMap<Key, Element>

inline fun <Element, Key, Value> KoneIterable<Element>.associateBy(keyEquality: Equality<Key> = Equality.defaultFor(), keyHashing: Hashing<Key>? = null, keyOrder: Order<Key>? = null, keySelector: (Element) -> Key, valueTransform: (Element) -> Value): KoneMap<Key, Value>

inline fun <T, K> KoneIterable<T>.associateBy(keyEquality: Equality<K> = Equality.defaultFor(), keyHashing: Hashing<K>? = null, keyOrder: Order<K>? = null, keySelector: (T) -> K, resolve: (key: K, currentValue: T, newValue: T) -> T): KoneMap<K, T>

inline fun <T, K, V> KoneIterable<T>.associateBy(keyEquality: Equality<K> = Equality.defaultFor(), keyHashing: Hashing<K>? = null, keyOrder: Order<K>? = null, keySelector: (T) -> K, valueTransform: (T) -> V, resolve: (key: K, currentValue: V, newValue: V) -> V): KoneMap<K, V>

associateByReified

inline fun <Element, Key> KoneIterable<Element>.associateByReified(keyEquality: Equality<Key> = Equality.defaultFor(), keyHashing: Hashing<Key>? = null, keyOrder: Order<Key>? = null, keySelector: (Element) -> Key): KoneReifiedMap<Key, Element>

inline fun <Element, Key, Value> KoneIterable<Element>.associateByReified(keyEquality: Equality<Key> = Equality.defaultFor(), keyHashing: Hashing<Key>? = null, keyOrder: Order<Key>? = null, keySelector: (Element) -> Key, valueTransform: (Element) -> Value): KoneReifiedMap<Key, Value>

inline fun <Element, Key> KoneIterable<Element>.associateByReified(keyReification: Reification<Key>, keyEquality: Equality<Key> = Equality.defaultFor(), keyHashing: Hashing<Key>? = null, keyOrder: Order<Key>? = null, keySelector: (Element) -> Key): KoneReifiedMap<Key, Element>

inline fun <Element, Key, Value> KoneIterable<Element>.associateByReified(keyReification: Reification<Key>, keyEquality: Equality<Key> = Equality.defaultFor(), keyHashing: Hashing<Key>? = null, keyOrder: Order<Key>? = null, keySelector: (Element) -> Key, valueTransform: (Element) -> Value): KoneReifiedMap<Key, Value>

inline fun <T, K> KoneIterable<T>.associateByReified(keyEquality: Equality<K> = Equality.defaultFor(), keyHashing: Hashing<K>? = null, keyOrder: Order<K>? = null, keySelector: (T) -> K, resolve: (key: K, currentValue: T, newValue: T) -> T): KoneReifiedMap<K, T>

inline fun <T, K, V> KoneIterable<T>.associateByReified(keyEquality: Equality<K> = Equality.defaultFor(), keyHashing: Hashing<K>? = null, keyOrder: Order<K>? = null, keySelector: (T) -> K, valueTransform: (T) -> V, resolve: (key: K, currentValue: V, newValue: V) -> V): KoneReifiedMap<K, V>

inline fun <T, K> KoneIterable<T>.associateByReified(keyReification: Reification<K>, keyEquality: Equality<K> = Equality.defaultFor(), keyHashing: Hashing<K>? = null, keyOrder: Order<K>? = null, keySelector: (T) -> K, resolve: (key: K, currentValue: T, newValue: T) -> T): KoneReifiedMap<K, T>

inline fun <T, K, V> KoneIterable<T>.associateByReified(keyReification: Reification<K>, keyEquality: Equality<K> = Equality.defaultFor(), keyHashing: Hashing<K>? = null, keyOrder: Order<K>? = null, keySelector: (T) -> K, valueTransform: (T) -> V, resolve: (key: K, currentValue: V, newValue: V) -> V): KoneReifiedMap<K, V>

associateByTo

inline fun <Element, Key, Destination : KoneMutableMap<in Key, in Element>> KoneIterable<Element>.associateByTo(destination: Destination, keySelector: (Element) -> Key): Destination

inline fun <Element, Key, Value, Destination : KoneMutableMap<in Key, in Value>> KoneIterable<Element>.associateByTo(destination: Destination, keySelector: (Element) -> Key, valueTransform: (Element) -> Value): Destination

inline fun <T, K, D : KoneMutableMap<K, T>> KoneIterable<T>.associateByTo(destination: D, keySelector: (T) -> K, resolve: (key: K, currentValue: T, newValue: T) -> T): D

inline fun <T, K, V, D : KoneMutableMap<in K, V>> KoneIterable<T>.associateByTo(destination: D, keySelector: (T) -> K, valueTransform: (T) -> V, resolve: (key: K, currentValue: V, newValue: V) -> V): D

associateReified

inline fun <Element, Key, Value> KoneIterable<Element>.associateReified(keyEquality: Equality<Key> = Equality.defaultFor(), keyHashing: Hashing<Key>? = null, keyOrder: Order<Key>? = null, transform: (Element) -> KoneMapEntry<Key, Value>): KoneReifiedMap<Key, Value>

inline fun <Element, Key, Value> KoneIterable<Element>.associateReified(keyReification: Reification<Key>, keyEquality: Equality<Key> = Equality.defaultFor(), keyHashing: Hashing<Key>? = null, keyOrder: Order<Key>? = null, transform: (Element) -> KoneMapEntry<Key, Value>): KoneReifiedMap<Key, Value>

inline fun <T, K, V> KoneIterable<T>.associateReified(keyEquality: Equality<K> = Equality.defaultFor(), keyHashing: Hashing<K>? = null, keyOrder: Order<K>? = null, transform: (T) -> KoneMapEntry<K, V>, resolve: (key: K, currentValue: V, newValue: V) -> V): KoneReifiedMap<K, V>

inline fun <T, K, V> KoneIterable<T>.associateReified(keyReification: Reification<K>, keyEquality: Equality<K> = Equality.defaultFor(), keyHashing: Hashing<K>? = null, keyOrder: Order<K>? = null, transform: (T) -> KoneMapEntry<K, V>, resolve: (key: K, currentValue: V, newValue: V) -> V): KoneReifiedMap<K, V>

associateTo

inline fun <Element, Key, Value, Destination : KoneMutableMap<in Key, in Value>> KoneIterable<Element>.associateTo(destination: Destination, transform: (Element) -> KoneMapEntry<Key, Value>): Destination

@IgnorableReturnValue

inline fun <T, K, V, D : KoneMutableMap<K, V>> KoneIterable<T>.associateTo(destination: D, transform: (T) -> KoneMapEntry<K, V>, resolve: (key: K, currentValue: V, newValue: V) -> V): D

associateWith

inline fun <Key, Value> KoneIterable<Key>.associateWith(keyEquality: Equality<Key> = Equality.defaultFor(), keyHashing: Hashing<Key>? = null, keyOrder: Order<Key>? = null, valueSelector: (Key) -> Value): KoneMap<Key, Value>

associateWithReified

inline fun <Key, Value> KoneIterable<Key>.associateWithReified(keyEquality: Equality<Key> = Equality.defaultFor(), keyHashing: Hashing<Key>? = null, keyOrder: Order<Key>? = null, valueSelector: (Key) -> Value): KoneReifiedMap<Key, Value>

inline fun <Key, Value> KoneIterable<Key>.associateWithReified(keyReification: Reification<Key>, keyEquality: Equality<Key> = Equality.defaultFor(), keyHashing: Hashing<Key>? = null, keyOrder: Order<Key>? = null, valueSelector: (Key) -> Value): KoneReifiedMap<Key, Value>

associateWithTo

inline fun <Key, Value, Destination : KoneMutableMap<in Key, in Value>> KoneIterable<Key>.associateWithTo(destination: Destination, valueSelector: (Key) -> Value): Destination

chunked

fun <E> KoneIterable<E>.chunked(size: UInt): KoneList<KoneList<E>>

fun <E, R> KoneIterable<E>.chunked(size: UInt, mapper: (chunk: KoneList<E>) -> R): KoneList<R>

contains

context(_: Equality<Element>)
operator fun <Element> KoneIterable<Element>.contains(element: Element): Boolean

Checks if there is an element equal (in terms of the provided Equality) to the provided element.

containsAllFrom

context(_: Equality<Element>)
fun <Element> KoneIterable<Element>.containsAllFrom(elements: KoneIterable<Element>): Boolean

Checks if there are elements equal (in terms of the provided Equality) to elements from provided elements.

copyTo

@IgnorableReturnValue

fun <E, D : KoneMutableList<in E>> KoneIterable<E>.copyTo(destination: D): D

@IgnorableReturnValue

fun <E, D : KoneMutableSet<in E>> KoneIterable<E>.copyTo(destination: D): D

count

fun KoneIterable<Boolean>.count(): UInt

inline fun <E> KoneIterable<E>.count(predicate: (value: E) -> Boolean): UInt

countIndexed

inline fun <E> KoneIterable<E>.countIndexed(predicate: (index: UInt, value: E) -> Boolean): UInt

drop

fun <E> KoneIterable<E>.drop(n: UInt): KoneList<E>

dropLast

fun <E> KoneIterable<E>.dropLast(n: UInt): KoneList<E>

filter

inline fun <E> KoneIterable<E>.filter(predicate: (E) -> Boolean): KoneList<E>

filterTo

@IgnorableReturnValue

inline fun <E, D : KoneMutableList<in E>> KoneIterable<E>.filterTo(destination: D, predicate: (E) -> Boolean): D

@IgnorableReturnValue

inline fun <E, D : KoneMutableSet<in E>> KoneIterable<E>.filterTo(destination: D, predicate: (E) -> Boolean): D

first

fun <E> KoneIterable<E>.first(): E

firstOfThat

inline fun <E, R> KoneIterable<E>.firstOfThat(transform: (E) -> R, predicate: (R) -> Boolean): R

firstOfThatMaybe

inline fun <E, R> KoneIterable<E>.firstOfThatMaybe(transform: (E) -> R, predicate: (R) -> Boolean): Maybe<R>

firstOfThatOrNull

inline fun <E, R> KoneIterable<E>.firstOfThatOrNull(transform: (E) -> R, predicate: (R) -> Boolean): R?

firstThat

inline fun <E> KoneIterable<E>.firstThat(predicate: (E) -> Boolean): E

firstThatMaybe

inline fun <E> KoneIterable<E>.firstThatMaybe(predicate: (E) -> Boolean): Maybe<E>

firstThatOrNull

inline fun <E> KoneIterable<E>.firstThatOrNull(predicate: (E) -> Boolean): E?

flatMap

inline fun <E, R> KoneIterable<E>.flatMap(transform: (E) -> KoneIterable<R>): KoneList<R>

flatMapIndexed

inline fun <E, R> KoneIterable<E>.flatMapIndexed(transform: (index: UInt, E) -> KoneIterable<R>): KoneList<R>

flatMapIndexedTo

@IgnorableReturnValue

inline fun <E, R, D : KoneMutableList<in R>> KoneIterable<E>.flatMapIndexedTo(destination: D, transform: (index: UInt, E) -> KoneIterable<R>): D

@IgnorableReturnValue

inline fun <E, R, D : KoneMutableSet<in R>> KoneIterable<E>.flatMapIndexedTo(destination: D, transform: (index: UInt, E) -> KoneIterable<R>): D

flatMapTo

@IgnorableReturnValue

inline fun <E, R, D : KoneMutableList<in R>> KoneIterable<E>.flatMapTo(destination: D, transform: (E) -> KoneIterable<R>): D

@IgnorableReturnValue

inline fun <E, R, D : KoneMutableSet<in R>> KoneIterable<E>.flatMapTo(destination: D, transform: (E) -> KoneIterable<R>): D

flatten

fun <E> KoneIterable<KoneIterable<E>>.flatten(): KoneList<E>

fold

inline fun <E, R> KoneIterable<E>.fold(initial: R, operation: (acc: R, E) -> R): R

foldIndexed

inline fun <E, R> KoneIterable<E>.foldIndexed(initial: R, operation: (index: UInt, acc: R, E) -> R): R

forEach

inline fun <E> KoneIterable<E>.forEach(block: (value: E) -> Unit)

forEachIndexed

inline fun <E> KoneIterable<E>.forEachIndexed(block: (index: UInt, value: E) -> Unit)

groupBy

inline fun <E, K> KoneIterable<E>.groupBy(keyEquality: Equality<K> = Equality.defaultFor(), keyHashing: Hashing<K>? = null, keyOrder: Order<K>? = null, keySelector: (E) -> K): KoneMap<K, KoneList<E>>

inline fun <E, K, V> KoneIterable<E>.groupBy(keyEquality: Equality<K> = Equality.defaultFor(), keyHashing: Hashing<K>? = null, keyOrder: Order<K>? = null, keySelector: (E) -> K, valueTransform: (E) -> V): KoneMap<K, KoneList<V>>

groupByTo

@IgnorableReturnValue

inline fun <E, K, D : KoneMutableMap<in K, KoneMutableList<E>>> KoneIterable<E>.groupByTo(destination: D, keySelector: (E) -> K): D

@IgnorableReturnValue

inline fun <E, K, V, D : KoneMutableMap<in K, KoneMutableList<V>>> KoneIterable<E>.groupByTo(destination: D, keySelector: (E) -> K, valueTransform: (E) -> V): D

heapsorted

fun <E : Comparable<E>> KoneIterable<E>.heapsorted(): KoneList<E>

context(_: Order<E>)
fun <E> KoneIterable<E>.heapsorted(): KoneList<E>

heapsortedBy

inline fun <E, R : Comparable<R>> KoneIterable<E>.heapsortedBy(selector: (E) -> R): KoneList<E>

context(_: Order<R>)
inline fun <E, R> KoneIterable<E>.heapsortedBy(selector: (E) -> R): KoneList<E>

heapsortedByDescending

inline fun <E, R : Comparable<R>> KoneIterable<E>.heapsortedByDescending(selector: (E) -> R): KoneList<E>

context(_: Order<R>)
inline fun <E, R> KoneIterable<E>.heapsortedByDescending(selector: (E) -> R): KoneList<E>

heapsortedDescending

fun <E : Comparable<E>> KoneIterable<E>.heapsortedDescending(): KoneList<E>

context(_: Order<E>)
fun <E> KoneIterable<E>.heapsortedDescending(): KoneList<E>

heapsortedWith

fun <E> KoneIterable<E>.heapsortedWith(comparator: Comparator<E>): KoneList<E>

heapsortedWithBy

inline fun <E, R> KoneIterable<E>.heapsortedWithBy(comparator: Comparator<R>, selector: (E) -> R): KoneList<E>

heapsortedWithByDescending

inline fun <E, R> KoneIterable<E>.heapsortedWithByDescending(comparator: Comparator<R>, selector: (E) -> R): KoneList<E>

heapsortedWithDescending

fun <E> KoneIterable<E>.heapsortedWithDescending(comparator: Comparator<E>): KoneList<E>

isEmpty

open fun isEmpty(): Boolean

Checks if the iterable is empty.

isNotEmpty

fun KoneIterable<*>.isNotEmpty(): Boolean

Checks if the iterable is not empty.

iterator

abstract operator override fun iterator(): KoneRemovableIterator<Element>

Iterator over elements of the collection. There must be exactly size number of elements in it.

joinTo

fun <E, A : Appendable> KoneIterable<E>.joinTo(buffer: A, separator: CharSequence = ", ", prefix: CharSequence = "", postfix: CharSequence = "", limit: UInt = UInt.MAX_VALUE, truncated: CharSequence = "...", transform: (E) -> CharSequence? = null): A

joinToString

fun <E> KoneIterable<E>.joinToString(separator: CharSequence = ", ", prefix: CharSequence = "", postfix: CharSequence = "", limit: UInt = UInt.MAX_VALUE, truncated: CharSequence = "...", transform: (E) -> CharSequence? = null): String

map

inline fun <E, R> KoneIterable<E>.map(transform: (E) -> R): KoneList<R>

mapIndexed

inline fun <E, R> KoneIterable<E>.mapIndexed(transform: (index: UInt, E) -> R): KoneList<R>

mapIndexedTo

@IgnorableReturnValue

inline fun <E, R, D : KoneMutableList<in R>> KoneIterable<E>.mapIndexedTo(destination: D, crossinline transform: (index: UInt, E) -> R): D

@IgnorableReturnValue

inline fun <E, R, D : KoneMutableSet<in R>> KoneIterable<E>.mapIndexedTo(destination: D, crossinline transform: (index: UInt, E) -> R): D

mapIndexedToInline

@IgnorableReturnValue

inline fun <E, R, D : KoneMutableList<in R>> KoneIterable<E>.mapIndexedToInline(destination: D, crossinline transform: (index: UInt, E) -> R): D

@IgnorableReturnValue

inline fun <E, R, D : KoneMutableSet<in R>> KoneIterable<E>.mapIndexedToInline(destination: D, crossinline transform: (index: UInt, E) -> R): D

mapTo

@IgnorableReturnValue

inline fun <E, R, D : KoneMutableList<in R>> KoneIterable<E>.mapTo(destination: D, crossinline transform: (E) -> R): D

@IgnorableReturnValue

inline fun <E, R, D : KoneMutableSet<in R>> KoneIterable<E>.mapTo(destination: D, crossinline transform: (E) -> R): D

mapToInline

@IgnorableReturnValue

inline fun <E, R, D : KoneMutableList<in R>> KoneIterable<E>.mapToInline(destination: D, transform: (E) -> R): D

@IgnorableReturnValue

inline fun <E, R, D : KoneMutableSet<in R>> KoneIterable<E>.mapToInline(destination: D, transform: (E) -> R): D

max

fun <E : Comparable<E>> KoneIterable<E>.max(): E

context(_: Order<E>)
fun <E> KoneIterable<E>.max(): E

maxBy

inline fun <E, R : Comparable<R>> KoneIterable<E>.maxBy(selector: (E) -> R): E

context(_: Order<R>)
inline fun <E, R> KoneIterable<E>.maxBy(selector: (E) -> R): E

maxByMaybe

inline fun <E, R : Comparable<R>> KoneIterable<E>.maxByMaybe(selector: (E) -> R): Maybe<E>

context(_: Order<R>)
inline fun <E, R> KoneIterable<E>.maxByMaybe(selector: (E) -> R): Maybe<E>

maxByOrElse

inline fun <E, R : Comparable<R>> KoneIterable<E>.maxByOrElse(default: () -> E, selector: (E) -> R): E

context(_: Order<R>)
inline fun <E, R> KoneIterable<E>.maxByOrElse(default: () -> E, selector: (E) -> R): E

maxByOrNull

inline fun <E, R : Comparable<R>> KoneIterable<E>.maxByOrNull(selector: (E) -> R): E?

context(_: Order<R>)
inline fun <E, R> KoneIterable<E>.maxByOrNull(selector: (E) -> R): E?

maxList

fun <E : Comparable<E>> KoneIterable<E>.maxList(): KoneList<E>

context(_: Order<E>)
fun <E> KoneIterable<E>.maxList(): KoneList<E>

maxListBy

inline fun <E, R : Comparable<R>> KoneIterable<E>.maxListBy(selector: (E) -> R): KoneList<E>

context(_: Order<R>)
inline fun <E, R> KoneIterable<E>.maxListBy(selector: (E) -> R): KoneList<E>

maxListOf

inline fun <E, R : Comparable<R>> KoneIterable<E>.maxListOf(selector: (E) -> R): KoneList<R>

context(_: Order<R>)
inline fun <E, R> KoneIterable<E>.maxListOf(selector: (E) -> R): KoneList<R>

maxListWith

fun <E> KoneIterable<E>.maxListWith(comparator: Comparator<E>): KoneList<E>

maxListWithBy

inline fun <E, R> KoneIterable<E>.maxListWithBy(comparator: Comparator<R>, selector: (E) -> R): KoneList<E>

maxListWithOf

inline fun <E, R> KoneIterable<E>.maxListWithOf(comparator: Comparator<R>, selector: (E) -> R): KoneList<R>

maxMaybe

fun <E : Comparable<E>> KoneIterable<E>.maxMaybe(): Maybe<E>

context(_: Order<E>)
fun <E> KoneIterable<E>.maxMaybe(): Maybe<E>

maxOf

inline fun <E, R : Comparable<R>> KoneIterable<E>.maxOf(selector: (E) -> R): R

context(_: Order<R>)
inline fun <E, R> KoneIterable<E>.maxOf(selector: (E) -> R): R

maxOfMaybe

inline fun <E, R : Comparable<R>> KoneIterable<E>.maxOfMaybe(selector: (E) -> R): Maybe<R>

context(_: Order<R>)
inline fun <E, R> KoneIterable<E>.maxOfMaybe(selector: (E) -> R): Maybe<R>

maxOfOrElse

inline fun <E, R : Comparable<R>> KoneIterable<E>.maxOfOrElse(default: () -> R, selector: (E) -> R): R

context(_: Order<R>)
inline fun <E, R> KoneIterable<E>.maxOfOrElse(default: () -> R, selector: (E) -> R): R

maxOfOrNull

inline fun <E, R : Comparable<R>> KoneIterable<E>.maxOfOrNull(selector: (E) -> R): R?

context(_: Order<R>)
inline fun <E, R> KoneIterable<E>.maxOfOrNull(selector: (E) -> R): R?

maxOrElse

inline fun <E : Comparable<E>> KoneIterable<E>.maxOrElse(default: () -> E): E

context(_: Order<E>)
inline fun <E> KoneIterable<E>.maxOrElse(default: () -> E): E

maxOrNull

fun <E : Comparable<E>> KoneIterable<E>.maxOrNull(): E?

context(_: Order<E>)
fun <E> KoneIterable<E>.maxOrNull(): E?

maxWith

fun <E> KoneIterable<E>.maxWith(comparator: Comparator<E>): E

maxWithBy

inline fun <E, R> KoneIterable<E>.maxWithBy(comparator: Comparator<R>, selector: (E) -> R): E

maxWithByMaybe

inline fun <E, R> KoneIterable<E>.maxWithByMaybe(comparator: Comparator<R>, selector: (E) -> R): Maybe<E>

maxWithByOrElse

inline fun <E, R> KoneIterable<E>.maxWithByOrElse(comparator: Comparator<R>, default: () -> E, selector: (E) -> R): E

maxWithByOrNull

inline fun <E, R> KoneIterable<E>.maxWithByOrNull(comparator: Comparator<R>, selector: (E) -> R): E?

maxWithMaybe

fun <E> KoneIterable<E>.maxWithMaybe(comparator: Comparator<E>): Maybe<E>

maxWithOf

inline fun <E, R> KoneIterable<E>.maxWithOf(comparator: Comparator<R>, selector: (E) -> R): R

maxWithOfMaybe

inline fun <E, R> KoneIterable<E>.maxWithOfMaybe(comparator: Comparator<R>, selector: (E) -> R): Maybe<R>

maxWithOfOrElse

inline fun <E, R> KoneIterable<E>.maxWithOfOrElse(comparator: Comparator<R>, default: () -> R, selector: (E) -> R): R

maxWithOfOrNull

inline fun <E, R> KoneIterable<E>.maxWithOfOrNull(comparator: Comparator<R>, selector: (E) -> R): R?

maxWithOrElse

inline fun <E> KoneIterable<E>.maxWithOrElse(comparator: Comparator<E>, default: () -> E): E

maxWithOrNull

fun <E> KoneIterable<E>.maxWithOrNull(comparator: Comparator<E>): E?

min

fun <E : Comparable<E>> KoneIterable<E>.min(): E

context(_: Order<E>)
fun <E> KoneIterable<E>.min(): E

minBy

inline fun <E, R : Comparable<R>> KoneIterable<E>.minBy(selector: (E) -> R): E

context(_: Order<R>)
inline fun <E, R> KoneIterable<E>.minBy(selector: (E) -> R): E

minByMaybe

inline fun <E, R : Comparable<R>> KoneIterable<E>.minByMaybe(selector: (E) -> R): Maybe<E>

context(_: Order<R>)
inline fun <E, R> KoneIterable<E>.minByMaybe(selector: (E) -> R): Maybe<E>

minByOrElse

inline fun <E, R : Comparable<R>> KoneIterable<E>.minByOrElse(default: () -> E, selector: (E) -> R): E

context(_: Order<R>)
inline fun <E, R> KoneIterable<E>.minByOrElse(default: () -> E, selector: (E) -> R): E

minByOrNull

inline fun <E, R : Comparable<R>> KoneIterable<E>.minByOrNull(selector: (E) -> R): E?

context(_: Order<R>)
inline fun <E, R> KoneIterable<E>.minByOrNull(selector: (E) -> R): E?

minList

fun <E : Comparable<E>> KoneIterable<E>.minList(): KoneList<E>

context(_: Order<E>)
fun <E> KoneIterable<E>.minList(): KoneList<E>

minListBy

inline fun <E, R : Comparable<R>> KoneIterable<E>.minListBy(selector: (E) -> R): KoneList<E>

context(_: Order<R>)
inline fun <E, R> KoneIterable<E>.minListBy(selector: (E) -> R): KoneList<E>

minListOf

inline fun <E, R : Comparable<R>> KoneIterable<E>.minListOf(selector: (E) -> R): KoneList<R>

context(_: Order<R>)
inline fun <E, R> KoneIterable<E>.minListOf(selector: (E) -> R): KoneList<R>

minListWith

fun <E> KoneIterable<E>.minListWith(comparator: Comparator<E>): KoneList<E>

minListWithBy

inline fun <E, R> KoneIterable<E>.minListWithBy(comparator: Comparator<R>, selector: (E) -> R): KoneList<E>

minListWithOf

inline fun <E, R> KoneIterable<E>.minListWithOf(comparator: Comparator<R>, selector: (E) -> R): KoneList<R>

minMaybe

fun <E : Comparable<E>> KoneIterable<E>.minMaybe(): Maybe<E>

context(_: Order<E>)
fun <E> KoneIterable<E>.minMaybe(): Maybe<E>

minOf

inline fun <E, R : Comparable<R>> KoneIterable<E>.minOf(selector: (E) -> R): R

context(_: Order<R>)
inline fun <E, R> KoneIterable<E>.minOf(selector: (E) -> R): R

minOfMaybe

inline fun <E, R : Comparable<R>> KoneIterable<E>.minOfMaybe(selector: (E) -> R): Maybe<R>

context(_: Order<R>)
inline fun <E, R> KoneIterable<E>.minOfMaybe(selector: (E) -> R): Maybe<R>

minOfOrElse

inline fun <E, R : Comparable<R>> KoneIterable<E>.minOfOrElse(default: () -> R, selector: (E) -> R): R

context(_: Order<R>)
inline fun <E, R> KoneIterable<E>.minOfOrElse(default: () -> R, selector: (E) -> R): R

minOfOrNull

inline fun <E, R : Comparable<R>> KoneIterable<E>.minOfOrNull(selector: (E) -> R): R?

context(_: Order<R>)
inline fun <E, R> KoneIterable<E>.minOfOrNull(selector: (E) -> R): R?

minOrElse

inline fun <E : Comparable<E>> KoneIterable<E>.minOrElse(default: () -> E): E

context(_: Order<E>)
inline fun <E> KoneIterable<E>.minOrElse(default: () -> E): E

minOrNull

fun <E : Comparable<E>> KoneIterable<E>.minOrNull(): E?

context(_: Order<E>)
fun <E> KoneIterable<E>.minOrNull(): E?

minWith

fun <E> KoneIterable<E>.minWith(comparator: Comparator<E>): E

minWithBy

inline fun <E, R> KoneIterable<E>.minWithBy(comparator: Comparator<R>, selector: (E) -> R): E

minWithByMaybe

inline fun <E, R> KoneIterable<E>.minWithByMaybe(comparator: Comparator<R>, selector: (E) -> R): Maybe<E>

minWithByOrElse

inline fun <E, R> KoneIterable<E>.minWithByOrElse(comparator: Comparator<R>, default: () -> E, selector: (E) -> R): E

minWithByOrNull

inline fun <E, R> KoneIterable<E>.minWithByOrNull(comparator: Comparator<R>, selector: (E) -> R): E?

minWithMaybe

fun <E> KoneIterable<E>.minWithMaybe(comparator: Comparator<E>): Maybe<E>

minWithOf

inline fun <E, R> KoneIterable<E>.minWithOf(comparator: Comparator<R>, selector: (E) -> R): R

minWithOfMaybe

inline fun <E, R> KoneIterable<E>.minWithOfMaybe(comparator: Comparator<R>, selector: (E) -> R): Maybe<R>

minWithOfOrElse

inline fun <E, R> KoneIterable<E>.minWithOfOrElse(comparator: Comparator<R>, default: () -> R, selector: (E) -> R): R

minWithOfOrNull

inline fun <E, R> KoneIterable<E>.minWithOfOrNull(comparator: Comparator<R>, selector: (E) -> R): R?

minWithOrElse

inline fun <E> KoneIterable<E>.minWithOrElse(comparator: Comparator<E>, default: () -> E): E

minWithOrNull

fun <E> KoneIterable<E>.minWithOrNull(comparator: Comparator<E>): E?

none

fun KoneIterable<Boolean>.none(): Boolean

inline fun <E> KoneIterable<E>.none(block: (value: E) -> Boolean): Boolean

noneIndexed

inline fun <E> KoneIterable<E>.noneIndexed(block: (index: UInt, value: E) -> Boolean): Boolean

quicksorted

fun <E : Comparable<E>> KoneIterable<E>.quicksorted(): KoneList<E>

context(_: Order<E>)
fun <E> KoneIterable<E>.quicksorted(): KoneList<E>

quicksortedBy

inline fun <E, R : Comparable<R>> KoneIterable<E>.quicksortedBy(selector: (E) -> R): KoneList<E>

context(_: Order<R>)
inline fun <E, R> KoneIterable<E>.quicksortedBy(selector: (E) -> R): KoneList<E>

quicksortedByDescending

inline fun <E, R : Comparable<R>> KoneIterable<E>.quicksortedByDescending(selector: (E) -> R): KoneList<E>

context(_: Order<R>)
inline fun <E, R> KoneIterable<E>.quicksortedByDescending(selector: (E) -> R): KoneList<E>

quicksortedDescending

fun <E : Comparable<E>> KoneIterable<E>.quicksortedDescending(): KoneList<E>

context(_: Order<E>)
fun <E> KoneIterable<E>.quicksortedDescending(): KoneList<E>

quicksortedWith

fun <E> KoneIterable<E>.quicksortedWith(comparator: Comparator<E>): KoneList<E>

quicksortedWithBy

inline fun <E, R> KoneIterable<E>.quicksortedWithBy(comparator: Comparator<R>, selector: (E) -> R): KoneList<E>

quicksortedWithByDescending

inline fun <E, R> KoneIterable<E>.quicksortedWithByDescending(comparator: Comparator<R>, selector: (E) -> R): KoneList<E>

quicksortedWithDescending

fun <E> KoneIterable<E>.quicksortedWithDescending(comparator: Comparator<E>): KoneList<E>

random

fun <E> KoneIterable<E>.random(random: Random): E

reduce

inline fun <E : R, R> KoneIterable<E>.reduce(operation: (acc: R, E) -> R): R

reduceIndexed

inline fun <E : R, R> KoneIterable<E>.reduceIndexed(operation: (index: UInt, acc: R, E) -> R): R

reduceIndexedMaybe

inline fun <E : R, R> KoneIterable<E>.reduceIndexedMaybe(operation: (index: UInt, acc: R, E) -> R): Maybe<R>

reduceIndexedOrNull

inline fun <E : R, R> KoneIterable<E>.reduceIndexedOrNull(operation: (index: UInt, acc: R, E) -> R): R?

reduceMaybe

inline fun <E : R, R> KoneIterable<E>.reduceMaybe(operation: (acc: R, E) -> R): Maybe<R>

reduceOrNull

inline fun <E : R, R> KoneIterable<E>.reduceOrNull(operation: (acc: R, E) -> R): R?

runningFold

inline fun <E, R> KoneIterable<E>.runningFold(initial: R, operation: (acc: R, E) -> R): KoneList<R>

runningFoldIndexed

inline fun <E, R> KoneIterable<E>.runningFoldIndexed(initial: R, operation: (index: UInt, acc: R, E) -> R): KoneList<R>

shuffled

fun <E> KoneIterable<E>.shuffled(random: Random = Random): KoneList<E>

single

fun <E> KoneIterable<E>.single(): E

fun <E> KoneIterable<E>.single(predicate: (E) -> Boolean): E

sorted

fun <E : Comparable<E>> KoneIterable<E>.sorted(): KoneList<E>

context(_: Order<E>)
fun <E> KoneIterable<E>.sorted(): KoneList<E>

sortedBy

inline fun <E, R : Comparable<R>> KoneIterable<E>.sortedBy(selector: (E) -> R): KoneList<E>

context(_: Order<R>)
inline fun <E, R> KoneIterable<E>.sortedBy(selector: (E) -> R): KoneList<E>

sortedByDescending

inline fun <E, R : Comparable<R>> KoneIterable<E>.sortedByDescending(selector: (E) -> R): KoneList<E>

context(_: Order<R>)
inline fun <E, R> KoneIterable<E>.sortedByDescending(selector: (E) -> R): KoneList<E>

sortedDescending

fun <E : Comparable<E>> KoneIterable<E>.sortedDescending(): KoneList<E>

context(_: Order<E>)
fun <E> KoneIterable<E>.sortedDescending(): KoneList<E>

sortedWith

fun <E> KoneIterable<E>.sortedWith(comparator: Comparator<E>): KoneList<E>

sortedWithBy

inline fun <E, R> KoneIterable<E>.sortedWithBy(comparator: Comparator<R>, selector: (E) -> R): KoneList<E>

sortedWithByDescending

inline fun <E, R> KoneIterable<E>.sortedWithByDescending(comparator: Comparator<R>, selector: (E) -> R): KoneList<E>

sortedWithDescending

fun <E> KoneIterable<E>.sortedWithDescending(comparator: Comparator<E>): KoneList<E>

take

fun <E> KoneIterable<E>.take(n: UInt): KoneList<E>

takeLast

fun <E> KoneIterable<E>.takeLast(n: UInt): KoneList<E>

toKoneArray

inline fun <Element> KoneIterable<Element>.toKoneArray(): KoneArray<Element>

toKoneBooleanArray

fun KoneIterable<Boolean>.toKoneBooleanArray(): KoneBooleanArray

toKoneByteArray

fun KoneIterable<Byte>.toKoneByteArray(): KoneByteArray

toKoneCharArray

fun KoneIterable<Char>.toKoneCharArray(): KoneCharArray

toKoneDoubleArray

fun KoneIterable<Double>.toKoneDoubleArray(): KoneDoubleArray

toKoneFloatArray

fun KoneIterable<Float>.toKoneFloatArray(): KoneFloatArray

toKoneIntArray

fun KoneIterable<Int>.toKoneIntArray(): KoneIntArray

toKoneList

fun <Element> KoneIterable<Element>.toKoneList(): KoneList<Element>

Converts this iterable to a KoneList.

toKoneLongArray

fun KoneIterable<Long>.toKoneLongArray(): KoneLongArray

toKoneMutableArray

inline fun <Element> KoneIterable<Element>.toKoneMutableArray(): KoneMutableArray<Element>

toKoneMutableBooleanArray

fun KoneIterable<Boolean>.toKoneMutableBooleanArray(): KoneMutableBooleanArray

toKoneMutableByteArray

fun KoneIterable<Byte>.toKoneMutableByteArray(): KoneMutableByteArray

toKoneMutableCharArray

fun KoneIterable<Char>.toKoneMutableCharArray(): KoneMutableCharArray

toKoneMutableDoubleArray

fun KoneIterable<Double>.toKoneMutableDoubleArray(): KoneMutableDoubleArray

toKoneMutableFloatArray

fun KoneIterable<Float>.toKoneMutableFloatArray(): KoneMutableFloatArray

toKoneMutableIntArray

fun KoneIterable<Int>.toKoneMutableIntArray(): KoneMutableIntArray

toKoneMutableList

fun <Element> KoneIterable<Element>.toKoneMutableList(): KoneMutableList<Element>

Converts this iterable to a KoneMutableList.

toKoneMutableLongArray

fun KoneIterable<Long>.toKoneMutableLongArray(): KoneMutableLongArray

toKoneMutableNoddedList

fun <Element> KoneIterable<Element>.toKoneMutableNoddedList(): KoneMutableNoddedList<Element>

Converts this iterable to a KoneMutableNoddedList.

toKoneMutableReifiedSet

inline fun <Element> KoneIterable<Element>.toKoneMutableReifiedSet(elementEquality: Equality<Element> = Equality.defaultFor(), elementHashing: Hashing<Element>? = null, elementOrder: Order<Element>? = null): KoneMutableReifiedSet<Element>

fun <Element> KoneIterable<Element>.toKoneMutableReifiedSet(elementReification: Reification<Element>, elementEquality: Equality<Element> = Equality.defaultFor(), elementHashing: Hashing<Element>? = null, elementOrder: Order<Element>? = null): KoneMutableReifiedSet<Element>

toKoneMutableSet

fun <Element> KoneIterable<Element>.toKoneMutableSet(elementEquality: Equality<Element> = Equality.defaultFor(), elementHashing: Hashing<Element>? = null, elementOrder: Order<Element>? = null): KoneMutableSet<Element>

toKoneMutableShortArray

fun KoneIterable<Short>.toKoneMutableShortArray(): KoneMutableShortArray

toKoneMutableUByteArray

fun KoneIterable<UByte>.toKoneMutableUByteArray(): KoneMutableUByteArray

toKoneMutableUIntArray

fun KoneIterable<UInt>.toKoneMutableUIntArray(): KoneMutableUIntArray

toKoneMutableULongArray

fun KoneIterable<ULong>.toKoneMutableULongArray(): KoneMutableULongArray

toKoneMutableUShortArray

fun KoneIterable<UShort>.toKoneMutableUShortArray(): KoneMutableUShortArray

toKoneNoddedList

fun <Element> KoneIterable<Element>.toKoneNoddedList(): KoneNoddedList<Element>

Converts this iterable to a KoneNoddedList.

toKoneReifiedSet

inline fun <Element> KoneIterable<Element>.toKoneReifiedSet(elementEquality: Equality<Element> = Equality.defaultFor(), elementHashing: Hashing<Element>? = null, elementOrder: Order<Element>? = null): KoneReifiedSet<Element>

fun <Element> KoneIterable<Element>.toKoneReifiedSet(elementReification: Reification<Element>, elementEquality: Equality<Element> = Equality.defaultFor(), elementHashing: Hashing<Element>? = null, elementOrder: Order<Element>? = null): KoneReifiedSet<Element>

toKoneSet

fun <Element> KoneIterable<Element>.toKoneSet(elementEquality: Equality<Element> = Equality.defaultFor(), elementHashing: Hashing<Element>? = null, elementOrder: Order<Element>? = null): KoneSet<Element>

toKoneSettableList

fun <Element> KoneIterable<Element>.toKoneSettableList(): KoneSettableList<Element>

Converts this iterable to a KoneSettableList.

toKoneSettableNoddedList

fun <Element> KoneIterable<Element>.toKoneSettableNoddedList(): KoneSettableNoddedList<Element>

Converts this iterable to a KoneSettableNoddedList.

toKoneShortArray

fun KoneIterable<Short>.toKoneShortArray(): KoneShortArray

toKoneUByteArray

fun KoneIterable<UByte>.toKoneUByteArray(): KoneUByteArray

toKoneUIntArray

fun KoneIterable<UInt>.toKoneUIntArray(): KoneUIntArray

toKoneULongArray

fun KoneIterable<ULong>.toKoneULongArray(): KoneULongArray

toKoneUShortArray

fun KoneIterable<UShort>.toKoneUShortArray(): KoneUShortArray

toList

fun <Element> KoneIterable<Element>.toList(): List<Element>

windowed

fun <E> KoneIterable<E>.windowed(size: UInt, step: UInt): KoneList<KoneList<E>>

fun <E, R> KoneIterable<E>.windowed(size: UInt, step: UInt, mapper: (window: KoneList<E>) -> R): KoneList<R>

withEach

inline fun <E> KoneIterable<E>.withEach(block: E.() -> Unit)

withEachIndexed

inline fun <E> KoneIterable<E>.withEachIndexed(block: E.(index: UInt) -> Unit)

withIndex

fun <E> KoneIterable<E>.withIndex(): KoneIterable<KoneIndexedValue<E>>