Пакет kotlin.sequences

Возвращает true , если все элементы соответствуют заданному предикату.

fun <T> Sequence<T>.all(predicate: (T) -> Boolean): Boolean

Возвращает true , если последовательность содержит хотя бы один элемент.

fun <T> Sequence<T>.any(): Boolean

Возвращает true , если хотя бы один элемент соответствует заданному предикату.

fun <T> Sequence<T>.any(predicate: (T) -> Boolean): Boolean

Создает экземпляр Iterable, который оборачивает исходную последовательность, возвращая её элементы при итерации.

fun <T> Sequence<T>.asIterable(): Iterable<T>

Возвращает эту последовательность как Sequence.

fun <T> Sequence<T>.asSequence(): Sequence<T>

Создает последовательность, которая возвращает все элементы из этого итератора. Последовательность ограничена итерацией только один раз.

fun <T> Iterator<T>.asSequence(): Sequence<T>

Возвращает Map, содержащий пары ключ-значение, предоставленные функцией transform, применённой к элементам заданной последовательности.

fun <T, K, V> Sequence<T>.associate(
    transform: (T) -> Pair<K, V>
): Map<K, V>

Возвращает Map, содержащий элементы из заданной последовательности, индексированные по ключу, возвращенному функцией keySelector, применённой к каждому элементу.

fun <T, K> Sequence<T>.associateBy(
    keySelector: (T) -> K
): Map<K, T>

Возвращает Map, содержащий значения, предоставленные функцией valueTransform и индексированные функцией keySelector, применёнными к элементам заданной последовательности.

fun <T, K, V> Sequence<T>.associateBy(
    keySelector: (T) -> K, 
    valueTransform: (T) -> V
): Map<K, V>

Заполняет и возвращает изменяемый map парами ключ-значение, где ключ предоставляется функцией keySelector, применённой к каждому элементу заданной последовательности, а значение — сам элемент.

fun <T, K, M : MutableMap<in K, in T>> Sequence<T>.associateByTo(
    destination: M, 
    keySelector: (T) -> K
): M

Заполняет и возвращает изменяемый map парами ключ-значение, где ключ предоставляется функцией keySelector, а значение — функцией valueTransform, применёнными к элементам заданной последовательности.

fun <T, K, V, M : MutableMap<in K, in V>> Sequence<T>.associateByTo(
    destination: M, 
    keySelector: (T) -> K, 
    valueTransform: (T) -> V
): M

Заполняет и возвращает изменяемый map парами ключ-значение, предоставленными функцией transform, применённой к каждому элементу заданной последовательности.

fun <T, K, V, M : MutableMap<in K, in V>> Sequence<T>.associateTo(
    destination: M, 
    transform: (T) -> Pair<K, V>
): M

Возвращает Map, где ключи — элементы из заданной последовательности, а значения производятся функцией valueSelector, применённой к каждому элементу.

fun <K, V> Sequence<K>.associateWith(
    valueSelector: (K) -> V
): Map<K, V>

Заполняет и возвращает изменяемую карту назначения парами ключ-значение для каждого элемента заданной последовательности, где ключ — сам элемент, а значение предоставляется функцией valueSelector, применённой к этому ключу.

fun <K, V, M : MutableMap<in K, in V>> Sequence<K>.associateWithTo(
    destination: M, 
    valueSelector: (K) -> V
): M

Возвращает среднее значение элементов в последовательности.

fun Sequence<Byte>.average(): Double

fun Sequence<Short>.average(): Double

fun Sequence<Int>.average(): Double

fun Sequence<Long>.average(): Double

fun Sequence<Float>.average(): Double

fun Sequence<Double>.average(): Double

Разбивает эту последовательность на последовательность списков, каждый из которых не превышает заданного размера.

fun <T> Sequence<T>.chunked(size: Int): Sequence<List<T>>

Разбивает эту последовательность на несколько списков, каждый из которых не превышает заданного размера, и применяет заданную функцию преобразования к каждому.

fun <T, R> Sequence<T>.chunked(
    size: Int, 
    transform: (List<T>) -> R
): Sequence<R>

