kone.collections/dev.lounres.kone.collections.list.implementations/KoneArraySettableList

KoneArraySettableList

@Serializable(with = KoneArraySettableListSerializer::class)
@JvmInline
value class KoneArraySettableList<Element> : KoneSettableList<Element> (source)

Represents a usual (settable) array of elements of type Element.

Implementation details

This implementation just holds an array (of fixed size) and proxies all operations straight to KoneMutableArray. The only difference between it and KoneMutableArray is that the last one must have reified type parameter while the first one must not.

Time complexity of operations

OperationWorst caseAverage
size\(\Theta(1)\)\(\Theta(1)\)
get\(\Theta(1)\)\(\Theta(1)\)
set\(\Theta(1)\)\(\Theta(1)\)
iterator\(\Theta(1)\)\(\Theta(1)\)
iteratorFrom\(\Theta(1)\)\(\Theta(1)\)
iterator.hasNext\(\Theta(1)\)\(\Theta(1)\)
iterator.hasPrevious\(\Theta(1)\)\(\Theta(1)\)
iterator.getNext\(\Theta(1)\)\(\Theta(1)\)
iterator.getPrevious\(\Theta(1)\)\(\Theta(1)\)
iterator.moveNext\(\Theta(1)\)\(\Theta(1)\)
iterator.movePrevious\(\Theta(1)\)\(\Theta(1)\)
iterator.setNext\(\Theta(1)\)\(\Theta(1)\)
iterator.setPrevious\(\Theta(1)\)\(\Theta(1)\)
iterator.nextIndex\(\Theta(1)\)\(\Theta(1)\)
iterator.previousIndex\(\Theta(1)\)\(\Theta(1)\)

Properties

Link copied to clipboard
val KoneList<*>.indices: UIntRange

Returns the list's indices range.

Link copied to clipboard
val KoneList<*>.lastIndex: UInt

Returns the last index of elements in the list.

Link copied to clipboard
open override val size: UInt

Number of elements in the collection.

Functions

Link copied to clipboard
fun KoneIterable<Boolean>.all(): Boolean
inline fun <E> KoneIterable<E>.all(block: (value: E) -> Boolean): Boolean
Link copied to clipboard
inline fun <E> KoneIterable<E>.allIndexed(block: (index: UInt, value: E) -> Boolean): Boolean
Link copied to clipboard
fun KoneIterable<Boolean>.any(): Boolean
inline fun <E> KoneIterable<E>.any(block: (value: E) -> Boolean): Boolean
Link copied to clipboard
inline fun <E> KoneIterable<E>.anyIndexed(block: (index: UInt, value: E) -> Boolean): Boolean
Link copied to clipboard
fun <Element> KoneIterable<Element>.asKoneSequence(): KoneSequence<Element>

Converts this KoneIterable to a KoneSequence by returning this iterable's iterators.

