kone.collections/dev.lounres.kone.collections.sequence/KoneSequence

KoneSequence

fun interface KoneSequence<out Element>(source)

Represents a sequence of elements that can be accessed via its iterator.

Usually the sequences are lazily evaluated and evaluated values are not cached. So you should think of them as a formal instance that can produce some values one-by-one. Also, there is no saying if it is finite or not.

Standard examples are either lazily evaluated finite sequence of elements like lazy mapping or filtering of an iterable or fixed infinite sequences (which, obviously, cannot be evaluated and stored anywhere in a fixed time) like Fibonacci numbers.

If you need to cache your values, so that the sequence won't be "reevaluated" again, there is KoneSequence.cached.

Type Parameters

Element

The type of elements in the sequence.

Types

Companion

object Companion

Functions

all

fun KoneSequence<Boolean>.all(): Boolean

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

allIndexed

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

any

fun KoneSequence<Boolean>.any(): Boolean

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

anyIndexed

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

cached

fun <Element> KoneSequence<Element>.cached(mode: KoneSequenceCacheThreadSafetyMode = NONE): KoneSequence<Element>

Returns a cached (memorized) version of this sequence.

chunked

fun <E> KoneSequence<E>.chunked(size: UInt): KoneSequence<KoneList<E>>

fun <E, R> KoneSequence<E>.chunked(size: UInt, mapper: (chunk: KoneList<E>) -> R): KoneSequence<R>

copyTo

@IgnorableReturnValue

fun <E, D : KoneMutableList<in E>> KoneSequence<E>.copyTo(destination: D): D

@IgnorableReturnValue

fun <E, D : KoneMutableSet<in E>> KoneSequence<E>.copyTo(destination: D): D

count

fun KoneSequence<Boolean>.count(): UInt

inline fun <E> KoneSequence<E>.count(predicate: (value: E) -> Boolean): UInt

countIndexed

inline fun <E> KoneSequence<E>.countIndexed(predicate: (index: UInt, value: E) -> Boolean): UInt

drop

fun <E> KoneSequence<E>.drop(n: UInt): KoneSequence<E>

dropLast

fun <E> KoneSequence<E>.dropLast(n: UInt): KoneSequence<E>

filter

fun <E> KoneSequence<E>.filter(predicate: (E) -> Boolean): KoneSequence<E>

filterTo

@IgnorableReturnValue

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

@IgnorableReturnValue

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

first

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

firstOfThat

inline fun <E, R> KoneSequence<E>.firstOfThat(transform: (E) -> R, predicate: (R) -> Boolean): R

firstOfThatMaybe

inline fun <E, R> KoneSequence<E>.firstOfThatMaybe(transform: (E) -> R, predicate: (R) -> Boolean): Maybe<R>

firstOfThatOrNull

inline fun <E, R> KoneSequence<E>.firstOfThatOrNull(transform: (E) -> R, predicate: (R) -> Boolean): R?

firstThat

inline fun <E> KoneSequence<E>.firstThat(predicate: (E) -> Boolean): E

firstThatMaybe

inline fun <E> KoneSequence<E>.firstThatMaybe(predicate: (E) -> Boolean): Maybe<E>

firstThatOrNull

inline fun <E> KoneSequence<E>.firstThatOrNull(predicate: (E) -> Boolean): E?

flatMap

fun <E, R> KoneSequence<E>.flatMap(transform: (E) -> KoneSequence<R>): KoneSequence<R>

flatMapIndexed

fun <E, R> KoneSequence<E>.flatMapIndexed(transform: (index: UInt, E) -> KoneSequence<R>): KoneSequence<R>

flatMapIndexedTo

@IgnorableReturnValue

inline fun <E, R, D : KoneMutableList<in R>> KoneSequence<E>.flatMapIndexedTo(destination: D, transform: (index: UInt, E) -> KoneIterable<R>): D

@IgnorableReturnValue

inline fun <E, R, D : KoneMutableSet<in R>> KoneSequence<E>.flatMapIndexedTo(destination: D, transform: (index: UInt, E) -> KoneIterable<R>): D

flatMapTo

@IgnorableReturnValue

inline fun <E, R, D : KoneMutableList<in R>> KoneSequence<E>.flatMapTo(destination: D, transform: (E) -> KoneIterable<R>): D

@IgnorableReturnValue

inline fun <E, R, D : KoneMutableSet<in R>> KoneSequence<E>.flatMapTo(destination: D, transform: (E) -> KoneIterable<R>): D

flatten

