Interface Sequence<T>

A Sequence provides a fluent functional API consisting of various intermediate and terminal operations for processing the iterated data. The operations are evaluated lazily to avoid examining all the input data when it's not necessary. Sequences can be iterated only once.

interface Sequence<T> {
    iterator: Iterator<T, any, undefined>;
    all<T>(this, predicate): boolean;
    any<T>(this, predicate?): boolean;
    asIterable<T>(this): Iterable<T>;
    associate<T, K, V>(this, transform): Map<K, V>;
    associateBy<K>(keySelector): Map<K, T>;
    associateBy<K>(key): Map<NonNullable<T>[K], T>;
    associateBy<K, V>(keySelector, valueTransformer): Map<K, V>;
    associateBy<K, V>(key, valueTransformer): Map<NonNullable<T>[K], V>;
    average(this): number;
    chunk<T>(this, chunkSize): T[][];
    contains<T>(this, element): boolean;
    count<T>(this, predicate?): number;
    distinct<T>(this): Sequence<T>;
    distinctBy<T, K>(this, selector): Sequence<T>;
    drop<T>(this, n): Sequence<T>;
    dropWhile<T>(this, predicate): Sequence<T>;
    elementAt<T>(this, index): T;
    elementAtOrElse<T>(this, index, defaultValue): T;
    elementAtOrNull<T>(this, index): null | T;
    filter<T>(this, predicate): Sequence<T>;
    filterIndexed<T>(this, predicate): Sequence<T>;
    filterNot<T>(this, predicate): Sequence<T>;
    filterNotNull<T>(this): Sequence<NonNullable<T>>;
    find<T>(this, predicate?): null | T;
    findLast<T>(this, predicate?): null | T;
    first<T>(this, predicate?): T;
    firstOrNull<T>(this, predicate?): null | T;
    flatMap<S, T>(this, transform): Sequence<T>;
    flatten<T>(this): Sequence<T>;
    fold<T, R>(this, initial, operation): R;
    foldIndexed<T, R>(this, initial, operation): R;
    forEach<T>(this, action): void;
    forEachIndexed<T>(this, action): void;
    groupBy<T, K>(this, keySelector): Map<K, T[]>;
    indexOf<T>(this, element): number;
    indexOfFirst<T>(this, predicate): number;
    indexOfLast<T>(this, predicate): number;
    isEmpty<T>(this): boolean;
    isNotEmpty<T>(this): boolean;
    joinTo<T>(this, config?): string;
    joinToString<T>(this, config?): string;
    last<T>(this, predicate?): T;
    lastOrNull<T>(this, predicate?): null | T;
    map<S, T>(this, transform): Sequence<T>;
    mapIndexed<T, R>(this, transform): Sequence<R>;
    mapNotNull<T, R>(this, transform): Sequence<NonNullable<R>>;
    max<T>(this): null | T;
    maxBy<T, R>(this, selector): null | T;
    maxWith<T>(this, compare): null | T;
    merge<T, S>(this, other, selector, prependNewValues?): Sequence<T>;
    min<T>(this): null | T;
    minBy<T, R>(this, selector): null | T;
    minWith<T>(this, compare): null | T;
    minus<T>(this, data): Sequence<T>;
    none<T>(this, predicate?): boolean;
    onEach<T>(this, action): Sequence<T>;
    onEachIndexed<T>(this, action): Sequence<T>;
    partition<T>(this, predicate): {
        false: T[];
        true: T[];
    };
    plus<T>(this, element): Sequence<T>;
    plus<T>(this, other): Sequence<T>;
    plus<T>(this, other): Sequence<T>;
    reduce<S, T>(this, operation): S;
    reduceIndexed<S, T>(this, operation): S;
    reverse<T>(this): Sequence<T>;
    single<T>(this, predicate?): T;
    singleOrNull<T>(this, predicate?): null | T;
    sorted<T>(this, composeComparator?): Sequence<T>;
    sortedBy<T, R>(this, selector): Sequence<T>;
    sortedBy<T>(this, key): Sequence<T>;
    sortedByDescending<T, R>(this, selector): Sequence<T>;
    sortedByDescending<T>(this, key): Sequence<T>;
    sortedDescending<T>(this): Sequence<T>;
    sortedWith<T>(this, comparison): Sequence<T>;
    sum(this): number;
    sumBy<T>(this, selector): number;
    take<T>(this, n): Sequence<T>;
    takeWhile<T>(this, predicate): Sequence<T>;
    toArray<T>(this, array?): T[];
    toAsyncSequence<T>(this, sequence?): AsyncSequence<T>;
    toList<T>(this, array?): T[];
    toMap<K, V>(this, map?): Map<K, V>;
    toMapNotNull<K, V>(this, map?): Map<NonNullable<K>, NonNullable<V>>;
    toSet<T>(this, set?): Set<T>;
    unzip<T, S>(this): [T[], S[]];
    withIndex<T>(this): Sequence<IndexedValue<T>>;
    zip<T, S>(this, other): Sequence<[T, S]>;
}

Type Parameters

Hierarchy

SequenceOperators<T>
- Sequence

Properties

`Readonly` iterator

iterator: Iterator<T, any, undefined>

Methods

all

