kone.collections/dev.lounres.kone.collections.set/KoneMutableLinkedSet

KoneMutableLinkedSet

@SubclassOptInRequired(markerClass = [DelicateCollectionsInheritanceAPI::class])

interface KoneMutableLinkedSet<Element> : KoneRemovableLinkedSet<Element> , KoneMutableSet<Element> (source)

Represents a composition of Equality context, an unordered collection of elements without repetitions with respect to the equality context with possibility to add and remove elements from it, 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

KoneMutableLinkedNoddedSet

KoneMutableLinkedReifiedSet

Types

Companion

object Companion

Properties

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

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

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

addSeveral

inline fun <Element> KoneMutableSet<Element>.addSeveral(number: UInt, builder: (index: UInt) -> Element)

all

fun KoneIterable<Boolean>.all(): Boolean

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

fun KoneIterable<Boolean>.any(): Boolean

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

asKoneSequence

fun <Element> KoneIterable<Element>.asKoneSequence(): KoneSequence<Element>

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

asKotlinCollection

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

associate

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>

associateBy

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>

associateByReified

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>

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

associateTo

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

associateWith

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>

associateWithReified

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>

associateWithTo

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

chunked

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>

contains

abstract operator fun contains(element: Element): Boolean

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

contains

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.

containsAllFrom

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.

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

copyTo

@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

count

fun KoneIterable<Boolean>.count(): UInt

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

@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

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

@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

flatMapTo

@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

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

groupByTo

@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

heapsorted

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

context(_: Order<E>)
fun <E> KoneIterable<E>.heapsorted(): KoneList<E>

heapsortedBy

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>

heapsortedByDescending

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>

heapsortedDescending

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

context(_: Order<E>)
fun <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

open fun isEmpty(): Boolean

Checks if the iterable is empty.

isNotEmpty

fun KoneIterable<*>.isNotEmpty(): Boolean

Checks if the iterable is not empty.

iterator

abstract operator override fun iterator(): KoneRemovableLinkedSetIterator<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

@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

mapIndexedToInline

@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

mapTo

@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

mapToInline

@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

max

fun <E : Comparable<E>> KoneIterable<E>.max(): E

context(_: Order<E>)
fun <E> KoneIterable<E>.max(): E

maxBy

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

maxByMaybe

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>

maxByOrElse

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

maxByOrNull

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?

maxList

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

context(_: Order<E>)
fun <E> KoneIterable<E>.maxList(): KoneList<E>

maxListBy

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>

maxListOf

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>

maxListWith

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

maxListWithBy

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

maxListWithOf

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

maxMaybe

fun <E : Comparable<E>> KoneIterable<E>.maxMaybe(): Maybe<E>

context(_: Order<E>)
fun <E> KoneIterable<E>.maxMaybe(): Maybe<E>

maxOf

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

maxOfMaybe

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>

maxOfOrElse

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

maxOfOrNull

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?

maxOrElse

inline fun <E : Comparable<E>> KoneIterable<E>.maxOrElse(default: () -> E): E

context(_: Order<E>)
inline fun <E> KoneIterable<E>.maxOrElse(default: () -> E): E

maxOrNull

fun <E : Comparable<E>> KoneIterable<E>.maxOrNull(): E?

context(_: Order<E>)
fun <E> KoneIterable<E>.maxOrNull(): E?

maxWith

fun <E> KoneIterable<E>.maxWith(comparator: Comparator<E>): E

maxWithBy

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

maxWithByMaybe

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

maxWithByOrElse

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

maxWithByOrNull

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

maxWithMaybe

fun <E> KoneIterable<E>.maxWithMaybe(comparator: Comparator<E>): Maybe<E>

maxWithOf

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

maxWithOfMaybe

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

maxWithOfOrElse

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

maxWithOfOrNull

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

maxWithOrElse

inline fun <E> KoneIterable<E>.maxWithOrElse(comparator: Comparator<E>, default: () -> E): E

maxWithOrNull

fun <E> KoneIterable<E>.maxWithOrNull(comparator: Comparator<E>): E?

min

fun <E : Comparable<E>> KoneIterable<E>.min(): E

context(_: Order<E>)
fun <E> KoneIterable<E>.min(): E

minBy

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

minByMaybe

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>

minByOrElse

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

minByOrNull

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?

minList

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

context(_: Order<E>)
fun <E> KoneIterable<E>.minList(): KoneList<E>

minListBy

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>

minListOf

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>

minListWith

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

minListWithBy

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

minListWithOf

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

minMaybe

fun <E : Comparable<E>> KoneIterable<E>.minMaybe(): Maybe<E>