fun <E> KoneSequence<KoneSequence<E>>.flatten(): KoneSequence<E>

fold

inline fun <E, R> KoneSequence<E>.fold(initial: R, operation: (acc: R, E) -> R): R

foldIndexed

inline fun <E, R> KoneSequence<E>.foldIndexed(initial: R, operation: (index: UInt, acc: R, E) -> R): R

forEach

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

forEachIndexed

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

iterator

abstract operator fun iterator(): KoneIterator<Element>

Returns an iterator over the elements of this sequence.

joinTo

fun <E, A : Appendable> KoneSequence<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> KoneSequence<E>.joinToString(separator: CharSequence = ", ", prefix: CharSequence = "", postfix: CharSequence = "", limit: UInt = UInt.MAX_VALUE, truncated: CharSequence = "...", transform: (E) -> CharSequence? = null): String

map

fun <E, R> KoneSequence<E>.map(transform: (E) -> R): KoneSequence<R>

mapIndexed

fun <E, R> KoneSequence<E>.mapIndexed(transform: (index: UInt, E) -> R): KoneSequence<R>

mapIndexedTo

@IgnorableReturnValue

inline fun <E, R, D : KoneMutableList<in R>> KoneSequence<E>.mapIndexedTo(destination: D, transform: (index: UInt, E) -> R): D

@IgnorableReturnValue

inline fun <E, R, D : KoneMutableSet<in R>> KoneSequence<E>.mapIndexedTo(destination: D, transform: (index: UInt, E) -> R): D

mapTo

@IgnorableReturnValue

inline fun <E, R, D : KoneMutableList<in R>> KoneSequence<E>.mapTo(destination: D, transform: (E) -> R): D

@IgnorableReturnValue

inline fun <E, R, D : KoneMutableSet<in R>> KoneSequence<E>.mapTo(destination: D, transform: (E) -> R): D

max

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

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

maxBy

inline fun <E, R : Comparable<R>> KoneSequence<E>.maxBy(selector: (E) -> R): E

context(_: Order<R>)
inline fun <E, R> KoneSequence<E>.maxBy(selector: (E) -> R): E

maxByMaybe

inline fun <E, R : Comparable<R>> KoneSequence<E>.maxByMaybe(selector: (E) -> R): Maybe<E>

context(_: Order<R>)
inline fun <E, R> KoneSequence<E>.maxByMaybe(selector: (E) -> R): Maybe<E>

maxByOrElse

inline fun <E, R : Comparable<R>> KoneSequence<E>.maxByOrElse(default: () -> E, selector: (E) -> R): E

context(_: Order<R>)
inline fun <E, R> KoneSequence<E>.maxByOrElse(default: () -> E, selector: (E) -> R): E

maxByOrNull

inline fun <E, R : Comparable<R>> KoneSequence<E>.maxByOrNull(selector: (E) -> R): E?

context(_: Order<R>)
inline fun <E, R> KoneSequence<E>.maxByOrNull(selector: (E) -> R): E?

maxIndex

fun <E : Comparable<E>> KoneSequence<E>.maxIndex(): UInt

context(_: Order<E>)
fun <E> KoneSequence<E>.maxIndex(): UInt

maxIndexBy

inline fun <E, R : Comparable<R>> KoneSequence<E>.maxIndexBy(selector: (E) -> R): UInt

context(_: Order<R>)
inline fun <E, R> KoneSequence<E>.maxIndexBy(selector: (E) -> R): UInt

maxIndexByOrElse

inline fun <E, R : Comparable<R>> KoneSequence<E>.maxIndexByOrElse(default: () -> UInt, selector: (E) -> R): UInt

context(_: Order<R>)
inline fun <E, R> KoneSequence<E>.maxIndexByOrElse(default: () -> UInt, selector: (E) -> R): UInt

maxIndexByOrNull

inline fun <E, R : Comparable<R>> KoneSequence<E>.maxIndexByOrNull(selector: (E) -> R): UInt?

context(_: Order<R>)
inline fun <E, R> KoneSequence<E>.maxIndexByOrNull(selector: (E) -> R): UInt?

maxIndexList

fun <E : Comparable<E>> KoneSequence<E>.maxIndexList(): KoneUIntArray

context(_: Order<E>)
fun <E> KoneSequence<E>.maxIndexList(): KoneUIntArray

maxIndexListBy

inline fun <E, R : Comparable<R>> KoneSequence<E>.maxIndexListBy(selector: (E) -> R): KoneUIntArray

