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

Type Parameters

Hierarchy

AsyncSequenceOperators<T>
- AsyncSequence

Properties

`Readonly` iterator

iterator: AsyncIterator<T, any, undefined>

Methods

all

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

any

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

asIterable

asIterable<T>(this): AsyncIterable<T>
Returns an iterable representation of the sequence.
Type Parameters
- T
Parameters
- this: AsyncSequence<T>
Returns AsyncIterable<T>
Inherited from AsyncSequenceOperators.asIterable
- Defined in operators/async/asIterable.ts:10

associate

associate<T, K, V>(this, transform): Promise<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: AsyncSequence<T>
- transform: ((value) => [K, V] | Promise<[K, V]>)
  - - (value): [K, V] | Promise<[K, V]>
    - Parameters
      value: T
      Returns [K, V] | Promise<[K, V]>
Returns Promise<Map<K, V>>
Inherited from AsyncSequenceOperators.associate
- Defined in operators/async/associate.ts:12

associateBy

associateBy<K>(keySelector): Promise<Map<K, T>>
Returns a map consisting of the elements mapped by the given keySelector.
Type Parameters
- K
Parameters
- keySelector: ((value) => K | Promise<K>)
  - - (value): K | Promise<K>
    - Parameters
      value: T
      Returns K | Promise<K>
Returns Promise<Map<K, T>>
Inherited from AsyncSequenceOperators.associateBy
- Defined in operators/async/associateBy.ts:12
associateBy<K>(key): Promise<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 Promise<Map<NonNullable<T>[K], T>>
Inherited from AsyncSequenceOperators.associateBy
- Defined in operators/async/associateBy.ts:20
associateBy<K, V>(keySelector, valueTransformer): Promise<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 | Promise<K>)
  - - (value): K | Promise<K>
    - Parameters
      value: T
      Returns K | Promise<K>
- valueTransformer: ((value) => V | Promise<V>)
  - - (value): V | Promise<V>
    - Parameters
      value: T
      Returns V | Promise<V>
Returns Promise<Map<K, V>>
Inherited from AsyncSequenceOperators.associateBy
- Defined in operators/async/associateBy.ts:30
associateBy<K, V>(key, valueTransformer): Promise<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 | Promise<V>)
  - - (value): V | Promise<V>
    - Parameters
      value: T
      Returns V | Promise<V>
Returns Promise<Map<NonNullable<T>[K], V>>
Inherited from AsyncSequenceOperators.associateBy
- Defined in operators/async/associateBy.ts:40

average

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

chunk

chunk<T>(this, chunkSize): Promise<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: AsyncSequence<T>
- chunkSize: number
Returns Promise<T[][]>
Inherited from AsyncSequenceOperators.chunk
- Defined in operators/async/chunk.ts:12

contains

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

count

count<T>(this, predicate?): Promise<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: AsyncSequence<T>
- Optional predicate: ((item) => boolean | Promise<boolean>)
  - - (item): boolean | Promise<boolean>
    - Parameters
      item: T
      Returns boolean | Promise<boolean>
Returns Promise<number>
Inherited from AsyncSequenceOperators.count
- Defined in operators/async/count.ts:12

distinct

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

distinctBy

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

drop

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

dropWhile

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

elementAt

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

elementAtOrElse

elementAtOrElse<T>(this, index, defaultValue): Promise<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: AsyncSequence<T>
- index: number
- defaultValue: ((index) => T | Promise<T>)
  - - (index): T | Promise<T>
    - Parameters
      index: number
      Returns T | Promise<T>
Returns Promise<T>
Inherited from AsyncSequenceOperators.elementAtOrElse
- Defined in operators/async/elementAtOrElse.ts:13

elementAtOrNull

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

filter

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

filterIndexed

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

filterNot

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

filterNotNull

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

find

find<T>(this, predicate?): Promise<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: AsyncSequence<T>
- Optional predicate: ((item) => boolean | Promise<boolean>)
  - - (item): boolean | Promise<boolean>
    - Parameters
      item: T
      Returns boolean | Promise<boolean>
Returns Promise<null | T>
Inherited from AsyncSequenceOperators.find
- Defined in operators/async/firstOrNull.ts:27

findLast

findLast<T>(this, predicate?): Promise<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: AsyncSequence<T>
- Optional predicate: ((value) => boolean | Promise<boolean>)
  - - (value): boolean | Promise<boolean>
    - Parameters
      value: T
      Returns boolean | Promise<boolean>
