kone.collections/dev.lounres.kone.collections.iterator/KoneLinearIterator

KoneLinearIterator

interface KoneLinearIterator<out Element> : KoneReversibleIterator<Element> (source)

Represents a KoneReversibleIterator over some collection of elements that has permanent order on the elements and permanent indices of the elements.

In such iterators, the next element is the next element in the order that has the next index among all indices of the elements.

Type Parameters

Element

The type of elements returned by the iterator.

Inheritors

KoneSettableLinearIterator

KoneExtendableLinearIterator

KoneRemovableLinearIterator

KoneNoddedListIterator

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.

getAndMovePrevious

fun <Element> KoneReversibleIterator<Element>.getAndMovePrevious(): Element

Gets the previous element, moves backward, 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.

getPrevious

abstract fun getPrevious(): Element

Returns previous element in the order or throws NoFollowingElementInIteratorException if there is no previous 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.

hasPrevious

abstract fun hasPrevious(): Boolean

Returns true iff there is previous 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.

movePrevious

abstract fun movePrevious()

Moves backward bypassing previous element or throws NoFollowingElementInIteratorException if there is no previous 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.

nextIndex

abstract fun nextIndex(): UInt

Returns index of the next element if it's present or throws NoFollowingElementInIteratorException if there is no next element.

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

previousIndex

abstract fun previousIndex(): UInt

Returns index of the previous element if it's present or throws NoFollowingElementInIteratorException if there is no previous element.

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?

reversed

fun <E> KoneLinearIterator<E>.reversed(): KoneLinearIterator<E>

fun <E> KoneReversibleIterator<E>.reversed(): KoneReversibleIterator<E>

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