all<T>(this, predicate): boolean
Returns true if all elements match the given predicate.
Type Parameters
- T
Parameters
- this: Sequence<T>
- predicate: ((item) => boolean)
  - - (item): boolean
    - Parameters
      item: T
      Returns boolean
Returns boolean
Inherited from SequenceOperators.all
- Defined in operators/sync/all.ts:11

any

any<T>(this, predicate?): boolean
Returns true if at least one element match the given predicate.
Type Parameters
- T
Parameters
- this: Sequence<T>
- Optional predicate: ((item) => boolean)
  - - (item): boolean
    - Parameters
      item: T
      Returns boolean
Returns boolean
Inherited from SequenceOperators.any
- Defined in operators/sync/any.ts:11

asIterable

asIterable<T>(this): Iterable<T>
Returns an iterable representation of the sequence.
Type Parameters
- T
Parameters
- this: Sequence<T>
Returns Iterable<T>
Inherited from SequenceOperators.asIterable
- Defined in operators/sync/asIterable.ts:10

associate

associate<T, K, V>(this, transform): Map<K, V>
Transforms each element into a key-value pair and returns the results as map. In case of duplicate keys the last key-value pair overrides the other.
Type Parameters
- T
- K
- V
Parameters
- this: Sequence<T>
- transform: ((value) => [K, V])
  - - (value): [K, V]
    - Parameters
      value: T
      Returns [K, V]
Returns Map<K, V>
Inherited from SequenceOperators.associate
- Defined in operators/sync/associate.ts:12

associateBy

associateBy<K>(keySelector): Map<K, T>
Returns a map consisting of the elements mapped by the given keySelector.
Type Parameters
- K
Parameters
- keySelector: ((value) => K)
  - - (value): K
    - Parameters
      value: T
      Returns K
Returns Map<K, T>
Inherited from SequenceOperators.associateBy
- Defined in operators/sync/associateBy.ts:12
associateBy<K>(key): Map<NonNullable<T>[K], T>
Returns a map consisting of the elements indexed by the given key.
Type Parameters
- K extends string | number | symbol
Parameters
- key: K
Returns Map<NonNullable<T>[K], T>
Inherited from SequenceOperators.associateBy
- Defined in operators/sync/associateBy.ts:20
associateBy<K, V>(keySelector, valueTransformer): Map<K, V>
Returns a map consisting of the elements mapped by the given keySelector. The value is transformed into another value by the valueTransformer.
Type Parameters
- K
- V
Parameters
- keySelector: ((value) => K)
  - - (value): K
    - Parameters
      value: T
      Returns K
- valueTransformer: ((value) => V)
  - - (value): V
    - Parameters
      value: T
      Returns V
Returns Map<K, V>
Inherited from SequenceOperators.associateBy
- Defined in operators/sync/associateBy.ts:30
associateBy<K, V>(key, valueTransformer): Map<NonNullable<T>[K], V>
Returns a map consisting of the elements indexed by the given key. The value is transformed into another value by the valueTransformer.
Type Parameters
- K extends string | number | symbol
- V
Parameters
- key: K
- valueTransformer: ((value) => V)
  - - (value): V
    - Parameters
      value: T
      Returns V
Returns Map<NonNullable<T>[K], V>
Inherited from SequenceOperators.associateBy
- Defined in operators/sync/associateBy.ts:40

average

average(this): number
Returns the average of all numbers of the sequence or NaN if the sequence is empty.
Parameters
- this: Sequence<number>
Returns number
Inherited from SequenceOperators.average
- Defined in operators/sync/average.ts:10

chunk

chunk<T>(this, chunkSize): T[][]
Splits the elements of the sequence into arrays which length is determined by the given chunkSize and returns all chunks as array.
Type Parameters
- T
Parameters
- this: Sequence<T>
- chunkSize: number
Returns T[][]
Inherited from SequenceOperators.chunk
- Defined in operators/sync/chunk.ts:12

contains

contains<T>(this, element): boolean
Returns true if the sequence contains the given element.
Type Parameters
- T
Parameters
- this: Sequence<T>
- element: T
Returns boolean
Inherited from SequenceOperators.contains
- Defined in operators/sync/contains.ts:11

count

count<T>(this, predicate?): number
Returns the number of elements of this sequence. If predicate is present, returns the number of elements matching the given predicate.
Type Parameters
- T
Parameters
- this: Sequence<T>
- Optional predicate: ((item) => boolean)
  - - (item): boolean
    - Parameters
      item: T
      Returns boolean
Returns number
Inherited from SequenceOperators.count
- Defined in operators/sync/count.ts:12

distinct

distinct<T>(this): Sequence<T>
Returns a new sequence which discards all duplicate elements.
Type Parameters
- T
Parameters
- this: Sequence<T>
Returns Sequence<T>
Inherited from SequenceOperators.distinct
- Defined in operators/sync/distinct.ts:29

distinctBy

distinctBy<T, K>(this, selector): Sequence<T>
Returns a new sequence which discards all elements with duplicate items determined by the given selector.
Type Parameters
- T
- K
Parameters
- this: Sequence<T>
- selector: ((item) => K)
  - - (item): K
    - Parameters
      item: T
      Returns K