Returns Promise<null | T>
Inherited from AsyncSequenceOperators.findLast
- Defined in operators/async/lastOrNull.ts:28

first

first<T>(this, predicate?): Promise<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: AsyncSequence<T>
- Optional predicate: ((item) => boolean | Promise<boolean>)
  - - (item): boolean | Promise<boolean>
    - Parameters
      item: T
      Returns boolean | Promise<boolean>
Returns Promise<T>
Inherited from AsyncSequenceOperators.first
- Defined in operators/async/first.ts:12

firstOrNull

firstOrNull<T>(this, predicate?): Promise<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: AsyncSequence<T>
- Optional predicate: ((item) => boolean | Promise<boolean>)
  - - (item): boolean | Promise<boolean>
    - Parameters
      item: T
      Returns boolean | Promise<boolean>
Returns Promise<null | T>
Inherited from AsyncSequenceOperators.firstOrNull
- Defined in operators/async/firstOrNull.ts:11

flatMap

flatMap<S, T>(this, transform): AsyncSequence<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: AsyncSequence<S>
- transform: ((value) => AsyncSequence<T> | Promise<AsyncSequence<T>>)
  - - (value): AsyncSequence<T> | Promise<AsyncSequence<T>>
    - Parameters
      value: S
      Returns AsyncSequence<T> | Promise<AsyncSequence<T>>
Returns AsyncSequence<T>
Inherited from AsyncSequenceOperators.flatMap
- Defined in operators/async/flatMap.ts:35

flatten

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

fold

fold<T, R>(this, initial, operation): Promise<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: AsyncSequence<T>
- initial: R
- operation: ((acc, element) => R | Promise<R>)
  - - (acc, element): R | Promise<R>
    - Parameters
      acc: R
      element: T
      Returns R | Promise<R>
Returns Promise<R>
Inherited from AsyncSequenceOperators.fold
- Defined in operators/async/fold.ts:14

foldIndexed

foldIndexed<T, R>(this, initial, operation): Promise<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: AsyncSequence<T>
- initial: R
- operation: ((index, acc, element) => R | Promise<R>)
  - - (index, acc, element): R | Promise<R>
    - Parameters
      index: number
      acc: R
      element: T
      Returns R | Promise<R>
Returns Promise<R>
Inherited from AsyncSequenceOperators.foldIndexed
- Defined in operators/async/foldIndexed.ts:15

forEach

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

forEachIndexed

forEachIndexed<T>(this, action): Promise<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: AsyncSequence<T>
- action: ((index, value) => unknown)
  - - (index, value): unknown
    - Parameters
      index: number
      value: T
      Returns unknown
Returns Promise<void>
Inherited from AsyncSequenceOperators.forEachIndexed
- Defined in operators/async/forEachIndexed.ts:11

groupBy

groupBy<T, K>(this, keySelector): Promise<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: AsyncSequence<T>
- keySelector: ((value) => K | Promise<K>)
  - - (value): K | Promise<K>
    - Parameters
      value: T
      Returns K | Promise<K>
Returns Promise<Map<K, T[]>>
Inherited from AsyncSequenceOperators.groupBy
- Defined in operators/async/groupBy.ts:11

indexOf

indexOf<T>(this, element): Promise<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: AsyncSequence<T>
- element: T
Returns Promise<number>
Inherited from AsyncSequenceOperators.indexOf
- Defined in operators/async/indexOf.ts:11

indexOfFirst

indexOfFirst<T>(this, predicate): Promise<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: AsyncSequence<T>
- predicate: ((value) => boolean | Promise<boolean>)
  - - (value): boolean | Promise<boolean>
    - Parameters
      value: T
      Returns boolean | Promise<boolean>
Returns Promise<number>
Inherited from AsyncSequenceOperators.indexOfFirst
- Defined in operators/async/indexOfFirst.ts:12

indexOfLast

indexOfLast<T>(this, predicate): Promise<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: AsyncSequence<T>
- predicate: ((value) => boolean | Promise<boolean>)
  - - (value): boolean | Promise<boolean>
    - Parameters
      value: T
      Returns boolean | Promise<boolean>
Returns Promise<number>
Inherited from AsyncSequenceOperators.indexOfLast
- Defined in operators/async/indexOfLast.ts:12

isEmpty

isEmpty<T>(this): Promise<boolean>
Returns true the sequence is empty
Type Parameters
- T
Parameters
- this: AsyncSequence<T>
Returns Promise<boolean>
Inherited from AsyncSequenceOperators.isEmpty
- Defined in operators/async/isEmpty.ts:10