Возвращает обернутую последовательность, которая предоставляет значения этой последовательности, но гарантирует, что к ней можно обратиться только один раз.

fun <T> Sequence<T>.constrainOnce(): Sequence<T>

Возвращает true , если элемент найден в последовательности.

operator fun <T> Sequence<T>.contains(element: T): Boolean

Возвращает количество элементов в этой последовательности.

fun <T> Sequence<T>.count(): Int

Возвращает количество элементов, соответствующих заданному предикату.

fun <T> Sequence<T>.count(predicate: (T) -> Boolean): Int

Возвращает последовательность, содержащую только уникальные элементы из заданной последовательности.

fun <T> Sequence<T>.distinct(): Sequence<T>

Возвращает последовательность, содержащую только элементы из заданной последовательности, имеющие уникальные ключи, возвращаемые заданной функцией selector.

fun <T, K> Sequence<T>.distinctBy(
    selector: (T) -> K
): Sequence<T>

Возвращает последовательность, содержащую все элементы, кроме первых n элементов.

fun <T> Sequence<T>.drop(n: Int): Sequence<T>

Возвращает последовательность, содержащую все элементы, кроме первых элементов, удовлетворяющих заданному предикату.

fun <T> Sequence<T>.dropWhile(
    predicate: (T) -> Boolean
): Sequence<T>

Возвращает элемент по заданному индексу или выбрасывает исключение IndexOutOfBoundsException, если индекс выходит за пределы этой последовательности.

fun <T> Sequence<T>.elementAt(index: Int): T

Возвращает элемент с заданным индексом или результат вызова функции defaultValue, если индекс находится за пределами этой последовательности.

fun <T> Sequence<T>.elementAtOrElse(
    index: Int, 
    defaultValue: (Int) -> T
): T

Возвращает элемент с заданным индексом или null если индекс находится за пределами этой последовательности.

fun <T> Sequence<T>.elementAtOrNull(index: Int): T?

Возвращает пустую последовательность.

fun <T> emptySequence(): Sequence<T>

Возвращает последовательность, содержащую только элементы, соответствующие заданному предикату.

fun <T> Sequence<T>.filter(
    predicate: (T) -> Boolean
): Sequence<T>

Возвращает последовательность, содержащую только элементы, соответствующие заданному предикату.

fun <T> Sequence<T>.filterIndexed(
    predicate: (index: Int, T) -> Boolean
): Sequence<T>

Добавляет все элементы, соответствующие заданному предикату, к заданному назначению.

fun <T, C : MutableCollection<in T>> Sequence<T>.filterIndexedTo(
    destination: C, 
    predicate: (index: Int, T) -> Boolean
): C

Возвращает последовательность, содержащую все элементы, являющиеся экземплярами указанного параметра типа R.

fun <R> Sequence<*>.filterIsInstance(): Sequence<R>

Возвращает последовательность, содержащую все элементы, являющиеся экземплярами указанного класса.

fun <R> Sequence<*>.filterIsInstance(
    klass: Class<R>
): Sequence<R>

Добавляет все элементы, являющиеся экземплярами указанного параметра типа R, к заданному назначению.

fun <R, C : MutableCollection<in R>> Sequence<*>.filterIsInstanceTo(
    destination: C
): C

Добавляет все элементы, являющиеся экземплярами указанного класса, к заданному назначению.

fun <C : MutableCollection<in R>, R> Sequence<*>.filterIsInstanceTo(
    destination: C, 
    klass: Class<R>
): C

Возвращает последовательность, содержащую все элементы, не соответствующие заданному предикату.

fun <T> Sequence<T>.filterNot(
    predicate: (T) -> Boolean
): Sequence<T>

Возвращает последовательность, содержащую все элементы, которые не являются null.

fun <T : Any> Sequence<T?>.filterNotNull(): Sequence<T>

Добавляет все элементы, которые не являются null, к заданному назначению.

fun <C : MutableCollection<in T>, T : Any> Sequence<T?>.filterNotNullTo(
    destination: C
): C

