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

KoneVirtualList

@Serializable(with = KoneVirtualListSerializer::class)
class KoneVirtualList<Element>(val size: UInt, generator: (index: UInt) -> Element) : KoneList<Element> (source)

Represents an immutable list which elements are not stored anywhere but are generated with generator function instead on each access.

Implementation details

This implementation holds only size value and generator function. Each time value with index i is accessed, generator is invoked on i and the result is returned. The result is not stored anywhere.

Time complexity of operations

Be aware that the formulas do not include generator time invocation!

OperationWorst caseAverage
size\(\Theta(1)\)\(\Theta(1)\)
get\(\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.nextIndex\(\Theta(1)\)\(\Theta(1)\)
iterator.previousIndex\(\Theta(1)\)\(\Theta(1)\)

Constructors

Link copied to clipboard
constructor(size: UInt, generator: (index: UInt) -> Element)

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
open operator override fun equals(other: Any?): Boolean

Legacy equality operation. Must return true iff the following holds.

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
open override fun hashCode(): Int

Legacy hash computation operation. Must return result of the following pseudocode:

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
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(): KoneLinearIterator<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): KoneLinearIterator<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>> 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> 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
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
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>> 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> 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