context(_: Order<R>)
inline fun <E, R> KoneSequence<E>.maxIndexListBy(selector: (E) -> R): KoneUIntArray

maxIndexListWith

fun <E> KoneSequence<E>.maxIndexListWith(comparator: Comparator<E>): KoneUIntArray

maxIndexListWithBy

inline fun <E, R> KoneSequence<E>.maxIndexListWithBy(comparator: Comparator<R>, selector: (E) -> R): KoneUIntArray

maxIndexOrElse

inline fun <E : Comparable<E>> KoneSequence<E>.maxIndexOrElse(default: () -> UInt): UInt

context(_: Order<E>)
inline fun <E> KoneSequence<E>.maxIndexOrElse(default: () -> UInt): UInt

maxIndexOrNull

fun <E : Comparable<E>> KoneSequence<E>.maxIndexOrNull(): UInt?

context(_: Order<E>)
fun <E> KoneSequence<E>.maxIndexOrNull(): UInt?

maxIndexWith

fun <E> KoneSequence<E>.maxIndexWith(comparator: Comparator<E>): UInt

maxIndexWithBy

inline fun <E, R> KoneSequence<E>.maxIndexWithBy(comparator: Comparator<R>, selector: (E) -> R): UInt

maxIndexWithByOrElse

inline fun <E, R> KoneSequence<E>.maxIndexWithByOrElse(comparator: Comparator<R>, default: () -> UInt, selector: (E) -> R): UInt

maxIndexWithByOrNull

inline fun <E, R> KoneSequence<E>.maxIndexWithByOrNull(comparator: Comparator<R>, selector: (E) -> R): UInt?

maxIndexWithOrElse

inline fun <E> KoneSequence<E>.maxIndexWithOrElse(comparator: Comparator<E>, default: () -> UInt): UInt

maxIndexWithOrNull

fun <E> KoneSequence<E>.maxIndexWithOrNull(comparator: Comparator<E>): UInt?

maxList

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

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

maxListBy

inline fun <E, R : Comparable<R>> KoneSequence<E>.maxListBy(selector: (E) -> R): KoneList<E>

context(_: Order<R>)
inline fun <E, R> KoneSequence<E>.maxListBy(selector: (E) -> R): KoneList<E>

maxListOf

inline fun <E, R : Comparable<R>> KoneSequence<E>.maxListOf(selector: (E) -> R): KoneList<R>

context(_: Order<R>)
inline fun <E, R> KoneSequence<E>.maxListOf(selector: (E) -> R): KoneList<R>

maxListWith

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

maxListWithBy

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

maxListWithOf

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

maxMaybe

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

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

maxOf

inline fun <E, R : Comparable<R>> KoneSequence<E>.maxOf(selector: (E) -> R): R

context(_: Order<R>)
inline fun <E, R> KoneSequence<E>.maxOf(selector: (E) -> R): R

maxOfMaybe

inline fun <E, R : Comparable<R>> KoneSequence<E>.maxOfMaybe(selector: (E) -> R): Maybe<R>

context(_: Order<R>)
inline fun <E, R> KoneSequence<E>.maxOfMaybe(selector: (E) -> R): Maybe<R>

maxOfOrElse

inline fun <E, R : Comparable<R>> KoneSequence<E>.maxOfOrElse(default: () -> R, selector: (E) -> R): R

context(_: Order<R>)
inline fun <E, R> KoneSequence<E>.maxOfOrElse(default: () -> R, selector: (E) -> R): R

maxOfOrNull

inline fun <E, R : Comparable<R>> KoneSequence<E>.maxOfOrNull(selector: (E) -> R): R?

context(_: Order<R>)
inline fun <E, R> KoneSequence<E>.maxOfOrNull(selector: (E) -> R): R?

maxOrElse

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

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

maxOrNull

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

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

maxWith

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

maxWithBy

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

maxWithByMaybe

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

maxWithByOrElse

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

maxWithByOrNull

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

maxWithMaybe

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

maxWithOf

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

maxWithOfMaybe

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

maxWithOfOrElse

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

maxWithOfOrNull

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

maxWithOrElse

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

maxWithOrNull

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

min

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

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

minBy

inline fun <E, R : Comparable<R>> KoneSequence<E>.minBy(selector: (E) -> R): E

context(_: Order<R>)
inline fun <E, R> KoneSequence<E>.minBy(selector: (E) -> R): E

minByMaybe

inline fun <E, R : Comparable<R>> KoneSequence<E>.minByMaybe(selector: (E) -> R): Maybe<E>