Returns Sequence<T>
Inherited from SequenceOperators.distinctBy
- Defined in operators/sync/distinctBy.ts:33

drop

drop<T>(this, n): Sequence<T>
Returns a new sequence which discards the first n elements;
Type Parameters
- T
Parameters
- this: Sequence<T>
- n: number
Returns Sequence<T>
Inherited from SequenceOperators.drop
- Defined in operators/sync/drop.ts:11

dropWhile

dropWhile<T>(this, predicate): Sequence<T>
Drops all elements of the sequence as long as the given predicate evaluates to true.
Type Parameters
- T
Parameters
- this: Sequence<T>
- predicate: ((item) => boolean)
  - - (item): boolean
    - Parameters
      item: T
      Returns boolean
Returns Sequence<T>
Inherited from SequenceOperators.dropWhile
- Defined in operators/sync/dropWhile.ts:32

elementAt

elementAt<T>(this, index): T
Returns the element at position index (zero-based) or throws an error if index is out of bounds.
Type Parameters
- T
Parameters
- this: Sequence<T>
- index: number
Returns T
Inherited from SequenceOperators.elementAt
- Defined in operators/sync/elementAt.ts:12

elementAtOrElse

elementAtOrElse<T>(this, index, defaultValue): T
Returns the element at position index (zero-based). If index is out of bounds returns the result of the given defaultValue function.
Type Parameters
- T
Parameters
- this: Sequence<T>
- index: number
- defaultValue: ((index) => T)
  - - (index): T
    - Parameters
      index: number
      Returns T
Returns T
Inherited from SequenceOperators.elementAtOrElse
- Defined in operators/sync/elementAtOrElse.ts:13

elementAtOrNull

elementAtOrNull<T>(this, index): null | T
Returns the element at position index (zero-based) or null if index is out of bounds.
Type Parameters
- T
Parameters
- this: Sequence<T>
- index: number
Returns null | T
Inherited from SequenceOperators.elementAtOrNull
- Defined in operators/sync/elementAtOrNull.ts:12

filter

filter<T>(this, predicate): Sequence<T>
Returns a new sequence consisting of all elements that match the given predicate.
Type Parameters
- T
Parameters
- this: Sequence<T>
- predicate: ((item) => boolean)
  - - (item): boolean
    - Parameters
      item: T
      Returns boolean
Returns Sequence<T>
Inherited from SequenceOperators.filter
- Defined in operators/sync/filter.ts:26

filterIndexed

filterIndexed<T>(this, predicate): Sequence<T>
Returns a new sequence consisting of all elements that match the given predicate.
Type Parameters
- T
Parameters
- this: Sequence<T>
- predicate: ((index, value) => boolean)
  - - (index, value): boolean
    - Parameters
      index: number
      value: T
      Returns boolean
Returns Sequence<T>
Inherited from SequenceOperators.filterIndexed
- Defined in operators/sync/filterIndexed.ts:11

filterNot

filterNot<T>(this, predicate): Sequence<T>
Returns a new sequence consisting of all elements that don't match the given predicate.
Type Parameters
- T
Parameters
- this: Sequence<T>
- predicate: ((value) => boolean)
  - - (value): boolean
    - Parameters
      value: T
      Returns boolean
Returns Sequence<T>
Inherited from SequenceOperators.filterNot
- Defined in operators/sync/filterNot.ts:11

filterNotNull

filterNotNull<T>(this): Sequence<NonNullable<T>>
Returns a new sequence consisting of all non-null elements.
Type Parameters
- T
Parameters
- this: Sequence<T>
Returns Sequence<NonNullable<T>>
Inherited from SequenceOperators.filterNotNull
- Defined in operators/sync/filterNotNull.ts:10

find

find<T>(this, predicate?): null | T
Returns the first element of the sequence or the first element matching predicate if present, otherwise returns null.
Type Parameters
- T
Parameters
- this: Sequence<T>
- Optional predicate: ((item) => boolean)
  - - (item): boolean
    - Parameters
      item: T
      Returns boolean
Returns null | T
Inherited from SequenceOperators.find
- Defined in operators/sync/firstOrNull.ts:27

findLast

findLast<T>(this, predicate?): null | T
Returns the last element of the sequence or the last element matching predicate if present, otherwise returns null.
Type Parameters
- T
Parameters
- this: Sequence<T>
- Optional predicate: ((value) => boolean)
  - - (value): boolean
    - Parameters
      value: T
      Returns boolean
Returns null | T
Inherited from SequenceOperators.findLast
- Defined in operators/sync/lastOrNull.ts:28

first

first<T>(this, predicate?): T
Returns the first element of the sequence or the first element matching predicate if present, otherwise throws an error.
Type Parameters
- T
Parameters
- this: Sequence<T>
- Optional predicate: ((item) => boolean)
  - - (item): boolean
    - Parameters
      item: T
      Returns boolean
Returns T
Inherited from SequenceOperators.first
- Defined in operators/sync/first.ts:12

firstOrNull

firstOrNull<T>(this, predicate?): null | T
Returns the first element of the sequence or the first element matching predicate if present, otherwise returns null.
Type Parameters
- T
Parameters
- this: Sequence<T>
- Optional predicate: ((item) => boolean)
  - - (item): boolean
    - Parameters
      item: T
      Returns boolean
