Adds provided number of elements at the end of the ordered collection. ith new element is a result of builder(i). The builder is consecutively called on indices from 0 to number exclusive.

addSeveralAt

open fun addSeveralAt(index: UInt, number: UInt, builder: (index: UInt) -> Element)

Adds provided number of elements before element with index index. ith new element is a result of builder(i). The builder is consecutively called on indices from 0 to number exclusive.

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

asKotlin

fun <Element> KoneIterable<Element>.asKotlin(): Collection<Element>

associate

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

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 <Element, Key> KoneIterable<Element>.associateBy(keyEquality: Equality<Key> = defaultEquality(), keyHashing: Hashing<Key>? = null, keyOrder: Order<Key>? = null, keySelector: (Element) -> Key): KoneMap<Key, Element>

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

inline fun <T, K> KoneIterable<T>.associateBy(keyEquality: Equality<K> = 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 <Element, Key> KoneIterable<Element>.associateByReified(keyEquality: Equality<Key> = defaultEquality(), keyHashing: Hashing<Key>? = null, keyOrder: Order<Key>? = null, keySelector: (Element) -> Key): KoneReifiedMap<Key, Element>

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

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

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

inline fun <T, K> KoneIterable<T>.associateByReified(keyEquality: Equality<K> = 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 <Element, Key, Destination : KoneMutableMap<in Key, in Element>> KoneIterable<Element>.associateByTo(destination: Destination, keySelector: (Element) -> Key): Destination

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

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

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

associateReified

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

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

inline fun <T, K, V> KoneIterable<T>.associateReified(keyEquality: Equality<K> = 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 <Element, Key, Value, Destination : KoneMutableMap<in Key, in Value>> KoneIterable<Element>.associateTo(destination: Destination, transform: (Element) -> KoneMapEntry<Key, Value>): Destination

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

associateWith

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

associateWithReified

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

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

associateWithTo

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

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

contains

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

containsAllFrom

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

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

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>

ensureCapacity

abstract fun ensureCapacity(minimalCapacity: UInt)

Increases inner structure's capacity so that it can hold minimalCapacity number of elements without reinitialization of the capacity.

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

foldIndexed

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

get

abstract operator fun get(index: UInt): Element

Returns element that is placed at the provided index.

getMaybe

fun <Element> KoneList<Element>.getMaybe(index: UInt): Maybe<Element>

Returns the element at the provided index wrapped in Some or None if index is out of bounds.

getOrElse

fun <Element> KoneList<Element>.getOrElse(index: UInt, block: () -> Element): Element

getOrNull

fun <Element> KoneList<Element>.getOrNull(index: UInt): Element?

Returns the element at the provided index or null if index is out of bounds.

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

heapsort

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

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

heapsortBy

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

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

heapsortByDescending

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

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

heapsortDescending

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

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

heapsorted

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

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

heapsortedBy

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

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

heapsortedByDescending

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

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

heapsortedDescending

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

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

heapsortedWith

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

heapsortedWithBy

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

heapsortedWithByDescending

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

heapsortedWithDescending

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

heapsortWith

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

heapsortWithBy

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

heapsortWithByDescending

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

heapsortWithDescending

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

isEmpty

fun <Element> KoneIterable<Element>.isEmpty(): Boolean

Checks if the iterable is empty.

isNotEmpty

fun <Element> KoneIterable<Element>.isNotEmpty(): Boolean

Checks if the iterable is not empty.

iterator

open operator override fun iterator(): KoneMutableListIterator<Element>

Initiates a mutable iterator over the collection's elements with pointer before the first element.

iteratorFrom

abstract override fun iteratorFrom(index: UInt): KoneMutableListIterator<Element>

Initiates a mutable iterator over the collection's elements with pointer between elements with indices index - 1 and index correspondingly.

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

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

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

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

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

quicksort

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

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

quicksortBy

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

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

quicksortByDescending

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

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

quicksortDescending

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

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

quicksorted

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

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

quicksortedBy

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

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

quicksortedByDescending

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

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

quicksortedDescending

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

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

quicksortedWith

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

quicksortedWithBy

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

quicksortedWithByDescending

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

quicksortedWithDescending

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

quicksortWith

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

quicksortWithBy

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

quicksortWithByDescending

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

quicksortWithDescending

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

random

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

reduce

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

reduceIndexed

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

reduceIndexedMaybe

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

reduceIndexedOrNull

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

reduceMaybe

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

reduceOrNull

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

remove

fun <Element> KoneMutableList<Element>.remove(element: Element)

removeAll

abstract fun removeAll()

Removes all elements and their places from the collection.

removeAllThat

open fun removeAllThat(predicate: (element: Element) -> Boolean)

Removes elements that satisfy the provided predicate.

removeAllThatIndexed

abstract fun removeAllThatIndexed(predicate: (index: UInt, element: Element) -> Boolean)

Removes elements that satisfy the provided predicate.

removeAt

abstract fun removeAt(index: UInt)

Removes element with the provided index.

retainAllThat

inline fun <Element> KoneMutableList<Element>.retainAllThat(crossinline predicate: (element: Element) -> Boolean)

Iterates over the collection and retains only the elements matching the predicate.

retainAllThatIndexed

inline fun <Element> KoneMutableList<Element>.retainAllThatIndexed(crossinline predicate: (index: UInt, element: Element) -> Boolean)

Iterates over the collection and retains only the elements matching the predicate.

reverse

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

reversed

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

runningFold

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

runningFoldIndexed

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

set

abstract operator fun set(index: UInt, element: Element)

Sets another value at the place with the provided index with respect to inner order of elements.

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>

toKoneArray

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

toKoneByteArray

fun KoneIterable<Byte>.toKoneByteArray(): KoneByteArray

toKoneContextualMutableReifiedSet

fun <Element> KoneIterable<Element>.toKoneContextualMutableReifiedSet(elementType: SuppliedType<Element>): KoneMutableReifiedSet<Element>

toKoneContextualMutableSet

fun <Element> KoneIterable<Element>.toKoneContextualMutableSet(elementType: SuppliedType<Element>): KoneMutableSet<Element>

toKoneContextualReifiedSet

fun <Element> KoneIterable<Element>.toKoneContextualReifiedSet(elementType: SuppliedType<Element>): KoneReifiedSet<Element>

toKoneContextualSet

fun <Element> KoneIterable<Element>.toKoneContextualSet(elementType: SuppliedType<Element>): KoneSet<Element>

toKoneDoubleArray

fun KoneIterable<Double>.toKoneDoubleArray(): KoneDoubleArray

toKoneFloatArray

fun KoneIterable<Float>.toKoneFloatArray(): KoneFloatArray

toKoneIntArray

fun KoneIterable<Int>.toKoneIntArray(): KoneIntArray

toKoneList

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

toKoneLongArray

fun KoneIterable<Long>.toKoneLongArray(): KoneLongArray

toKoneMutableArray

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

toKoneMutableByteArray

fun KoneIterable<Byte>.toKoneMutableByteArray(): KoneMutableByteArray

toKoneMutableDoubleArray

fun KoneIterable<Double>.toKoneMutableDoubleArray(): KoneMutableDoubleArray

toKoneMutableFloatArray

fun KoneIterable<Float>.toKoneMutableFloatArray(): KoneMutableFloatArray

toKoneMutableIntArray

fun KoneIterable<Int>.toKoneMutableIntArray(): KoneMutableIntArray

toKoneMutableList

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

toKoneMutableLongArray

fun KoneIterable<Long>.toKoneMutableLongArray(): KoneMutableLongArray

toKoneMutableReifiedSet

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

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

toKoneMutableSet

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

toKoneMutableShortArray

fun KoneIterable<Short>.toKoneMutableShortArray(): KoneMutableShortArray

toKoneMutableUByteArray

fun KoneIterable<UByte>.toKoneMutableUByteArray(): KoneMutableUByteArray

toKoneMutableUIntArray

fun KoneIterable<UInt>.toKoneMutableUIntArray(): KoneMutableUIntArray

toKoneMutableULongArray

fun KoneIterable<ULong>.toKoneMutableULongArray(): KoneMutableULongArray

toKoneMutableUShortArray

fun KoneIterable<UShort>.toKoneMutableUShortArray(): KoneMutableUShortArray

toKoneReifiedSet

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

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

toKoneSet

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

toKoneSettableList

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

toKoneShortArray

fun KoneIterable<Short>.toKoneShortArray(): KoneShortArray

toKoneUByteArray

fun KoneIterable<UByte>.toKoneUByteArray(): KoneUByteArray

toKoneUIntArray

fun KoneIterable<UInt>.toKoneUIntArray(): KoneUIntArray

toKoneULongArray

fun KoneIterable<ULong>.toKoneULongArray(): KoneULongArray

toKoneUShortArray

fun KoneIterable<UShort>.toKoneUShortArray(): KoneUShortArray

toList

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

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