isNotEmpty

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

joinTo

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

joinToString

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

last

last<T>(this, predicate?): Promise<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: AsyncSequence<T>
- Optional predicate: ((value) => boolean | Promise<boolean>)
  - - (value): boolean | Promise<boolean>
    - Parameters
      value: T
      Returns boolean | Promise<boolean>
Returns Promise<T>
Inherited from AsyncSequenceOperators.last
- Defined in operators/async/last.ts:12

lastOrNull

lastOrNull<T>(this, predicate?): Promise<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: AsyncSequence<T>
- Optional predicate: ((value) => boolean | Promise<boolean>)
  - - (value): boolean | Promise<boolean>
    - Parameters
      value: T
      Returns boolean | Promise<boolean>
Returns Promise<null | T>
Inherited from AsyncSequenceOperators.lastOrNull
- Defined in operators/async/lastOrNull.ts:11

map

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

mapIndexed

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

mapNotNull

mapNotNull<T, R>(this, transform): AsyncSequence<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: AsyncSequence<T>
- transform: ((value) => undefined | null | R | Promise<undefined | null | R>)
  - - (value): undefined | null | R | Promise<undefined | null | R>
    - Parameters
      value: T
      Returns undefined | null | R | Promise<undefined | null | R>
Returns AsyncSequence<NonNullable<R>>
Inherited from AsyncSequenceOperators.mapNotNull
- Defined in operators/async/mapNotNull.ts:12

max

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

maxBy

maxBy<T, R>(this, selector): Promise<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: AsyncSequence<T>
- selector: ((value) => R | Promise<R>)
  - - (value): R | Promise<R>
    - Parameters
      value: T
      Returns R | Promise<R>
Returns Promise<null | T>
Inherited from AsyncSequenceOperators.maxBy
- Defined in operators/async/maxBy.ts:12

maxWith

maxWith<T>(this, compare): Promise<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: AsyncSequence<T>
- compare: ((a, b) => number | Promise<number>)
  - - (a, b): number | Promise<number>
    - Parameters
      a: T
      b: T
      Returns number | Promise<number>
Returns Promise<null | T>
Inherited from AsyncSequenceOperators.maxWith
- Defined in operators/async/maxWith.ts:12

merge

merge<T, S>(this, other, selector, prependNewValues?): AsyncSequence<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: AsyncSequence<T>
- other: AsyncSequence<T> | AsyncIterable<T> | Iterable<T>
- selector: ((value) => S | Promise<S>)
  - - (value): S | Promise<S>
    - Parameters
      value: T
      Returns S | Promise<S>
- prependNewValues: boolean = false
Returns AsyncSequence<T>
Inherited from AsyncSequenceOperators.merge
- Defined in operators/async/merge.ts:90

min

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

minBy

minBy<T, R>(this, selector): Promise<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: AsyncSequence<T>
- selector: ((value) => R | Promise<R>)
  - - (value): R | Promise<R>
    - Parameters
      value: T
      Returns R | Promise<R>
Returns Promise<null | T>
Inherited from AsyncSequenceOperators.minBy
- Defined in operators/async/minBy.ts:12

minWith

minWith<T>(this, compare): Promise<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: AsyncSequence<T>
- compare: ((a, b) => number | Promise<number>)
  - - (a, b): number | Promise<number>
    - Parameters
      a: T
      b: T
      Returns number | Promise<number>
Returns Promise<null | T>
Inherited from AsyncSequenceOperators.minWith
- Defined in operators/async/minWith.ts:12

minus

minus<T>(this, data): AsyncSequence<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: AsyncSequence<T>
- data: T | AsyncSequence<T> | T[]
Returns AsyncSequence<T>
Inherited from AsyncSequenceOperators.minus
- Defined in operators/async/minus.ts:12

none

none<T>(this, predicate?): Promise<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: AsyncSequence<T>
- Optional predicate: ((value) => boolean | Promise<boolean>)
  - - (value): boolean | Promise<boolean>
    - Parameters
      value: T
      Returns boolean | Promise<boolean>
Returns Promise<boolean>
Inherited from AsyncSequenceOperators.none
- Defined in operators/async/none.ts:12

onEach

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

onEachIndexed

onEachIndexed<T>(this, action): AsyncSequence<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: AsyncSequence<T>
- action: ((index, value) => unknown)
  - - (index, value): unknown
    - Parameters
      index: number
      value: T
      Returns unknown
Returns AsyncSequence<T>
Inherited from AsyncSequenceOperators.onEachIndexed
- Defined in operators/async/onEachIndexed.ts:12