Link copied to clipboard
Link copied to clipboard
inline fun <Element, Key, Value> KoneIterable<Element>.associate(keyEquality: Equality<Key> = Equality.defaultFor(), 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> = 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>
Link copied to clipboard
inline fun <Element, Key> KoneIterable<Element>.associateBy(keyEquality: Equality<Key> = Equality.defaultFor(), keyHashing: Hashing<Key>? = null, keyOrder: Order<Key>? = null, keySelector: (Element) -> Key): KoneMap<Key, Element>
inline fun <Element, Key, Value> KoneIterable<Element>.associateBy(keyEquality: Equality<Key> = Equality.defaultFor(), keyHashing: Hashing<Key>? = null, keyOrder: Order<Key>? = null, keySelector: (Element) -> Key, valueTransform: (Element) -> Value): KoneMap<Key, Value>
inline fun <T, K> KoneIterable<T>.associateBy(keyEquality: Equality<K> = Equality.defaultFor(), keyHashing: Hashing<K>? = null, keyOrder: Order<K>? = null, keySelector: (T) -> K, resolve: (key: K, currentValue: T, newValue: T) -> T): KoneMap<K, T>
inline fun <T, K, V> KoneIterable<T>.associateBy(keyEquality: Equality<K> = Equality.defaultFor(), keyHashing: Hashing<K>? = null, keyOrder: Order<K>? = null, keySelector: (T) -> K, valueTransform: (T) -> V, resolve: (key: K, currentValue: V, newValue: V) -> V): KoneMap<K, V>
Link copied to clipboard
inline fun <Element, Key> KoneIterable<Element>.associateByReified(keyEquality: Equality<Key> = Equality.defaultFor(), keyHashing: Hashing<Key>? = null, keyOrder: Order<Key>? = null, keySelector: (Element) -> Key): KoneReifiedMap<Key, Element>
inline fun <Element, Key, Value> KoneIterable<Element>.associateByReified(keyEquality: Equality<Key> = Equality.defaultFor(), keyHashing: Hashing<Key>? = null, keyOrder: Order<Key>? = null, keySelector: (Element) -> Key, valueTransform: (Element) -> Value): KoneReifiedMap<Key, Value>
inline fun <Element, Key> KoneIterable<Element>.associateByReified(keyReification: Reification<Key>, keyEquality: Equality<Key> = Equality.defaultFor(), keyHashing: Hashing<Key>? = null, keyOrder: Order<Key>? = null, keySelector: (Element) -> Key): KoneReifiedMap<Key, Element>
inline fun <Element, Key, Value> KoneIterable<Element>.associateByReified(keyReification: Reification<Key>, keyEquality: Equality<Key> = Equality.defaultFor(), keyHashing: Hashing<Key>? = null, keyOrder: Order<Key>? = null, keySelector: (Element) -> Key, valueTransform: (Element) -> Value): KoneReifiedMap<Key, Value>
inline fun <T, K> KoneIterable<T>.associateByReified(keyEquality: Equality<K> = Equality.defaultFor(), keyHashing: Hashing<K>? = null, keyOrder: Order<K>? = null, keySelector: (T) -> K, resolve: (key: K, currentValue: T, newValue: T) -> T): KoneReifiedMap<K, T>
inline fun <T, K, V> KoneIterable<T>.associateByReified(keyEquality: Equality<K> = Equality.defaultFor(), keyHashing: Hashing<K>? = null, keyOrder: Order<K>? = null, keySelector: (T) -> K, valueTransform: (T) -> V, resolve: (key: K, currentValue: V, newValue: V) -> V): KoneReifiedMap<K, V>
inline fun <T, K> KoneIterable<T>.associateByReified(keyReification: Reification<K>, keyEquality: Equality<K> = Equality.defaultFor(), keyHashing: Hashing<K>? = null, keyOrder: Order<K>? = null, keySelector: (T) -> K, resolve: (key: K, currentValue: T, newValue: T) -> T): KoneReifiedMap<K, T>
inline fun <T, K, V> KoneIterable<T>.associateByReified(keyReification: Reification<K>, keyEquality: Equality<K> = Equality.defaultFor(), keyHashing: Hashing<K>? = null, keyOrder: Order<K>? = null, keySelector: (T) -> K, valueTransform: (T) -> V, resolve: (key: K, currentValue: V, newValue: V) -> V): KoneReifiedMap<K, V>
Link copied to clipboard
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
Link copied to clipboard
inline fun <Element, Key, Value> KoneIterable<Element>.associateReified(keyEquality: Equality<Key> = Equality.defaultFor(), keyHashing: Hashing<Key>? = null, keyOrder: Order<Key>? = null, transform: (Element) -> KoneMapEntry<Key, Value>): KoneReifiedMap<Key, Value>
inline fun <Element, Key, Value> KoneIterable<Element>.associateReified(keyReification: Reification<Key>, keyEquality: Equality<Key> = Equality.defaultFor(), keyHashing: Hashing<Key>? = null, keyOrder: Order<Key>? = null, transform: (Element) -> KoneMapEntry<Key, Value>): KoneReifiedMap<Key, Value>
inline fun <T, K, V> KoneIterable<T>.associateReified(keyEquality: Equality<K> = Equality.defaultFor(), keyHashing: Hashing<K>? = null, keyOrder: Order<K>? = null, transform: (T) -> KoneMapEntry<K, V>, resolve: (key: K, currentValue: V, newValue: V) -> V): KoneReifiedMap<K, V>
inline fun <T, K, V> KoneIterable<T>.associateReified(keyReification: Reification<K>, keyEquality: Equality<K> = Equality.defaultFor(), keyHashing: Hashing<K>? = null, keyOrder: Order<K>? = null, transform: (T) -> KoneMapEntry<K, V>, resolve: (key: K, currentValue: V, newValue: V) -> V): KoneReifiedMap<K, V>
Link copied to clipboard
inline fun <Element, Key, Value, Destination : KoneMutableMap<in Key, in Value>> KoneIterable<Element>.associateTo(destination: Destination, transform: (Element) -> KoneMapEntry<Key, Value>): Destination
@IgnorableReturnValue
inline fun <T, K, V, D : KoneMutableMap<K, V>> KoneIterable<T>.associateTo(destination: D, transform: (T) -> KoneMapEntry<K, V>, resolve: (key: K, currentValue: V, newValue: V) -> V): D
Link copied to clipboard
inline fun <Key, Value> KoneIterable<Key>.associateWith(keyEquality: Equality<Key> = Equality.defaultFor(), keyHashing: Hashing<Key>? = null, keyOrder: Order<Key>? = null, valueSelector: (Key) -> Value): KoneMap<Key, Value>
Link copied to clipboard
inline fun <Key, Value> KoneIterable<Key>.associateWithReified(keyEquality: Equality<Key> = Equality.defaultFor(), keyHashing: Hashing<Key>? = null, keyOrder: Order<Key>? = null, valueSelector: (Key) -> Value): KoneReifiedMap<Key, Value>
inline fun <Key, Value> KoneIterable<Key>.associateWithReified(keyReification: Reification<Key>, keyEquality: Equality<Key> = Equality.defaultFor(), keyHashing: Hashing<Key>? = null, keyOrder: Order<Key>? = null, valueSelector: (Key) -> Value): KoneReifiedMap<Key, Value>
Link copied to clipboard
inline fun <Key, Value, Destination : KoneMutableMap<in Key, in Value>> KoneIterable<Key>.associateWithTo(destination: Destination, valueSelector: (Key) -> Value): Destination
Link copied to clipboard
fun <E> KoneIterable<E>.chunked(size: UInt): KoneList<KoneList<E>>
fun <E, R> KoneIterable<E>.chunked(size: UInt, mapper: (chunk: KoneList<E>) -> R): KoneList<R>
Link copied to clipboard
operator fun <E> KoneList<E>.component1(): E
Link copied to clipboard
operator fun <E> KoneList<E>.component10(): E
Link copied to clipboard
operator fun <E> KoneList<E>.component11(): E
Link copied to clipboard
operator fun <E> KoneList<E>.component12(): E
Link copied to clipboard
operator fun <E> KoneList<E>.component13(): E
Link copied to clipboard
operator fun <E> KoneList<E>.component14(): E
Link copied to clipboard
operator fun <E> KoneList<E>.component15(): E
Link copied to clipboard
operator fun <E> KoneList<E>.component2(): E
Link copied to clipboard
operator fun <E> KoneList<E>.component3(): E
Link copied to clipboard
operator fun <E> KoneList<E>.component4(): E
Link copied to clipboard
operator fun <E> KoneList<E>.component5(): E
Link copied to clipboard
operator fun <E> KoneList<E>.component6(): E
Link copied to clipboard
operator fun <E> KoneList<E>.component7(): E
Link copied to clipboard
operator fun <E> KoneList<E>.component8(): E
Link copied to clipboard
operator fun <E> KoneList<E>.component9(): E
Link copied to clipboard
context(_: Equality<Element>)
operator fun <Element> KoneIterable<Element>.contains(element: Element): Boolean

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

Link copied to clipboard
context(_: Equality<Element>)
fun <Element> KoneIterable<Element>.containsAllFrom(elements: KoneIterable<Element>): Boolean

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

Link copied to clipboard
@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
Link copied to clipboard
fun KoneIterable<Boolean>.count(): UInt
inline fun <E> KoneIterable<E>.count(predicate: (value: E) -> Boolean): UInt
Link copied to clipboard
inline fun <E> KoneIterable<E>.countIndexed(predicate: (index: UInt, value: E) -> Boolean): UInt
Link copied to clipboard
fun <E> KoneIterable<E>.drop(n: UInt): KoneList<E>
fun <E> KoneList<E>.drop(n: UInt): KoneList<E>
Link copied to clipboard
Link copied to clipboard
inline fun <E> KoneIterable<E>.filter(predicate: (E) -> Boolean): KoneList<E>
Link copied to clipboard
@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
Link copied to clipboard
fun <E> KoneIterable<E>.first(): E
Link copied to clipboard
context(_: Equality<E>)
fun <E> KoneList<E>.firstIndexOf(element: E): UInt
Link copied to clipboard
inline fun <E> KoneList<E>.firstIndexThat(predicate: (index: UInt, element: E) -> Boolean): UInt
Link copied to clipboard
inline fun <E, R> KoneIterable<E>.firstOfThat(transform: (E) -> R, predicate: (R) -> Boolean): R
Link copied to clipboard
inline fun <E, R> KoneList<E>.firstOfThatIndexed(transform: (index: UInt, E) -> R, predicate: (R) -> Boolean): R
Link copied to clipboard
inline fun <E, R> KoneList<E>.firstOfThatIndexedMaybe(transform: (index: UInt, E) -> R, predicate: (R) -> Boolean): Maybe<R>
Link copied to clipboard
inline fun <E, R> KoneList<E>.firstOfThatIndexedOrNull(transform: (index: UInt, E) -> R, predicate: (R) -> Boolean): R?
Link copied to clipboard
inline fun <E, R> KoneIterable<E>.firstOfThatMaybe(transform: (E) -> R, predicate: (R) -> Boolean): Maybe<R>
Link copied to clipboard
inline fun <E, R> KoneIterable<E>.firstOfThatOrNull(transform: (E) -> R, predicate: (R) -> Boolean): R?
Link copied to clipboard
inline fun <E> KoneIterable<E>.firstThat(predicate: (E) -> Boolean): E
Link copied to clipboard
inline fun <E> KoneList<E>.firstThatIndexed(predicate: (index: UInt, E) -> Boolean): E
Link copied to clipboard
inline fun <E> KoneList<E>.firstThatIndexedMaybe(predicate: (index: UInt, E) -> Boolean): Maybe<E>
Link copied to clipboard
inline fun <E> KoneList<E>.firstThatIndexedOrNull(predicate: (index: UInt, E) -> Boolean): E?
Link copied to clipboard
inline fun <E> KoneIterable<E>.firstThatMaybe(predicate: (E) -> Boolean): Maybe<E>
Link copied to clipboard
inline fun <E> KoneIterable<E>.firstThatOrNull(predicate: (E) -> Boolean): E?
Link copied to clipboard
inline fun <E, R> KoneIterable<E>.flatMap(transform: (E) -> KoneIterable<R>): KoneList<R>
Link copied to clipboard
inline fun <E, R> KoneIterable<E>.flatMapIndexed(transform: (index: UInt, E) -> KoneIterable<R>): KoneList<R>
Link copied to clipboard
@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
Link copied to clipboard
@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
Link copied to clipboard
Link copied to clipboard
inline fun <E, R> KoneIterable<E>.fold(initial: R, operation: (acc: R, E) -> R): R
Link copied to clipboard
inline fun <E, R> KoneIterable<E>.foldIndexed(initial: R, operation: (index: UInt, acc: R, E) -> R): R
Link copied to clipboard
inline fun <E, R> KoneList<E>.foldRight(initial: R, operation: (acc: R, E) -> R): R
Link copied to clipboard
inline fun <E, R> KoneList<E>.foldRightIndexed(initial: R, operation: (index: UInt, acc: R, E) -> R): R
Link copied to clipboard
inline fun <E> KoneIterable<E>.forEach(block: (value: E) -> Unit)
Link copied to clipboard
inline fun <E> KoneIterable<E>.forEachIndexed(block: (index: UInt, value: E) -> Unit)
Link copied to clipboard
open operator override fun get(index: UInt): Element

Returns element that is placed at the provided index.

Link copied to clipboard
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.

Link copied to clipboard
fun <Element> KoneList<Element>.getOrElse(index: UInt, block: () -> Element): Element

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

Link copied to clipboard
fun <Element> KoneList<Element>.getOrNull(index: UInt): Element?

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

Link copied to clipboard
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>>
Link copied to clipboard
@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
Link copied to clipboard
fun <E : Comparable<E>> KoneSettableList<E>.heapsort()
context(order: Order<E>)
fun <E> KoneSettableList<E>.heapsort()
Link copied to clipboard
inline fun <E, R : Comparable<R>> KoneSettableList<E>.heapsortBy(selector: (E) -> R)
context(order: Order<R>)
inline fun <E, R> KoneSettableList<E>.heapsortBy(selector: (E) -> R)
Link copied to clipboard
inline fun <E, R : Comparable<R>> KoneSettableList<E>.heapsortByDescending(selector: (E) -> R)
context(order: Order<R>)
inline fun <E, R> KoneSettableList<E>.heapsortByDescending(selector: (E) -> R)
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
inline fun <E, R : Comparable<R>> KoneIterable<E>.heapsortedBy(selector: (E) -> R): KoneList<E>
context(_: Order<R>)
inline fun <E, R> KoneIterable<E>.heapsortedBy(selector: (E) -> R): KoneList<E>
Link copied to clipboard
inline fun <E, R : Comparable<R>> KoneIterable<E>.heapsortedByDescending(selector: (E) -> R): KoneList<E>
context(_: Order<R>)
inline fun <E, R> KoneIterable<E>.heapsortedByDescending(selector: (E) -> R): KoneList<E>
Link copied to clipboard
Link copied to clipboard
fun <E> KoneIterable<E>.heapsortedWith(comparator: Comparator<E>): KoneList<E>
Link copied to clipboard
inline fun <E, R> KoneIterable<E>.heapsortedWithBy(comparator: Comparator<R>, selector: (E) -> R): KoneList<E>
Link copied to clipboard
inline fun <E, R> KoneIterable<E>.heapsortedWithByDescending(comparator: Comparator<R>, selector: (E) -> R): KoneList<E>
Link copied to clipboard
Link copied to clipboard
fun <E> KoneSettableList<E>.heapsortWith(comparator: Comparator<E>)
Link copied to clipboard
inline fun <E, R> KoneSettableList<E>.heapsortWithBy(comparator: Comparator<R>, selector: (E) -> R)
Link copied to clipboard
inline fun <E, R> KoneSettableList<E>.heapsortWithByDescending(comparator: Comparator<R>, selector: (E) -> R)
Link copied to clipboard
Link copied to clipboard
open fun isEmpty(): Boolean

Checks if the iterable is empty.

Link copied to clipboard
fun KoneIterable<*>.isNotEmpty(): Boolean

Checks if the iterable is not empty.

Link copied to clipboard
open operator override fun iterator(): KoneSettableLinearIterator<Element>

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

Link copied to clipboard
open override fun iteratorFrom(index: UInt): KoneSettableLinearIterator<Element>

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

Link copied to clipboard
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
Link copied to clipboard
fun <E> KoneIterable<E>.joinToString(separator: CharSequence = ", ", prefix: CharSequence = "", postfix: CharSequence = "", limit: UInt = UInt.MAX_VALUE, truncated: CharSequence = "...", transform: (E) -> CharSequence? = null): String
Link copied to clipboard
fun <E> KoneList<E>.last(): E
Link copied to clipboard
context(_: Equality<E>)
fun <E> KoneList<E>.lastIndexOf(element: E): UInt
Link copied to clipboard
inline fun <E> KoneList<E>.lastIndexThat(predicate: (index: UInt, element: E) -> Boolean): UInt
Link copied to clipboard
inline fun <E, R> KoneList<E>.lastOfThat(transform: (E) -> R, predicate: (R) -> Boolean): R
Link copied to clipboard
inline fun <E, R> KoneList<E>.lastOfThatIndexed(transform: (index: UInt, E) -> R, predicate: (R) -> Boolean): R
Link copied to clipboard
inline fun <E, R> KoneList<E>.lastOfThatIndexedMaybe(transform: (index: UInt, E) -> R, predicate: (R) -> Boolean): Maybe<R>
Link copied to clipboard
inline fun <E, R> KoneList<E>.lastOfThatIndexedOrNull(transform: (index: UInt, E) -> R, predicate: (R) -> Boolean): R?
Link copied to clipboard
inline fun <E, R> KoneList<E>.lastOfThatMaybe(transform: (E) -> R, predicate: (R) -> Boolean): Maybe<R>
Link copied to clipboard
inline fun <E, R> KoneList<E>.lastOfThatOrNull(transform: (E) -> R, predicate: (R) -> Boolean): R?
Link copied to clipboard
inline fun <E> KoneList<E>.lastThat(predicate: (E) -> Boolean): E
Link copied to clipboard
inline fun <E> KoneList<E>.lastThatIndexed(predicate: (index: UInt, E) -> Boolean): E
Link copied to clipboard
inline fun <E> KoneList<E>.lastThatIndexedMaybe(predicate: (index: UInt, E) -> Boolean): Maybe<E>
Link copied to clipboard
inline fun <E> KoneList<E>.lastThatIndexedOrNull(predicate: (index: UInt, E) -> Boolean): E?
Link copied to clipboard
inline fun <E> KoneList<E>.lastThatMaybe(predicate: (E) -> Boolean): Maybe<E>
Link copied to clipboard
inline fun <E> KoneList<E>.lastThatOrNull(predicate: (E) -> Boolean): E?
Link copied to clipboard
inline fun <E, R> KoneIterable<E>.map(transform: (E) -> R): KoneList<R>
Link copied to clipboard
inline fun <E, R> KoneIterable<E>.mapIndexed(transform: (index: UInt, E) -> R): KoneList<R>
Link copied to clipboard
@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
Link copied to clipboard
@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
Link copied to clipboard
@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
Link copied to clipboard
@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
Link copied to clipboard
fun <E : Comparable<E>> KoneIterable<E>.max(): E
context(_: Order<E>)
fun <E> KoneIterable<E>.max(): E
Link copied to clipboard
inline fun <E, R : Comparable<R>> KoneIterable<E>.maxBy(selector: (E) -> R): E
context(_: Order<R>)
inline fun <E, R> KoneIterable<E>.maxBy(selector: (E) -> R): E
Link copied to clipboard
inline fun <E, R : Comparable<R>> KoneIterable<E>.maxByMaybe(selector: (E) -> R): Maybe<E>
context(_: Order<R>)
inline fun <E, R> KoneIterable<E>.maxByMaybe(selector: (E) -> R): Maybe<E>
Link copied to clipboard
inline fun <E, R : Comparable<R>> KoneIterable<E>.maxByOrElse(default: () -> E, selector: (E) -> R): E
context(_: Order<R>)
inline fun <E, R> KoneIterable<E>.maxByOrElse(default: () -> E, selector: (E) -> R): E
Link copied to clipboard
inline fun <E, R : Comparable<R>> KoneIterable<E>.maxByOrNull(selector: (E) -> R): E?
context(_: Order<R>)
inline fun <E, R> KoneIterable<E>.maxByOrNull(selector: (E) -> R): E?
Link copied to clipboard
fun <E : Comparable<E>> KoneList<E>.maxIndex(): UInt
context(_: Order<E>)
fun <E> KoneList<E>.maxIndex(): UInt
Link copied to clipboard
inline fun <E, R : Comparable<R>> KoneList<E>.maxIndexBy(selector: (E) -> R): UInt
context(_: Order<R>)
inline fun <E, R> KoneList<E>.maxIndexBy(selector: (E) -> R): UInt
Link copied to clipboard
inline fun <E, R : Comparable<R>> KoneList<E>.maxIndexByOrElse(default: () -> UInt, selector: (E) -> R): UInt
context(_: Order<R>)
inline fun <E, R> KoneList<E>.maxIndexByOrElse(default: () -> UInt, selector: (E) -> R): UInt
Link copied to clipboard
inline fun <E, R : Comparable<R>> KoneList<E>.maxIndexByOrNull(selector: (E) -> R): UInt?
context(_: Order<R>)
inline fun <E, R> KoneList<E>.maxIndexByOrNull(selector: (E) -> R): UInt?
Link copied to clipboard
Link copied to clipboard
inline fun <E, R : Comparable<R>> KoneList<E>.maxIndexListBy(selector: (E) -> R): KoneUIntArray
context(_: Order<R>)
inline fun <E, R> KoneList<E>.maxIndexListBy(selector: (E) -> R): KoneUIntArray
Link copied to clipboard
Link copied to clipboard
inline fun <E, R> KoneList<E>.maxIndexListWithBy(comparator: Comparator<R>, selector: (E) -> R): KoneUIntArray
Link copied to clipboard
inline fun <E : Comparable<E>> KoneList<E>.maxIndexOrElse(default: () -> UInt): UInt
context(_: Order<E>)
inline fun <E> KoneList<E>.maxIndexOrElse(default: () -> UInt): UInt
Link copied to clipboard
fun <E : Comparable<E>> KoneList<E>.maxIndexOrNull(): UInt?
context(_: Order<E>)
fun <E> KoneList<E>.maxIndexOrNull(): UInt?
Link copied to clipboard
fun <E> KoneList<E>.maxIndexWith(comparator: Comparator<E>): UInt
Link copied to clipboard
inline fun <E, R> KoneList<E>.maxIndexWithBy(comparator: Comparator<R>, selector: (E) -> R): UInt
Link copied to clipboard
inline fun <E, R> KoneList<E>.maxIndexWithByOrElse(comparator: Comparator<R>, default: () -> UInt, selector: (E) -> R): UInt
Link copied to clipboard
inline fun <E, R> KoneList<E>.maxIndexWithByOrNull(comparator: Comparator<R>, selector: (E) -> R): UInt?
Link copied to clipboard
inline fun <E> KoneList<E>.maxIndexWithOrElse(comparator: Comparator<E>, default: () -> UInt): UInt
Link copied to clipboard
fun <E> KoneList<E>.maxIndexWithOrNull(comparator: Comparator<E>): UInt?
Link copied to clipboard
fun <E : Comparable<E>> KoneIterable<E>.maxList(): KoneList<E>
context(_: Order<E>)
fun <E> KoneIterable<E>.maxList(): KoneList<E>
Link copied to clipboard
inline fun <E, R : Comparable<R>> KoneIterable<E>.maxListBy(selector: (E) -> R): KoneList<E>
context(_: Order<R>)
inline fun <E, R> KoneIterable<E>.maxListBy(selector: (E) -> R): KoneList<E>
Link copied to clipboard
inline fun <E, R : Comparable<R>> KoneIterable<E>.maxListOf(selector: (E) -> R): KoneList<R>
context(_: Order<R>)
inline fun <E, R> KoneIterable<E>.maxListOf(selector: (E) -> R): KoneList<R>
Link copied to clipboard
fun <E> KoneIterable<E>.maxListWith(comparator: Comparator<E>): KoneList<E>
Link copied to clipboard
inline fun <E, R> KoneIterable<E>.maxListWithBy(comparator: Comparator<R>, selector: (E) -> R): KoneList<E>
Link copied to clipboard
inline fun <E, R> KoneIterable<E>.maxListWithOf(comparator: Comparator<R>, selector: (E) -> R): KoneList<R>
Link copied to clipboard
fun <E : Comparable<E>> KoneIterable<E>.maxMaybe(): Maybe<E>
context(_: Order<E>)
fun <E> KoneIterable<E>.maxMaybe(): Maybe<E>
Link copied to clipboard
inline fun <E, R : Comparable<R>> KoneIterable<E>.maxOf(selector: (E) -> R): R
context(_: Order<R>)
inline fun <E, R> KoneIterable<E>.maxOf(selector: (E) -> R): R
Link copied to clipboard
inline fun <E, R : Comparable<R>> KoneIterable<E>.maxOfMaybe(selector: (E) -> R): Maybe<R>
context(_: Order<R>)
inline fun <E, R> KoneIterable<E>.maxOfMaybe(selector: (E) -> R): Maybe<R>
Link copied to clipboard
inline fun <E, R : Comparable<R>> KoneIterable<E>.maxOfOrElse(default: () -> R, selector: (E) -> R): R
context(_: Order<R>)
inline fun <E, R> KoneIterable<E>.maxOfOrElse(default: () -> R, selector: (E) -> R): R
Link copied to clipboard
inline fun <E, R : Comparable<R>> KoneIterable<E>.maxOfOrNull(selector: (E) -> R): R?
context(_: Order<R>)
inline fun <E, R> KoneIterable<E>.maxOfOrNull(selector: (E) -> R): R?
Link copied to clipboard
inline fun <E : Comparable<E>> KoneIterable<E>.maxOrElse(default: () -> E): E
context(_: Order<E>)
inline fun <E> KoneIterable<E>.maxOrElse(default: () -> E): E
Link copied to clipboard
fun <E : Comparable<E>> KoneIterable<E>.maxOrNull(): E?
context(_: Order<E>)
fun <E> KoneIterable<E>.maxOrNull(): E?
Link copied to clipboard
fun <E> KoneIterable<E>.maxWith(comparator: Comparator<E>): E
Link copied to clipboard
inline fun <E, R> KoneIterable<E>.maxWithBy(comparator: Comparator<R>, selector: (E) -> R): E
Link copied to clipboard
inline fun <E, R> KoneIterable<E>.maxWithByMaybe(comparator: Comparator<R>, selector: (E) -> R): Maybe<E>
Link copied to clipboard
inline fun <E, R> KoneIterable<E>.maxWithByOrElse(comparator: Comparator<R>, default: () -> E, selector: (E) -> R): E
Link copied to clipboard
inline fun <E, R> KoneIterable<E>.maxWithByOrNull(comparator: Comparator<R>, selector: (E) -> R): E?
Link copied to clipboard
fun <E> KoneIterable<E>.maxWithMaybe(comparator: Comparator<E>): Maybe<E>
Link copied to clipboard
inline fun <E, R> KoneIterable<E>.maxWithOf(comparator: Comparator<R>, selector: (E) -> R): R
Link copied to clipboard
inline fun <E, R> KoneIterable<E>.maxWithOfMaybe(comparator: Comparator<R>, selector: (E) -> R): Maybe<R>
Link copied to clipboard
inline fun <E, R> KoneIterable<E>.maxWithOfOrElse(comparator: Comparator<R>, default: () -> R, selector: (E) -> R): R
Link copied to clipboard
inline fun <E, R> KoneIterable<E>.maxWithOfOrNull(comparator: Comparator<R>, selector: (E) -> R): R?
Link copied to clipboard
inline fun <E> KoneIterable<E>.maxWithOrElse(comparator: Comparator<E>, default: () -> E): E
Link copied to clipboard
fun <E> KoneIterable<E>.maxWithOrNull(comparator: Comparator<E>): E?
Link copied to clipboard
fun <E : Comparable<E>> KoneIterable<E>.min(): E
context(_: Order<E>)
fun <E> KoneIterable<E>.min(): E
Link copied to clipboard
inline fun <E, R : Comparable<R>> KoneIterable<E>.minBy(selector: (E) -> R): E
context(_: Order<R>)
inline fun <E, R> KoneIterable<E>.minBy(selector: (E) -> R): E
Link copied to clipboard
inline fun <E, R : Comparable<R>> KoneIterable<E>.minByMaybe(selector: (E) -> R): Maybe<E>
context(_: Order<R>)
inline fun <E, R> KoneIterable<E>.minByMaybe(selector: (E) -> R): Maybe<E>
Link copied to clipboard
inline fun <E, R : Comparable<R>> KoneIterable<E>.minByOrElse(default: () -> E, selector: (E) -> R): E
context(_: Order<R>)
inline fun <E, R> KoneIterable<E>.minByOrElse(default: () -> E, selector: (E) -> R): E
Link copied to clipboard
inline fun <E, R : Comparable<R>> KoneIterable<E>.minByOrNull(selector: (E) -> R): E?
context(_: Order<R>)
inline fun <E, R> KoneIterable<E>.minByOrNull(selector: (E) -> R): E?
Link copied to clipboard
fun <E : Comparable<E>> KoneList<E>.minIndex(): UInt
context(_: Order<E>)
fun <E> KoneList<E>.minIndex(): UInt
Link copied to clipboard
inline fun <E, R : Comparable<R>> KoneList<E>.minIndexBy(selector: (E) -> R): UInt
context(_: Order<R>)
inline fun <E, R> KoneList<E>.minIndexBy(selector: (E) -> R): UInt
Link copied to clipboard
inline fun <E, R : Comparable<R>> KoneList<E>.minIndexByOrElse(default: () -> UInt, selector: (E) -> R): UInt
context(_: Order<R>)
inline fun <E, R> KoneList<E>.minIndexByOrElse(default: () -> UInt, selector: (E) -> R): UInt
Link copied to clipboard
inline fun <E, R : Comparable<R>> KoneList<E>.minIndexByOrNull(selector: (E) -> R): UInt?
context(_: Order<R>)
inline fun <E, R> KoneList<E>.minIndexByOrNull(selector: (E) -> R): UInt?
Link copied to clipboard
Link copied to clipboard
inline fun <E, R : Comparable<R>> KoneList<E>.minIndexListBy(selector: (E) -> R): KoneUIntArray
context(_: Order<R>)
inline fun <E, R> KoneList<E>.minIndexListBy(selector: (E) -> R): KoneUIntArray
Link copied to clipboard
Link copied to clipboard
inline fun <E, R> KoneList<E>.minIndexListWithBy(comparator: Comparator<R>, selector: (E) -> R): KoneUIntArray
Link copied to clipboard
inline fun <E : Comparable<E>> KoneList<E>.minIndexOrElse(default: () -> UInt): UInt
context(_: Order<E>)
inline fun <E> KoneList<E>.minIndexOrElse(default: () -> UInt): UInt
Link copied to clipboard
fun <E : Comparable<E>> KoneList<E>.minIndexOrNull(): UInt?
context(_: Order<E>)
fun <E> KoneList<E>.minIndexOrNull(): UInt?
Link copied to clipboard
fun <E> KoneList<E>.minIndexWith(comparator: Comparator<E>): UInt
Link copied to clipboard
inline fun <E, R> KoneList<E>.minIndexWithBy(comparator: Comparator<R>, selector: (E) -> R): UInt
Link copied to clipboard
inline fun <E, R> KoneList<E>.minIndexWithByOrElse(comparator: Comparator<R>, default: () -> UInt, selector: (E) -> R): UInt
Link copied to clipboard
inline fun <E, R> KoneList<E>.minIndexWithByOrNull(comparator: Comparator<R>, selector: (E) -> R): UInt?
Link copied to clipboard
inline fun <E> KoneList<E>.minIndexWithOrElse(comparator: Comparator<E>, default: () -> UInt): UInt
Link copied to clipboard
fun <E> KoneList<E>.minIndexWithOrNull(comparator: Comparator<E>): UInt?
Link copied to clipboard
fun <E : Comparable<E>> KoneIterable<E>.minList(): KoneList<E>
context(_: Order<E>)
fun <E> KoneIterable<E>.minList(): KoneList<E>
Link copied to clipboard
inline fun <E, R : Comparable<R>> KoneIterable<E>.minListBy(selector: (E) -> R): KoneList<E>
context(_: Order<R>)
inline fun <E, R> KoneIterable<E>.minListBy(selector: (E) -> R): KoneList<E>
Link copied to clipboard
inline fun <E, R : Comparable<R>> KoneIterable<E>.minListOf(selector: (E) -> R): KoneList<R>
context(_: Order<R>)
inline fun <E, R> KoneIterable<E>.minListOf(selector: (E) -> R): KoneList<R>
Link copied to clipboard
fun <E> KoneIterable<E>.minListWith(comparator: Comparator<E>): KoneList<E>
Link copied to clipboard
inline fun <E, R> KoneIterable<E>.minListWithBy(comparator: Comparator<R>, selector: (E) -> R): KoneList<E>
Link copied to clipboard
inline fun <E, R> KoneIterable<E>.minListWithOf(comparator: Comparator<R>, selector: (E) -> R): KoneList<R>
Link copied to clipboard
fun <E : Comparable<E>> KoneIterable<E>.minMaybe(): Maybe<E>
context(_: Order<E>)
fun <E> KoneIterable<E>.minMaybe(): Maybe<E>
Link copied to clipboard
inline fun <E, R : Comparable<R>> KoneIterable<E>.minOf(selector: (E) -> R): R
context(_: Order<R>)
inline fun <E, R> KoneIterable<E>.minOf(selector: (E) -> R): R
Link copied to clipboard
inline fun <E, R : Comparable<R>> KoneIterable<E>.minOfMaybe(selector: (E) -> R): Maybe<R>
context(_: Order<R>)
inline fun <E, R> KoneIterable<E>.minOfMaybe(selector: (E) -> R): Maybe<R>
Link copied to clipboard
inline fun <E, R : Comparable<R>> KoneIterable<E>.minOfOrElse(default: () -> R, selector: (E) -> R): R
context(_: Order<R>)
inline fun <E, R> KoneIterable<E>.minOfOrElse(default: () -> R, selector: (E) -> R): R
Link copied to clipboard
inline fun <E, R : Comparable<R>> KoneIterable<E>.minOfOrNull(selector: (E) -> R): R?
context(_: Order<R>)
inline fun <E, R> KoneIterable<E>.minOfOrNull(selector: (E) -> R): R?
Link copied to clipboard
inline fun <E : Comparable<E>> KoneIterable<E>.minOrElse(default: () -> E): E
context(_: Order<E>)
inline fun <E> KoneIterable<E>.minOrElse(default: () -> E): E
Link copied to clipboard
fun <E : Comparable<E>> KoneIterable<E>.minOrNull(): E?
context(_: Order<E>)
fun <E> KoneIterable<E>.minOrNull(): E?
Link copied to clipboard
fun <E> KoneIterable<E>.minWith(comparator: Comparator<E>): E
Link copied to clipboard
inline fun <E, R> KoneIterable<E>.minWithBy(comparator: Comparator<R>, selector: (E) -> R): E
Link copied to clipboard
inline fun <E, R> KoneIterable<E>.minWithByMaybe(comparator: Comparator<R>, selector: (E) -> R): Maybe<E>
Link copied to clipboard
inline fun <E, R> KoneIterable<E>.minWithByOrElse(comparator: Comparator<R>, default: () -> E, selector: (E) -> R): E
Link copied to clipboard
inline fun <E, R> KoneIterable<E>.minWithByOrNull(comparator: Comparator<R>, selector: (E) -> R): E?
Link copied to clipboard
fun <E> KoneIterable<E>.minWithMaybe(comparator: Comparator<E>): Maybe<E>
Link copied to clipboard
inline fun <E, R> KoneIterable<E>.minWithOf(comparator: Comparator<R>, selector: (E) -> R): R
Link copied to clipboard
inline fun <E, R> KoneIterable<E>.minWithOfMaybe(comparator: Comparator<R>, selector: (E) -> R): Maybe<R>
Link copied to clipboard
inline fun <E, R> KoneIterable<E>.minWithOfOrElse(comparator: Comparator<R>, default: () -> R, selector: (E) -> R): R
Link copied to clipboard
inline fun <E, R> KoneIterable<E>.minWithOfOrNull(comparator: Comparator<R>, selector: (E) -> R): R?
Link copied to clipboard
inline fun <E> KoneIterable<E>.minWithOrElse(comparator: Comparator<E>, default: () -> E): E
Link copied to clipboard
fun <E> KoneIterable<E>.minWithOrNull(comparator: Comparator<E>): E?
Link copied to clipboard
fun KoneIterable<Boolean>.none(): Boolean
inline fun <E> KoneIterable<E>.none(block: (value: E) -> Boolean): Boolean
Link copied to clipboard
inline fun <E> KoneIterable<E>.noneIndexed(block: (index: UInt, value: E) -> Boolean): Boolean
Link copied to clipboard
Link copied to clipboard
inline fun <E, R : Comparable<R>> KoneSettableList<E>.quicksortBy(selector: (E) -> R)
context(_: Order<R>)
inline fun <E, R> KoneSettableList<E>.quicksortBy(selector: (E) -> R)
Link copied to clipboard
inline fun <E, R : Comparable<R>> KoneSettableList<E>.quicksortByDescending(selector: (E) -> R)
context(_: Order<R>)
inline fun <E, R> KoneSettableList<E>.quicksortByDescending(selector: (E) -> R)
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
inline fun <E, R : Comparable<R>> KoneIterable<E>.quicksortedBy(selector: (E) -> R): KoneList<E>
context(_: Order<R>)
inline fun <E, R> KoneIterable<E>.quicksortedBy(selector: (E) -> R): KoneList<E>
Link copied to clipboard
inline fun <E, R : Comparable<R>> KoneIterable<E>.quicksortedByDescending(selector: (E) -> R): KoneList<E>
context(_: Order<R>)
inline fun <E, R> KoneIterable<E>.quicksortedByDescending(selector: (E) -> R): KoneList<E>
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
inline fun <E, R> KoneIterable<E>.quicksortedWithBy(comparator: Comparator<R>, selector: (E) -> R): KoneList<E>
Link copied to clipboard
inline fun <E, R> KoneIterable<E>.quicksortedWithByDescending(comparator: Comparator<R>, selector: (E) -> R): KoneList<E>
Link copied to clipboard
Link copied to clipboard
fun <E> KoneSettableList<E>.quicksortWith(comparator: Comparator<E>)
Link copied to clipboard
inline fun <E, R> KoneSettableList<E>.quicksortWithBy(comparator: Comparator<R>, selector: (E) -> R)
Link copied to clipboard
inline fun <E, R> KoneSettableList<E>.quicksortWithByDescending(comparator: Comparator<R>, selector: (E) -> R)
Link copied to clipboard
Link copied to clipboard
fun <E> KoneIterable<E>.random(random: Random): E
Link copied to clipboard
inline fun <E : R, R> KoneIterable<E>.reduce(operation: (acc: R, E) -> R): R
Link copied to clipboard
inline fun <E : R, R> KoneIterable<E>.reduceIndexed(operation: (index: UInt, acc: R, E) -> R): R
Link copied to clipboard
inline fun <E : R, R> KoneIterable<E>.reduceIndexedMaybe(operation: (index: UInt, acc: R, E) -> R): Maybe<R>
Link copied to clipboard
inline fun <E : R, R> KoneIterable<E>.reduceIndexedOrNull(operation: (index: UInt, acc: R, E) -> R): R?
Link copied to clipboard
inline fun <E : R, R> KoneIterable<E>.reduceMaybe(operation: (acc: R, E) -> R): Maybe<R>
Link copied to clipboard
inline fun <E : R, R> KoneIterable<E>.reduceOrNull(operation: (acc: R, E) -> R): R?
Link copied to clipboard
Link copied to clipboard
fun <E> KoneList<E>.reversed(): KoneList<E>
Link copied to clipboard
inline fun <E, R> KoneIterable<E>.runningFold(initial: R, operation: (acc: R, E) -> R): KoneList<R>
Link copied to clipboard
inline fun <E, R> KoneIterable<E>.runningFoldIndexed(initial: R, operation: (index: UInt, acc: R, E) -> R): KoneList<R>
Link copied to clipboard
open operator override fun set(index: UInt, element: Element)

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

Link copied to clipboard
fun <E> KoneSettableList<E>.shuffle(random: Random = Random)
Link copied to clipboard
fun <E> KoneIterable<E>.shuffled(random: Random = Random): KoneList<E>
Link copied to clipboard
fun <E> KoneIterable<E>.single(): E
fun <E> KoneIterable<E>.single(predicate: (E) -> Boolean): E
Link copied to clipboard
fun <E> KoneList<E>.slice(fromIndex: UInt, untilIndex: UInt): KoneList<E>
Link copied to clipboard
fun <E : Comparable<E>> KoneSettableList<E>.sort()
context(_: Order<E>)
fun <E> KoneSettableList<E>.sort()
Link copied to clipboard
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)
Link copied to clipboard
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)
Link copied to clipboard
Link copied to clipboard
fun <E : Comparable<E>> KoneIterable<E>.sorted(): KoneList<E>
context(_: Order<E>)
fun <E> KoneIterable<E>.sorted(): KoneList<E>
Link copied to clipboard
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>
Link copied to clipboard
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>
Link copied to clipboard
Link copied to clipboard
fun <E> KoneIterable<E>.sortedWith(comparator: Comparator<E>): KoneList<E>
Link copied to clipboard
inline fun <E, R> KoneIterable<E>.sortedWithBy(comparator: Comparator<R>, selector: (E) -> R): KoneList<E>
Link copied to clipboard
inline fun <E, R> KoneIterable<E>.sortedWithByDescending(comparator: Comparator<R>, selector: (E) -> R): KoneList<E>
Link copied to clipboard
Link copied to clipboard
fun <E> KoneSettableList<E>.sortWith(comparator: Comparator<E>)
Link copied to clipboard
inline fun <E, R> KoneSettableList<E>.sortWithBy(comparator: Comparator<R>, selector: (E) -> R)
Link copied to clipboard
inline fun <E, R> KoneSettableList<E>.sortWithByDescending(comparator: Comparator<R>, selector: (E) -> R)
Link copied to clipboard
Link copied to clipboard
fun <E> KoneIterable<E>.take(n: UInt): KoneList<E>
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
fun <Element> KoneIterable<Element>.toKoneList(): KoneList<Element>