Returns null | T
Inherited from SequenceOperators.firstOrNull
- Defined in operators/sync/firstOrNull.ts:11

flatMap

flatMap<S, T>(this, transform): Sequence<T>
Transforms each element into a sequence of items and returns a flat single sequence of all those items.
Type Parameters
- S
- T
Parameters
- this: Sequence<S>
- transform: ((value) => Sequence<T>)
  - - (value): Sequence<T>
    - Parameters
      value: S
      Returns Sequence<T>
Returns Sequence<T>
Inherited from SequenceOperators.flatMap
- Defined in operators/sync/flatMap.ts:35

flatten

flatten<T>(this): Sequence<T>
Returns a single flat sequence of all the items from all sequences or iterables.
Type Parameters
- T
Parameters
- this: Sequence<Sequence<T> | Iterable<T>>
Returns Sequence<T>
Inherited from SequenceOperators.flatten
- Defined in operators/sync/flatten.ts:10

fold

fold<T, R>(this, initial, operation): R
Accumulates all elements of the sequence into a single result by applying the given operation starting with the initial value. The result of the last operation will be passed as accumulated value to the getNext invocation of the operation until all elements of the sequence are processed.
Type Parameters
- T
- R
Parameters
- this: Sequence<T>
- initial: R
- operation: ((acc, element) => R)
  - - (acc, element): R
    - Parameters
      acc: R
      element: T
      Returns R
Returns R
Inherited from SequenceOperators.fold
- Defined in operators/sync/fold.ts:14

foldIndexed

foldIndexed<T, R>(this, initial, operation): R
Accumulates all elements of the sequence into a single result by applying the given operation starting with the initial value. The result of the last operation will be passed as accumulated value to the getNext invocation of the operation as well as the index of the current element (zero-based) until all elements of the sequence are processed.
Type Parameters
- T
- R
Parameters
- this: Sequence<T>
- initial: R
- operation: ((index, acc, element) => R)
  - - (index, acc, element): R
    - Parameters
      index: number
      acc: R
      element: T
      Returns R
Returns R
Inherited from SequenceOperators.foldIndexed
- Defined in operators/sync/foldIndexed.ts:15

forEach

forEach<T>(this, action): void
Performs the given action (side-effect) for each element of the sequence.
Type Parameters
- T
Parameters
- this: Sequence<T>
- action: ((item) => unknown)
  - - (item): unknown
    - Parameters
      item: T
      Returns unknown
Returns void
Inherited from SequenceOperators.forEach
- Defined in operators/sync/forEach.ts:10

forEachIndexed

forEachIndexed<T>(this, action): void
Performs the given action (side-effect) for each element of the sequence and passes the index of the current element (zero-based).
Type Parameters
- T
Parameters
- this: Sequence<T>
- action: ((index, value) => unknown)
  - - (index, value): unknown
    - Parameters
      index: number
      value: T
      Returns unknown
Returns void
Inherited from SequenceOperators.forEachIndexed
- Defined in operators/sync/forEachIndexed.ts:11

groupBy

groupBy<T, K>(this, keySelector): Map<K, T[]>
Groups all elements of the sequence into a map. Keys are determined by the given keySelector function.
Type Parameters
- T
- K
Parameters
- this: Sequence<T>
- keySelector: ((value) => K)
  - - (value): K
    - Parameters
      value: T
      Returns K
Returns Map<K, T[]>
Inherited from SequenceOperators.groupBy
- Defined in operators/sync/groupBy.ts:11

indexOf

indexOf<T>(this, element): number
Returns the zero-based index of the given element or -1 if the sequence does not contain the element.
Type Parameters
- T
Parameters
- this: Sequence<T>
- element: T
Returns number
Inherited from SequenceOperators.indexOf
- Defined in operators/sync/indexOf.ts:11

indexOfFirst

indexOfFirst<T>(this, predicate): number
Returns the zero-based index of the first element matching the given predicate or -1 if no element matches the predicate.
Type Parameters
- T
Parameters
- this: Sequence<T>
- predicate: ((value) => boolean)
  - - (value): boolean
    - Parameters
      value: T
      Returns boolean
Returns number
Inherited from SequenceOperators.indexOfFirst
- Defined in operators/sync/indexOfFirst.ts:12

indexOfLast

indexOfLast<T>(this, predicate): number
Returns the zero-based index of the last element matching the given predicate or -1 if no element matches the predicate.
Type Parameters
- T
Parameters
- this: Sequence<T>
- predicate: ((value) => boolean)
  - - (value): boolean
    - Parameters
      value: T
      Returns boolean
Returns number
Inherited from SequenceOperators.indexOfLast
- Defined in operators/sync/indexOfLast.ts:12

isEmpty

isEmpty<T>(this): boolean
Returns true the sequence is empty
Type Parameters
- T
Parameters
- this: Sequence<T>
Returns boolean
Inherited from SequenceOperators.isEmpty
- Defined in operators/sync/isEmpty.ts:10

isNotEmpty

isNotEmpty<T>(this): boolean
Returns true the sequence is not empty
Type Parameters
- T
Parameters
- this: Sequence<T>
Returns boolean
Inherited from SequenceOperators.isNotEmpty
- Defined in operators/sync/isNotEmpty.ts:10