partition

partition<T>(this, predicate): Promise<{
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: AsyncSequence<T>
- predicate: ((value) => boolean | Promise<boolean>)
  - - (value): boolean | Promise<boolean>
    - Parameters
      value: T
      Returns boolean | Promise<boolean>
Returns Promise<{
false: T[];
true: T[];
}>
Inherited from AsyncSequenceOperators.partition
- Defined in operators/async/partition.ts:12

plus

plus<T>(this, element): AsyncSequence<T>
Appends the given element to the end of the sequence and returns a new sequence.
Type Parameters
- T
Parameters
- this: AsyncSequence<T>
- element: T
Returns AsyncSequence<T>
Inherited from AsyncSequenceOperators.plus
- Defined in operators/async/plus.ts:30
plus<T>(this, other): AsyncSequence<T>
Appends the given array to the end of the sequence and returns a new sequence.
Type Parameters
- T
Parameters
- this: AsyncSequence<T>
- other: T[]
Returns AsyncSequence<T>
Inherited from AsyncSequenceOperators.plus
- Defined in operators/async/plus.ts:38
plus<T>(this, other): AsyncSequence<T>
Appends the given sequence to the end of the sequence and returns a new sequence.
Type Parameters
- T
Parameters
- this: AsyncSequence<T>
- other: AsyncSequence<T>
Returns AsyncSequence<T>
Inherited from AsyncSequenceOperators.plus
- Defined in operators/async/plus.ts:46

reduce

reduce<S, T>(this, operation): Promise<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: AsyncSequence<T>
- operation: ((acc, value) => S | Promise<S>)
  - - (acc, value): S | Promise<S>
    - Parameters
      acc: S
      value: T
      Returns S | Promise<S>
Returns Promise<S>
Inherited from AsyncSequenceOperators.reduce
- Defined in operators/async/reduce.ts:14

reduceIndexed

reduceIndexed<S, T>(this, operation): Promise<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: AsyncSequence<T>
- operation: ((index, acc, element) => S | Promise<S>)
  - - (index, acc, element): S | Promise<S>
    - Parameters
      index: number
      acc: S
      element: T
      Returns S | Promise<S>
Returns Promise<S>
Inherited from AsyncSequenceOperators.reduceIndexed
- Defined in operators/async/reduceIndexed.ts:14

reverse

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

single

single<T>(this, predicate?): Promise<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: AsyncSequence<T>
- Optional predicate: ((value) => boolean | Promise<boolean>)
  - - (value): boolean | Promise<boolean>
    - Parameters
      value: T
      Returns boolean | Promise<boolean>
Returns Promise<T>
Inherited from AsyncSequenceOperators.single
- Defined in operators/async/single.ts:13

singleOrNull

singleOrNull<T>(this, predicate?): Promise<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: AsyncSequence<T>
- Optional predicate: ((value) => boolean | Promise<boolean>)
  - - (value): boolean | Promise<boolean>
    - Parameters
      value: T
      Returns boolean | Promise<boolean>
Returns Promise<null | T>
Inherited from AsyncSequenceOperators.singleOrNull
- Defined in operators/async/singleOrNull.ts:13

sorted

sorted<T>(this, composeComparator?): AsyncSequence<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: AsyncSequence<T>
- Optional composeComparator: ((factory) => Comparator<T>)
  - - (factory): Comparator<T>
    - Parameters
      factory: ComparatorFactory<T>
      Returns Comparator<T>
Returns AsyncSequence<T>
Inherited from AsyncSequenceOperators.sorted
- Defined in operators/async/sorted.ts:54

sortedBy

sortedBy<T, R>(this, selector): AsyncSequence<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: AsyncSequence<T>
- selector: ((value) => R | Promise<R>)
  - - (value): R | Promise<R>
    - Parameters
      value: T
      Returns R | Promise<R>
Returns AsyncSequence<T>
Inherited from AsyncSequenceOperators.sortedBy
- Defined in operators/async/sortedBy.ts:13
sortedBy<T>(this, key): AsyncSequence<T>
Returns a new sequence with all elements sorted ascending by the value of the given key.
Type Parameters
- T
Parameters
- this: AsyncSequence<T>
- key: keyof NonNullable<T>
Returns AsyncSequence<T>
Inherited from AsyncSequenceOperators.sortedBy
- Defined in operators/async/sortedBy.ts:20

sortedByDescending

sortedByDescending<T, R>(this, selector): AsyncSequence<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: AsyncSequence<T>
- selector: ((value) => R | Promise<R>)
  - - (value): R | Promise<R>
    - Parameters
      value: T
      Returns R | Promise<R>
Returns AsyncSequence<T>
Inherited from AsyncSequenceOperators.sortedByDescending
- Defined in operators/async/sortedByDescending.ts:13
sortedByDescending<T>(this, key): AsyncSequence<T>
Returns a new sequence with all elements sorted descending by the value of the given key.
Type Parameters
- T
Parameters
- this: AsyncSequence<T>
- key: keyof NonNullable<T>
Returns AsyncSequence<T>
Inherited from AsyncSequenceOperators.sortedByDescending
- Defined in operators/async/sortedByDescending.ts:20

sortedDescending

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

sortedWith

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

sum

sum(this): Promise<number>
Returns the sum of all numbers.
Parameters
- this: AsyncSequence<number>
Returns Promise<number>
Inherited from AsyncSequenceOperators.sum
- Defined in operators/async/sum.ts:10

sumBy

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

take

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

takeWhile

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

toArray

toArray<T>(this, array?): Promise<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: AsyncSequence<T>
- Optional array: T[]
Returns Promise<T[]>
Inherited from AsyncSequenceOperators.toArray
- Defined in operators/async/toArray.ts:12

toList

toList<T>(this, array?): Promise<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: AsyncSequence<T>
- Optional array: T[]
Returns Promise<T[]>
Inherited from AsyncSequenceOperators.toList
- Defined in operators/async/toArray.ts:27

toMap

toMap<K, V>(this, map?): Promise<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: AsyncSequence<[K, V]>
- Optional map: Map<K, V>
Returns Promise<Map<K, V>>
Inherited from AsyncSequenceOperators.toMap
- Defined in operators/async/toMap.ts:12

toMapNotNull

toMapNotNull<K, V>(this, map?): Promise<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: AsyncSequence<[K, V]>
- Optional map: Map<NonNullable<K>, NonNullable<V>>
Returns Promise<Map<NonNullable<K>, NonNullable<V>>>
Inherited from AsyncSequenceOperators.toMapNotNull
- Defined in operators/async/toMapNotNull.ts:12

toSequence

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

toSet

toSet<T>(this, set?): Promise<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: AsyncSequence<T>
- Optional set: Set<T>
Returns Promise<Set<T>>
Inherited from AsyncSequenceOperators.toSet
- Defined in operators/async/toSet.ts:12

unzip

unzip<T, S>(this): Promise<[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: AsyncSequence<[T, S]>
Returns Promise<[T[], S[]]>
Inherited from AsyncSequenceOperators.unzip
- Defined in operators/async/unzip.ts:11

withIndex

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

zip

zip<T, S>(this, other): AsyncSequence<[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: AsyncSequence<T>
- other: AsyncSequence<S>
Returns AsyncSequence<[T, S]>
Inherited from AsyncSequenceOperators.zip
- Defined in operators/async/zip.ts:30

Interface AsyncSequence<T>

Type Parameters

Hierarchy

Index

Properties

Methods

Properties

Readonly iterator

Methods

all

Type Parameters

Parameters

Parameters

Returns boolean | Promise<boolean>

Returns Promise<boolean>

any

Type Parameters

Parameters

Parameters

Returns boolean | Promise<boolean>

Returns Promise<boolean>

asIterable

Type Parameters

Parameters

Returns AsyncIterable<T>

associate

Type Parameters

Parameters

Parameters

Returns [K, V] | Promise<[K, V]>

Returns Promise<Map<K, V>>

associateBy

Type Parameters

Parameters

Parameters

Returns K | Promise<K>

Returns Promise<Map<K, T>>

Type Parameters

Parameters

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

Type Parameters

Parameters

Parameters

Returns K | Promise<K>

Parameters

Returns V | Promise<V>

Returns Promise<Map<K, V>>

Type Parameters

Parameters

Parameters

Returns V | Promise<V>

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

average

Parameters

Returns Promise<number>

chunk

Type Parameters

Parameters

Returns Promise<T[][]>

contains

Type Parameters

Parameters

Returns Promise<boolean>

count

Type Parameters

Parameters

Parameters

Returns boolean | Promise<boolean>

Returns Promise<number>

distinct

Type Parameters

Parameters

Returns AsyncSequence<T>

distinctBy

Type Parameters

Parameters

Parameters

Returns K | Promise<K>

Returns AsyncSequence<T>

drop

`Readonly` iterator