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

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

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 если элемент 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>

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

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, в заданный destination.

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

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

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, в заданный destination.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

fun <T> iterator(
    block: suspend SequenceScope<T>.() -> Unit
): Iterator<T>

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

fun <T, A : Appendable> Sequence<T>.joinTo(
    buffer: A, 
    separator: CharSequence = ", ", 
    prefix: CharSequence = "", 
    postfix: CharSequence = "", 
    limit: Int = -1, 
    truncated: CharSequence = "...", 
    transform: ((T) -> CharSequence)? = null
): A

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

fun <T> Sequence<T>.joinToString(
    separator: CharSequence = ", ", 
    prefix: CharSequence = "", 
    postfix: CharSequence = "", 
    limit: Int = -1, 
    truncated: CharSequence = "...", 
    transform: ((T) -> CharSequence)? = null
): String

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

fun <T, R : Any> Sequence<T>.mapIndexedNotNull(
    transform: (index: Int, T) -> R?
): Sequence<R>

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

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

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

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

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

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

Применяет заданную функцию transform к каждому элементу в исходной последовательности и добавляет только результаты, не равные null, в заданное значение 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

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

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

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

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

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

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

Учитывая функцию 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

Возвращает сумму всех значений, полученных функцией Требования к платформе и версии: JVM (1.4), JS (1.4), Native (1.4)

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

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

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

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

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

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

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