Добавляет все элементы, не соответствующие заданному предикату, к заданному назначению.

fun <T, C : MutableCollection<in T>> Sequence<T>.filterNotTo(
    destination: C, 
    predicate: (T) -> Boolean
): C

Добавляет все элементы, соответствующие заданному предикату, к заданному назначению.

fun <T, C : MutableCollection<in T>> Sequence<T>.filterTo(
    destination: C, 
    predicate: (T) -> Boolean
): C

Возвращает первый элемент, соответствующий заданному предикату, или null если такой элемент не найден.

fun <T> Sequence<T>.find(predicate: (T) -> Boolean): T?

Возвращает последний элемент, соответствующий заданному предикату, или null если такой элемент не найден.

fun <T> Sequence<T>.findLast(predicate: (T) -> Boolean): T?

Возвращает первый элемент.

fun <T> Sequence<T>.first(): T

Возвращает первый элемент, соответствующий заданному предикату.

fun <T> Sequence<T>.first(predicate: (T) -> Boolean): T

Возвращает первый элемент или null если последовательность пуста.

fun <T> Sequence<T>.firstOrNull(): T?

Возвращает первый элемент, соответствующий заданному предикату, или null если элемент не найден.

fun <T> Sequence<T>.firstOrNull(
    predicate: (T) -> Boolean
): T?

Возвращает единую последовательность всех элементов из результатов функции transform, вызываемой для каждого элемента исходной последовательности.

fun <T, R> Sequence<T>.flatMap(
    transform: (T) -> Iterable<R>
): Sequence<R>

fun <T, R> Sequence<T>.flatMap(
    transform: (T) -> Sequence<R>
): Sequence<R>

Возвращает единую последовательность всех элементов, полученных в результате работы функции transform, вызываемой для каждого элемента и его индекса в исходной последовательности.

fun <T, R> Sequence<T>.flatMapIndexed(
    transform: (index: Int, T) -> Iterable<R>
): Sequence<R>

fun <T, R> Sequence<T>.flatMapIndexed(
    transform: (index: Int, T) -> Sequence<R>
): Sequence<R>

Добавляет все элементы, полученные в результате работы функции transform, вызываемой для каждого элемента и его индекса в исходной последовательности, в заданный destination.

fun <T, R, C : MutableCollection<in R>> Sequence<T>.flatMapIndexedTo(
    destination: C, 
    transform: (index: Int, T) -> Iterable<R>
): C

fun <T, R, C : MutableCollection<in R>> Sequence<T>.flatMapIndexedTo(
    destination: C, 
    transform: (index: Int, T) -> Sequence<R>
): C

Добавляет все элементы, полученные в результате работы функции transform, вызываемой для каждого элемента исходной последовательности, в заданный destination.

fun <T, R, C : MutableCollection<in R>> Sequence<T>.flatMapTo(
    destination: C, 
    transform: (T) -> Iterable<R>
): C

fun <T, R, C : MutableCollection<in R>> Sequence<T>.flatMapTo(
    destination: C, 
    transform: (T) -> Sequence<R>
): C

Возвращает последовательность всех элементов из всех последовательностей в этой последовательности.

fun <T> Sequence<Sequence<T>>.flatten(): Sequence<T>

Возвращает последовательность всех элементов из всех итерируемых объектов в этой последовательности.

fun <T> Sequence<Iterable<T>>.flatten(): Sequence<T>

Накапливает значение, начиная с начального значения и применяя операцию слева направо к текущему накопленному значению и каждому элементу.

fun <T, R> Sequence<T>.fold(
    initial: R, 
    operation: (acc: R, T) -> R
): R

Накапливает значение, начиная с начального значения и применяя операцию слева направо к текущему накопленному значению и каждому элементу с его индексом в исходной последовательности.

fun <T, R> Sequence<T>.foldIndexed(
    initial: R, 
    operation: (index: Int, acc: R, T) -> R
): R

Выполняет заданное действие для каждого элемента.

fun <T> Sequence<T>.forEach(action: (T) -> Unit)

