kone.collections/dev.lounres.kone.collections.set/KoneRemovableNoddedSetIterator

KoneRemovableNoddedSetIterator

interface KoneRemovableNoddedSetIterator<out Element> : KoneNoddedSetIterator<Element> , KoneRemovableIterator<Element> (source)

Represents iterator over KoneMutableNoddedSet.

Inheritors

KoneRemovableLinkedNoddedSetIterator

Functions

all

fun KoneIterator<Boolean>.all(): Boolean

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

allIndexed

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

any

fun KoneIterator<Boolean>.any(): Boolean

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

anyIndexed

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

asKoneSequence

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

Converts this KoneIterator to a KoneSequence by wrapping it.

asKotlinIterator

fun <Element> KoneIterator<Element>.asKotlinIterator(): Iterator<Element>

blocking

fun <E> KoneIterator<E>.blocking(): KoneIterator<E>

chunked

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

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

copyTo

@IgnorableReturnValue

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

@IgnorableReturnValue

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

count

fun KoneIterator<Boolean>.count(): UInt

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

countIndexed

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

drop

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

dropLast

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

equals

abstract operator override fun equals(other: Any?): Boolean

Legacy equality operation. Must return the result of referential equality.

filter

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

filterTo

@IgnorableReturnValue

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

@IgnorableReturnValue

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

first

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

firstOfThat

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

firstOfThatMaybe

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

firstOfThatOrNull

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

firstThat

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

firstThatMaybe

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

firstThatOrNull

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

flatMap

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

flatMapIndexed

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

flatMapIndexedTo

@IgnorableReturnValue

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

@IgnorableReturnValue

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

flatMapTo

@IgnorableReturnValue

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

@IgnorableReturnValue

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

flatten

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

fold

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

foldIndexed

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

forEach

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

forEachIndexed

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

getAndMoveNext

fun <Element> KoneIterator<Element>.getAndMoveNext(): Element

Gets the next element in this iterator, moves forward, and returns the got element.

getNext

abstract fun getNext(): Element

Returns next element in the order or throws NoFollowingElementInIteratorException if there is no next element.

getNextNode

abstract override fun getNextNode(): KoneRemovableSetNode<Element>

Returns a node corresponding to the next element or throws NoFollowingElementInIteratorException if there is no next element.

hasDuplicates

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

hashCode

abstract override fun hashCode(): Int

Legacy hash computation operation. Must return any Int value.

hasNext

abstract operator fun hasNext(): Boolean

Returns true iff there is next element in the order.

iterator

inline operator fun <E> KoneIterator<E>.iterator(): KoneIterator<E>

joinTo

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

map

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

mapIndexed

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

mapIndexedTo

@IgnorableReturnValue

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

@IgnorableReturnValue

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

mapTo

@IgnorableReturnValue

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

@IgnorableReturnValue

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

max

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

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

maxBy

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

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

maxByMaybe

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

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

maxByOrElse

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

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

maxByOrNull

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

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

maxIndex

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

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

maxIndexBy

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

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

maxIndexByOrElse

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

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

maxIndexByOrNull

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

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

maxIndexList

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

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

maxIndexListBy

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

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

maxIndexListWith

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

maxIndexListWithBy

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

maxIndexOrElse

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

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

maxIndexOrNull

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

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

maxIndexWith

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

maxIndexWithBy

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

maxIndexWithByOrElse

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

maxIndexWithByOrNull

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

maxIndexWithOrElse

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

maxIndexWithOrNull

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

maxList

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

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

maxListBy

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

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

maxListOf

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

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

maxListWith

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

maxListWithBy

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

maxListWithOf

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

maxMaybe

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

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

maxOf

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

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

maxOfMaybe

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

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

maxOfOrElse

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

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

maxOfOrNull

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

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

maxOrElse

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

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

maxOrNull

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

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

maxWith

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

maxWithBy

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

maxWithByMaybe

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

maxWithByOrElse

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

maxWithByOrNull

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

maxWithMaybe

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

maxWithOf

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

maxWithOfMaybe

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

maxWithOfOrElse

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

maxWithOfOrNull

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

maxWithOrElse

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

maxWithOrNull

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

min

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

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

minBy

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

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

minByMaybe

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

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

minByOrElse

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

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

minByOrNull

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

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

minIndex

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

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

minIndexBy

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

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

minIndexByOrElse

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

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

minIndexByOrNull

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

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

minIndexList

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

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

minIndexListBy

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

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

minIndexListWith

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

minIndexListWithBy

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

minIndexOrElse

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

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

minIndexOrNull

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

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

minIndexWith

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

minIndexWithBy

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

minIndexWithByOrElse

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

minIndexWithByOrNull

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

minIndexWithOrElse

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

minIndexWithOrNull

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

minList

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

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

minListBy

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

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

minListOf

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

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

minListWith

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

minListWithBy

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

minListWithOf

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

minMaybe

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

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

minOf

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

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

minOfMaybe

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

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

minOfOrElse

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

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

minOfOrNull

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

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

minOrElse

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

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

minOrNull

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

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

minWith

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

minWithBy

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

minWithByMaybe

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

minWithByOrElse

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

minWithByOrNull

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

minWithMaybe

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

minWithOf

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

minWithOfMaybe

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

minWithOfOrElse

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

minWithOfOrNull

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

minWithOrElse

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

minWithOrNull

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

moveNext

abstract fun moveNext()

Moves forward bypassing next element or throws NoFollowingElementInIteratorException if there is no next element.

inline operator fun <Element> KoneIterator<Element>.next(): Element

Gets the next element moves forward and returns the got element. It is an operator function to use in for cycles.

none

fun KoneIterator<Boolean>.none(): Boolean

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

noneIndexed

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

reduce

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

reduceIndexed

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

reduceIndexedMaybe

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

reduceIndexedOrNull

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

reduceMaybe

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

reduceOrNull

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

removeNext

abstract fun removeNext()

Removes the next element if it's present or throws NoFollowingElementInIteratorException if there is no next element.

runningFold

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

runningFoldIndexed

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

single

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

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

take

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

takeLast

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

toKoneList

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

Converts this iterator to a KoneList.

toKoneMutableList

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

Converts this iterator to a KoneMutableList.

toKoneMutableNoddedList

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

Converts this iterator to a KoneMutableNoddedList.

toKoneNoddedList

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

Converts this iterator to a KoneNoddedList.

toKoneSettableList

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

Converts this iterator to a KoneSettableList.

toKoneSettableNoddedList

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

Converts this iterator to a KoneSettableNoddedList.

toString

abstract override fun toString(): String

Represents the list node as a string. Must return any string. It's better if the method returns descriptive string representation. So that anyone understanding the iterator implementation details can understand its current state.

windowed

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

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

withEach

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

withEachIndexed

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

withIndex

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