kone.collections/dev.lounres.kone.collections.utils

Package-level declarations

Types

KoneIndexedValue

data class KoneIndexedValue<out E>(val index: UInt, val value: E)

Functions

all

fun KoneIterable<Boolean>.all(): Boolean

fun KoneIterator<Boolean>.all(): Boolean

fun KoneSequence<Boolean>.all(): Boolean

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

inline fun <E> KoneIterator<E>.all(block: (value: E) -> Boolean): Boolean

inline fun <E> KoneSequence<E>.all(block: (value: E) -> Boolean): Boolean

allIndexed

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

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

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

any

fun KoneIterable<Boolean>.any(): Boolean

fun KoneIterator<Boolean>.any(): Boolean

fun KoneSequence<Boolean>.any(): Boolean

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

inline fun <E> KoneIterator<E>.any(block: (value: E) -> Boolean): Boolean

inline fun <E> KoneSequence<E>.any(block: (value: E) -> Boolean): Boolean

anyIndexed

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

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

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

associate

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 <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 <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 <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 <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

@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

blocking

fun <E> KoneIterator<E>.blocking(): KoneIterator<E>

change

inline fun <K, V> KoneMutableMap<in K, V>.change(key: K, transform: (currentValue: V) -> V)

chunked

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

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

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

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

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

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

component1

operator fun <E> KoneList<E>.component1(): E

component10

operator fun <E> KoneList<E>.component10(): E

component11

operator fun <E> KoneList<E>.component11(): E

component12

operator fun <E> KoneList<E>.component12(): E

component13

operator fun <E> KoneList<E>.component13(): E

component14

operator fun <E> KoneList<E>.component14(): E

component15

operator fun <E> KoneList<E>.component15(): E

component2

operator fun <E> KoneList<E>.component2(): E

component3

operator fun <E> KoneList<E>.component3(): E

component4

operator fun <E> KoneList<E>.component4(): E

component5

operator fun <E> KoneList<E>.component5(): E

component6

operator fun <E> KoneList<E>.component6(): E

component7

operator fun <E> KoneList<E>.component7(): E

component8

operator fun <E> KoneList<E>.component8(): E

component9

operator fun <E> KoneList<E>.component9(): E

computeOn

inline fun <K, V, R> KoneMap<in K, V>.computeOn(key: K, compute: (Maybe<V>) -> R): R

computeOnOrElse

inline fun <K, V, R> KoneMap<K, V>.computeOnOrElse(key: K, defaultResult: () -> R, compute: (value: V) -> R): R

copyMapTo

@IgnorableReturnValue

inline fun <K, V, W, D : KoneMutableMap<K, W>> KoneMap<out K, V>.copyMapTo(destination: D, transform: (KoneMapEntry<K, V>) -> W): D

copyMapToBy

@IgnorableReturnValue

inline fun <K, V, W, D : KoneMutableMap<K, W>> KoneMap<out K, V>.copyMapToBy(destination: D, transform: (KoneMapEntry<K, V>) -> W, resolve: (key: K, currentValue: W, newValue: V) -> W): D

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

@IgnorableReturnValue

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

@IgnorableReturnValue

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

@IgnorableReturnValue

fun <K, V, D : KoneMutableMap<K, V>> KoneMap<out K, V>.copyTo(destination: D): D

@IgnorableReturnValue

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

@IgnorableReturnValue

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

copyToBy

@IgnorableReturnValue

inline fun <K, V : W, W, D : KoneMutableMap<K, W>> KoneMap<out K, V>.copyToBy(destination: D, resolve: (key: K, currentValue: W, newValue: V) -> W): D

count

fun KoneIterable<Boolean>.count(): UInt

fun KoneIterator<Boolean>.count(): UInt

fun KoneSequence<Boolean>.count(): UInt

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

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

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

countIndexed

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

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

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

drop

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

fun <E> KoneIterator<E>.drop(n: UInt): KoneIterator<E>

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

fun <E> KoneSequence<E>.drop(n: UInt): KoneSequence<E>

dropLast

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

fun <E> KoneIterator<E>.dropLast(n: UInt): KoneIterator<E>

fun <E> KoneSequence<E>.dropLast(n: UInt): KoneSequence<E>

filter

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

fun <E> KoneIterator<E>.filter(predicate: (E) -> Boolean): KoneIterator<E>

fun <E> KoneSequence<E>.filter(predicate: (E) -> Boolean): KoneSequence<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

@IgnorableReturnValue

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

@IgnorableReturnValue

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

@IgnorableReturnValue

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

@IgnorableReturnValue

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

first

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

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

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

firstIndexOf

context(_: Equality<E>)
fun <E> KoneList<E>.firstIndexOf(element: E): UInt

firstIndexThat

inline fun <E> KoneList<E>.firstIndexThat(predicate: (index: UInt, element: E) -> Boolean): UInt

firstOfThat

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

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

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

firstOfThatIndexed

inline fun <E, R> KoneList<E>.firstOfThatIndexed(transform: (index: UInt, E) -> R, predicate: (R) -> Boolean): R

firstOfThatIndexedMaybe

inline fun <E, R> KoneList<E>.firstOfThatIndexedMaybe(transform: (index: UInt, E) -> R, predicate: (R) -> Boolean): Maybe<R>

firstOfThatIndexedOrNull

inline fun <E, R> KoneList<E>.firstOfThatIndexedOrNull(transform: (index: UInt, E) -> R, predicate: (R) -> Boolean): R?