Выполняет заданное действие для каждого элемента, предоставляя последовательный индекс с элементом.

fun <T> Sequence<T>.forEachIndexed(
    action: (index: Int, T) -> Unit)

Возвращает последовательность, которая вызывает функцию для расчета следующего значения на каждой итерации до тех пор, пока функция не вернёт null.

fun <T : Any> generateSequence(
    nextFunction: () -> T?
): Sequence<T>

Возвращает последовательность, определённую начальным значением начальное_значение и функцией следующая_функция, которая вызывается для расчёта следующего значения на основе предыдущего на каждой итерации.

fun <T : Any> generateSequence(
    seed: T?, 
    nextFunction: (T) -> T?
): Sequence<T>

Возвращает последовательность, определённую функцией функция_начального_значения, которая вызывается для получения начального значения, и функция_следующего_значения, которая вызывается для расчёта следующего значения на основе предыдущего на каждой итерации.

fun <T : Any> generateSequence(
    seedFunction: () -> T?, 
    nextFunction: (T) -> T?
): Sequence<T>

Группирует элементы исходной последовательности по ключу, возвращаемому заданной функцией keySelector, применённой к каждому элементу, и возвращает карту, где каждый ключ группы связан со списком соответствующих элементов.

fun <T, K> Sequence<T>.groupBy(
    keySelector: (T) -> K
): Map<K, List<T>>

Группирует значения, возвращаемые функцией valueTransform, применённой к каждому элементу исходной последовательности, по ключу, возвращаемому заданной функцией keySelector, применённой к элементу, и возвращает карту, где каждый ключ группы связан со списком соответствующих значений.

fun <T, K, V> Sequence<T>.groupBy(
    keySelector: (T) -> K, 
    valueTransform: (T) -> V
): Map<K, List<V>>

Группирует элементы исходной последовательности по ключу, возвращаемому заданной функцией keySelector, применённой к каждому элементу, и помещает в карту назначение каждый ключ группы, связанный со списком соответствующих элементов.

fun <T, K, M : MutableMap<in K, MutableList<T>>> Sequence<T>.groupByTo(
    destination: M, 
    keySelector: (T) -> K
): M

Группирует значения, возвращаемые функцией valueTransform, применённой к каждому элементу исходной последовательности, по ключу, возвращаемому заданной функцией keySelector, применённой к элементу, и помещает в карту назначение каждый ключ группы, связанный со списком соответствующих значений.

fun <T, K, V, M : MutableMap<in K, MutableList<V>>> Sequence<T>.groupByTo(
    destination: M, 
    keySelector: (T) -> K, 
    valueTransform: (T) -> V
): M

Создаёт источник Grouping из последовательности для последующего использования с операциями группирования и сворачивания с использованием указанной функции keySelector для извлечения ключа из каждого элемента.

fun <T, K> Sequence<T>.groupingBy(
    keySelector: (T) -> K
): Grouping<T, K>

Возвращает последовательность, которая итерируется по элементам либо этой последовательности, либо, если эта последовательность окажется пустой, последовательности, возвращаемой функцией значение_по_умолчанию.

fun <T> Sequence<T>.ifEmpty(
    defaultValue: () -> Sequence<T>
): Sequence<T>

Возвращает первый индекс элемента элемент, или -1, если последовательность не содержит элемент.

fun <T> Sequence<T>.indexOf(element: T): Int

Возвращает индекс первого элемента, соответствующего заданному предикату, или -1, если последовательность не содержит такого элемента.

fun <T> Sequence<T>.indexOfFirst(
    predicate: (T) -> Boolean
): Int

Возвращает индекс последнего элемента, соответствующего заданному

fun <T> Sequence<T>.indexOfLast(
    predicate: (T) -> Boolean
): Int

Применяет заданную функцию transform к каждому элементу и его индексу в исходной последовательности и добавляет результаты в заданное назначение.

fun <T, R, C : MutableCollection<in R>> Sequence<T>.mapIndexedTo(
    destination: C, 
    transform: (index: Int, T) -> R
): C