joinTo

joinTo<T>(this, config?): string
Joins all elements of the sequence into a string with the given configuration.
Type Parameters
- T
Parameters
- this: Sequence<T>
- config: JoinToStringConfig<T> = defaults
Returns string
Inherited from SequenceOperators.joinTo
- Defined in operators/sync/joinToString.ts:73

joinToString

joinToString<T>(this, config?): string
Joins all elements of the sequence into a string with the given configuration.
Type Parameters
- T
Parameters
- this: Sequence<T>
- config: JoinToStringConfig<T> = defaults
Returns string
Inherited from SequenceOperators.joinToString
- Defined in operators/sync/joinToString.ts:31

last

last<T>(this, predicate?): T
Returns the last element of the sequence or the last element matching predicate if present, otherwise throws an error.
Type Parameters
- T
Parameters
- this: Sequence<T>
- Optional predicate: ((value) => boolean)
  - - (value): boolean
    - Parameters
      value: T
      Returns boolean
Returns T
Inherited from SequenceOperators.last
- Defined in operators/sync/last.ts:12

lastOrNull

lastOrNull<T>(this, predicate?): null | T
Returns the last element of the sequence or the last element matching predicate if present, otherwise returns null.
Type Parameters
- T
Parameters
- this: Sequence<T>
- Optional predicate: ((value) => boolean)
  - - (value): boolean
    - Parameters
      value: T
      Returns boolean
Returns null | T
Inherited from SequenceOperators.lastOrNull
- Defined in operators/sync/lastOrNull.ts:11

map

map<S, T>(this, transform): Sequence<T>
Transforms each element into another value by applying the given transform function and returns a new sequence.
Type Parameters
- S
- T
Parameters
- this: Sequence<S>
- transform: ((element) => T)
  - - (element): T
    - Parameters
      element: S
      Returns T
Returns Sequence<T>
Inherited from SequenceOperators.map
- Defined in operators/sync/map.ts:24

mapIndexed

mapIndexed<T, R>(this, transform): Sequence<R>
Transforms each element into another value by applying the given transform function and returns a new sequence.
Type Parameters
- T
- R
Parameters
- this: Sequence<T>
- transform: ((index, value) => R)
  - - (index, value): R
    - Parameters
      index: number
      value: T
      Returns R
Returns Sequence<R>
Inherited from SequenceOperators.mapIndexed
- Defined in operators/sync/mapIndexed.ts:11

mapNotNull

mapNotNull<T, R>(this, transform): Sequence<NonNullable<R>>
Transforms each element into another value by applying the given transform function and returns a new sequence. Transformations into null or undefined values are discarded.
Type Parameters
- T
- R
Parameters
- this: Sequence<T>
- transform: ((value) => undefined | null | R)
  - - (value): undefined | null | R
    - Parameters
      value: T
      Returns undefined | null | R
Returns Sequence<NonNullable<R>>
Inherited from SequenceOperators.mapNotNull
- Defined in operators/sync/mapNotNull.ts:12

max

max<T>(this): null | T
Returns the maximum element of the sequence or null if sequence is empty.
Type Parameters
- T
Parameters
- this: Sequence<T>
Returns null | T
Inherited from SequenceOperators.max
- Defined in operators/sync/max.ts:10

maxBy

maxBy<T, R>(this, selector): null | T
Returns the maximum element by comparing the results of the given selector function for each element of the sequence or null if the sequence is empty.
Type Parameters
- T
- R
Parameters
- this: Sequence<T>
- selector: ((value) => R)
  - - (value): R
    - Parameters
      value: T
      Returns R
Returns null | T
Inherited from SequenceOperators.maxBy
- Defined in operators/sync/maxBy.ts:12

maxWith

maxWith<T>(this, compare): null | T
Returns the maximum element of the sequence by evaluating the given compare function or null if sequence is empty.
Type Parameters
- T
Parameters
- this: Sequence<T>
- compare: ((a, b) => number)
  - - (a, b): number
    - Parameters
      a: T
      b: T
      Returns number
Returns null | T
Inherited from SequenceOperators.maxWith
- Defined in operators/sync/maxWith.ts:12

merge

merge<T, S>(this, other, selector, prependNewValues?): Sequence<T>
Merges the elements of both sequences into a new sequence. Each element of this sequence is eventually replaced with an element of the other sequence by comparing results of the given selector function. If no value is found in the other sequence the element is retained. New elements of the other sequence are appended to the end of the new sequence or prepended to the start of the new sequence, if prependNewValues is set to true. This operation is not lazy evaluated.
Type Parameters
- T
- S
Parameters
- this: Sequence<T>
- other: Sequence<T> | Iterable<T>
- selector: ((value) => S)
  - - (value): S
    - Parameters
      value: T
      Returns S
- prependNewValues: boolean = false
Returns Sequence<T>
Inherited from SequenceOperators.merge
- Defined in operators/sync/merge.ts:89

min

min<T>(this): null | T
Returns the minimum element of the sequence or null if sequence is empty.
Type Parameters
- T
Parameters
- this: Sequence<T>
Returns null | T
Inherited from SequenceOperators.min
- Defined in operators/sync/min.ts:10

minBy

