Options
All
  • Public
  • Public/Protected
  • All
Menu

Class AsyncSequence<T>

Describes a lazily computed sequence of elements that can be asynchronously iterated over, allowing for composition of intermediate operations in an efficient, on-demand execution order.

Type parameters

  • T

    The type of the values contained by this sequence.

Hierarchy

  • AsyncSequence

Implements

  • AsyncIterable<T>

Index

Constructors

Protected constructor

  • new AsyncSequence<T>(iterable: AwaitableIterable<T>, size?: number): AsyncSequence<T>

Properties

Protected Readonly _size

_size: number

A cached size for sequences with available size information (eg. sequences made from a sized iterable, or sequences mapped from an already sized sequence).

Not of much use for AsyncSequences, since most sized iterables are collections, which don't tend to be asynchronous. Still, a couple cases like Promise<T>[] are sized.
Remains here mostly for API consistency. Less than 0 for non-deterministically sized sequences, like FilteringSequences.

Protected Readonly _values

_values: AwaitableIterable<T>

The underlying asynchronous iterable contained by this sequence. The values are dispatched through its iterator, so any type implementing the asynciterator symbol or having Promises as their parameterized type is fine.

Methods

[asyncIterator]

  • [asyncIterator](): AsyncGenerator<T, any, unknown>
  • Returns an asynchronous generator yielding all values contained by this sequence.

    Returns AsyncGenerator<T, any, unknown>

[toStringTag]

  • [toStringTag](): string

concat

  • Returns a new AsyncSequence containing the values of this sequence and the one provided as an argument. This operation is intermediate and stateless.

    The created sequence will be sized if and only if both of the concatenated sequences are of known size. Otherwise, size information is lost.

    Parameters

    Returns AsyncSequence<T>

contains

  • contains(value: T): Promise<boolean>
  • Returns a promise resolving to true if value is identical to one contained by this sequence. This is a short-circuiting terminal operation.

    Parameters

    • value: T

    Returns Promise<boolean>

containsAll

  • containsAll(values: Iterable<T>): Promise<boolean>
  • Returns a promise resolving to true if all the values in values are contained by this sequence. This is a short-circuiting terminal operation.

    Parameters

    • values: Iterable<T>

    Returns Promise<boolean>

count

  • count(): Promise<number>
  • count(predicate: (item: T) => boolean | Promise<boolean>): Promise<number>
  • count(predicate: (item: T, index?: number) => boolean | Promise<boolean>): Promise<number>
  • If a predicate is provided, returns a promise resolving to the amount of elements in this sequence that fulfilled it. Otherwise, resolved to the the amount of elements in this sequence. This is a terminal operation.

    Returns Promise<number>

  • Parameters

    • predicate: (item: T) => boolean | Promise<boolean>
        • (item: T): boolean | Promise<boolean>
        • Parameters

          • item: T

          Returns boolean | Promise<boolean>

    Returns Promise<number>

  • Parameters

    • predicate: (item: T, index?: number) => boolean | Promise<boolean>
        • (item: T, index?: number): boolean | Promise<boolean>
        • Parameters

          • item: T
          • Optional index: number

          Returns boolean | Promise<boolean>

    Returns Promise<number>

drop

dropWhile

  • dropWhile(predicate: (item: T) => boolean | Promise<boolean>): AsyncSequence<T>
  • dropWhile(predicate: (item: T, index?: number) => boolean | Promise<boolean>): AsyncSequence<T>
  • Returns a new AsyncSequence skipping the first n elements that fulfill a given asynchronous predicate. This operation is intermediate and stateful.

    The sequence created is non-sized.

    Parameters

    • predicate: (item: T) => boolean | Promise<boolean>
        • (item: T): boolean | Promise<boolean>
        • Parameters

          • item: T

          Returns boolean | Promise<boolean>

    Returns AsyncSequence<T>

  • Parameters

    • predicate: (item: T, index?: number) => boolean | Promise<boolean>
        • (item: T, index?: number): boolean | Promise<boolean>
        • Parameters

          • item: T
          • Optional index: number

          Returns boolean | Promise<boolean>

    Returns AsyncSequence<T>