Возвращает последовательность, содержащую только результаты применения заданной функции transform к каждому элементу в исходной последовательности.

fun <T, R : Any> Sequence<T>.mapNotNull(
    transform: (T) -> R?
): Sequence<R>

Применяет заданную функцию transform к каждому элементу в исходной последовательности и добавляет только непустые результаты в заданное назначение.

fun <T, R : Any, C : MutableCollection<in R>> Sequence<T>.mapNotNullTo(
    destination: C, 
    transform: (T) -> R?
): C

Применяет заданную функцию transform к каждому элементу исходной последовательности и добавляет результаты в заданное назначение.

fun <T, R, C : MutableCollection<in R>> Sequence<T>.mapTo(
    destination: C, 
    transform: (T) -> R
): C

Возвращает первый элемент, дающий наибольшее значение заданной функции, или null если элементов нет.

fun <T, R : Comparable<R>> Sequence<T>.maxByOrNull(
    selector: (T) -> R
): T?

Возвращает наибольшее значение среди всех значений, полученных функцией selector, примененной к каждому элементу в последовательности.

fun <T> Sequence<T>.maxOf(selector: (T) -> Double): Double

fun <T> Sequence<T>.maxOf(selector: (T) -> Float): Float

fun <T, R : Comparable<R>> Sequence<T>.maxOf(
    selector: (T) -> R
): R

Возвращает наибольшее значение среди всех значений, полученных функцией selector, примененной к каждому элементу в последовательности, или null если элементов нет.

fun <T> Sequence<T>.maxOfOrNull(
    selector: (T) -> Double
): Double?

fun <T> Sequence<T>.maxOfOrNull(
    selector: (T) -> Float
): Float?

fun <T, R : Comparable<R>> Sequence<T>.maxOfOrNull(
    selector: (T) -> R
): R?

Возвращает наибольшее значение согласно предоставленному компаратору среди всех значений, полученных функцией selector, примененной к каждому элементу в последовательности.

fun <T, R> Sequence<T>.maxOfWith(
    comparator: Comparator<in R>, 
    selector: (T) -> R
): R

Возвращает наибольшее значение согласно предоставленному компаратору среди всех значений, полученных функцией selector, примененной к каждому элементу в последовательности, или null если элементов нет.

fun <T, R> Sequence<T>.maxOfWithOrNull(
    comparator: Comparator<in R>, 
    selector: (T) -> R
): R?

Возвращает наибольший элемент или null если элементов нет.

fun Sequence<Double>.maxOrNull(): Double?

fun Sequence<Float>.maxOrNull(): Float?

fun <T : Comparable<T>> Sequence<T>.maxOrNull(): T?

Возвращает первый элемент с наибольшим значением в соответствии с предоставленным компаратором или null , если элементов нет.

fun <T> Sequence<T>.maxWithOrNull(
    comparator: Comparator<in T>
): T?

Возвращает первый элемент, дающий наименьшее значение заданной функции, или null , если элементов нет.

fun <T, R : Comparable<R>> Sequence<T>.minByOrNull(
    selector: (T) -> R
): T?

Возвращает наименьшее значение среди всех значений, полученных функцией selector, применённой к каждому элементу в последовательности.

fun <T> Sequence<T>.minOf(selector: (T) -> Double): Double

fun <T> Sequence<T>.minOf(selector: (T) -> Float): Float

fun <T, R : Comparable<R>> Sequence<T>.minOf(
    selector: (T) -> R
): R

Возвращает наименьшее значение среди всех значений, полученных функцией selector, применённой к каждому элементу в последовательности, или null , если элементов нет.

fun <T> Sequence<T>.minOfOrNull(
    selector: (T) -> Double
): Double?

fun <T> Sequence<T>.minOfOrNull(
    selector: (T) -> Float
): Float?

fun <T, R : Comparable<R>> Sequence<T>.minOfOrNull(
    selector: (T) -> R
): R?

Возвращает наименьшее значение в соответствии с предоставленным компаратором среди всех значений, полученных функцией selector, применённой к каждому элементу в последовательности.

