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

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

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

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

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

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

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

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?

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

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

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

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>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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?

Возвращает наибольший элемент или 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>

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

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

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

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>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Возвращает сумму всех значений, полученных функцией

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

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