elementAt

  • elementAt(index: number): Promise<undefined | T>
  • Returns a promise resolving to the element at index, or to undefined if the index is out of bounds. Since AsyncSequences are not a Random Access collection, this operation is O(n). This is a short-circuiting terminal operation.

    Parameters

    • index: number

    Returns Promise<undefined | T>

every

  • every(predicate: (item: T) => boolean | Promise<boolean>): Promise<boolean>
  • every(predicate: (item: T, index?: number) => boolean | Promise<boolean>): Promise<boolean>
  • Returns a promise resolving to true if all elements in this sequence fulfill the given asynchronous predicate. This is a short-circuiting terminal operation.

    Parameters

    • predicate: (item: T) => boolean | Promise<boolean>
        • (item: T): boolean | Promise<boolean>
        • Parameters

          • item: T

          Returns boolean | Promise<boolean>

    Returns Promise<boolean>

  • Parameters

    • predicate: (item: T, index?: number) => boolean | Promise<boolean>
        • (item: T, index?: number): boolean | Promise<boolean>
        • Parameters

          • item: T
          • Optional index: number

          Returns boolean | Promise<boolean>

    Returns Promise<boolean>

filter

  • filter(predicate: (item: T) => boolean | Promise<boolean>): AsyncSequence<T>
  • filter(predicate: (item: T, index?: number) => boolean | Promise<boolean>): AsyncSequence<T>
  • filter<S>(predicate: (item: T) => boolean | Promise<boolean>): AsyncSequence<S>
  • filter<S>(predicate: (item: T, index?: number) => boolean | Promise<boolean>): AsyncSequence<S>
  • Returns a new AsyncSequence keeping the elements in this sequence that fulfill the given asynchronous predicate. This operation is intermediate and stateless.

    The sequence created is non-sized.

    Parameters

    • predicate: (item: T) => boolean | Promise<boolean>
        • (item: T): boolean | Promise<boolean>
        • Parameters

          • item: T

          Returns boolean | Promise<boolean>

    Returns AsyncSequence<T>

  • Parameters

    • predicate: (item: T, index?: number) => boolean | Promise<boolean>
        • (item: T, index?: number): boolean | Promise<boolean>
        • Parameters

          • item: T
          • Optional index: number

          Returns boolean | Promise<boolean>

    Returns AsyncSequence<T>

  • Type parameters

    • S

    Parameters

    • predicate: (item: T) => boolean | Promise<boolean>
        • (item: T): boolean | Promise<boolean>
        • Parameters

          • item: T

          Returns boolean | Promise<boolean>

    Returns AsyncSequence<S>

  • Type parameters

    • S

    Parameters

    • predicate: (item: T, index?: number) => boolean | Promise<boolean>
        • (item: T, index?: number): boolean | Promise<boolean>
        • Parameters

          • item: T
          • Optional index: number

          Returns boolean | Promise<boolean>

    Returns AsyncSequence<S>

find

  • find(predicate: (item: T) => boolean | Promise<boolean>): Promise<undefined | T>
  • find(predicate: (item: T, index?: number) => boolean | Promise<boolean>): Promise<undefined | T>
  • Returns a promise resolving to the first item fulfilling an asynchronous predicate, or to undefined if none does. This is a short-circuiting terminal operation.

    Parameters

    • predicate: (item: T) => boolean | Promise<boolean>
        • (item: T): boolean | Promise<boolean>
        • Parameters

          • item: T

          Returns boolean | Promise<boolean>

    Returns Promise<undefined | T>

  • Parameters

    • predicate: (item: T, index?: number) => boolean | Promise<boolean>
        • (item: T, index?: number): boolean | Promise<boolean>
        • Parameters

          • item: T
          • Optional index: number

          Returns boolean | Promise<boolean>

    Returns Promise<undefined | T>