fun <T, R> Sequence<T>.minOfWith(
    comparator: Comparator<in R>, 
    selector: (T) -> R
): R

Возвращает наименьшее значение в соответствии с предоставленным компаратором среди всех значений, полученных функцией selector, применённой к каждому элементу в последовательности, или null , если элементов нет.

fun <T, R> Sequence<T>.minOfWithOrNull(
    comparator: Comparator<in R>, 
    selector: (T) -> R
): R?

Возвращает наименьший элемент или null , если элементов нет.

fun Sequence<Double>.minOrNull(): Double?

fun Sequence<Float>.minOrNull(): Float?

fun <T : Comparable<T>> Sequence<T>.minOrNull(): T?

Возвращает последовательность, содержащую все элементы исходной последовательности без первого вхождения заданного элемента.

operator fun <T> Sequence<T>.minus(element: T): Sequence<T>

Возвращает последовательность, содержащую все элементы исходной последовательности, за исключением элементов, содержащихся в заданном массиве elements.

operator fun <T> Sequence<T>.minus(
    elements: Array<out T>
): Sequence<T>

Возвращает последовательность, содержащую все элементы исходной последовательности, за исключением элементов, содержащихся в заданном сборе элементов.

operator fun <T> Sequence<T>.minus(
    elements: Iterable<T>
): Sequence<T>

Возвращает последовательность, содержащую все элементы исходной последовательности, за исключением элементов, содержащихся в заданной последовательности элементов.

operator fun <T> Sequence<T>.minus(
    elements: Sequence<T>
): Sequence<T>

Возвращает последовательность, содержащую все элементы исходной последовательности без первого вхождения заданного элемента.

fun <T> Sequence<T>.minusElement(element: T): Sequence<T>

Возвращает первый элемент с наименьшим значением в соответствии с предоставленным компаратором или null если элементов нет.

fun <T> Sequence<T>.minWithOrNull(
    comparator: Comparator<in T>
): T?

Возвращает true если последовательность не содержит элементов.

fun <T> Sequence<T>.none(): Boolean

Возвращает true если ни один элемент не соответствует заданному предикату.

fun <T> Sequence<T>.none(predicate: (T) -> Boolean): Boolean

Возвращает последовательность, которая выполняет заданное действие над каждым элементом исходной последовательности по мере их прохождения.

fun <T> Sequence<T>.onEach(action: (T) -> Unit): Sequence<T>

Возвращает последовательность, которая выполняет заданное действие над каждым элементом исходной последовательности по мере их прохождения.

fun <T> Sequence<T>.onEachIndexed(
    action: (index: Int, T) -> Unit
): Sequence<T>

Возвращает эту последовательность, если она не null, и пустую последовательность в противном случае.

fun <T> Sequence<T>?.orEmpty(): Sequence<T>

Разделяет исходную последовательность на пару списков, где первый список содержит элементы, для которых предикат вернул true, а второй список содержит элементы, для которых предикат вернул false.

fun <T> Sequence<T>.partition(
    predicate: (T) -> Boolean
): Pair<List<T>, List<T>>

Возвращает последовательность, содержащую все элементы исходной последовательности, а затем заданный элемент.

operator fun <T> Sequence<T>.plus(element: T): Sequence<T>

Возвращает последовательность, содержащую все элементы исходной последовательности, а затем все элементы заданного массива элементов.

operator fun <T> Sequence<T>.plus(
    elements: Array<out T>
): Sequence<T>

Возвращает последовательность, содержащую все элементы исходной последовательности, а затем все элементы заданного набора элементов.

operator fun <T> Sequence<T>.plus(
    elements: Iterable<T>
): Sequence<T>

Возвращает последовательность, содержащую все элементы исходной последовательности, а затем все элементы заданной последовательности элементов.

operator fun <T> Sequence<T>.plus(
    elements: Sequence<T>
): Sequence<T>

Возвращает последовательность, содержащую все элементы исходной последовательности и затем заданный элемент.

fun <T> Sequence<T>.plusElement(element: T): Sequence<T>

Накапливает значение, начиная с первого элемента и применяя операцию слева направо к текущему значению аккумулятора и каждому элементу.