minBy<T, R>(this, selector): null | T
Returns the minimum element by comparing the results of the given selector function for each element of the sequence or null if the sequence is empty.
Type Parameters
- T
- R
Parameters
- this: Sequence<T>
- selector: ((value) => R)
  - - (value): R
    - Parameters
      value: T
      Returns R
Returns null | T
Inherited from SequenceOperators.minBy
- Defined in operators/sync/minBy.ts:12

minWith

minWith<T>(this, compare): null | T
Returns the minimum element of the sequence by evaluating the given compare function or null if sequence is empty.
Type Parameters
- T
Parameters
- this: Sequence<T>
- compare: ((a, b) => number)
  - - (a, b): number
    - Parameters
      a: T
      b: T
      Returns number
Returns null | T
Inherited from SequenceOperators.minWith
- Defined in operators/sync/minWith.ts:11

minus

minus<T>(this, data): Sequence<T>
Removes the given data and returns a new sequence. Data can either be a single element, an array of elements or a sequence of elements.
Type Parameters
- T
Parameters
- this: Sequence<T>
- data: T | Sequence<T> | T[]
Returns Sequence<T>
Inherited from SequenceOperators.minus
- Defined in operators/sync/minus.ts:12

none

none<T>(this, predicate?): boolean
Returns true if no element match the given predicate or if the sequence is empty if no predicate is present.
Type Parameters
- T
Parameters
- this: Sequence<T>
- Optional predicate: ((value) => boolean)
  - - (value): boolean
    - Parameters
      value: T
      Returns boolean
Returns boolean
Inherited from SequenceOperators.none
- Defined in operators/sync/none.ts:12

onEach

onEach<T>(this, action): Sequence<T>
Performs the given action for each element and returns the sequence.
Type Parameters
- T
Parameters
- this: Sequence<T>
- action: ((value) => unknown)
  - - (value): unknown
    - Parameters
      value: T
      Returns unknown
Returns Sequence<T>
Inherited from SequenceOperators.onEach
- Defined in operators/sync/onEach.ts:11

onEachIndexed

onEachIndexed<T>(this, action): Sequence<T>
Performs the given action for each element and returns the sequence and passes the index of the current element (zero-based).
Type Parameters
- T
Parameters
- this: Sequence<T>
- action: ((index, value) => unknown)
  - - (index, value): unknown
    - Parameters
      index: number
      value: T
      Returns unknown
Returns Sequence<T>
Inherited from SequenceOperators.onEachIndexed
- Defined in operators/sync/onEachIndexed.ts:12

partition

partition<T>(this, predicate): {
false: T[];
true: T[];
}
Evaluates the given predicate for each element of the sequence and assorts each element into one of two lists according to the result of the predicate. Returns both lists as an object.
Type Parameters
- T
Parameters
- this: Sequence<T>
- predicate: ((value) => boolean)
  - - (value): boolean
    - Parameters
      value: T
      Returns boolean
Returns {
false: T[];
true: T[];
}
- false: T[]
- true: T[]
Inherited from SequenceOperators.partition
- Defined in operators/sync/partition.ts:12

plus

plus<T>(this, element): Sequence<T>
Appends the given element to the end of the sequence and returns a new sequence.
Type Parameters
- T
Parameters
- this: Sequence<T>
- element: T
Returns Sequence<T>
Inherited from SequenceOperators.plus
- Defined in operators/sync/plus.ts:29
plus<T>(this, other): Sequence<T>
Appends the given array to the end of the sequence and returns a new sequence.
Type Parameters
- T
Parameters
- this: Sequence<T>
- other: T[]
Returns Sequence<T>
Inherited from SequenceOperators.plus
- Defined in operators/sync/plus.ts:37
plus<T>(this, other): Sequence<T>
Appends the given sequence to the end of the sequence and returns a new sequence.
Type Parameters
- T
Parameters
- this: Sequence<T>
- other: Sequence<T>
Returns Sequence<T>
Inherited from SequenceOperators.plus
- Defined in operators/sync/plus.ts:45

reduce

reduce<S, T>(this, operation): S
Reduces the whole sequence to a single value by invoking operation with each element from left to right. For every invocation of the operation acc is the result of the last invocation. For the first invocation of the operation acc is the first element of the sequence.
Type Parameters
- S
- T
Parameters
- this: Sequence<T>
- operation: ((acc, value) => S)
  - - (acc, value): S
    - Parameters
      acc: S
      value: T
      Returns S
Returns S
Inherited from SequenceOperators.reduce
- Defined in operators/sync/reduce.ts:14

reduceIndexed

reduceIndexed<S, T>(this, operation): S
Reduces the whole sequence to a single value by invoking operation with each element from left to right. For every invocation of the operation acc is the result of the last invocation. For the first invocation of the operation acc is the first element of the sequence. In addition the index of the current element is also passed to the operation.
Type Parameters
- S
- T
Parameters
- this: Sequence<T>
- operation: ((index, acc, element) => S)
  - - (index, acc, element): S
    - Parameters
      index: number
      acc: S
      element: T
      Returns S
Returns S
Inherited from SequenceOperators.reduceIndexed
- Defined in operators/sync/reduceIndexed.ts:14

reverse