Converts this iterable to a KoneList.

Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
inline fun <Element> KoneIterable<Element>.toKoneMutableReifiedSet(elementEquality: Equality<Element> = Equality.defaultFor(), elementHashing: Hashing<Element>? = null, elementOrder: Order<Element>? = null): KoneMutableReifiedSet<Element>
fun <Element> KoneIterable<Element>.toKoneMutableReifiedSet(elementReification: Reification<Element>, elementEquality: Equality<Element> = Equality.defaultFor(), elementHashing: Hashing<Element>? = null, elementOrder: Order<Element>? = null): KoneMutableReifiedSet<Element>
Link copied to clipboard
fun <Element> KoneIterable<Element>.toKoneMutableSet(elementEquality: Equality<Element> = Equality.defaultFor(), elementHashing: Hashing<Element>? = null, elementOrder: Order<Element>? = null): KoneMutableSet<Element>
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
inline fun <Element> KoneIterable<Element>.toKoneReifiedSet(elementEquality: Equality<Element> = Equality.defaultFor(), elementHashing: Hashing<Element>? = null, elementOrder: Order<Element>? = null): KoneReifiedSet<Element>
fun <Element> KoneIterable<Element>.toKoneReifiedSet(elementReification: Reification<Element>, elementEquality: Equality<Element> = Equality.defaultFor(), elementHashing: Hashing<Element>? = null, elementOrder: Order<Element>? = null): KoneReifiedSet<Element>
Link copied to clipboard
fun <Element> KoneIterable<Element>.toKoneSet(elementEquality: Equality<Element> = Equality.defaultFor(), elementHashing: Hashing<Element>? = null, elementOrder: Order<Element>? = null): KoneSet<Element>
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
open override fun toString(): String

Represents the list as a string. Must return a string in the following form.

Link copied to clipboard
fun <E> KoneIterable<E>.windowed(size: UInt, step: UInt): KoneList<KoneList<E>>
fun <E, R> KoneIterable<E>.windowed(size: UInt, step: UInt, mapper: (window: KoneList<E>) -> R): KoneList<R>
Link copied to clipboard
inline fun <E> KoneIterable<E>.withEach(block: E.() -> Unit)
Link copied to clipboard
inline fun <E> KoneIterable<E>.withEachIndexed(block: E.(index: UInt) -> Unit)
Link copied to clipboard
Generated by Dokka
Copyright © 2025 Gleb Minaev
All rights reserved. Licensed under the Apache License, Version 2.0. See the license in file LICENSE