Последовательность

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

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

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

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>

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

fun <T> Sequence<T>.elementAtOrNull(index: Int): 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

Выполняет заданное action для каждого элемента.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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>

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

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

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

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 : Comparable<T>> Sequence<T>.sorted(): Sequence<T>

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

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

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

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

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

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

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

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

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

fun Sequence<Byte>.sum(): Int

fun Sequence<Short>.sum(): Int

fun Sequence<Int>.sum(): Int

fun Sequence<Long>.sum(): Long

fun Sequence<Float>.sum(): Float

fun Sequence<Double>.sum(): Double

fun Sequence<UInt>.sum(): UInt

fun Sequence<ULong>.sum(): ULong

fun Sequence<UByte>.sum(): UInt

fun Sequence<UShort>.sum(): UInt

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

fun <K, V> Sequence<Pair<K, V>>.toMap(): Map<K, V>

Заполняет и возвращает назначение изменяемую карту парами ключ-значение из заданной последовательности пар.

fun <K, V, M : MutableMap<in K, in V>> Sequence<Pair<K, V>>.toMap(
    destination: M
): M

Возвращает новый 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>>

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

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

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

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

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>