reverse<T>(this): Sequence<T>
Returns a new sequence with all elements of the sequence in reverse order.
Type Parameters
- T
Parameters
- this: Sequence<T>
Returns Sequence<T>
Inherited from SequenceOperators.reverse
- Defined in operators/sync/reverse.ts:10

single

single<T>(this, predicate?): T
Returns the single element of the sequence or throws error if the sequence has more than one element or none at all. If a predicate is passed returns the single element matching the predicate or throws an error if more or less than one element match the predicate.
Type Parameters
- T
Parameters
- this: Sequence<T>
- Optional predicate: ((value) => boolean)
  - - (value): boolean
    - Parameters
      value: T
      Returns boolean
Returns T
Inherited from SequenceOperators.single
- Defined in operators/sync/single.ts:13

singleOrNull

singleOrNull<T>(this, predicate?): null | T
Returns the single element of the sequence or null if the sequence has more than one element or none at all. If a predicate is passed returns the single element matching the predicate or null if more or less than one element match the predicate.
Type Parameters
- T
Parameters
- this: Sequence<T>
- Optional predicate: ((value) => boolean)
  - - (value): boolean
    - Parameters
      value: T
      Returns boolean
Returns null | T
Inherited from SequenceOperators.singleOrNull
- Defined in operators/sync/singleOrNull.ts:13

sorted

sorted<T>(this, composeComparator?): Sequence<T>
Returns a new sequence with all elements sorted by the comparator specified by the given composeComparator function or in natural order if no arguments are given.
Type Parameters
- T
Parameters
- this: Sequence<T>
- Optional composeComparator: ((factory) => Comparator<T>)
  - - (factory): Comparator<T>
    - Parameters
      factory: ComparatorFactory<T>
      Returns Comparator<T>
Returns Sequence<T>
Inherited from SequenceOperators.sorted
- Defined in operators/sync/sorted.ts:54

sortedBy

sortedBy<T, R>(this, selector): Sequence<T>
Returns a new sequence with all elements sorted ascending by the value specified by the given selector function.
Type Parameters
- T
- R
Parameters
- this: Sequence<T>
- selector: ((value) => R)
  - - (value): R
    - Parameters
      value: T
      Returns R
Returns Sequence<T>
Inherited from SequenceOperators.sortedBy
- Defined in operators/sync/sortedBy.ts:13
sortedBy<T>(this, key): Sequence<T>
Returns a new sequence with all elements sorted ascending by the value of the given key.
Type Parameters
- T
Parameters
- this: Sequence<T>
- key: keyof NonNullable<T>
Returns Sequence<T>
Inherited from SequenceOperators.sortedBy
- Defined in operators/sync/sortedBy.ts:20

sortedByDescending

sortedByDescending<T, R>(this, selector): Sequence<T>
Returns a new sequence with all elements sorted descending by the value specified by the given selector function.
Type Parameters
- T
- R
Parameters
- this: Sequence<T>
- selector: ((value) => R)
  - - (value): R
    - Parameters
      value: T
      Returns R
Returns Sequence<T>
Inherited from SequenceOperators.sortedByDescending
- Defined in operators/sync/sortedByDescending.ts:13
sortedByDescending<T>(this, key): Sequence<T>
Returns a new sequence with all elements sorted descending by the value of the given key.
Type Parameters
- T
Parameters
- this: Sequence<T>
- key: keyof NonNullable<T>
Returns Sequence<T>
Inherited from SequenceOperators.sortedByDescending
- Defined in operators/sync/sortedByDescending.ts:20

sortedDescending

sortedDescending<T>(this): Sequence<T>
Returns a new sequence with all elements sorted in reverse (descending) natural order.
Type Parameters
- T
Parameters
- this: Sequence<T>
Returns Sequence<T>
Inherited from SequenceOperators.sortedDescending
- Defined in operators/sync/sortedDescending.ts:10

sortedWith

sortedWith<T>(this, comparison): Sequence<T>
Returns a new sequence with all elements sorted be the given compare function.
Type Parameters
- T
Parameters
- this: Sequence<T>
- comparison: ((a, b) => number)
  - - (a, b): number
    - Parameters
      a: T
      b: T
      Returns number
Returns Sequence<T>
Inherited from SequenceOperators.sortedWith
- Defined in operators/sync/sortedWith.ts:11

sum

sum(this): number
Returns the sum of all numbers.
Parameters
- this: Sequence<number>
Returns number
Inherited from SequenceOperators.sum
- Defined in operators/sync/sum.ts:10

sumBy

sumBy<T>(this, selector): number
Returns the sum of all numbers specified by the given selector function.
Type Parameters
- T
Parameters
- this: Sequence<T>
- selector: ((value) => number)
  - - (value): number
    - Parameters
      value: T
      Returns number
Returns number
Inherited from SequenceOperators.sumBy
- Defined in operators/sync/sumBy.ts:11

take

take<T>(this, n): Sequence<T>
Returns a new sequence consisting of the first n elements. All other elements are discarded.
Type Parameters
- T
Parameters
- this: Sequence<T>
- n: number
Returns Sequence<T>
Inherited from SequenceOperators.take
- Defined in operators/sync/take.ts:12

takeWhile