findIndex

  • findIndex(predicate: (item: T) => boolean | Promise<boolean>): Promise<number>
  • Returns a promise resolving to the index of the first item fulfilling an asynchronous predicate, or to -1 if none does. This is a short-circuiting terminal operation.

    Parameters

    • predicate: (item: T) => boolean | Promise<boolean>
        • (item: T): boolean | Promise<boolean>
        • Parameters

          • item: T

          Returns boolean | Promise<boolean>

    Returns Promise<number>

findLast

  • findLast(predicate: (item: T) => boolean | Promise<boolean>): Promise<undefined | T>
  • findLast(predicate: (item: T, index?: number) => boolean | Promise<boolean>): Promise<undefined | T>
  • Returns a promise resolving to the last item fulfilling an asynchronous predicate, or to undefined if none does. This is a terminal operation.

    Parameters

    • predicate: (item: T) => boolean | Promise<boolean>
        • (item: T): boolean | Promise<boolean>
        • Parameters

          • item: T

          Returns boolean | Promise<boolean>

    Returns Promise<undefined | T>

  • Parameters

    • predicate: (item: T, index?: number) => boolean | Promise<boolean>
        • (item: T, index?: number): boolean | Promise<boolean>
        • Parameters

          • item: T
          • Optional index: number

          Returns boolean | Promise<boolean>

    Returns Promise<undefined | T>

findLastIndex

  • findLastIndex(predicate: (item: T) => boolean | Promise<boolean>): Promise<number>
  • Returns a promise resolving to the index of the last item fulfilling an asynchronous predicate, or to -1 if none does. This is a terminal operation.

    Parameters

    • predicate: (item: T) => boolean | Promise<boolean>
        • (item: T): boolean | Promise<boolean>
        • Parameters

          • item: T

          Returns boolean | Promise<boolean>

    Returns Promise<number>

first

  • first(): Promise<undefined | T>
  • Returns a promise resolving to the first element of this sequence, or to undefined if it's empty. This is a short-circuiting terminal operation and it does not hang for infinite sequences.

    Returns Promise<undefined | T>

flatMap

flatten

fold

  • fold<R>(initial: R, operation: (accumulator: R, current: T) => R | Promise<R>): Promise<R>
  • fold<R>(initial: R, operation: (accumulator: R, current: T, index?: number) => R | Promise<R>): Promise<R>
  • Returns a promise resolving to the value resulting from recursively applying an asynchronous operation on an initial value and the current value for every item of this sequence. This is a terminal operation.

    Type parameters

    • R

    Parameters

    • initial: R
    • operation: (accumulator: R, current: T) => R | Promise<R>
        • (accumulator: R, current: T): R | Promise<R>
        • Parameters

          • accumulator: R
          • current: T

          Returns R | Promise<R>

    Returns Promise<R>

  • Type parameters

    • R

    Parameters

    • initial: R
    • operation: (accumulator: R, current: T, index?: number) => R | Promise<R>
        • (accumulator: R, current: T, index?: number): R | Promise<R>
        • Parameters

          • accumulator: R
          • current: T
          • Optional index: number

          Returns R | Promise<R>

    Returns Promise<R>

forEach

  • forEach(action: (item: T) => void | Promise<void>): Promise<void>
  • forEach(action: (item: T, index?: number) => void | Promise<void>): Promise<void>
  • Returns an empty promise performing an asynchronous operation on every item of this sequence. This is a terminal operation.

    Parameters

    • action: (item: T) => void | Promise<void>
        • (item: T): void | Promise<void>
        • Parameters

          • item: T

          Returns void | Promise<void>

    Returns Promise<void>

  • Parameters

    • action: (item: T, index?: number) => void | Promise<void>
        • (item: T, index?: number): void | Promise<void>
        • Parameters

          • item: T
          • Optional index: number

          Returns void | Promise<void>

    Returns Promise<void>

