Пакет 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>

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

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

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

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

Заполняет и возвращает изменяемую карту destination парами ключ-значение, предоставленными функцией 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>

Заполняет и возвращает изменяемую карту destination парами ключ-значение для каждого элемента заданной последовательности, где ключ — сам элемент, а значение — результат применения функции 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>>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Возвращает первый элемент, соответствующий заданному predicate, или 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>

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

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

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

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 к каждому элементу и его индексу в исходной последовательности и добавляет результаты в заданное значение destination.

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 к каждому элементу в исходной последовательности и добавляет только непустые результаты в заданное значение destination.

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

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

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

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

fun Sequence<Double>.max(): Double

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

fun Sequence<Float>.max(): Float

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

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

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

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

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

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

Возвращает первый элемент, дающий наибольшее значение заданной функции, или 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?

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

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

Возвращает наибольшее значение по заданному comparator среди всех значений, полученных с помощью функции 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?

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

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

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

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

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

fun Sequence<Double>.min(): Double

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

fun Sequence<Float>.min(): Float

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

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

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

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

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

fun <T, R : Comparable<R>> Sequence<T>.minBy(
    selector: (T) -> R
): 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>

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

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>

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

fun <T> Sequence<T>.minWith(comparator: Comparator<in T>): 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>

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

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

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

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

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

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

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

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

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

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

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

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>

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

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

Добавляет все элементы в заданную коллекцию destination.

fun <T, C : MutableCollection<in T>> Sequence<T>.toCollection(
    destination: C
): C

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

fun <T> Sequence<T>.toHashSet(): HashSet<T>

Возвращает List, содержащий все элементы.

fun <T> Sequence<T>.toList(): List<T>

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

fun <T> Sequence<T>.toMutableList(): MutableList<T>

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

fun <T> Sequence<T>.toMutableSet(): MutableSet<T>

Возвращает Set всех элементов.

fun <T> Sequence<T>.toSet(): Set<T>

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

fun <T : Comparable<T>> Sequence<T>.toSortedSet(): SortedSet<T>

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

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

fun <T, R> Sequence<Pair<T, R>>.unzip(): Pair<List<T>, List<R>>

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

fun <T> Sequence<T>.windowed(
    size: Int, 
    step: Int = 1, 
    partialWindows: Boolean = false
): Sequence<List<T>>

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

fun <T, R> Sequence<T>.windowed(
    size: Int, 
    step: Int = 1, 
    partialWindows: Boolean = false, 
    transform: (List<T>) -> R
): Sequence<R>

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

fun <T> Sequence<T>.withIndex(): Sequence<IndexedValue<T>>

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

infix fun <T, R> Sequence<T>.zip(
    other: Sequence<R>
): Sequence<Pair<T, R>>

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

fun <T, R, V> Sequence<T>.zip(
    other: Sequence<R>, 
    transform: (a: T, b: R) -> V
): Sequence<V>

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

fun <T> Sequence<T>.zipWithNext(): Sequence<Pair<T, T>>

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

fun <T, R> Sequence<T>.zipWithNext(
    transform: (a: T, b: T) -> R
): Sequence<R>