takeWhile<T>(this, predicate): Sequence<T>
Takes all elements of the sequence as long as the given predicate evaluates to true.
Type Parameters
- T
Parameters
- this: Sequence<T>
- predicate: ((item) => boolean)
  - - (item): boolean
    - Parameters
      item: T
      Returns boolean
Returns Sequence<T>
Inherited from SequenceOperators.takeWhile
- Defined in operators/sync/takeWhile.ts:27

toArray

toArray<T>(this, array?): T[]
Returns all elements of the sequence as array. If an array is passed the elements are appended to the end of the array.
Type Parameters
- T
Parameters
- this: Sequence<T>
- Optional array: T[]
Returns T[]
Inherited from SequenceOperators.toArray
- Defined in operators/sync/toArray.ts:12

toAsyncSequence

toAsyncSequence<T>(this, sequence?): AsyncSequence<T>
Returns an async variant of the sequence.
Type Parameters
- T
Parameters
- this: Sequence<T>
- Optional sequence: AsyncSequence<T>
Returns AsyncSequence<T>
Inherited from SequenceOperators.toAsyncSequence
- Defined in operators/sync/toAsyncSequence.ts:10

toList

toList<T>(this, array?): T[]
Returns all elements of the sequence as array. If an array is passed the elements are appended to the end of the array.
Type Parameters
- T
Parameters
- this: Sequence<T>
- Optional array: T[]
Returns T[]
Inherited from SequenceOperators.toList
- Defined in operators/sync/toArray.ts:27

toMap

toMap<K, V>(this, map?): Map<K, V>
Returns a map consisting of each key-value pair. If a map is passed the pairs are set on this map. Duplicate keys override each other.
Type Parameters
- K
- V
Parameters
- this: Sequence<[K, V]>
- Optional map: Map<K, V>
Returns Map<K, V>
Inherited from SequenceOperators.toMap
- Defined in operators/sync/toMap.ts:12

toMapNotNull

toMapNotNull<K, V>(this, map?): Map<NonNullable<K>, NonNullable<V>>
Returns a map consisting of each key-value pair. Pairs with null or undefined keys or values are discarded. If a map is passed the pairs are set on this map. Duplicate keys override each other.
Type Parameters
- K
- V
Parameters
- this: Sequence<[K, V]>
- Optional map: Map<NonNullable<K>, NonNullable<V>>
Returns Map<NonNullable<K>, NonNullable<V>>
Inherited from SequenceOperators.toMapNotNull
- Defined in operators/sync/toMapNotNull.ts:12

toSet

toSet<T>(this, set?): Set<T>
Returns all elements of the sequence as set. If a set is passed the elements are added to this set.
Type Parameters
- T
Parameters
- this: Sequence<T>
- Optional set: Set<T>
Returns Set<T>
Inherited from SequenceOperators.toSet
- Defined in operators/sync/toSet.ts:12

unzip

unzip<T, S>(this): [T[], S[]]
Returns a pair of arrays where the first array contains all first values and the second array all second values from each input pair of the sequence.
Type Parameters
- T
- S
Parameters
- this: Sequence<[T, S]>
Returns [T[], S[]]
Inherited from SequenceOperators.unzip
- Defined in operators/sync/unzip.ts:11

withIndex

withIndex<T>(this): Sequence<IndexedValue<T>>
Returns a new sequence consisting of indexed values for all original elements.
Type Parameters
- T
Parameters
- this: Sequence<T>
Returns Sequence<IndexedValue<T>>
Inherited from SequenceOperators.withIndex
- Defined in operators/sync/withIndex.ts:33

zip

zip<T, S>(this, other): Sequence<[T, S]>
Returns a new sequence consisting of pairs built the elements of both sequences with the same index. The resulting sequence has the length of the shortest input sequence. All other elements are discarded.
Type Parameters
- T
- S
Parameters
- this: Sequence<T>
- other: Sequence<S>
Returns Sequence<[T, S]>
Inherited from SequenceOperators.zip
- Defined in operators/sync/zip.ts:30

Interface Sequence<T>

Type Parameters

Hierarchy

Index

Properties

Methods

Properties

Readonly iterator

Methods

all

Type Parameters

Parameters

Parameters

Returns boolean

Returns boolean

any

Type Parameters

Parameters

Parameters

Returns boolean

Returns boolean

asIterable

Type Parameters

Parameters

Returns Iterable<T>

associate

Type Parameters

Parameters

Parameters

Returns [K, V]

Returns Map<K, V>

associateBy

Type Parameters

Parameters

Parameters

Returns K

Returns Map<K, T>

Type Parameters

Parameters

Returns Map<NonNullable<T>[K], T>

Type Parameters

Parameters

Parameters

Returns K

Parameters

Returns V

Returns Map<K, V>

Type Parameters

Parameters

Parameters

Returns V

Returns Map<NonNullable<T>[K], V>

average

Parameters

Returns number

chunk

Type Parameters

Parameters

Returns T[][]

contains

Type Parameters

Parameters

Returns boolean

count

Type Parameters

Parameters

Parameters

Returns boolean

Returns number

distinct

Type Parameters

Parameters

Returns Sequence<T>

distinctBy

Type Parameters

Parameters

Parameters

Returns K

Returns Sequence<T>

drop

`Readonly` iterator