fun <S, T : S> Sequence<T>.reduce(
    operation: (acc: S, T) -> S
): S

Накапливает значение, начиная с первого элемента и применяя операцию слева направо к текущему значению аккумулятора и каждому элементу с его индексом в исходной последовательности.

fun <S, T : S> Sequence<T>.reduceIndexed(
    operation: (index: Int, acc: S, T) -> S
): S

Накапливает значение, начиная с первого элемента и применяя операцию слева направо к текущему значению аккумулятора и каждому элементу с его индексом в исходной последовательности.

fun <S, T : S> Sequence<T>.reduceIndexedOrNull(
    operation: (index: Int, acc: S, T) -> S
): S?

Накапливает значение, начиная с первого элемента и применяя операцию слева направо к текущему значению аккумулятора и каждому элементу.

fun <S, T : S> Sequence<T>.reduceOrNull(
    operation: (acc: S, T) -> S
): S?

Возвращает исходную коллекцию, содержащую все элементы, не являющиеся null, и выбрасывает исключение IllegalArgumentException, если имеются какие-либо элементы null.

fun <T : Any> Sequence<T?>.requireNoNulls(): Sequence<T>

Возвращает последовательность, содержащую последовательные значения накопления, генерируемые путем применения operation слева направо к каждому элементу и текущему значению накопителя, которое начинается со значения initial.

fun <T, R> Sequence<T>.runningFold(
    initial: R, 
    operation: (acc: R, T) -> R
): Sequence<R>

Возвращает последовательность, содержащую последовательные значения накопления, генерируемые путем применения operation слева направо к каждому элементу, его индексу в исходной последовательности и текущему значению накопителя, которое начинается со значения initial.

fun <T, R> Sequence<T>.runningFoldIndexed(
    initial: R, 
    operation: (index: Int, acc: R, T) -> R
): Sequence<R>

Возвращает последовательность, содержащую последовательные значения накопления, генерируемые путем применения operation слева направо к каждому элементу и текущему значению накопителя, которое начинается с первого элемента этой последовательности.

fun <S, T : S> Sequence<T>.runningReduce(
    operation: (acc: S, T) -> S
): Sequence<S>

Возвращает последовательность, содержащую последовательные значения накопления, генерируемые путем применения operation слева направо к каждому элементу, его индексу в исходной последовательности и текущему значению накопителя, которое начинается с первого элемента этой последовательности.

fun <S, T : S> Sequence<T>.runningReduceIndexed(
    operation: (index: Int, acc: S, T) -> S
): Sequence<S>

Возвращает последовательность, содержащую последовательные значения накопления, генерируемые путем применения operation слева направо к каждому элементу и текущему значению накопителя, которое начинается со значения initial.

fun <T, R> Sequence<T>.scan(
    initial: R, 
    operation: (acc: R, T) -> R
): Sequence<R>

Возвращает последовательность, содержащую последовательные значения накопления, генерируемые путем применения operation слева направо к каждому элементу, его индексу в исходной последовательности и текущему значению накопителя, которое начинается со значения initial.

fun <T, R> Sequence<T>.scanIndexed(
    initial: R, 
    operation: (index: Int, acc: R, T) -> R
): Sequence<R>

Построит Sequence лениво, выдавая значения по одному.

fun <T> sequence(
    block: suspend SequenceScope<T>.() -> Unit
): Sequence<T>

Учитывая функцию iterator, создает Sequence, которая возвращает значения через Iterator, предоставленный этой функцией. Значения вычисляются лениво, и последовательность потенциально бесконечна.

fun <T> Sequence(iterator: () -> Iterator<T>): Sequence<T>

Создает последовательность, которая возвращает указанные значения.

fun <T> sequenceOf(vararg elements: T): Sequence<T>

Возвращает последовательность, которая случайным образом перемешивает элементы этой последовательности.

fun <T> Sequence<T>.shuffled(): Sequence<T>

Возвращает последовательность, которая случайным образом перемешивает элементы этой последовательности, используя указанный экземпляр random в качестве источника случайности.