groupBy

  • groupBy<K>(selector: (item: T) => K): Promise<Map<K, T[]>>
  • Groups items in this sequence into a map promise by a key generated by the selector provided. All items that generate the same key (according to {@link Map.has()} equality) will end up in the same bucket. This is a terminal operation.

    Note: TinyLazySeq is opinionated about grouping algorithms and does not provide a "group to object" equivalent (this method is equivalent to {@link Map.groupBy()}, and AsyncSequence does not provide an {@link Object.groupBy()} version). The library developer discourages the usage of objects as maps, as frequent dynamic addition of keys degrades property access performance.

    Type parameters

    • K

    Parameters

    • selector: (item: T) => K
        • (item: T): K
        • Parameters

          • item: T

          Returns K

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

indexOf

  • indexOf(value: T): Promise<number>
  • Returns a promise resolving to the the index of the first item of this sequence value is identical to. If there is none, resolves to -1. This is a short-circuiting terminal operation.

    Parameters

    • value: T

    Returns Promise<number>

isEmpty

  • isEmpty(): Promise<boolean>
  • Returns a promise resolving to true if this collection contains no elements. This is a short-circuiting terminal operation and it does not hang for infinite sequences.

    Returns Promise<boolean>

join

  • join(): Promise<string>
  • join(options: { limit?: number; postfix?: string; prefix?: string; separator?: string; truncated?: string; transform?: any }): Promise<string>
  • Returns a promise resolving to a string representation of this sequence. This is a terminal operation.

    Returns Promise<string>

  • Parameters

    • options: { limit?: number; postfix?: string; prefix?: string; separator?: string; truncated?: string; transform?: any }
      • Optional limit?: number
      • Optional postfix?: string
      • Optional prefix?: string
      • Optional separator?: string
      • Optional truncated?: string
      • transform?:function
        • transform(item: T): string | Promise<string>

    Returns Promise<string>

last

  • last(): Promise<undefined | T>
  • Returns a promise resolving to the last element contained by this sequence. This is a terminal operation.

    Returns Promise<undefined | T>

lastIndexOf

  • lastIndexOf(value: T): Promise<number>
  • Returns a promise resolving to the index of the last element of this sequence value is identical to, or to -1 if none is. This is a terminal operation.

    Parameters

    • value: T

    Returns Promise<number>

map

  • map<U>(transform: (item: T) => U | Promise<U>): AsyncSequence<U>
  • map<U>(transform: (item: T, index?: number) => U | Promise<U>): AsyncSequence<U>
  • Returns a new AsyncSequence asynchronously transforming each value of this sequence. This operation is intermediate and stateless.

    The sequence created retains size information.

    Type parameters

    • U

    Parameters

    • transform: (item: T) => U | Promise<U>
        • (item: T): U | Promise<U>
        • Parameters

          • item: T

          Returns U | Promise<U>

    Returns AsyncSequence<U>

  • Type parameters

    • U

    Parameters

    • transform: (item: T, index?: number) => U | Promise<U>
        • (item: T, index?: number): U | Promise<U>
        • Parameters

          • item: T
          • Optional index: number

          Returns U | Promise<U>

    Returns AsyncSequence<U>

reduce

  • reduce<R>(operation: (accumulator: R, current: T) => R | Promise<R>): Promise<null | R>
  • reduce<R>(operation: (accumulator: R, current: T, index?: number) => R | Promise<R>): Promise<null | R>
  • Returns a promise resolving to a value resulting from recursively applying an asynchronous operation on the first element of this sequence and the current value for every item of this sequence after the first. This is a terminal operation.

    Type parameters

    • R

    Parameters

    • operation: (accumulator: R, current: T) => R | Promise<R>
        • (accumulator: R, current: T): R | Promise<R>
        • Parameters

          • accumulator: R
          • current: T

          Returns R | Promise<R>

    Returns Promise<null | R>

  • Type parameters

    • R

    Parameters

    • operation: (accumulator: R, current: T, index?: number) => R | Promise<R>
        • (accumulator: R, current: T, index?: number): R | Promise<R>
        • Parameters

          • accumulator: R
          • current: T
          • Optional index: number

          Returns R | Promise<R>

    Returns Promise<null | R>