context(_: Order<R>)
inline fun <E, R> KoneSequence<E>.minByMaybe(selector: (E) -> R): Maybe<E>

minByOrElse

inline fun <E, R : Comparable<R>> KoneSequence<E>.minByOrElse(default: () -> E, selector: (E) -> R): E

context(_: Order<R>)
inline fun <E, R> KoneSequence<E>.minByOrElse(default: () -> E, selector: (E) -> R): E

minByOrNull

inline fun <E, R : Comparable<R>> KoneSequence<E>.minByOrNull(selector: (E) -> R): E?

context(_: Order<R>)
inline fun <E, R> KoneSequence<E>.minByOrNull(selector: (E) -> R): E?

minIndex

fun <E : Comparable<E>> KoneSequence<E>.minIndex(): UInt

context(_: Order<E>)
fun <E> KoneSequence<E>.minIndex(): UInt

minIndexBy

inline fun <E, R : Comparable<R>> KoneSequence<E>.minIndexBy(selector: (E) -> R): UInt

context(_: Order<R>)
inline fun <E, R> KoneSequence<E>.minIndexBy(selector: (E) -> R): UInt

minIndexByOrElse

inline fun <E, R : Comparable<R>> KoneSequence<E>.minIndexByOrElse(default: () -> UInt, selector: (E) -> R): UInt

context(_: Order<R>)
inline fun <E, R> KoneSequence<E>.minIndexByOrElse(default: () -> UInt, selector: (E) -> R): UInt

minIndexByOrNull

context(_: Order<R>)
inline fun <E, R> KoneSequence<E>.minIndexByOrNull(selector: (E) -> R): UInt?

minIndexList

fun <E : Comparable<E>> KoneSequence<E>.minIndexList(): KoneUIntArray

context(_: Order<E>)
fun <E> KoneSequence<E>.minIndexList(): KoneUIntArray

minIndexListBy

inline fun <E, R : Comparable<R>> KoneSequence<E>.minIndexListBy(selector: (E) -> R): KoneUIntArray

context(_: Order<R>)
inline fun <E, R> KoneSequence<E>.minIndexListBy(selector: (E) -> R): KoneUIntArray

minIndexListWith

fun <E> KoneSequence<E>.minIndexListWith(comparator: Comparator<E>): KoneUIntArray

minIndexListWithBy

inline fun <E, R> KoneSequence<E>.minIndexListWithBy(comparator: Comparator<R>, selector: (E) -> R): KoneUIntArray

minIndexOrElse

inline fun <E : Comparable<E>> KoneSequence<E>.minIndexOrElse(default: () -> UInt): UInt

context(_: Order<E>)
inline fun <E> KoneSequence<E>.minIndexOrElse(default: () -> UInt): UInt

minIndexOrNull

fun <E : Comparable<E>> KoneSequence<E>.minIndexOrNull(): UInt?

context(_: Order<E>)
fun <E> KoneSequence<E>.minIndexOrNull(): UInt?

minIndexWith

fun <E> KoneSequence<E>.minIndexWith(comparator: Comparator<E>): UInt

minIndexWithBy

inline fun <E, R> KoneSequence<E>.minIndexWithBy(comparator: Comparator<R>, selector: (E) -> R): UInt

minIndexWithByOrElse

inline fun <E, R> KoneSequence<E>.minIndexWithByOrElse(comparator: Comparator<R>, default: () -> UInt, selector: (E) -> R): UInt

minIndexWithByOrNull

inline fun <E, R> KoneSequence<E>.minIndexWithByOrNull(comparator: Comparator<R>, selector: (E) -> R): UInt?

minIndexWithOrElse

inline fun <E> KoneSequence<E>.minIndexWithOrElse(comparator: Comparator<E>, default: () -> UInt): UInt

minIndexWithOrNull

fun <E> KoneSequence<E>.minIndexWithOrNull(comparator: Comparator<E>): UInt?

minIndexyOrNull

inline fun <E, R : Comparable<R>> KoneSequence<E>.minIndexyOrNull(selector: (E) -> R): UInt?

minList

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

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

minListBy

inline fun <E, R : Comparable<R>> KoneSequence<E>.minListBy(selector: (E) -> R): KoneList<E>

context(_: Order<R>)
inline fun <E, R> KoneSequence<E>.minListBy(selector: (E) -> R): KoneList<E>

minListOf

inline fun <E, R : Comparable<R>> KoneSequence<E>.minListOf(selector: (E) -> R): KoneList<R>