fun <T> Sequence<T>.shuffled(random: Random): Sequence<T>

Возвращает единственный элемент или вызывает исключение, если последовательность пуста или содержит более одного элемента.

fun <T> Sequence<T>.single(): T

Возвращает единственный элемент, соответствующий заданному predicate, или вызывает исключение, если нет ни одного или более одного совпадающего элемента.

fun <T> Sequence<T>.single(predicate: (T) -> Boolean): T

Возвращает единственный элемент или null если последовательность пуста или содержит более одного элемента.

fun <T> Sequence<T>.singleOrNull(): T?

Возвращает единственный элемент, соответствующий заданному predicate, или null если элемент не найден или найдено более одного элемента.

fun <T> Sequence<T>.singleOrNull(
    predicate: (T) -> Boolean
): T?

Возвращает последовательность, которая выдает элементы этой последовательности, отсортированные в соответствии с их естественным порядком сортировки.

fun <T : Comparable<T>> Sequence<T>.sorted(): Sequence<T>

Возвращает последовательность, которая выдает элементы этой последовательности, отсортированные в соответствии с естественным порядком сортировки значения, возвращаемого указанной функцией selector.

fun <T, R : Comparable<R>> Sequence<T>.sortedBy(
    selector: (T) -> R?
): Sequence<T>

Возвращает последовательность, которая выдает элементы этой последовательности, отсортированные по убыванию в соответствии с естественным порядком сортировки значения, возвращаемого указанной функцией selector.

fun <T, R : Comparable<R>> Sequence<T>.sortedByDescending(
    selector: (T) -> R?
): Sequence<T>

Возвращает последовательность, которая выдает элементы этой последовательности, отсортированные по убыванию в соответствии с их естественным порядком сортировки.

fun <T : Comparable<T>> Sequence<T>.sortedDescending(): Sequence<T>

Возвращает последовательность, которая выдает элементы этой последовательности, отсортированные в соответствии с указанным comparator.

fun <T> Sequence<T>.sortedWith(
    comparator: Comparator<in T>
): Sequence<T>

Возвращает сумму всех элементов в последовательности.

fun Sequence<Byte>.sum(): Int

fun Sequence<Short>.sum(): Int

fun Sequence<Int>.sum(): Int

fun Sequence<Long>.sum(): Long

fun Sequence<Float>.sum(): Float

fun Sequence<Double>.sum(): Double

fun Sequence<UInt>.sum(): UInt

fun Sequence<ULong>.sum(): ULong

fun Sequence<UByte>.sum(): UInt

fun Sequence<UShort>.sum(): UInt

Возвращает сумму всех значений, полученных с помощью функции selector, примененной к каждому элементу в последовательности.

fun <T> Sequence<T>.sumBy(selector: (T) -> Int): Int

Возвращает сумму всех значений, полученных с помощью функции selector, примененной к каждому элементу в последовательности.

fun <T> Sequence<T>.sumByDouble(
    selector: (T) -> Double
): Double

Возвращает сумму всех значений, полученных с помощью функции selector, примененной к каждому элементу в последовательности.

fun <T> Sequence<T>.sumOf(selector: (T) -> Double): Double

fun <T> Sequence<T>.sumOf(selector: (T) -> Int): Int

fun <T> Sequence<T>.sumOf(selector: (T) -> Long): Long

fun <T> Sequence<T>.sumOf(selector: (T) -> UInt): UInt

fun <T> Sequence<T>.sumOf(selector: (T) -> ULong): ULong

fun <T> Sequence<T>.sumOf(
    selector: (T) -> BigDecimal
): BigDecimal

fun <T> Sequence<T>.sumOf(
    selector: (T) -> BigInteger
): BigInteger

Возвращает последовательность, содержащую первые n элементов.

fun <T> Sequence<T>.take(n: Int): Sequence<T>

Возвращает последовательность, содержащую первые элементы, удовлетворяющие заданному

fun <T> Sequence<T>.takeWhile(
    predicate: (T) -> Boolean
): Sequence<T>