size

  • size(): number
  • Returns the size of the iterable wrapped by this sequence if said iterable is a sized collection (by implementing a length or size property). Otherwise, returns a negative number.

    Returns number

some

  • some(): Promise<boolean>
  • some(predicate?: (item: T) => boolean | Promise<boolean>): Promise<boolean>
  • some(predicate?: (item: T, index?: number) => boolean | Promise<boolean>): Promise<boolean>
  • If a predicate is provided, returns a promise resolving to true if at least one element of this sequence fulfills it. Otherwise, returns a promise resolving to true if there is at least one element in this sequence. This is short-circuiting terminal operation.

    Returns Promise<boolean>

  • Parameters

    • Optional predicate: (item: T) => boolean | Promise<boolean>
        • (item: T): boolean | Promise<boolean>
        • Parameters

          • item: T

          Returns boolean | Promise<boolean>

    Returns Promise<boolean>

  • Parameters

    • Optional predicate: (item: T, index?: number) => boolean | Promise<boolean>
        • (item: T, index?: number): boolean | Promise<boolean>
        • Parameters

          • item: T
          • Optional index: number

          Returns boolean | Promise<boolean>

    Returns Promise<boolean>

take

takeWhile

  • takeWhile(predicate: (item: T) => boolean | Promise<boolean>): AsyncSequence<T>
  • takeWhile(predicate: (item: T, index?: number) => boolean | Promise<boolean>): AsyncSequence<T>
  • Returns a new AsyncSequence dropping all elements after an asynchronous predicate stops fulfilling for the first time. This operation is intermediate and stateful.

    The sequence created is non-sized.

    Parameters

    • predicate: (item: T) => boolean | Promise<boolean>
        • (item: T): boolean | Promise<boolean>
        • Parameters

          • item: T

          Returns boolean | Promise<boolean>

    Returns AsyncSequence<T>

  • Parameters

    • predicate: (item: T, index?: number) => boolean | Promise<boolean>
        • (item: T, index?: number): boolean | Promise<boolean>
        • Parameters

          • item: T
          • Optional index: number

          Returns boolean | Promise<boolean>

    Returns AsyncSequence<T>

toArray

  • toArray(): Promise<T[]>
  • Returns a promise resolving to an array containing the elements of this sequence. This is a terminal operation.

    Returns Promise<T[]>

toString

  • toString(): string
  • Returns a string representation of this sequence and its estimated size, which could be one of the following:

    • 0: Sequence (empty)
    • an integer: Sequence (5)
    • unknown size: Sequence (unknown)

    Returns string

Static empty

Static from

  • from<T>(source: AwaitableIterable<T> | AwaitableIterator<T>): AsyncSequence<T>
  • Creates an asynchronous lazy sequence wrapping the provided iterable. The sequence created is sized if the provided iterable has a length or size property.
    Otherwise, size is less than 0 (unknown).

    Type parameters

    • T

    Parameters

    • source: AwaitableIterable<T> | AwaitableIterator<T>

    Returns AsyncSequence<T>

Static generate

  • generate<T>(initial: Promise<T>, nextValue: (current: T) => null | T | Promise<T>): AsyncSequence<T>
  • Creates an asynchronous lazy sequence whose elements are generated by the recursive application of nextValue on initial until nextValue returns null.
    The sequence created is non-sized (unknown).

    Type parameters

    • T

    Parameters

    • initial: Promise<T>
    • nextValue: (current: T) => null | T | Promise<T>
        • (current: T): null | T | Promise<T>
        • Parameters

          • current: T

          Returns null | T | Promise<T>

    Returns AsyncSequence<T>

Static of

  • Creates an asynchronous lazy sequence containing the provided arguments.
    The sequence created is sized (known).

    Type parameters

    • T

    Parameters

    • Rest ...args: Promise<T>[]

    Returns AsyncSequence<T>

Generated using TypeDoc