firstOfThatMaybe

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

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

inline fun <E, R> KoneSequence<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?

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

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

firstThat

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

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

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

firstThatIndexed

inline fun <E> KoneList<E>.firstThatIndexed(predicate: (index: UInt, E) -> Boolean): E

firstThatIndexedMaybe

inline fun <E> KoneList<E>.firstThatIndexedMaybe(predicate: (index: UInt, E) -> Boolean): Maybe<E>

firstThatIndexedOrNull

inline fun <E> KoneList<E>.firstThatIndexedOrNull(predicate: (index: UInt, E) -> Boolean): E?

firstThatMaybe

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

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

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

firstThatOrNull

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

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

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

flatMap

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

fun <E, R> KoneIterator<E>.flatMap(transform: (E) -> KoneIterator<R>): KoneIterator<R>

fun <E, R> KoneSequence<E>.flatMap(transform: (E) -> KoneSequence<R>): KoneSequence<R>

flatMapIndexed

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

fun <E, R> KoneIterator<E>.flatMapIndexed(transform: (index: UInt, E) -> KoneIterator<R>): KoneIterator<R>

fun <E, R> KoneSequence<E>.flatMapIndexed(transform: (index: UInt, E) -> KoneSequence<R>): KoneSequence<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

@IgnorableReturnValue

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

@IgnorableReturnValue

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

@IgnorableReturnValue

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

@IgnorableReturnValue

inline fun <E, R, D : KoneMutableSet<in R>> KoneSequence<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

@IgnorableReturnValue

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

@IgnorableReturnValue

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

@IgnorableReturnValue

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

@IgnorableReturnValue

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

flatten

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

fun <E> KoneIterator<KoneIterator<E>>.flatten(): KoneIterator<E>

fun <E> KoneSequence<KoneSequence<E>>.flatten(): KoneSequence<E>

fold

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

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

inline fun <K, V, R> KoneMap<out K, V>.fold(initial: R, operation: (acc: R, KoneMapEntry<K, V>) -> R): R

inline fun <E, R> KoneSequence<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

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

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

foldRight

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

foldRightIndexed

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

forEach

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

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

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

forEachIndexed

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

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

inline fun <E> KoneSequence<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

hasDuplicates

fun <E> KoneIterator<E>.hasDuplicates(elementEquality: Equality<E> = Equality.defaultFor(), elementHashing: Hashing<E>? = null, elementOrder: Order<E>? = null): Boolean

iterator

inline operator fun <E> KoneIterator<E>.iterator(): KoneIterator<E>

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

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

fun <E, A : Appendable> KoneSequence<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

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

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

last

fun <E> KoneList<E>.last(): E

lastIndexOf

context(_: Equality<E>)
fun <E> KoneList<E>.lastIndexOf(element: E): UInt

lastIndexThat

inline fun <E> KoneList<E>.lastIndexThat(predicate: (index: UInt, element: E) -> Boolean): UInt

lastOfThat

inline fun <E, R> KoneList<E>.lastOfThat(transform: (E) -> R, predicate: (R) -> Boolean): R

lastOfThatIndexed

inline fun <E, R> KoneList<E>.lastOfThatIndexed(transform: (index: UInt, E) -> R, predicate: (R) -> Boolean): R

lastOfThatIndexedMaybe

inline fun <E, R> KoneList<E>.lastOfThatIndexedMaybe(transform: (index: UInt, E) -> R, predicate: (R) -> Boolean): Maybe<R>

lastOfThatIndexedOrNull

inline fun <E, R> KoneList<E>.lastOfThatIndexedOrNull(transform: (index: UInt, E) -> R, predicate: (R) -> Boolean): R?

lastOfThatMaybe

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

lastOfThatOrNull

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

lastThat

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

lastThatIndexed

inline fun <E> KoneList<E>.lastThatIndexed(predicate: (index: UInt, E) -> Boolean): E

lastThatIndexedMaybe

inline fun <E> KoneList<E>.lastThatIndexedMaybe(predicate: (index: UInt, E) -> Boolean): Maybe<E>

lastThatIndexedOrNull

inline fun <E> KoneList<E>.lastThatIndexedOrNull(predicate: (index: UInt, E) -> Boolean): E?

lastThatMaybe

inline fun <E> KoneList<E>.lastThatMaybe(predicate: (E) -> Boolean): Maybe<E>

lastThatOrNull

inline fun <E> KoneList<E>.lastThatOrNull(predicate: (E) -> Boolean): E?

map

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

fun <E, R> KoneIterator<E>.map(transform: (E) -> R): KoneIterator<R>

fun <E, R> KoneSequence<E>.map(transform: (E) -> R): KoneSequence<R>

mapIndexed

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

fun <E, R> KoneIterator<E>.mapIndexed(transform: (index: UInt, E) -> R): KoneIterator<R>

fun <E, R> KoneSequence<E>.mapIndexed(transform: (index: UInt, E) -> R): KoneSequence<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

@IgnorableReturnValue

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

@IgnorableReturnValue

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

@IgnorableReturnValue

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

@IgnorableReturnValue

