kone.collections/dev.lounres.kone.collections.set/KoneMutableLinkedNoddedSet

KoneMutableLinkedNoddedSet

interface KoneMutableLinkedNoddedSet<Element> : KoneLinkedNoddedSet<Element> , KoneMutableLinkedSet<Element> , KoneMutableNoddedSet<Element> (source)

Represents a nodded version of KoneMutableLinkedSet.

It means that there is exactly one KoneMutableLinkedSetNode corresponding to each place that can effectively access the places element and index as well as other things that can be found in its documentation.

Inheritors

KoneMutableLinkedNoddedReifiedSet

KoneListBackedMutableLinkedNoddedSet

Properties

nodes

open override val nodes: KoneReifiedSet<KoneMutableLinkedSetNode<Element>>

Returns new reified set consisting of the current nodes of that set.

nodesView

abstract override val nodesView: KoneReifiedSet<KoneMutableLinkedSetNode<Element>>

Reified set that is a view on nodes of that set.

size

abstract val size: UInt

Number of elements in the collection.

Functions

add

abstract fun add(element: Element)

Adds the element to the collection if there is no equal to it element in the collection already.

addAllFrom

fun <Element> KoneMutableSet<Element>.addAllFrom(elements: KoneIterable<Element>)

addNode

abstract override fun addNode(element: Element): KoneMutableLinkedSetNode<Element>

addSeveral

abstract fun addSeveral(number: UInt, builder: (index: UInt) -> Element)

Adds elements builder(0u), builder(1u), ..., builder(number-1u) to the collection. Each element is added iff there is no equal to it element in the collection already.

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

nodeOf

abstract override fun nodeOf(element: @UnsafeVariance Element): KoneMutableLinkedSetNode<Element>

Returns a node that corresponds to the element in the set equal to the specified element or throws NoCorrespondingNodeException if there is no such element.

nodeOfOrNull

abstract override fun nodeOfOrNull(element: @UnsafeVariance Element): KoneMutableLinkedSetNode<Element>?

Returns a node that corresponds to the element in the set equal to the specified element or null if there is no such element.

none

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

noneIndexed

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

plusAssign

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

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

product

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

productOf

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

productOfIndexed

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

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?

remove

abstract fun remove(element: Element)

Removes an element equal to the specified element from the collection if there is such one or does nothing otherwise.

removeAll

abstract fun removeAll()

Removes all elements from the collection.

removeAllFrom

fun <Element> KoneMutableSet<Element>.removeAllFrom(elements: KoneIterable<Element>)

removeAllThat

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

Removes all elements satisfying the predicate from the collection.

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

KoneMutableLinkedNoddedSet

See also

Inheritors

Properties

Functions