kone.collections/dev.lounres.kone.collections.set/KoneLinkedSet

KoneLinkedSet

interface KoneLinkedSet<Element> : KoneSet<Element> , KoneReversibleIterable<Element> (source)

Represents a composition of Equality context, an unordered collection of elements without repetitions with respect to the equality context, and structure of a linked list on the elements of the collection.

However, the order of elements in the linked structure may be defined in different ways. For example, it may be a chronological order (i.e. new elements are added to the end of the order and reconstruction of the set won't change the order). Or an order corresponding to the inner structure of the set (for example, in the order induced by som specified Order, and reconstruction of the set will change the order). See implementations' documentations to get the behaviour you need.

Inheritors

KoneMutableLinkedSet

KoneLinkedNoddedSet

KoneLinkedReifiedSet

Properties

size

abstract val size: UInt

Number of elements in the collection.

Functions

all

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

allIndexed

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

any

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

anyIndexed

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

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

contains

abstract operator fun contains(element: Element): Boolean

Checks if there is an element equal to the specified element.

contains

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

containsAllFrom

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

fun <Element> KoneSet<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>

dropLast

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

filter

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

filterTo

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

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

first

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

firstOfThat

inline fun <E, R> KoneIterable<E>.firstOfThat(transform: (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

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

forEach

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

forEachIndexed

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

groupBy

inline fun <E, K> KoneIterable<E>.groupBy(keyEquality: Equality<K> = defaultEquality(), keyHashing: Hashing<K>? = null, keyOrder: Order<K>? = null, keySelector: (E) -> K): KoneMap<K, KoneList<E>>

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

groupByTo

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

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

groupContextualBy

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

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

hasDuplicates

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

hasDuplicatesContextual

fun <E> KoneIterable<E>.hasDuplicatesContextual(elementType: SuppliedType<E>): Boolean

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>

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

abstract operator override fun iterator(): KoneLinkedSetIterator<Element>

Iterator over elements of the collection. There must be exactly size number of elements in it.

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

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

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

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>

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?

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>

shuffled

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

single

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

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>

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>

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