context(_: Order<R>)
inline fun <E, R> KoneSequence<E>.minListOf(selector: (E) -> R): KoneList<R>

minListWith

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

minListWithBy

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

minListWithOf

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

minMaybe

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

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

minOf

inline fun <E, R : Comparable<R>> KoneSequence<E>.minOf(selector: (E) -> R): R

context(_: Order<R>)
inline fun <E, R> KoneSequence<E>.minOf(selector: (E) -> R): R

minOfMaybe

inline fun <E, R : Comparable<R>> KoneSequence<E>.minOfMaybe(selector: (E) -> R): Maybe<R>

context(_: Order<R>)
inline fun <E, R> KoneSequence<E>.minOfMaybe(selector: (E) -> R): Maybe<R>

minOfOrElse

inline fun <E, R : Comparable<R>> KoneSequence<E>.minOfOrElse(default: () -> R, selector: (E) -> R): R

context(_: Order<R>)
inline fun <E, R> KoneSequence<E>.minOfOrElse(default: () -> R, selector: (E) -> R): R

minOfOrNull

inline fun <E, R : Comparable<R>> KoneSequence<E>.minOfOrNull(selector: (E) -> R): R?

context(_: Order<R>)
inline fun <E, R> KoneSequence<E>.minOfOrNull(selector: (E) -> R): R?

minOrElse

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

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

minOrNull

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

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

minWith

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

minWithBy

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

minWithByMaybe

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

minWithByOrElse

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

minWithByOrNull

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

minWithMaybe

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

minWithOf

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

minWithOfMaybe

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

minWithOfOrElse

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

minWithOfOrNull

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

minWithOrElse

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

minWithOrNull

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

none

fun KoneSequence<Boolean>.none(): Boolean

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

noneIndexed

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

reduce

inline fun <E : R, R> KoneSequence<E>.reduce(operation: (acc: R, E) -> R): R

reduceIndexed

inline fun <E : R, R> KoneSequence<E>.reduceIndexed(operation: (index: UInt, acc: R, E) -> R): R

reduceIndexedMaybe

inline fun <E : R, R> KoneSequence<E>.reduceIndexedMaybe(operation: (index: UInt, acc: R, E) -> R): Maybe<R>

reduceIndexedOrNull

inline fun <E : R, R> KoneSequence<E>.reduceIndexedOrNull(operation: (index: UInt, acc: R, E) -> R): R?

reduceMaybe

inline fun <E : R, R> KoneSequence<E>.reduceMaybe(operation: (acc: R, E) -> R): Maybe<R>

reduceOrNull

inline fun <E : R, R> KoneSequence<E>.reduceOrNull(operation: (acc: R, E) -> R): R?

runningFold

fun <E, R> KoneSequence<E>.runningFold(initial: R, operation: (acc: R, E) -> R): KoneSequence<R>

runningFoldIndexed

fun <E, R> KoneSequence<E>.runningFoldIndexed(initial: R, operation: (index: UInt, acc: R, E) -> R): KoneSequence<R>

single

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

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

take

fun <E> KoneSequence<E>.take(n: UInt): KoneSequence<E>

takeLast

fun <E> KoneSequence<E>.takeLast(n: UInt): KoneSequence<E>

toKoneList

fun <Element> KoneSequence<Element>.toKoneList(): KoneList<Element>

Converts this sequence to a KoneList.

toKoneMutableList

fun <Element> KoneSequence<Element>.toKoneMutableList(): KoneMutableList<Element>

Converts this sequence to a KoneMutableList.

toKoneMutableNoddedList

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

Converts this sequence to a KoneMutableNoddedList.

toKoneNoddedList

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

Converts this sequence to a KoneNoddedList.

toKoneSettableList

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

Converts this sequence to a KoneSettableList.

toKoneSettableNoddedList

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

Converts this sequence to a KoneSettableNoddedList.

windowed

fun <E> KoneSequence<E>.windowed(size: UInt, step: UInt): KoneSequence<KoneList<E>>

fun <E, R> KoneSequence<E>.windowed(size: UInt, step: UInt, mapper: (window: KoneList<E>) -> R): KoneSequence<R>

withEach

inline fun <E> KoneSequence<E>.withEach(block: E.() -> Unit)

withEachIndexed

inline fun <E> KoneSequence<E>.withEachIndexed(block: E.(index: UInt) -> Unit)

withIndex

fun <E> KoneSequence<E>.withIndex(): KoneSequence<KoneIndexedValue<E>>