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

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

allIndexed

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

any

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

anyIndexed

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

associate

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

associateBy

inline fun <T, K> KoneIterable<T>.associateBy(keyEquality: Equality<K> = defaultEquality(), 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> = defaultEquality(), 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> = defaultEquality(), 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> = defaultEquality(), 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> = defaultEquality(), 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> = defaultEquality(), 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> = defaultEquality(), keyHashing: Hashing<K>? = null, keyOrder: Order<K>? = null, transform: (T) -> Pair<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> = defaultEquality(), keyHashing: Hashing<K>? = null, keyOrder: Order<K>? = null, transform: (T) -> Pair<K, V>, resolve: (key: K, currentValue: V, newValue: V) -> V): KoneReifiedMap<K, V>

associateTo

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

change

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

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

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

copyMapToBy

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

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

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

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

copyToBy

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

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>

fun <E> KoneList<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

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

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

first

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

firstIndexOf

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

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>

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

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>

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

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

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

flatMapTo

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

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

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

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

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)

forEachIndexed

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

groupBy

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

groupByTo

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

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

groupContextualBy

inline fun <E, K> KoneIterable<E>.groupContextualBy(keyType: SuppliedType<K>, keySelector: (E) -> K): KoneMap<K, KoneList<E>>

inline fun <E, K, V> KoneIterable<E>.groupContextualBy(keyType: SuppliedType<K>, keySelector: (E) -> K, valueTransform: (E) -> V): KoneMap<K, KoneList<V>>

hasDuplicates

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

hasDuplicatesContextual

fun <E> KoneIterable<E>.hasDuplicatesContextual(elementType: SuppliedType<E>): 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

joinToString

fun <E> KoneIterable<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

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>

mapIndexed

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

mapIndexedTo

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

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

mapKeys

inline fun <K, V, L> KoneMap<out K, V>.mapKeys(keyEquality: Equality<L> = defaultEquality(), 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> = defaultEquality(), 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> = defaultEquality(), 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

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

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

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

mapValuesTo

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> KoneIterable<E>.max(): E

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

maxBy

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

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

maxList

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

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

maxListBy

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

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

maxListOf

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

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

maxListWith

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

maxListWithBy

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

maxListWithOf

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

maxOf

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

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

maxOfOrNull

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

maxWith

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

maxWithBy

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

maxWithOf

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

merge

fun <K, V1 : W, V2 : W, W> merge(map1: KoneMap<out K, V1>, map2: KoneMap<out K, V2>, keyEquality: Equality<K> = defaultEquality(), 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> = defaultEquality(), 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> = defaultEquality(), 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> = defaultEquality(), 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> = defaultEquality(), 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> = defaultEquality(), 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> KoneIterable<E>.min(): E

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

minBy

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

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

minList

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

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

minListBy

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

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

minListOf

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

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

minListWith

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

minListWithBy

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

minListWithOf

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

minOf

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

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

minWith

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

minWithBy

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

minWithOf

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

none

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

plusAssign

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

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

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

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

product

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

productOf

fun <E, N> KoneIterable<E>.productOf(selector: (E) -> N): N

productOfIndexed

inline fun <E, N> KoneIterable<E>.productOfIndexed(selector: (index: UInt, E) -> N): N

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

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

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>

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?

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>

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?

reverse

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

reversed

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

fun <E> KoneIterable<E>.reversed(): KoneList<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>

runningFold

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

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

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

setOrChange

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

slice

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

sort

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

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

sortBy

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

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

sortByDescending

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

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

sortDescending

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

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

sorted

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

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

sortedBy

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

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

sortedByDescending

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

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

sortedDescending

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

fun <E : Comparable<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>)

sum

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

sumOf

fun <E, N> KoneIterable<E>.sumOf(selector: (E) -> N): N

sumOfIndexed

inline fun <E, N> KoneIterable<E>.sumOfIndexed(selector: (index: UInt, E) -> N): N

take

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

takeLast

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

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

withChanged

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

withChangedContextual

inline fun <K, V> KoneMap<K, V>.withChangedContextual(key: K, keyType: SuppliedType<K>, transform: (currentValue: V) -> V): KoneMap<K, V>

withChangedContextualReified

inline fun <K, V> KoneMap<K, V>.withChangedContextualReified(key: K, keyType: SuppliedType<K>, transform: (currentValue: V) -> V): KoneReifiedMap<K, V>

withChangedReified

inline fun <K, V> KoneMap<K, V>.withChangedReified(key: K, keyEquality: Equality<K> = defaultEquality(), 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> = defaultEquality(), 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)

withEachIndexed

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

withIndex

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

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

withSetOrChanged

inline fun <K, V> KoneMap<out K, V>.withSetOrChanged(key: K, keyEquality: Equality<K> = defaultEquality(), 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> = defaultEquality(), 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> = defaultEquality(), keyHashing: Hashing<K>? = null, keyOrder: Order<K>? = null, valueOnSet: () -> V, transformOnChange: (currentValue: V) -> V): KoneReifiedMap<K, V>