inline fun <E, R, D : KoneMutableSet<in R>> KoneSequence<E>.mapIndexedTo(destination: D, 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

mapKeys

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

mapKeysReified

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

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

mapKeysTo

@IgnorableReturnValue

inline fun <K, V, L, D : KoneMutableMap<in L, V>> KoneMap<out K, V>.mapKeysTo(destination: D, transform: (KoneMapEntry<K, V>) -> L, resolve: (key: L, currentValue: V, newValue: V) -> V): D

mapReduce

inline fun <K, V, T : R, R> KoneMap<out K, V>.mapReduce(transform: (KoneMapEntry<K, V>) -> T, operation: (acc: R, T) -> R): R

mapReduceMaybe

inline fun <K, V, T : R, R> KoneMap<out K, V>.mapReduceMaybe(transform: (KoneMapEntry<K, V>) -> T, operation: (acc: R, T) -> R): Maybe<R>

mapReduceOrNull

inline fun <K, V, T : R, R> KoneMap<out K, V>.mapReduceOrNull(transform: (KoneMapEntry<K, V>) -> T, operation: (acc: R, T) -> R): R?

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

@IgnorableReturnValue

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

@IgnorableReturnValue

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

@IgnorableReturnValue

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

@IgnorableReturnValue

inline fun <E, R, D : KoneMutableSet<in R>> KoneSequence<E>.mapTo(destination: D, 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

mapValuesTo

@IgnorableReturnValue

inline fun <K, V, W, D : KoneMutableMap<in K, W>> KoneMap<out K, V>.mapValuesTo(destination: D, transform: (KoneMapEntry<K, V>) -> W, resolve: (key: K, currentValue: W, newValue: W) -> W): D

max

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

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

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

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

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

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

maxBy

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

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

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

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

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

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

maxByMaybe

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

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

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

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

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

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

maxByOrElse

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

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

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

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

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

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

maxByOrNull

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

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

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

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

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

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

maxIndex

fun <E : Comparable<E>> KoneIterator<E>.maxIndex(): UInt

fun <E : Comparable<E>> KoneList<E>.maxIndex(): UInt

fun <E : Comparable<E>> KoneSequence<E>.maxIndex(): UInt

context(_: Order<E>)
fun <E> KoneIterator<E>.maxIndex(): UInt

context(_: Order<E>)
fun <E> KoneList<E>.maxIndex(): UInt

context(_: Order<E>)
fun <E> KoneSequence<E>.maxIndex(): UInt

maxIndexBy

inline fun <E, R : Comparable<R>> KoneIterator<E>.maxIndexBy(selector: (E) -> R): UInt

inline fun <E, R : Comparable<R>> KoneList<E>.maxIndexBy(selector: (E) -> R): UInt

inline fun <E, R : Comparable<R>> KoneSequence<E>.maxIndexBy(selector: (E) -> R): UInt

context(_: Order<R>)
inline fun <E, R> KoneIterator<E>.maxIndexBy(selector: (E) -> R): UInt

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

context(_: Order<R>)
inline fun <E, R> KoneSequence<E>.maxIndexBy(selector: (E) -> R): UInt

maxIndexByOrElse

inline fun <E, R : Comparable<R>> KoneIterator<E>.maxIndexByOrElse(default: () -> UInt, selector: (E) -> R): UInt

inline fun <E, R : Comparable<R>> KoneList<E>.maxIndexByOrElse(default: () -> UInt, selector: (E) -> R): UInt

inline fun <E, R : Comparable<R>> KoneSequence<E>.maxIndexByOrElse(default: () -> UInt, selector: (E) -> R): UInt

context(_: Order<R>)
inline fun <E, R> KoneIterator<E>.maxIndexByOrElse(default: () -> UInt, selector: (E) -> R): UInt

context(_: Order<R>)
inline fun <E, R> KoneList<E>.maxIndexByOrElse(default: () -> UInt, selector: (E) -> R): UInt

context(_: Order<R>)
inline fun <E, R> KoneSequence<E>.maxIndexByOrElse(default: () -> UInt, selector: (E) -> R): UInt

maxIndexByOrNull

inline fun <E, R : Comparable<R>> KoneIterator<E>.maxIndexByOrNull(selector: (E) -> R): UInt?

inline fun <E, R : Comparable<R>> KoneList<E>.maxIndexByOrNull(selector: (E) -> R): UInt?

inline fun <E, R : Comparable<R>> KoneSequence<E>.maxIndexByOrNull(selector: (E) -> R): UInt?

context(_: Order<R>)
inline fun <E, R> KoneIterator<E>.maxIndexByOrNull(selector: (E) -> R): UInt?

context(_: Order<R>)
inline fun <E, R> KoneList<E>.maxIndexByOrNull(selector: (E) -> R): UInt?

context(_: Order<R>)
inline fun <E, R> KoneSequence<E>.maxIndexByOrNull(selector: (E) -> R): UInt?

maxIndexList

fun <E : Comparable<E>> KoneIterator<E>.maxIndexList(): KoneUIntArray

fun <E : Comparable<E>> KoneList<E>.maxIndexList(): KoneUIntArray

fun <E : Comparable<E>> KoneSequence<E>.maxIndexList(): KoneUIntArray

context(_: Order<E>)
fun <E> KoneIterator<E>.maxIndexList(): KoneUIntArray

context(_: Order<E>)
fun <E> KoneList<E>.maxIndexList(): KoneUIntArray

context(_: Order<E>)
fun <E> KoneSequence<E>.maxIndexList(): KoneUIntArray

maxIndexListBy

inline fun <E, R : Comparable<R>> KoneIterator<E>.maxIndexListBy(selector: (E) -> R): KoneUIntArray

inline fun <E, R : Comparable<R>> KoneList<E>.maxIndexListBy(selector: (E) -> R): KoneUIntArray

inline fun <E, R : Comparable<R>> KoneSequence<E>.maxIndexListBy(selector: (E) -> R): KoneUIntArray

context(_: Order<R>)
inline fun <E, R> KoneIterator<E>.maxIndexListBy(selector: (E) -> R): KoneUIntArray

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

context(_: Order<R>)
inline fun <E, R> KoneSequence<E>.maxIndexListBy(selector: (E) -> R): KoneUIntArray

maxIndexListWith

fun <E> KoneIterator<E>.maxIndexListWith(comparator: Comparator<E>): KoneUIntArray

fun <E> KoneList<E>.maxIndexListWith(comparator: Comparator<E>): KoneUIntArray

fun <E> KoneSequence<E>.maxIndexListWith(comparator: Comparator<E>): KoneUIntArray

maxIndexListWithBy

inline fun <E, R> KoneIterator<E>.maxIndexListWithBy(comparator: Comparator<R>, selector: (E) -> R): KoneUIntArray

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

inline fun <E, R> KoneSequence<E>.maxIndexListWithBy(comparator: Comparator<R>, selector: (E) -> R): KoneUIntArray

maxIndexOrElse

inline fun <E : Comparable<E>> KoneIterator<E>.maxIndexOrElse(default: () -> UInt): UInt

inline fun <E : Comparable<E>> KoneList<E>.maxIndexOrElse(default: () -> UInt): UInt

inline fun <E : Comparable<E>> KoneSequence<E>.maxIndexOrElse(default: () -> UInt): UInt

context(_: Order<E>)
inline fun <E> KoneIterator<E>.maxIndexOrElse(default: () -> UInt): UInt

context(_: Order<E>)
inline fun <E> KoneList<E>.maxIndexOrElse(default: () -> UInt): UInt

context(_: Order<E>)
inline fun <E> KoneSequence<E>.maxIndexOrElse(default: () -> UInt): UInt

maxIndexOrNull

fun <E : Comparable<E>> KoneIterator<E>.maxIndexOrNull(): UInt?

fun <E : Comparable<E>> KoneList<E>.maxIndexOrNull(): UInt?

fun <E : Comparable<E>> KoneSequence<E>.maxIndexOrNull(): UInt?

context(_: Order<E>)
fun <E> KoneIterator<E>.maxIndexOrNull(): UInt?

context(_: Order<E>)
fun <E> KoneList<E>.maxIndexOrNull(): UInt?

context(_: Order<E>)
fun <E> KoneSequence<E>.maxIndexOrNull(): UInt?

maxIndexWith

fun <E> KoneIterator<E>.maxIndexWith(comparator: Comparator<E>): UInt

fun <E> KoneList<E>.maxIndexWith(comparator: Comparator<E>): UInt

fun <E> KoneSequence<E>.maxIndexWith(comparator: Comparator<E>): UInt

maxIndexWithBy

inline fun <E, R> KoneIterator<E>.maxIndexWithBy(comparator: Comparator<R>, selector: (E) -> R): UInt

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

inline fun <E, R> KoneSequence<E>.maxIndexWithBy(comparator: Comparator<R>, selector: (E) -> R): UInt

maxIndexWithByOrElse

inline fun <E, R> KoneIterator<E>.maxIndexWithByOrElse(comparator: Comparator<R>, default: () -> UInt, selector: (E) -> R): UInt

inline fun <E, R> KoneList<E>.maxIndexWithByOrElse(comparator: Comparator<R>, default: () -> UInt, selector: (E) -> R): UInt

inline fun <E, R> KoneSequence<E>.maxIndexWithByOrElse(comparator: Comparator<R>, default: () -> UInt, selector: (E) -> R): UInt

maxIndexWithByOrNull

inline fun <E, R> KoneIterator<E>.maxIndexWithByOrNull(comparator: Comparator<R>, selector: (E) -> R): UInt?

inline fun <E, R> KoneList<E>.maxIndexWithByOrNull(comparator: Comparator<R>, selector: (E) -> R): UInt?

inline fun <E, R> KoneSequence<E>.maxIndexWithByOrNull(comparator: Comparator<R>, selector: (E) -> R): UInt?

maxIndexWithOrElse

inline fun <E> KoneIterator<E>.maxIndexWithOrElse(comparator: Comparator<E>, default: () -> UInt): UInt

inline fun <E> KoneList<E>.maxIndexWithOrElse(comparator: Comparator<E>, default: () -> UInt): UInt

inline fun <E> KoneSequence<E>.maxIndexWithOrElse(comparator: Comparator<E>, default: () -> UInt): UInt

maxIndexWithOrNull

fun <E> KoneIterator<E>.maxIndexWithOrNull(comparator: Comparator<E>): UInt?

fun <E> KoneList<E>.maxIndexWithOrNull(comparator: Comparator<E>): UInt?

fun <E> KoneSequence<E>.maxIndexWithOrNull(comparator: Comparator<E>): UInt?

maxList

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

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

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

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

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

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

maxListBy

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

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

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

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

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

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

maxListOf

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

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

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

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

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

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

maxListWith

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

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

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

maxListWithBy

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

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

inline fun <E, R> KoneSequence<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>

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

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

maxMaybe

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

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

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

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

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

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

maxOf

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

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

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

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

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

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

maxOfMaybe

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

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

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

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

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

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

maxOfOrElse

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

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

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

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

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

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

maxOfOrNull

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

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

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

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

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

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

maxOrElse

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

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

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

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

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

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

maxOrNull

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

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

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

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

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

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

maxWith

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

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

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

maxWithBy

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

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

inline fun <E, R> KoneSequence<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>

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

inline fun <E, R> KoneSequence<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

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

inline fun <E, R> KoneSequence<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?

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

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

maxWithMaybe

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

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

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

maxWithOf

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

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

inline fun <E, R> KoneSequence<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>

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

inline fun <E, R> KoneSequence<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

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

inline fun <E, R> KoneSequence<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?

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

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

maxWithOrElse

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

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

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

maxWithOrNull

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

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

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

merge

fun <K, V1 : W, V2 : W, W> merge(map1: KoneMap<out K, V1>, map2: KoneMap<out K, V2>, keyEquality: Equality<K> = Equality.defaultFor(), keyHashing: Hashing<K>? = null, keyOrder: Order<K>? = null): KoneMap<K, W>

mergeBy

inline fun <K, V1 : W, V2 : W, W> mergeBy(map1: KoneMap<out K, V1>, map2: KoneMap<out K, V2>, keyEquality: Equality<K> = Equality.defaultFor(), keyHashing: Hashing<K>? = null, keyOrder: Order<K>? = null, resolve: (key: K, value1: V1, value2: V2) -> W): KoneMap<K, W>

mergeByReified

inline fun <K, V1 : W, V2 : W, W> mergeByReified(map1: KoneMap<out K, V1>, map2: KoneMap<out K, V2>, keyEquality: Equality<K> = Equality.defaultFor(), keyHashing: Hashing<K>? = null, keyOrder: Order<K>? = null, resolve: (key: K, value1: V1, value2: V2) -> W): KoneReifiedMap<K, W>

inline fun <K, V1 : W, V2 : W, W> mergeByReified(map1: KoneMap<out K, V1>, map2: KoneMap<out K, V2>, keyReification: Reification<K>, keyEquality: Equality<K> = Equality.defaultFor(), keyHashing: Hashing<K>? = null, keyOrder: Order<K>? = null, resolve: (key: K, value1: V1, value2: V2) -> W): KoneReifiedMap<K, W>

mergeReified

inline fun <K, V1 : W, V2 : W, W> mergeReified(map1: KoneMap<out K, V1>, map2: KoneMap<out K, V2>, keyEquality: Equality<K> = Equality.defaultFor(), keyHashing: Hashing<K>? = null, keyOrder: Order<K>? = null): KoneReifiedMap<K, W>

fun <K, V1 : W, V2 : W, W> mergeReified(map1: KoneMap<out K, V1>, map2: KoneMap<out K, V2>, keyReification: Reification<K>, keyEquality: Equality<K> = Equality.defaultFor(), keyHashing: Hashing<K>? = null, keyOrder: Order<K>? = null): KoneReifiedMap<K, W>

mergeTo

fun <K, V, D : KoneMutableMap<in K, in V>> mergeTo(map1: KoneMap<out K, V>, map2: KoneMap<out K, V>, destination: D): D

mergeToBy

inline fun <K, V1 : W, V2 : W, W, D : KoneMutableMap<K, W>> mergeToBy(map1: KoneMap<out K, V1>, map2: KoneMap<out K, V2>, destination: D, resolve: (key: K, value1: V1, value2: V2) -> W): D

mergingAll

inline fun <K, V1, V2> mergingAll(map1: KoneMap<K, V1>, map2: KoneMap<K, V2>, operation1: (KoneMapEntry<K, V1>) -> Boolean, operation2: (KoneMapEntry<K, V2>) -> Boolean, operationMerge: (key: K, value1: V1, value2: V2) -> Boolean): Boolean

mergingAny

inline fun <K, V1, V2> mergingAny(map1: KoneMap<K, V1>, map2: KoneMap<K, V2>, operation1: (KoneMapEntry<K, V1>) -> Boolean, operation2: (KoneMapEntry<K, V2>) -> Boolean, operationMerge: (key: K, value1: V1, value2: V2) -> Boolean): Boolean

mergingFold

inline fun <K, V1, V2, R> mergingFold(map1: KoneMap<K, V1>, map2: KoneMap<K, V2>, initial: R, operation1: (acc: R, KoneMapEntry<K, V1>) -> R, operation2: (acc: R, KoneMapEntry<K, V2>) -> R, operationMerge: (acc: R, key: K, value1: V1, value2: V2) -> R): R

mergingNone

inline fun <K, V1, V2> mergingNone(map1: KoneMap<K, V1>, map2: KoneMap<K, V2>, operation1: (KoneMapEntry<K, V1>) -> Boolean, operation2: (KoneMapEntry<K, V2>) -> Boolean, operationMerge: (key: K, value1: V1, value2: V2) -> Boolean): Boolean

min

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

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

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

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

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

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

minBy

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

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

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

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

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

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

minByMaybe

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

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

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

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

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

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

minByOrElse

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

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

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

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

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

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

minByOrNull

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

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

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

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

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

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

minIndex

fun <E : Comparable<E>> KoneIterator<E>.minIndex(): UInt

fun <E : Comparable<E>> KoneList<E>.minIndex(): UInt

fun <E : Comparable<E>> KoneSequence<E>.minIndex(): UInt

context(_: Order<E>)
fun <E> KoneIterator<E>.minIndex(): UInt

context(_: Order<E>)
fun <E> KoneList<E>.minIndex(): UInt

context(_: Order<E>)
fun <E> KoneSequence<E>.minIndex(): UInt

minIndexBy

inline fun <E, R : Comparable<R>> KoneIterator<E>.minIndexBy(selector: (E) -> R): UInt

inline fun <E, R : Comparable<R>> KoneList<E>.minIndexBy(selector: (E) -> R): UInt

inline fun <E, R : Comparable<R>> KoneSequence<E>.minIndexBy(selector: (E) -> R): UInt

context(_: Order<R>)
inline fun <E, R> KoneIterator<E>.minIndexBy(selector: (E) -> R): UInt

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

context(_: Order<R>)
inline fun <E, R> KoneSequence<E>.minIndexBy(selector: (E) -> R): UInt

minIndexByOrElse

inline fun <E, R : Comparable<R>> KoneIterator<E>.minIndexByOrElse(default: () -> UInt, selector: (E) -> R): UInt

inline fun <E, R : Comparable<R>> KoneList<E>.minIndexByOrElse(default: () -> UInt, selector: (E) -> R): UInt

inline fun <E, R : Comparable<R>> KoneSequence<E>.minIndexByOrElse(default: () -> UInt, selector: (E) -> R): UInt

context(_: Order<R>)
inline fun <E, R> KoneIterator<E>.minIndexByOrElse(default: () -> UInt, selector: (E) -> R): UInt

context(_: Order<R>)
inline fun <E, R> KoneList<E>.minIndexByOrElse(default: () -> UInt, selector: (E) -> R): UInt

context(_: Order<R>)
inline fun <E, R> KoneSequence<E>.minIndexByOrElse(default: () -> UInt, selector: (E) -> R): UInt

minIndexByOrNull

inline fun <E, R : Comparable<R>> KoneIterator<E>.minIndexByOrNull(selector: (E) -> R): UInt?

inline fun <E, R : Comparable<R>> KoneList<E>.minIndexByOrNull(selector: (E) -> R): UInt?

context(_: Order<R>)
inline fun <E, R> KoneIterator<E>.minIndexByOrNull(selector: (E) -> R): UInt?

context(_: Order<R>)
inline fun <E, R> KoneList<E>.minIndexByOrNull(selector: (E) -> R): UInt?

context(_: Order<R>)
inline fun <E, R> KoneSequence<E>.minIndexByOrNull(selector: (E) -> R): UInt?

minIndexList

fun <E : Comparable<E>> KoneIterator<E>.minIndexList(): KoneUIntArray

fun <E : Comparable<E>> KoneList<E>.minIndexList(): KoneUIntArray

fun <E : Comparable<E>> KoneSequence<E>.minIndexList(): KoneUIntArray

context(_: Order<E>)
fun <E> KoneIterator<E>.minIndexList(): KoneUIntArray

context(_: Order<E>)
fun <E> KoneList<E>.minIndexList(): KoneUIntArray

context(_: Order<E>)
fun <E> KoneSequence<E>.minIndexList(): KoneUIntArray

minIndexListBy

inline fun <E, R : Comparable<R>> KoneIterator<E>.minIndexListBy(selector: (E) -> R): KoneUIntArray

inline fun <E, R : Comparable<R>> KoneList<E>.minIndexListBy(selector: (E) -> R): KoneUIntArray

inline fun <E, R : Comparable<R>> KoneSequence<E>.minIndexListBy(selector: (E) -> R): KoneUIntArray

context(_: Order<R>)
inline fun <E, R> KoneIterator<E>.minIndexListBy(selector: (E) -> R): KoneUIntArray

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

context(_: Order<R>)
inline fun <E, R> KoneSequence<E>.minIndexListBy(selector: (E) -> R): KoneUIntArray

minIndexListWith

fun <E> KoneIterator<E>.minIndexListWith(comparator: Comparator<E>): KoneUIntArray

fun <E> KoneList<E>.minIndexListWith(comparator: Comparator<E>): KoneUIntArray

fun <E> KoneSequence<E>.minIndexListWith(comparator: Comparator<E>): KoneUIntArray

minIndexListWithBy

inline fun <E, R> KoneIterator<E>.minIndexListWithBy(comparator: Comparator<R>, selector: (E) -> R): KoneUIntArray

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

inline fun <E, R> KoneSequence<E>.minIndexListWithBy(comparator: Comparator<R>, selector: (E) -> R): KoneUIntArray

minIndexOrElse

inline fun <E : Comparable<E>> KoneIterator<E>.minIndexOrElse(default: () -> UInt): UInt

inline fun <E : Comparable<E>> KoneList<E>.minIndexOrElse(default: () -> UInt): UInt

inline fun <E : Comparable<E>> KoneSequence<E>.minIndexOrElse(default: () -> UInt): UInt

context(_: Order<E>)
inline fun <E> KoneIterator<E>.minIndexOrElse(default: () -> UInt): UInt

context(_: Order<E>)
inline fun <E> KoneList<E>.minIndexOrElse(default: () -> UInt): UInt

context(_: Order<E>)
inline fun <E> KoneSequence<E>.minIndexOrElse(default: () -> UInt): UInt

minIndexOrNull

fun <E : Comparable<E>> KoneIterator<E>.minIndexOrNull(): UInt?

fun <E : Comparable<E>> KoneList<E>.minIndexOrNull(): UInt?

fun <E : Comparable<E>> KoneSequence<E>.minIndexOrNull(): UInt?

context(_: Order<E>)
fun <E> KoneIterator<E>.minIndexOrNull(): UInt?

context(_: Order<E>)
fun <E> KoneList<E>.minIndexOrNull(): UInt?

context(_: Order<E>)
fun <E> KoneSequence<E>.minIndexOrNull(): UInt?

minIndexWith

fun <E> KoneIterator<E>.minIndexWith(comparator: Comparator<E>): UInt

fun <E> KoneList<E>.minIndexWith(comparator: Comparator<E>): UInt

fun <E> KoneSequence<E>.minIndexWith(comparator: Comparator<E>): UInt

minIndexWithBy

inline fun <E, R> KoneIterator<E>.minIndexWithBy(comparator: Comparator<R>, selector: (E) -> R): UInt

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

inline fun <E, R> KoneSequence<E>.minIndexWithBy(comparator: Comparator<R>, selector: (E) -> R): UInt

minIndexWithByOrElse

inline fun <E, R> KoneIterator<E>.minIndexWithByOrElse(comparator: Comparator<R>, default: () -> UInt, selector: (E) -> R): UInt

inline fun <E, R> KoneList<E>.minIndexWithByOrElse(comparator: Comparator<R>, default: () -> UInt, selector: (E) -> R): UInt

inline fun <E, R> KoneSequence<E>.minIndexWithByOrElse(comparator: Comparator<R>, default: () -> UInt, selector: (E) -> R): UInt

minIndexWithByOrNull

inline fun <E, R> KoneIterator<E>.minIndexWithByOrNull(comparator: Comparator<R>, selector: (E) -> R): UInt?

inline fun <E, R> KoneList<E>.minIndexWithByOrNull(comparator: Comparator<R>, selector: (E) -> R): UInt?

inline fun <E, R> KoneSequence<E>.minIndexWithByOrNull(comparator: Comparator<R>, selector: (E) -> R): UInt?

minIndexWithOrElse

inline fun <E> KoneIterator<E>.minIndexWithOrElse(comparator: Comparator<E>, default: () -> UInt): UInt

inline fun <E> KoneList<E>.minIndexWithOrElse(comparator: Comparator<E>, default: () -> UInt): UInt

inline fun <E> KoneSequence<E>.minIndexWithOrElse(comparator: Comparator<E>, default: () -> UInt): UInt

minIndexWithOrNull

fun <E> KoneIterator<E>.minIndexWithOrNull(comparator: Comparator<E>): UInt?

fun <E> KoneList<E>.minIndexWithOrNull(comparator: Comparator<E>): UInt?

fun <E> KoneSequence<E>.minIndexWithOrNull(comparator: Comparator<E>): UInt?

minIndexyOrNull

inline fun <E, R : Comparable<R>> KoneSequence<E>.minIndexyOrNull(selector: (E) -> R): UInt?

minList

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

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

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

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

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

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

minListBy

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

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

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

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

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

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

minListOf

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

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

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

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

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

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

minListWith

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

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

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

minListWithBy

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

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

inline fun <E, R> KoneSequence<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>

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

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

minMaybe

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

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

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

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

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

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

minOf

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

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

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

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

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

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

minOfMaybe

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

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

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

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

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

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

minOfOrElse

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

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

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

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

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

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

minOfOrNull

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

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

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

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

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

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

minOrElse

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

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

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

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

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

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

minOrNull

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

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

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

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

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

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

minusAssign

operator fun <E> KoneMutableSet<E>.minusAssign(element: E)

operator fun <E> KoneMutableSet<E>.minusAssign(elements: KoneIterable<E>)

operator fun <E> KoneMutableSet<E>.minusAssign(elements: KoneIterator<E>)

operator fun <E> KoneMutableSet<E>.minusAssign(elements: KoneSequence<E>)

minWith

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

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

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

minWithBy

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

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

inline fun <E, R> KoneSequence<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>

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

inline fun <E, R> KoneSequence<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

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

inline fun <E, R> KoneSequence<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?

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

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

minWithMaybe

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

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

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

minWithOf

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

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

inline fun <E, R> KoneSequence<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>

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

inline fun <E, R> KoneSequence<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

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

inline fun <E, R> KoneSequence<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?

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

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

minWithOrElse

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

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

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

minWithOrNull

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

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

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

none

fun KoneIterable<Boolean>.none(): Boolean

fun KoneIterator<Boolean>.none(): Boolean

fun KoneSequence<Boolean>.none(): Boolean

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

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

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

noneIndexed

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

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

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

plusAssign

operator fun <E> KoneMutableList<E>.plusAssign(element: E)

operator fun <E> KoneMutableList<E>.plusAssign(elements: KoneIterable<E>)

operator fun <E> KoneMutableList<E>.plusAssign(elements: KoneIterator<E>)

operator fun <E> KoneMutableList<E>.plusAssign(elements: KoneSequence<E>)

operator fun <E> KoneMutableSet<E>.plusAssign(element: E)

operator fun <E> KoneMutableSet<E>.plusAssign(elements: KoneIterable<E>)

operator fun <E> KoneMutableSet<E>.plusAssign(elements: KoneIterator<E>)

operator fun <E> KoneMutableSet<E>.plusAssign(elements: KoneSequence<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

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

inline fun <E : R, R> KoneSequence<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

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

inline fun <E : R, R> KoneSequence<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>

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

inline fun <E : R, R> KoneSequence<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?

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

inline fun <E : R, R> KoneSequence<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>

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

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

reduceOrNull

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

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

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

reverse

fun <E> KoneSettableList<E>.reverse()

reversed

fun <E> KoneExtendableLinearIterator<E>.reversed(): KoneExtendableLinearIterator<E>

fun <E> KoneLinearIterator<E>.reversed(): KoneLinearIterator<E>

fun <E> KoneMutableLinearIterator<E>.reversed(): KoneMutableLinearIterator<E>

fun <E> KoneRemovableLinearIterator<E>.reversed(): KoneRemovableLinearIterator<E>

fun <E> KoneReversibleExtendableIterator<E>.reversed(): KoneReversibleExtendableIterator<E>

fun <E> KoneReversibleIterator<E>.reversed(): KoneReversibleIterator<E>

fun <E> KoneReversibleMutableIterator<E>.reversed(): KoneReversibleMutableIterator<E>

fun <E> KoneReversibleRemovableIterator<E>.reversed(): KoneReversibleRemovableIterator<E>

fun <E> KoneReversibleSettableIterator<E>.reversed(): KoneReversibleSettableIterator<E>

fun <E> KoneSettableLinearIterator<E>.reversed(): KoneSettableLinearIterator<E>

fun <E> KoneList<E>.reversed(): KoneList<E>

runningFold

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

fun <E, R> KoneIterator<E>.runningFold(initial: R, operation: (acc: R, E) -> R): KoneIterator<R>

fun <E, R> KoneSequence<E>.runningFold(initial: R, operation: (acc: R, E) -> R): KoneSequence<R>

runningFoldIndexed

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

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

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

setOrChange

@IgnorableReturnValue

inline fun <K, V> KoneMutableMap<K, V>.setOrChange(key: K, valueOnSet: () -> V, transformOnChange: (currentValue: V) -> V): V

shuffle

fun <E> KoneSettableList<E>.shuffle(random: Random = Random)

shuffled

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

single

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

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

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

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

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

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

slice

fun <E> KoneList<E>.slice(fromIndex: UInt, untilIndex: UInt): KoneList<E>

sort

fun <E : Comparable<E>> KoneSettableList<E>.sort()

context(_: Order<E>)
fun <E> KoneSettableList<E>.sort()

sortBy

inline fun <E, R : Comparable<R>> KoneSettableList<E>.sortBy(selector: (E) -> R)

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

sortByDescending

inline fun <E, R : Comparable<R>> KoneSettableList<E>.sortByDescending(selector: (E) -> R)

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

sortDescending

fun <E : Comparable<E>> KoneSettableList<E>.sortDescending()

context(_: Order<E>)
fun <E> KoneSettableList<E>.sortDescending()

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>

sortWith

fun <E> KoneSettableList<E>.sortWith(comparator: Comparator<E>)

sortWithBy

inline fun <E, R> KoneSettableList<E>.sortWithBy(comparator: Comparator<R>, selector: (E) -> R)

sortWithByDescending

inline fun <E, R> KoneSettableList<E>.sortWithByDescending(comparator: Comparator<R>, selector: (E) -> R)

sortWithDescending

fun <E> KoneSettableList<E>.sortWithDescending(comparator: Comparator<E>)

take

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

fun <E> KoneIterator<E>.take(n: UInt): KoneIterator<E>

fun <E> KoneSequence<E>.take(n: UInt): KoneSequence<E>

takeLast

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

fun <E> KoneIterator<E>.takeLast(n: UInt): KoneIterator<E>

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

fun <E> KoneSequence<E>.takeLast(n: UInt): KoneSequence<E>

windowed

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

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

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

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

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

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

withChanged

inline fun <K, V> KoneMap<K, V>.withChanged(key: K, keyEquality: Equality<K> = Equality.defaultFor(), keyHashing: Hashing<K>? = null, keyOrder: Order<K>? = null, transform: (currentValue: V) -> V): KoneMap<K, V>

withChangedReified

inline fun <K, V> KoneMap<K, V>.withChangedReified(key: K, keyEquality: Equality<K> = Equality.defaultFor(), keyHashing: Hashing<K>? = null, keyOrder: Order<K>? = null, transform: (currentValue: V) -> V): KoneReifiedMap<K, V>

inline fun <K, V> KoneMap<K, V>.withChangedReified(key: K, keyReification: Reification<K>, keyEquality: Equality<K> = Equality.defaultFor(), keyHashing: Hashing<K>? = null, keyOrder: Order<K>? = null, transform: (currentValue: V) -> V): KoneReifiedMap<K, V>

withEach

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

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

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

withEachIndexed

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

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

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

withIndex

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

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

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

withSetOrChanged

inline fun <K, V> KoneMap<out K, V>.withSetOrChanged(key: K, keyEquality: Equality<K> = Equality.defaultFor(), keyHashing: Hashing<K>? = null, keyOrder: Order<K>? = null, valueOnSet: () -> V, transformOnChange: (currentValue: V) -> V): KoneMap<K, V>

withSetOrChangedReified

inline fun <K, V> KoneMap<out K, V>.withSetOrChangedReified(key: K, keyEquality: Equality<K> = Equality.defaultFor(), keyHashing: Hashing<K>? = null, keyOrder: Order<K>? = null, valueOnSet: () -> V, transformOnChange: (currentValue: V) -> V): KoneReifiedMap<K, V>

inline fun <K, V> KoneMap<out K, V>.withSetOrChangedReified(key: K, keyReification: Reification<K>, keyEquality: Equality<K> = Equality.defaultFor(), keyHashing: Hashing<K>? = null, keyOrder: Order<K>? = null, valueOnSet: () -> V, transformOnChange: (currentValue: V) -> V): KoneReifiedMap<K, V>