context(_: Order<E>)
fun <E> KoneIterable<E>.minMaybe(): Maybe<E>

minOf

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

minOfMaybe

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>

minOfOrElse

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

minOfOrNull

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?

minOrElse

inline fun <E : Comparable<E>> KoneIterable<E>.minOrElse(default: () -> E): E

context(_: Order<E>)
inline fun <E> KoneIterable<E>.minOrElse(default: () -> E): E

minOrNull

fun <E : Comparable<E>> KoneIterable<E>.minOrNull(): E?

context(_: Order<E>)
fun <E> KoneIterable<E>.minOrNull(): E?

minusAssign

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

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

operator fun <E> KoneMutableSet<E>.minusAssign(elements: KoneIterator<E>)

operator fun <E> KoneMutableSet<E>.minusAssign(elements: KoneSequence<E>)

minWith

fun <E> KoneIterable<E>.minWith(comparator: Comparator<E>): E

minWithBy

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

minWithByMaybe

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

minWithByOrElse

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

minWithByOrNull

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

minWithMaybe

fun <E> KoneIterable<E>.minWithMaybe(comparator: Comparator<E>): Maybe<E>

minWithOf

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

minWithOfMaybe

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

minWithOfOrElse

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

minWithOfOrNull

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

minWithOrElse

inline fun <E> KoneIterable<E>.minWithOrElse(comparator: Comparator<E>, default: () -> E): E

minWithOrNull

fun <E> KoneIterable<E>.minWithOrNull(comparator: Comparator<E>): E?

none

fun KoneIterable<Boolean>.none(): Boolean

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

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

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

quicksorted

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

context(_: Order<E>)
fun <E> KoneIterable<E>.quicksorted(): KoneList<E>

quicksortedBy

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>

quicksortedByDescending

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>

quicksortedDescending

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

context(_: Order<E>)
fun <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> KoneRemovableSet<Element>.removeAllFrom(elements: KoneIterable<Element>)

fun <Element> KoneRemovableSet<Element>.removeAllFrom(elements: KoneIterator<Element>)

fun <Element> KoneRemovableSet<Element>.removeAllFrom(elements: KoneSequence<Element>)

removeAllThat

inline fun <Element> KoneRemovableSet<Element>.removeAllThat(predicate: (element: Element) -> Boolean)

retainAllThat

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

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

fun <E> KoneIterable<E>.single(predicate: (E) -> Boolean): E

sorted

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

context(_: Order<E>)
fun <E> KoneIterable<E>.sorted(): KoneList<E>

sortedBy

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>

sortedByDescending

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>

sortedDescending

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

context(_: Order<E>)
fun <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>

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>

toKoneBooleanArray

fun KoneIterable<Boolean>.toKoneBooleanArray(): KoneBooleanArray

toKoneByteArray

fun KoneIterable<Byte>.toKoneByteArray(): KoneByteArray

toKoneCharArray

fun KoneIterable<Char>.toKoneCharArray(): KoneCharArray

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>

Converts this iterable to a KoneList.

toKoneLongArray

fun KoneIterable<Long>.toKoneLongArray(): KoneLongArray

toKoneMutableArray

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

toKoneMutableBooleanArray

fun KoneIterable<Boolean>.toKoneMutableBooleanArray(): KoneMutableBooleanArray

toKoneMutableByteArray

fun KoneIterable<Byte>.toKoneMutableByteArray(): KoneMutableByteArray

toKoneMutableCharArray

fun KoneIterable<Char>.toKoneMutableCharArray(): KoneMutableCharArray

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>

Converts this iterable to a KoneMutableList.

toKoneMutableLongArray

fun KoneIterable<Long>.toKoneMutableLongArray(): KoneMutableLongArray

toKoneMutableNoddedList

fun <Element> KoneIterable<Element>.toKoneMutableNoddedList(): KoneMutableNoddedList<Element>

Converts this iterable to a KoneMutableNoddedList.

toKoneMutableReifiedSet

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>

toKoneMutableSet

fun <Element> KoneIterable<Element>.toKoneMutableSet(elementEquality: Equality<Element> = Equality.defaultFor(), 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

toKoneNoddedList

fun <Element> KoneIterable<Element>.toKoneNoddedList(): KoneNoddedList<Element>

Converts this iterable to a KoneNoddedList.

toKoneReifiedSet

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>

toKoneSet

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

toKoneSettableList

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

Converts this iterable to a KoneSettableList.

toKoneSettableNoddedList

fun <Element> KoneIterable<Element>.toKoneSettableNoddedList(): KoneSettableNoddedList<Element>

Converts this iterable to a KoneSettableNoddedList.

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>

windowed

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>

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