Interface IAsyncEnumerable<TSource>

Async Iterable type with methods from LINQ.

interface IAsyncEnumerable<TSource> {
    "[asyncIterator]"(): AsyncIterableIterator<TSource>;
    aggregate(func: (x: TSource, y: TSource) => TSource): Promise<TSource>;
    aggregate<TAccumulate>(
        seed: TAccumulate,
        func: (x: TAccumulate, y: TSource) => TAccumulate,
    ): Promise<TAccumulate>;
    aggregate<TAccumulate, TResult>(
        seed: TAccumulate,
        func: (x: TAccumulate, y: TSource) => TAccumulate,
        resultSelector: (x: TAccumulate) => TResult,
    ): Promise<TResult>;
    all(predicate: (x: TSource) => boolean): Promise<boolean>;
    allAsync(predicate: (x: TSource) => Promise<boolean>): Promise<boolean>;
    any(predicate?: (x: TSource) => boolean): Promise<boolean>;
    anyAsync(predicate: (x: TSource) => Promise<boolean>): Promise<boolean>;
    append(element: TSource): IAsyncEnumerable<TSource>;
    asParallel(): IParallelEnumerable<TSource>;
    average(this: IAsyncParallel<number>): Promise<number>;
    average(selector: (x: TSource) => number): Promise<number>;
    averageAsync(selector: (x: TSource) => Promise<number>): Promise<number>;
    chunk(size: number): IAsyncEnumerable<TSource[]>;
    concatenate(second: IAsyncEnumerable<TSource>): IAsyncEnumerable<TSource>;
    contains(
        value: TSource,
        comparer?: IEqualityComparer<TSource>,
    ): Promise<boolean>;
    containsAsync(
        value: TSource,
        comparer: IAsyncEqualityComparer<TSource>,
    ): Promise<boolean>;
    count(predicate?: (x: TSource) => boolean): Promise<number>;
    countAsync(predicate: (x: TSource) => Promise<boolean>): Promise<number>;
    defaultIfEmpty(
        defaultValue: TSource | Promise<TSource>,
    ): IAsyncEnumerable<TSource>;
    distinct(comparer?: IEqualityComparer<TSource>): IAsyncEnumerable<TSource>;
    distinctAsync(
        comparer: IAsyncEqualityComparer<TSource>,
    ): IAsyncEnumerable<TSource>;
    each(action: (x: TSource) => void): IAsyncEnumerable<TSource>;
    eachAsync(action: (x: TSource) => Promise<void>): IAsyncEnumerable<TSource>;
    elementAt(index: number): Promise<TSource>;
    elementAtOrDefault(index: number): Promise<null | TSource>;
    except(
        second: IAsyncEnumerable<TSource>,
        comparer?: IEqualityComparer<TSource>,
    ): IAsyncEnumerable<TSource>;
    exceptAsync(
        second: IAsyncEnumerable<TSource>,
        comparer: IAsyncEqualityComparer<TSource>,
    ): IAsyncEnumerable<TSource>;
    first(predicate?: (x: TSource) => boolean): Promise<TSource>;
    firstAsync(predicate: (x: TSource) => Promise<boolean>): Promise<TSource>;
    firstOrDefault(
        predicate?: (x: TSource) => boolean,
    ): Promise<null | TSource>;
    firstOrDefaultAsync(
        predicate: (x: TSource) => Promise<boolean>,
    ): Promise<null | TSource>;
    groupBy<TKey extends SelectorKeyType>(
        keySelector: (x: TSource) => TKey,
    ): IAsyncEnumerable<IGrouping<TKey, TSource>>;
    groupBy<TKey>(
        keySelector: (x: TSource) => TKey,
        comparer: IEqualityComparer<TKey>,
    ): IAsyncEnumerable<IGrouping<TKey, TSource>>;
    groupByAsync<TKey extends SelectorKeyType>(
        keySelector: (x: TSource) => TKey | Promise<TKey>,
    ): IAsyncEnumerable<IGrouping<TKey, TSource>>;
    groupByAsync<TKey>(
        keySelector: (x: TSource) => TKey | Promise<TKey>,
        comparer: IEqualityComparer<TKey> | IAsyncEqualityComparer<TKey>,
    ): IAsyncEnumerable<IGrouping<TKey, TSource>>;
    groupByWithSel<TKey extends SelectorKeyType, TElement>(
        keySelector: (x: TSource) => TKey,
        elementSelector: (x: TSource) => TElement,
        comparer?: IEqualityComparer<TKey>,
    ): IAsyncEnumerable<IGrouping<TKey, TElement>>;
    groupByWithSel<TKey, TElement>(
        keySelector: (x: TSource) => TKey,
        elementSelector: (x: TSource) => TElement,
        comparer: IEqualityComparer<TKey>,
    ): IAsyncEnumerable<IGrouping<TKey, TElement>>;
    groupJoin<TInner, TKey, TResult>(
        inner: Iterable<TInner, any, any> | AsyncIterable<TInner, any, any>,
        outerKeySelector: (value: TSource) => TKey,
        innerKeySelector: (value: TInner) => TKey,
        resultSelector: (element: TSource, collection: TInner[]) => TResult,
        comparer?: IEqualityComparer<TKey>,
    ): IAsyncEnumerable<TResult>;
    groupJoinAsync<TInner, TKey, TResult>(
        inner: Iterable<TInner, any, any> | AsyncIterable<TInner, any, any>,
        outerKeySelector: (value: TSource) => TKey | Promise<TKey>,
        innerKeySelector: (value: TInner) => TKey | Promise<TKey>,
        resultSelector: (
            element: TSource,
            collection: TInner[],
        ) => TResult | Promise<TResult>,
        comparer?: IEqualityComparer<TKey>,
    ): IAsyncEnumerable<TResult>;
    intersect(
        second: IAsyncEnumerable<TSource>,
        comparer?: IEqualityComparer<TSource>,
    ): IAsyncEnumerable<TSource>;
    intersectAsync(
        second: IAsyncEnumerable<TSource>,
        comparer: IAsyncEqualityComparer<TSource>,
    ): IAsyncEnumerable<TSource>;
    joinByKey<TInner, TKey, TResult>(
        inner: IAsyncEnumerable<TInner>,
        outerKeySelector: (x: TSource) => TKey,
        innerKeySelector: (x: TInner) => TKey,
        resultSelector: (x: TSource, y: TInner) => TResult,
        comparer?: IEqualityComparer<TKey>,
    ): IAsyncEnumerable<TResult>;
    last(predicate?: (x: TSource) => boolean): Promise<TSource>;
    lastAsync(predicate: (x: TSource) => Promise<boolean>): Promise<TSource>;
    lastOrDefault(predicate?: (x: TSource) => boolean): Promise<null | TSource>;
    lastOrDefaultAsync(
        predicate: (x: TSource) => Promise<boolean>,
    ): Promise<null | TSource>;
    max(this: IAsyncParallel<number>): Promise<number>;
    max(selector: (x: TSource) => number): Promise<number>;
    maxAsync(selector: (x: TSource) => Promise<number>): Promise<number>;
    min(this: IAsyncParallel<number>): Promise<number>;
    min(selector: (x: TSource) => number): Promise<number>;
    minAsync(selector: (x: TSource) => Promise<number>): Promise<number>;
    ofType<TType extends OfType>(
        type: TType,
    ): IAsyncEnumerable<InferType<TType>>;
    order(comparer?: IComparer<TSource>): IOrderedAsyncEnumerable<TSource>;
    orderBy<TKey>(
        predicate: (x: TSource) => TKey,
        comparer?: IComparer<TKey>,
    ): IOrderedAsyncEnumerable<TSource>;
    orderByAsync<TKey>(
        predicate: (x: TSource) => Promise<TKey>,
        comparer?: IComparer<TKey>,
    ): IOrderedAsyncEnumerable<TSource>;
    orderByDescending<TKey>(
        predicate: (x: TSource) => TKey,
        comparer?: IComparer<TKey>,
    ): IOrderedAsyncEnumerable<TSource>;
    orderByDescendingAsync<TKey>(
        predicate: (x: TSource) => Promise<TKey>,
        comparer?: IComparer<TKey>,
    ): IOrderedAsyncEnumerable<TSource>;
    orderDescending(
        comparer?: IComparer<TSource>,
    ): IOrderedAsyncEnumerable<TSource>;
    partition(
        predicate: (x: TSource) => boolean,
    ): Promise<[pass: TSource[], fail: TSource[]]>;
    partitionAsync(
        predicate: (x: TSource) => Promise<boolean>,
    ): Promise<[pass: TSource[], fail: TSource[]]>;
    prepend(element: TSource): IAsyncEnumerable<TSource>;
    reverse(): IAsyncEnumerable<TSource>;
    select<TResult>(
        selector: (x: TSource, index: number) => TResult,
    ): IAsyncEnumerable<TResult>;
    select<TKey extends string | number | symbol>(
        key: TKey,
    ): IAsyncEnumerable<TSource[TKey]>;
    selectAsync<TResult>(
        selector: (x: TSource, index: number) => Promise<TResult>,
    ): IAsyncEnumerable<TResult>;
    selectAsync<TKey extends string | number | symbol, TResult>(
        this: IAsyncEnumerable<{ [key: string]: Promise<TResult> }>,
        key: TKey,
    ): IAsyncEnumerable<TResult>;
    selectMany<TResult>(
        selector: (x: TSource, index: number) => Iterable<TResult>,
    ): IAsyncEnumerable<TResult>;
    selectMany<
        TBindedSource extends { [key: string]: Iterable<TOut, any, any> },
        TOut,
    >(
        this: IAsyncEnumerable<TBindedSource>,
        selector: keyof TBindedSource,
    ): IAsyncEnumerable<TOut>;
    selectManyAsync<TResult>(
        selector: (
            x: TSource,
            index: number,
        ) => Promise<Iterable<TResult, any, any>>,
    ): IAsyncEnumerable<TResult>;
    sequenceEquals(
        second: AsyncIterable<TSource>,
        comparer?: IEqualityComparer<TSource>,
    ): Promise<boolean>;
    sequenceEqualsAsync(
        second: AsyncIterable<TSource>,
        comparer: IAsyncEqualityComparer<TSource>,
    ): Promise<boolean>;
    single(predicate?: (x: TSource) => boolean): Promise<TSource>;
    singleAsync(predicate: (x: TSource) => Promise<boolean>): Promise<TSource>;
    singleOrDefault(
        predicate?: (x: TSource) => boolean,
    ): Promise<null | TSource>;
    singleOrDefaultAsync(
        predicate: (x: TSource) => Promise<boolean>,
    ): Promise<null | TSource>;
    skip(count: number): IAsyncEnumerable<TSource>;
    skipWhile(
        predicate: (x: TSource, index: number) => boolean,
    ): IAsyncEnumerable<TSource>;
    skipWhileAsync(
        predicate: (x: TSource, index: number) => Promise<boolean>,
    ): IAsyncEnumerable<TSource>;
    sum(this: IAsyncParallel<number>): Promise<number>;
    sum(selector: (x: TSource) => number): Promise<number>;
    sumAsync(selector: (x: TSource) => Promise<number>): Promise<number>;
    take(amount: number): IAsyncEnumerable<TSource>;
    takeWhile(
        predicate: (x: TSource, index: number) => boolean,
    ): IAsyncEnumerable<TSource>;
    takeWhileAsync(
        predicate: (x: TSource, index: number) => Promise<boolean>,
    ): IAsyncEnumerable<TSource>;
    toArray(): Promise<TSource[]>;
    toMap<TKey>(selector: (x: TSource) => TKey): Promise<Map<TKey, TSource[]>>;
    toMapAsync<TKey>(
        selector: (x: TSource) => Promise<TKey>,
    ): Promise<Map<TKey, TSource[]>>;
    toObject<TKey extends string | number | symbol>(
        selector: (x: TSource) => TKey,
    ): Promise<Record<TKey, TSource>>;
    toObjectAsync<TKey extends string | number | symbol>(
        selector: (x: TSource) => Promise<TKey>,
    ): Promise<Record<TKey, TSource>>;
    toSet(): Promise<Set<TSource>>;
    union(
        second: AsyncIterable<TSource>,
        comparer?: IEqualityComparer<TSource>,
    ): IAsyncEnumerable<TSource>;
    unionAsync(
        second: AsyncIterable<TSource>,
        comparer: IAsyncEqualityComparer<TSource>,
    ): IAsyncEnumerable<TSource>;
    where(
        predicate: (x: TSource, index: number) => boolean,
    ): IAsyncEnumerable<TSource>;
    whereAsync(
        predicate: (x: TSource, index: number) => Promise<boolean>,
    ): IAsyncEnumerable<TSource>;
    zip<TSecond, TResult>(
        second: AsyncIterable<TSecond>,
        resultSelector: (x: TSource, y: TSecond) => TResult,
    ): IAsyncEnumerable<TResult>;
    zip<TSecond>(
        second: AsyncIterable<TSecond>,
    ): IAsyncEnumerable<[TSource, TSecond]>;
    zipAsync<TSecond, TResult>(
        second: AsyncIterable<TSecond>,
        resultSelector: (x: TSource, y: TSecond) => Promise<TResult>,
    ): IAsyncEnumerable<TResult>;
}

Type Parameters

TSource

Hierarchy (View Summary)

IAsyncParallel<TSource>
- IAsyncEnumerable
  - IOrderedAsyncEnumerable

Index

Methods

[asyncIterator] aggregate all allAsync any anyAsync append asParallel average averageAsync chunk concatenate contains containsAsync count countAsync defaultIfEmpty distinct distinctAsync each eachAsync elementAt elementAtOrDefault except exceptAsync first firstAsync firstOrDefault firstOrDefaultAsync groupBy groupByAsync groupByWithSel groupJoin groupJoinAsync intersect intersectAsync joinByKey last lastAsync lastOrDefault lastOrDefaultAsync max maxAsync min minAsync ofType order orderBy orderByAsync orderByDescending orderByDescendingAsync orderDescending partition partitionAsync prepend reverse select selectAsync selectMany selectManyAsync sequenceEquals sequenceEqualsAsync single singleAsync singleOrDefault singleOrDefaultAsync skip skipWhile skipWhileAsync sum sumAsync take takeWhile takeWhileAsync toArray toMap toMapAsync toObject toObjectAsync toSet union unionAsync where whereAsync zip zipAsync

Methods

[asyncIterator]

"[asyncIterator]"(): AsyncIterableIterator<TSource>
Returns AsyncIterableIterator<TSource>
Inherited from IAsyncParallel.[asyncIterator]
- Defined in src/types/IAsyncParallel.ts:292

aggregate

aggregate(func: (x: TSource, y: TSource) => TSource): Promise<TSource>
Applies an accumulator function over a sequence.
Parameters
- func: (x: TSource, y: TSource) => TSource
  An accumulator function to be invoked on each element.
Returns Promise<TSource>
The final accumulator value.
Inherited from IAsyncParallel.aggregate
- Defined in src/types/IAsyncParallel.ts:12
aggregate<TAccumulate>(
seed: TAccumulate,
func: (x: TAccumulate, y: TSource) => TAccumulate,
): Promise<TAccumulate>
Applies an accumulator function over a sequence. The specified seed value is used as the initial accumulator value.
Type Parameters
- TAccumulate
Parameters
- seed: TAccumulate
  The initial accumulator value.
- func: (x: TAccumulate, y: TSource) => TAccumulate
  An accumulator function to be invoked on each element.
Returns Promise<TAccumulate>
The final accumulator value.
Inherited from IAsyncParallel.aggregate
- Defined in src/types/IAsyncParallel.ts:20
aggregate<TAccumulate, TResult>(
    seed: TAccumulate,
    func: (x: TAccumulate, y: TSource) => TAccumulate,
    resultSelector: (x: TAccumulate) => TResult,
): Promise<TResult>
Applies an accumulator function over a sequence. The specified seed value is used as the initial accumulator value, and the specified function is used to select the result value.
Type Parameters
- TAccumulate
- TResult
Parameters
- seed: TAccumulate
  The initial accumulator value.
- func: (x: TAccumulate, y: TSource) => TAccumulate
  An accumulator function to be invoked on each element.
- resultSelector: (x: TAccumulate) => TResult
  A function to transform the final accumulator value into the result value.
Returns Promise<TResult>
The transformed final accumulator value.
Inherited from IAsyncParallel.aggregate
- Defined in src/types/IAsyncParallel.ts:30

all

all(predicate: (x: TSource) => boolean): Promise<boolean>
Determines whether all elements of a sequence satisfy a condition.
Parameters
- predicate: (x: TSource) => boolean
  A function to test each element for a condition.
Returns Promise<boolean>
true if every element of the source sequence passes the test in the specified predicate, or if the sequence is empty; otherwise, false.
Inherited from IAsyncParallel.all
- Defined in src/types/IAsyncParallel.ts:40

allAsync

allAsync(predicate: (x: TSource) => Promise<boolean>): Promise<boolean>
Determines whether all elements of a sequence satisfy a condition.
Parameters
- predicate: (x: TSource) => Promise<boolean>
  An async function to test each element for a condition.
Returns Promise<boolean>
true if every element of the source sequence passes the test in the specified predicate, or if the sequence is empty; otherwise, false.
Inherited from IAsyncParallel.allAsync
- Defined in src/types/IAsyncParallel.ts:47

any

any(predicate?: (x: TSource) => boolean): Promise<boolean>
Determines whether a sequence contains any elements. If predicate is specified, determines whether any element of a sequence satisfies a condition.
Parameters
- Optionalpredicate: (x: TSource) => boolean
  A function to test each element for a condition.
Returns Promise<boolean>
true if the source sequence contains any elements or passes the test specified; otherwise, false.
Inherited from IAsyncParallel.any
- Defined in src/types/IAsyncParallel.ts:54

anyAsync

anyAsync(predicate: (x: TSource) => Promise<boolean>): Promise<boolean>
Determines whether any element of a sequence satisfies a condition.
Parameters
- predicate: (x: TSource) => Promise<boolean>
  An async function to test each element for a condition.
Returns Promise<boolean>
true if the source sequence contains any elements or passes the test specified; otherwise, false.
Inherited from IAsyncParallel.anyAsync
- Defined in src/types/IAsyncParallel.ts:60

append

append(element: TSource): IAsyncEnumerable<TSource>
Appends a value to the end of the sequence.
Parameters
- element: TSource
  The value to append to the sequence.
Returns IAsyncEnumerable<TSource>
An IAsyncEnumerable that ends with the specified element.
- Defined in src/types/IAsyncEnumerable.ts:21

asParallel

asParallel(): IParallelEnumerable<TSource>
Converts an async iterable to a Parallel Enumerable.

Returns IParallelEnumerable<TSource>
Parallel Enumerable of source
- Defined in src/types/IAsyncEnumerable.ts:26

average

average(this: IAsyncParallel<number>): Promise<number>
Computes the average of a sequence of number values.
Parameters
- this: IAsyncParallel<number>
Returns Promise<number>
The average of the sequence of values.

Throws
source contains no elements.
Inherited from IAsyncParallel.average
- Defined in src/types/IAsyncParallel.ts:66
average(selector: (x: TSource) => number): Promise<number>
Computes the average of a sequence of values that are obtained by invoking a transform function on each element of the input sequence.
Parameters
- selector: (x: TSource) => number
  A transform function to apply to each element.
Returns Promise<number>
The average of the sequence of values.

Throws
source contains no elements.
Inherited from IAsyncParallel.average
- Defined in src/types/IAsyncParallel.ts:74

averageAsync

averageAsync(selector: (x: TSource) => Promise<number>): Promise<number>
Computes the average of a sequence of values that are obtained by invoking a transform function on each element of the input sequence.
Parameters
- selector: (x: TSource) => Promise<number>
  An async transform function to apply to each element.
Returns Promise<number>
The average of the sequence of values.

Throws
source contains no elements.
Inherited from IAsyncParallel.averageAsync
- Defined in src/types/IAsyncParallel.ts:82

chunk

chunk(size: number): IAsyncEnumerable<TSource[]>
Splits the elements of a sequence into chunks of size at most size.
Parameters
- size: number
  The maximum size of each chunk.
Returns IAsyncEnumerable<TSource[]>
An IAsyncEnumerable that contains the elements the input sequence split into chunks of size size.
- Defined in src/types/IAsyncEnumerable.ts:32

concatenate

concatenate(second: IAsyncEnumerable<TSource>): IAsyncEnumerable<TSource>
Concatenates two async sequences.
Parameters
- second: IAsyncEnumerable<TSource>
  The sequence to concatenate to the first sequence.
Returns IAsyncEnumerable<TSource>
An IAsyncEnumerable that contains the concatenated elements of the two sequences.
- Defined in src/types/IAsyncEnumerable.ts:38

contains

contains(
value: TSource,
comparer?: IEqualityComparer<TSource>,
): Promise<boolean>
Determines whether a sequence contains a specified element by using the specified or default IEqualityComparer.
Parameters
- value: TSource
  The value to locate in the sequence.
- Optionalcomparer: IEqualityComparer<TSource>
  An equality comparer to compare values. Optional.
Returns Promise<boolean>
true if the source sequence contains an element that has the specified value; otherwise, false.
Inherited from IAsyncParallel.contains
- Defined in src/types/IAsyncParallel.ts:90

containsAsync

containsAsync(
value: TSource,
comparer: IAsyncEqualityComparer<TSource>,
): Promise<boolean>
Determines whether a sequence contains a specified element by using the specified or default IEqualityComparer.
Parameters
- value: TSource
  The value to locate in the sequence.
- comparer: IAsyncEqualityComparer<TSource>
  An async equality comparer to compare values.
Returns Promise<boolean>
true if the source sequence contains an element that has the specified value; otherwise, false.
Inherited from IAsyncParallel.containsAsync
- Defined in src/types/IAsyncParallel.ts:98

count

count(predicate?: (x: TSource) => boolean): Promise<number>
Returns the number of elements in a sequence or represents how many elements in the specified sequence satisfy a condition if the predicate is specified.
Parameters
- Optionalpredicate: (x: TSource) => boolean
  A function to test each element for a condition. Optional.
Returns Promise<number>
The number of elements in the input sequence.
Inherited from IAsyncParallel.count
- Defined in src/types/IAsyncParallel.ts:106

countAsync

countAsync(predicate: (x: TSource) => Promise<boolean>): Promise<number>
Returns the number of elements in a sequence or represents how many elements in the specified sequence satisfy a condition if the predicate is specified.
Parameters
- predicate: (x: TSource) => Promise<boolean>
  A function to test each element for a condition.
Returns Promise<number>
The number of elements in the input sequence.
Inherited from IAsyncParallel.countAsync
- Defined in src/types/IAsyncParallel.ts:114

defaultIfEmpty

defaultIfEmpty(
defaultValue: TSource | Promise<TSource>,
): IAsyncEnumerable<TSource>
Returns the elements of an IAsyncEnumerable, or a default valued singleton collection if the sequence is empty.
Parameters
- defaultValue: TSource | Promise<TSource>
  The value, or Promise that gives back that value, to return if the sequence is empty.
Returns IAsyncEnumerable<TSource>
An IAsyncEnumerable that contains defaultValue if source is empty; otherwise, source.
- Defined in src/types/IAsyncEnumerable.ts:44

distinct

distinct(comparer?: IEqualityComparer<TSource>): IAsyncEnumerable<TSource>
Returns distinct elements from a sequence by using the default or specified equality comparer to compare values.
Parameters
- Optionalcomparer: IEqualityComparer<TSource>
  An IEqualityComparer to compare values. Optional. Defaults to Strict Equality Comparison.
Returns IAsyncEnumerable<TSource>
An IAsyncEnumerable that contains distinct elements from the source sequence.
- Defined in src/types/IAsyncEnumerable.ts:51

distinctAsync

distinctAsync(
comparer: IAsyncEqualityComparer<TSource>,
): IAsyncEnumerable<TSource>
Returns distinct elements from a sequence by using the specified equality comparer to compare values.
Parameters
- comparer: IAsyncEqualityComparer<TSource>
  An IAsyncEqualityComparer to compare values.
Returns IAsyncEnumerable<TSource>
An IAsyncEnumerable that contains distinct elements from the source sequence.
- Defined in src/types/IAsyncEnumerable.ts:57

each

each(action: (x: TSource) => void): IAsyncEnumerable<TSource>
Performs a specified action on each element of the Iterable
Parameters
- action: (x: TSource) => void
  The action to take an each element
Returns IAsyncEnumerable<TSource>
A new IAsyncEnumerable that executes the action lazily as you iterate.
- Defined in src/types/IAsyncEnumerable.ts:63

eachAsync

eachAsync(action: (x: TSource) => Promise<void>): IAsyncEnumerable<TSource>
Performs a specified action on each element of the Iterable
Parameters
- action: (x: TSource) => Promise<void>
  The async action to take an each element
Returns IAsyncEnumerable<TSource>
A new IAsyncEnumerable that executes the action lazily as you iterate.
- Defined in src/types/IAsyncEnumerable.ts:69

elementAt

elementAt(index: number): Promise<TSource>
Returns the element at a specified index in a sequence.
Parameters
- index: number
  The zero-based index of the element to retrieve.
Returns Promise<TSource>
The element at the specified position in the source sequence.

Throws
index is less than 0 or greater than or equal to the number of elements in source.
Inherited from IAsyncParallel.elementAt
- Defined in src/types/IAsyncParallel.ts:122

elementAtOrDefault

elementAtOrDefault(index: number): Promise<null | TSource>
Returns the element at a specified index in a sequence or a default value if the index is out of range.
Parameters
- index: number
  The zero-based index of the element to retrieve.
Returns Promise<null | TSource>
null if the index is outside the bounds of the source sequence; otherwise, the element at the specified position in the source sequence.
Inherited from IAsyncParallel.elementAtOrDefault
- Defined in src/types/IAsyncParallel.ts:130

except

except(
second: IAsyncEnumerable<TSource>,
comparer?: IEqualityComparer<TSource>,
): IAsyncEnumerable<TSource>
Produces the set difference of two sequences by using the comparer provided or EqualityComparer to compare values.
Parameters
- second: IAsyncEnumerable<TSource>
  An IAsyncEnumerable whose elements that also occur in the first sequence will cause those elements to be removed from the returned sequence.
- Optionalcomparer: IEqualityComparer<TSource>
  An IEqualityComparer to compare values. Optional.
Returns IAsyncEnumerable<TSource>
A sequence that contains the set difference of the elements of two sequences.
- Defined in src/types/IAsyncEnumerable.ts:78

exceptAsync

exceptAsync(
second: IAsyncEnumerable<TSource>,
comparer: IAsyncEqualityComparer<TSource>,
): IAsyncEnumerable<TSource>
Produces the set difference of two sequences by using the comparer provided to compare values.
Parameters
- second: IAsyncEnumerable<TSource>
  An IAsyncEnumerable whose elements that also occur in the first sequence will cause those elements to be removed from the returned sequence.
- comparer: IAsyncEqualityComparer<TSource>
  An IAsyncEqualityComparer to compare values.
Returns IAsyncEnumerable<TSource>
A sequence that contains the set difference of the elements of two sequences.
- Defined in src/types/IAsyncEnumerable.ts:86

first

first(predicate?: (x: TSource) => boolean): Promise<TSource>
Parameters
- Optionalpredicate: (x: TSource) => boolean
Returns Promise<TSource>
Throws
Sequence contains no elements

Throws
Sequence contains no matching elements
Inherited from IAsyncParallel.first
- Defined in src/types/IAsyncParallel.ts:135

firstAsync

firstAsync(predicate: (x: TSource) => Promise<boolean>): Promise<TSource>
Returns the first element in a sequence that satisfies a specified condition.
Parameters
- predicate: (x: TSource) => Promise<boolean>
  A function to test each element for a condition.
Returns Promise<TSource>
The first element in the sequence that passes the test in the specified predicate function.

Throws
No elements in Iteration matching predicate
Inherited from IAsyncParallel.firstAsync
- Defined in src/types/IAsyncParallel.ts:142

firstOrDefault

firstOrDefault(predicate?: (x: TSource) => boolean): Promise<null | TSource>
Returns first element in sequence that satisfies predicate otherwise returns the first element in the sequence. Returns null if no value found.
Parameters
- Optionalpredicate: (x: TSource) => boolean
  A function to test each element for a condition. Optional.
Returns Promise<null | TSource>
The first element in the sequence or the first element that passes the test in the specified predicate function. Returns null if no value found.
Inherited from IAsyncParallel.firstOrDefault
- Defined in src/types/IAsyncParallel.ts:151

firstOrDefaultAsync

firstOrDefaultAsync(
predicate: (x: TSource) => Promise<boolean>,
): Promise<null | TSource>
Returns the first element of the sequence that satisfies a condition or a default value if no such element is found.
Parameters
- predicate: (x: TSource) => Promise<boolean>
  An async function to test each element for a condition.
Returns Promise<null | TSource>
null if source is empty or if no element passes the test specified by predicate; otherwise, the first element in source that passes the test specified by predicate.
Inherited from IAsyncParallel.firstOrDefaultAsync
- Defined in src/types/IAsyncParallel.ts:159

groupBy

groupBy<TKey extends SelectorKeyType>(
keySelector: (x: TSource) => TKey,
): IAsyncEnumerable<IGrouping<TKey, TSource>>
Groups the elements of a sequence according to a specified key selector function.
Type Parameters
- TKey extends SelectorKeyType
Parameters
- keySelector: (x: TSource) => TKey
  A function to extract the key for each element.
Returns IAsyncEnumerable<IGrouping<TKey, TSource>>
An IAsyncEnumerable<IGrouping<TKey, TSource>> where each IGrouping<TKey,TElement> object contains a sequence of objects and a key.
- Defined in src/types/IAsyncEnumerable.ts:95
groupBy<TKey>(
keySelector: (x: TSource) => TKey,
comparer: IEqualityComparer<TKey>,
): IAsyncEnumerable<IGrouping<TKey, TSource>>
Groups the elements of a sequence according to a key selector function. The keys are compared by using a comparer and each group's elements are projected by using a specified function.
Type Parameters
- TKey
Parameters
- keySelector: (x: TSource) => TKey
  A function to extract the key for each element.
- comparer: IEqualityComparer<TKey>
  An IAsyncEqualityComparer to compare keys.
Returns IAsyncEnumerable<IGrouping<TKey, TSource>>
- Defined in src/types/IAsyncEnumerable.ts:103

groupByAsync

groupByAsync<TKey extends SelectorKeyType>(
keySelector: (x: TSource) => TKey | Promise<TKey>,
): IAsyncEnumerable<IGrouping<TKey, TSource>>
Groups the elements of a sequence according to a specified key selector function.
Type Parameters
- TKey extends SelectorKeyType
Parameters
- keySelector: (x: TSource) => TKey | Promise<TKey>
  A function to extract the key for each element.
Returns IAsyncEnumerable<IGrouping<TKey, TSource>>
An IAsyncEnumerable<IGrouping<TKey, TSource>> where each IGrouping<TKey,TElement> object contains a sequence of objects and a key.
- Defined in src/types/IAsyncEnumerable.ts:112
groupByAsync<TKey>(
keySelector: (x: TSource) => TKey | Promise<TKey>,
comparer: IEqualityComparer<TKey> | IAsyncEqualityComparer<TKey>,
): IAsyncEnumerable<IGrouping<TKey, TSource>>
Groups the elements of a sequence according to a specified key selector function.
Type Parameters
- TKey
Parameters
- keySelector: (x: TSource) => TKey | Promise<TKey>
  A function to extract the key for each element.
- comparer: IEqualityComparer<TKey> | IAsyncEqualityComparer<TKey>
  An IEqualityComparer or IAsyncEqualityComparer to compare keys.
Returns IAsyncEnumerable<IGrouping<TKey, TSource>>
An IAsyncEnumerable<IGrouping<TKey, TSource>> where each IGrouping<TKey,TElement> object contains a sequence of objects and a key.
- Defined in src/types/IAsyncEnumerable.ts:121

groupByWithSel

groupByWithSel<TKey extends SelectorKeyType, TElement>(
    keySelector: (x: TSource) => TKey,
    elementSelector: (x: TSource) => TElement,
    comparer?: IEqualityComparer<TKey>,
): IAsyncEnumerable<IGrouping<TKey, TElement>>
Groups the elements of a sequence according to a specified key selector function and projects the elements for each group by using a specified function.
Type Parameters
- TKey extends SelectorKeyType
- TElement
Parameters
- keySelector: (x: TSource) => TKey
  A function to extract the key for each element.
- elementSelector: (x: TSource) => TElement
  A function to map each source element to an element in an IGrouping<TKey,TElement>.
- Optionalcomparer: IEqualityComparer<TKey>
  An IEqualityComparer to compare keys.
Returns IAsyncEnumerable<IGrouping<TKey, TElement>>
An IAsyncEnumerable<IGrouping<TKey, TElement>> where each IGrouping<TKey,TElement> object contains a collection of objects of type TElement and a key.
- Defined in src/types/IAsyncEnumerable.ts:133
groupByWithSel<TKey, TElement>(
    keySelector: (x: TSource) => TKey,
    elementSelector: (x: TSource) => TElement,
    comparer: IEqualityComparer<TKey>,
): IAsyncEnumerable<IGrouping<TKey, TElement>>
Groups the elements of a sequence according to a key selector function. The keys are compared by using a comparer and each group's elements are projected by using a specified function.
Type Parameters
- TKey
- TElement
Parameters
- keySelector: (x: TSource) => TKey
  A function to extract the key for each element.
- elementSelector: (x: TSource) => TElement
  A function to map each source element to an element in an IGrouping<TKey,TElement>.
- comparer: IEqualityComparer<TKey>
  An IEqualityComparer to compare keys.
Returns IAsyncEnumerable<IGrouping<TKey, TElement>>
An IAsyncEnumerable<IGrouping<TKey,TElement>> where each IGrouping<TKey,TElement> object contains a collection of objects of type TElement and a key.
- Defined in src/types/IAsyncEnumerable.ts:146

groupJoin

groupJoin<TInner, TKey, TResult>(
    inner: Iterable<TInner, any, any> | AsyncIterable<TInner, any, any>,
    outerKeySelector: (value: TSource) => TKey,
    innerKeySelector: (value: TInner) => TKey,
    resultSelector: (element: TSource, collection: TInner[]) => TResult,
    comparer?: IEqualityComparer<TKey>,
): IAsyncEnumerable<TResult>
Correlates the elements of two sequences based on equality of keys and groups the results.
Type Parameters
- TInner
- TKey
- TResult
Parameters
- inner: Iterable<TInner, any, any> | AsyncIterable<TInner, any, any>
  The sequence to join to the first sequence.
- outerKeySelector: (value: TSource) => TKey
  The sequence to join to the first sequence.
- innerKeySelector: (value: TInner) => TKey
  A function to extract the join key from each element of the second sequence.
- resultSelector: (element: TSource, collection: TInner[]) => TResult
  A function to create a result element from an element from the first sequence and a collection of matching elements from the second sequence.
- Optionalcomparer: IEqualityComparer<TKey>
  To compare keys. Optional.
Returns IAsyncEnumerable<TResult>
An IAsyncEnumerable that contains elements of type TResult that are obtained by performing a grouped join on two sequences.
- Defined in src/types/IAsyncEnumerable.ts:159

groupJoinAsync

groupJoinAsync<TInner, TKey, TResult>(
    inner: Iterable<TInner, any, any> | AsyncIterable<TInner, any, any>,
    outerKeySelector: (value: TSource) => TKey | Promise<TKey>,
    innerKeySelector: (value: TInner) => TKey | Promise<TKey>,
    resultSelector: (
        element: TSource,
        collection: TInner[],
    ) => TResult | Promise<TResult>,
    comparer?: IEqualityComparer<TKey>,
): IAsyncEnumerable<TResult>
Correlates the elements of two sequences based on equality of keys and groups the results.
Type Parameters
- TInner
- TKey
- TResult
Parameters
- inner: Iterable<TInner, any, any> | AsyncIterable<TInner, any, any>
  The sequence to join to the first sequence. Can be async.
- outerKeySelector: (value: TSource) => TKey | Promise<TKey>
  The sequence to join to the first sequence. Can be async.
- innerKeySelector: (value: TInner) => TKey | Promise<TKey>
  A function to extract the join key from each element of the second sequence.
- resultSelector: (element: TSource, collection: TInner[]) => TResult | Promise<TResult>
  A function to create a result element from an element from the first sequence and a collection of matching elements from the second sequence. Can be async.
- Optionalcomparer: IEqualityComparer<TKey>
  To compare keys. Optional.
Returns IAsyncEnumerable<TResult>
An IAsyncEnumerable that contains elements of type TResult that are obtained by performing a grouped join on two sequences.
- Defined in src/types/IAsyncEnumerable.ts:174

intersect

intersect(
second: IAsyncEnumerable<TSource>,
comparer?: IEqualityComparer<TSource>,
): IAsyncEnumerable<TSource>
Produces the set intersection of two sequences by using the specified IEqualityComparer to compare values. If no comparer is selected, uses the StrictEqualityComparer.
Parameters
- second: IAsyncEnumerable<TSource>
  An Iterable whose distinct elements that also appear in the first sequence will be returned.
- Optionalcomparer: IEqualityComparer<TSource>
  An IEqualityComparer to compare values. Optional.
Returns IAsyncEnumerable<TSource>
An async sequence that contains the elements that form the set intersection of two sequences.
- Defined in src/types/IAsyncEnumerable.ts:187

intersectAsync

intersectAsync(
second: IAsyncEnumerable<TSource>,
comparer: IAsyncEqualityComparer<TSource>,
): IAsyncEnumerable<TSource>
Produces the set intersection of two sequences by using the specified IAsyncEqualityComparer to compare values.
Parameters
- second: IAsyncEnumerable<TSource>
  An Iterable whose distinct elements that also appear in the first sequence will be returned.
- comparer: IAsyncEqualityComparer<TSource>
  An IAsyncEqualityComparer to compare values.
Returns IAsyncEnumerable<TSource>
A sequence that contains the elements that form the set intersection of two sequences.
- Defined in src/types/IAsyncEnumerable.ts:195

joinByKey

joinByKey<TInner, TKey, TResult>(
    inner: IAsyncEnumerable<TInner>,
    outerKeySelector: (x: TSource) => TKey,
    innerKeySelector: (x: TInner) => TKey,
    resultSelector: (x: TSource, y: TInner) => TResult,
    comparer?: IEqualityComparer<TKey>,
): IAsyncEnumerable<TResult>
Correlates the elements of two sequences based on matching keys. A specified IEqualityComparer is used to compare keys or the strict equality comparer.
Type Parameters
- TInner
- TKey
- TResult
Parameters
- inner: IAsyncEnumerable<TInner>
  The sequence to join to the first sequence.
- outerKeySelector: (x: TSource) => TKey
  A function to extract the join key from each element of the first sequence.
- innerKeySelector: (x: TInner) => TKey
  A function to extract the join key from each element of the second sequence.
- resultSelector: (x: TSource, y: TInner) => TResult
  A function to create a result element from two matching elements.
- Optionalcomparer: IEqualityComparer<TKey>
  An IEqualityComparer to hash and compare keys. Optional.
Returns IAsyncEnumerable<TResult>
An IAsyncEnumerable that has elements of type TResult that are obtained by performing an inner join on two sequences.
- Defined in src/types/IAsyncEnumerable.ts:209

last

last(predicate?: (x: TSource) => boolean): Promise<TSource>
Parameters
- Optionalpredicate: (x: TSource) => boolean
Returns Promise<TSource>
Throws
Sequence contains no elements

Throws
Sequence contains no matching element
Inherited from IAsyncParallel.last
- Defined in src/types/IAsyncParallel.ts:164

lastAsync

lastAsync(predicate: (x: TSource) => Promise<boolean>): Promise<TSource>
Parameters
- predicate: (x: TSource) => Promise<boolean>
Returns Promise<TSource>
Throws
Sequence contains no matching element
Inherited from IAsyncParallel.lastAsync
- Defined in src/types/IAsyncParallel.ts:168

lastOrDefault

lastOrDefault(predicate?: (x: TSource) => boolean): Promise<null | TSource>
Parameters
- Optionalpredicate: (x: TSource) => boolean
Returns Promise<null | TSource>
Inherited from IAsyncParallel.lastOrDefault
- Defined in src/types/IAsyncParallel.ts:169

lastOrDefaultAsync

lastOrDefaultAsync(
predicate: (x: TSource) => Promise<boolean>,
): Promise<null | TSource>
Parameters
- predicate: (x: TSource) => Promise<boolean>
Returns Promise<null | TSource>
Inherited from IAsyncParallel.lastOrDefaultAsync
- Defined in src/types/IAsyncParallel.ts:170

max

max(this: IAsyncParallel<number>): Promise<number>
Returns the maximum value in a sequence of values.
Parameters
- this: IAsyncParallel<number>
  Async Iteration of Numbers
Returns Promise<number>
Throws
Sequence contains no elements
Inherited from IAsyncParallel.max
- Defined in src/types/IAsyncParallel.ts:176
max(selector: (x: TSource) => number): Promise<number>
Invokes a transform function on each element of a sequence and returns the maximum value.
Parameters
- selector: (x: TSource) => number
  A transform function to apply to each element.
Returns Promise<number>
Throws
Sequence contains no elements
Inherited from IAsyncParallel.max
- Defined in src/types/IAsyncParallel.ts:182

maxAsync

maxAsync(selector: (x: TSource) => Promise<number>): Promise<number>
Invokes an async transform function on each element of a sequence and returns the maximum value.
Parameters
- selector: (x: TSource) => Promise<number>
  A transform function to apply to each element.
Returns Promise<number>
Throws
Sequence contains no elements
Inherited from IAsyncParallel.maxAsync
- Defined in src/types/IAsyncParallel.ts:188

min

min(this: IAsyncParallel<number>): Promise<number>
Returns the minimum value in a sequence of values.
Parameters
- this: IAsyncParallel<number>
Returns Promise<number>
Throws
Sequence contains no elements
Inherited from IAsyncParallel.min
- Defined in src/types/IAsyncParallel.ts:193
min(selector: (x: TSource) => number): Promise<number>
Invokes a transform function on each element of a sequence and returns the minimum value.
Parameters
- selector: (x: TSource) => number
  A transform function to apply to each element.
Returns Promise<number>
Throws
Sequence contains no elements
Inherited from IAsyncParallel.min
- Defined in src/types/IAsyncParallel.ts:199

minAsync

minAsync(selector: (x: TSource) => Promise<number>): Promise<number>
Invokes a transform function on each element of a sequence and returns the minimum value.
Parameters
- selector: (x: TSource) => Promise<number>
  A transform function to apply to each element.
Returns Promise<number>
Throws
Sequence contains no elements
Inherited from IAsyncParallel.minAsync
- Defined in src/types/IAsyncParallel.ts:205

ofType

ofType<TType extends OfType>(type: TType): IAsyncEnumerable<InferType<TType>>
Applies a type filter to a source iteration
Type Parameters
- TType extends OfType
Parameters
- type: TType
  Either value for typeof or a consturctor function
Returns IAsyncEnumerable<InferType<TType>>
Values that match the type string or are instance of type
- Defined in src/types/IAsyncEnumerable.ts:220

order

order(comparer?: IComparer<TSource>): IOrderedAsyncEnumerable<TSource>
Sorts the elements of a sequence in ascending order by using a specified or default comparer.
Parameters
- Optionalcomparer: IComparer<TSource>
  An IComparer to compare values. Optional.
Returns IOrderedAsyncEnumerable<TSource>
An IOrderedAsyncEnumerable whose elements are sorted.
- Defined in src/types/IAsyncEnumerable.ts:226

orderBy

orderBy<TKey>(
predicate: (x: TSource) => TKey,
comparer?: IComparer<TKey>,
): IOrderedAsyncEnumerable<TSource>
Sorts the elements of a sequence in ascending order by using a specified or default comparer.
Type Parameters
- TKey
Parameters
- predicate: (x: TSource) => TKey
  A function to extract a key from an element.
- Optionalcomparer: IComparer<TKey>
  An IComparer to compare keys. Optional.
Returns IOrderedAsyncEnumerable<TSource>
An IOrderedAsyncEnumerable whose elements are sorted according to a key.
- Defined in src/types/IAsyncEnumerable.ts:234

orderByAsync

orderByAsync<TKey>(
predicate: (x: TSource) => Promise<TKey>,
comparer?: IComparer<TKey>,
): IOrderedAsyncEnumerable<TSource>
Sorts the elements of a sequence in ascending order by using a specified comparer.
Type Parameters
- TKey
Parameters
- predicate: (x: TSource) => Promise<TKey>
  An async function to extract a key from an element.
- Optionalcomparer: IComparer<TKey>
  An IComparer to compare keys.
Returns IOrderedAsyncEnumerable<TSource>
An IOrderedAsyncEnumerable whose elements are sorted according to a key.
- Defined in src/types/IAsyncEnumerable.ts:243

orderByDescending

orderByDescending<TKey>(
predicate: (x: TSource) => TKey,
comparer?: IComparer<TKey>,
): IOrderedAsyncEnumerable<TSource>
Sorts the elements of a sequence in descending order by using a specified or default comparer.
Type Parameters
- TKey
Parameters
- predicate: (x: TSource) => TKey
  A function to extract a key from an element.
- Optionalcomparer: IComparer<TKey>
  An IComparer to compare keys. Optional.
Returns IOrderedAsyncEnumerable<TSource>
An IOrderedAsyncEnumerable whose elements are sorted in descending order according to a key.
- Defined in src/types/IAsyncEnumerable.ts:252

orderByDescendingAsync

orderByDescendingAsync<TKey>(
predicate: (x: TSource) => Promise<TKey>,
comparer?: IComparer<TKey>,
): IOrderedAsyncEnumerable<TSource>
Sorts the elements of a sequence in descending order by using a specified comparer.
Type Parameters
- TKey
Parameters
- predicate: (x: TSource) => Promise<TKey>
  An async function to extract a key from an element.
- Optionalcomparer: IComparer<TKey>
  An IComparer to compare keys.
Returns IOrderedAsyncEnumerable<TSource>
An IOrderedAsyncEnumerable whose elements are sorted in descending order according to a key.
- Defined in src/types/IAsyncEnumerable.ts:261

orderDescending

orderDescending(comparer?: IComparer<TSource>): IOrderedAsyncEnumerable<TSource>
Sorts the elements of a sequence in descending order by using a specified or default comparer.
Parameters
- Optionalcomparer: IComparer<TSource>
  An IComparer to compare values. Optional.
Returns IOrderedAsyncEnumerable<TSource>
An IOrderedAsyncEnumerable whose elements are sorted in descending order.
- Defined in src/types/IAsyncEnumerable.ts:269

partition

partition(
predicate: (x: TSource) => boolean,
): Promise<[pass: TSource[], fail: TSource[]]>
Partitions the values into a tuple of failing and passing arrays
Parameters
- predicate: (x: TSource) => boolean
  Predicate to determine whether a value passes or fails
Returns Promise<[pass: TSource[], fail: TSource[]]>
[values that pass, values that fail]
Inherited from IAsyncParallel.partition
- Defined in src/types/IAsyncParallel.ts:217

partitionAsync

partitionAsync(
predicate: (x: TSource) => Promise<boolean>,
): Promise<[pass: TSource[], fail: TSource[]]>
Partitions the values into a tuple of failing and passing arrays
Parameters
- predicate: (x: TSource) => Promise<boolean>
  Async predicate to determine whether a value passes or fails
Returns Promise<[pass: TSource[], fail: TSource[]]>
[values that pass, values that fail]
Inherited from IAsyncParallel.partitionAsync
- Defined in src/types/IAsyncParallel.ts:223

prepend

prepend(element: TSource): IAsyncEnumerable<TSource>
Adds a value to the beginning of the sequence.
Parameters
- element: TSource
  The value to prepend to the sequence.
Returns IAsyncEnumerable<TSource>
An IAsyncEnumerable that begins with the specified element.
- Defined in src/types/IAsyncEnumerable.ts:276

reverse

reverse(): IAsyncEnumerable<TSource>
Inverts the order of the elements in a sequence.

Returns IAsyncEnumerable<TSource>
An async sequence whose elements correspond to those of the input sequence in reverse order.
- Defined in src/types/IAsyncEnumerable.ts:281

select

select<TResult>(
selector: (x: TSource, index: number) => TResult,
): IAsyncEnumerable<TResult>
Projects each element of a sequence into a new form.
Type Parameters
- TResult
Parameters
- selector: (x: TSource, index: number) => TResult
  A transform function to apply to each element.
Returns IAsyncEnumerable<TResult>
An IAsyncEnumerable whose elements are the result of invoking the transform function on each element of source.
- Defined in src/types/IAsyncEnumerable.ts:288
select<TKey extends string | number | symbol>(
key: TKey,
): IAsyncEnumerable<TSource[TKey]>
Projects each element of a sequence into a new form.
Type Parameters
- TKey extends string | number | symbol
Parameters
- key: TKey
  A key of TSource.
Returns IAsyncEnumerable<TSource[TKey]>
An IAsyncEnumerable whose elements are the result of getting the value from the key on each element of source.
- Defined in src/types/IAsyncEnumerable.ts:295

selectAsync

selectAsync<TResult>(
selector: (x: TSource, index: number) => Promise<TResult>,
): IAsyncEnumerable<TResult>
Projects each element of a sequence into a new form.
Type Parameters
- TResult
Parameters
- selector: (x: TSource, index: number) => Promise<TResult>
  An async transform function to apply to each element.
Returns IAsyncEnumerable<TResult>
An IAsyncEnumerable whose elements are the result of invoking the transform function on each element of source.
- Defined in src/types/IAsyncEnumerable.ts:302
selectAsync<TKey extends string | number | symbol, TResult>(
this: IAsyncEnumerable<{ [key: string]: Promise<TResult> }>,
key: TKey,
): IAsyncEnumerable<TResult>
Projects each element of a sequence into a new form.
Type Parameters
- TKey extends string | number | symbol
- TResult
Parameters
- this: IAsyncEnumerable<{ [key: string]: Promise<TResult> }>
- key: TKey
  A key of the elements in the sequence
Returns IAsyncEnumerable<TResult>
An IAsyncEnumerable whoe elements are the result of getting the value for key on each element of source.
- Defined in src/types/IAsyncEnumerable.ts:309

selectMany

selectMany<TResult>(
selector: (x: TSource, index: number) => Iterable<TResult>,
): IAsyncEnumerable<TResult>
Projects each element of a sequence to an IAsyncEnumerable and flattens the resulting sequences into one sequence.
Type Parameters
- TResult
Parameters
- selector: (x: TSource, index: number) => Iterable<TResult>
  A transform function to apply to each element.
Returns IAsyncEnumerable<TResult>
An IAsyncEnumerable whose elements are the result of invoking the one-to-many transform function on each element of the input sequence.
- Defined in src/types/IAsyncEnumerable.ts:319
selectMany<
    TBindedSource extends { [key: string]: Iterable<TOut, any, any> },
    TOut,
>(
    this: IAsyncEnumerable<TBindedSource>,
    selector: keyof TBindedSource,
): IAsyncEnumerable<TOut>
Projects each element of a sequence to an IAsyncEnumerable and flattens the resulting sequences into one sequence.
Type Parameters
- TBindedSource extends { [key: string]: Iterable<TOut, any, any> }
- TOut
Parameters
- this: IAsyncEnumerable<TBindedSource>
- selector: keyof TBindedSource
  A string key of TSource.
Returns IAsyncEnumerable<TOut>
An IAsyncEnumerable whose elements are the result of invoking the parameter the key is tried to on each element of the input sequence.
- Defined in src/types/IAsyncEnumerable.ts:327

selectManyAsync

selectManyAsync<TResult>(
    selector: (
        x: TSource,
        index: number,
    ) => Promise<Iterable<TResult, any, any>>,
): IAsyncEnumerable<TResult>
Projects each element of a sequence to an IAsyncEnumerable and flattens the resulting sequences into one sequence.
Type Parameters
- TResult
Parameters
- selector: (x: TSource, index: number) => Promise<Iterable<TResult, any, any>>
  A transform function to apply to each element.
Returns IAsyncEnumerable<TResult>
An IAsyncEnumerable whose elements are the result of invoking the one-to-many transform function on each element of the input sequence.
- Defined in src/types/IAsyncEnumerable.ts:337

sequenceEquals

sequenceEquals(
second: AsyncIterable<TSource>,
comparer?: IEqualityComparer<TSource>,
): Promise<boolean>
Determines whether or not two sequences are equal
Parameters
- second: AsyncIterable<TSource>
  second iterable
- Optionalcomparer: IEqualityComparer<TSource>
  Compare function to use, by default is
Returns Promise<boolean>
Whether or not the two iterations are equal

See
- Defined in src/types/IAsyncEnumerable.ts:345

sequenceEqualsAsync

sequenceEqualsAsync(
second: AsyncIterable<TSource>,
comparer: IAsyncEqualityComparer<TSource>,
): Promise<boolean>
Compares two sequences to see if they are equal using an async comparer function.
Parameters
- second: AsyncIterable<TSource>
  Second Sequence
- comparer: IAsyncEqualityComparer<TSource>
  Async Comparer
Returns Promise<boolean>
Whether or not the two iterations are equal
- Defined in src/types/IAsyncEnumerable.ts:352

single

single(predicate?: (x: TSource) => boolean): Promise<TSource>
Parameters
- Optionalpredicate: (x: TSource) => boolean
Returns Promise<TSource>
Inherited from IAsyncParallel.single
- Defined in src/types/IAsyncParallel.ts:225

singleAsync

singleAsync(predicate: (x: TSource) => Promise<boolean>): Promise<TSource>
Parameters
- predicate: (x: TSource) => Promise<boolean>
Returns Promise<TSource>
Throws
Sequence contains more than one matching element

Throws
Sequence contains no matching element
Inherited from IAsyncParallel.singleAsync
- Defined in src/types/IAsyncParallel.ts:230

singleOrDefault

singleOrDefault(predicate?: (x: TSource) => boolean): Promise<null | TSource>
Parameters
- Optionalpredicate: (x: TSource) => boolean
Returns Promise<null | TSource>
Throws
Sequence contains more than one matching element
Inherited from IAsyncParallel.singleOrDefault
- Defined in src/types/IAsyncParallel.ts:234

singleOrDefaultAsync

singleOrDefaultAsync(
predicate: (x: TSource) => Promise<boolean>,
): Promise<null | TSource>
Parameters
- predicate: (x: TSource) => Promise<boolean>
Returns Promise<null | TSource>
Throws
Sequence contains more than one matching element
Inherited from IAsyncParallel.singleOrDefaultAsync
- Defined in src/types/IAsyncParallel.ts:238

skip

skip(count: number): IAsyncEnumerable<TSource>
Bypasses a specified number of elements in a sequence and then returns the remaining elements.
Parameters
- count: number
  The number of elements to skip before returning the remaining elements.
Returns IAsyncEnumerable<TSource>
An IAsyncEnumerable that contains the elements that occur after the specified index in the input sequence.
- Defined in src/types/IAsyncEnumerable.ts:360

skipWhile

skipWhile(
predicate: (x: TSource, index: number) => boolean,
): IAsyncEnumerable<TSource>
Bypasses elements in a sequence as long as a specified condition is true and then returns the remaining elements. The element's index is used in the logic of the predicate function.
Parameters
- predicate: (x: TSource, index: number) => boolean
  A function to test each source element for a condition; the second parameter of the function represents the index of the source element.
Returns IAsyncEnumerable<TSource>
An IAsyncEnumerable that contains the elements from the input sequence starting at the first element in the linear series that does not pass the test specified by predicate.
- Defined in src/types/IAsyncEnumerable.ts:369

skipWhileAsync

skipWhileAsync(
predicate: (x: TSource, index: number) => Promise<boolean>,
): IAsyncEnumerable<TSource>
Bypasses elements in a sequence as long as a specified condition is true and then returns the remaining elements. The element's index is used in the logic of the predicate function.
Parameters
- predicate: (x: TSource, index: number) => Promise<boolean>
  A function to test each source element for a condition; the second parameter of the function represents the index of the source element.
Returns IAsyncEnumerable<TSource>
An IAsyncEnumerable that contains the elements from the input sequence starting at the first element in the linear series that does not pass the test specified by predicate.
- Defined in src/types/IAsyncEnumerable.ts:378

sum

sum(this: IAsyncParallel<number>): Promise<number>
Computes the sum of the sequence of numeric values.
Parameters
- this: IAsyncParallel<number>
Returns Promise<number>
A promise of the sum of the values in the sequence.
Inherited from IAsyncParallel.sum
- Defined in src/types/IAsyncParallel.ts:243
sum(selector: (x: TSource) => number): Promise<number>
Computes the sum of the sequence of numeric values that are obtained by invoking a transform function on each element of the input sequence.
Parameters
- selector: (x: TSource) => number
  A transform function to apply to each element.
Returns Promise<number>
A promise of the sum of the projected values.
Inherited from IAsyncParallel.sum
- Defined in src/types/IAsyncParallel.ts:250

sumAsync

sumAsync(selector: (x: TSource) => Promise<number>): Promise<number>
Computes the sum of the sequence of numeric values that are obtained by invoking a transform function on each element of the input sequence.
Parameters
- selector: (x: TSource) => Promise<number>
  An async transform function to apply to each element.
Returns Promise<number>
A promise of the sum of the projected values.
Inherited from IAsyncParallel.sumAsync
- Defined in src/types/IAsyncParallel.ts:257

take

take(amount: number): IAsyncEnumerable<TSource>
Returns a specified number of contiguous elements from the start of a sequence.
Parameters
- amount: number
  The number of elements to return.
Returns IAsyncEnumerable<TSource>
An IAsyncEnumerable that contains the specified number of elements from the start of the input sequence.
- Defined in src/types/IAsyncEnumerable.ts:385

takeWhile

takeWhile(
predicate: (x: TSource, index: number) => boolean,
): IAsyncEnumerable<TSource>
Returns elements from a sequence as long as a specified condition is true. The element's index is used in the logic of the predicate function.
Parameters
- predicate: (x: TSource, index: number) => boolean
  A function to test each source element for a condition; the second parameter of the function represents the index of the source element.
Returns IAsyncEnumerable<TSource>
An IAsyncEnumerable that contains elements from the input sequence that occur before the element at which the test no longer passes.
- Defined in src/types/IAsyncEnumerable.ts:394

takeWhileAsync

takeWhileAsync(
predicate: (x: TSource, index: number) => Promise<boolean>,
): IAsyncEnumerable<TSource>
Returns elements from a sequence as long as a specified condition is true. The element's index is used in the logic of the predicate function.
Parameters
- predicate: (x: TSource, index: number) => Promise<boolean>
  A async function to test each source element for a condition; the second parameter of the function represents the index of the source element.
Returns IAsyncEnumerable<TSource>
An IAsyncEnumerable that contains elements from the input sequence that occur before the element at which the test no longer passes.
- Defined in src/types/IAsyncEnumerable.ts:403

toArray

toArray(): Promise<TSource[]>
Creates an array from a IAsyncEnumerable or IParallelEnumerable

Returns Promise<TSource[]>
An array of elements
Inherited from IAsyncParallel.toArray
- Defined in src/types/IAsyncParallel.ts:262

toMap

toMap<TKey>(selector: (x: TSource) => TKey): Promise<Map<TKey, TSource[]>>
Converts the async or parallel iteration to a Map<TKey, TSource[]>.
Type Parameters
- TKey
Parameters
- selector: (x: TSource) => TKey
  A function to serve as a key selector.
Returns Promise<Map<TKey, TSource[]>>
A promise for Map<TKey, TSource[]>
Inherited from IAsyncParallel.toMap
- Defined in src/types/IAsyncParallel.ts:268

toMapAsync

toMapAsync<TKey>(
selector: (x: TSource) => Promise<TKey>,
): Promise<Map<TKey, TSource[]>>
Converts the async or parallel iteration to a Map<TKey, TSource[]>.
Type Parameters
- TKey
Parameters
- selector: (x: TSource) => Promise<TKey>
  An async function to serve as a key selector.
Returns Promise<Map<TKey, TSource[]>>
A promise for Map<TKey, TSource[]>
Inherited from IAsyncParallel.toMapAsync
- Defined in src/types/IAsyncParallel.ts:274

toObject

toObject<TKey extends string | number | symbol>(
selector: (x: TSource) => TKey,
): Promise<Record<TKey, TSource>>
Converts the Iteration to an Object. Duplicate values will be overriden.
Type Parameters
- TKey extends string | number | symbol
Parameters
- selector: (x: TSource) => TKey
  A function to determine the Key based on the value.
Returns Promise<Record<TKey, TSource>>
Promise of KVP Object
Inherited from IAsyncParallel.toObject
- Defined in src/types/IAsyncParallel.ts:280

toObjectAsync

toObjectAsync<TKey extends string | number | symbol>(
selector: (x: TSource) => Promise<TKey>,
): Promise<Record<TKey, TSource>>
Converts the Iteration to an Object. Duplicate values will be overriden.
Type Parameters
- TKey extends string | number | symbol
Parameters
- selector: (x: TSource) => Promise<TKey>
  An async function to determine the Key based on the value.
Returns Promise<Record<TKey, TSource>>
Promise of KVP Object
Inherited from IAsyncParallel.toObjectAsync
- Defined in src/types/IAsyncParallel.ts:286

toSet

toSet(): Promise<Set<TSource>>
Converts the async iteration to a Set

Returns Promise<Set<TSource>>
A promise for a set containing the iteration values
Inherited from IAsyncParallel.toSet
- Defined in src/types/IAsyncParallel.ts:291

union

union(
second: AsyncIterable<TSource>,
comparer?: IEqualityComparer<TSource>,
): IAsyncEnumerable<TSource>
Produces the set union of two sequences by using scrict equality comparison or a specified IEqualityComparer.
Parameters
- second: AsyncIterable<TSource>
  An AsyncIterable whose distinct elements form the second set for the union.
- Optionalcomparer: IEqualityComparer<TSource>
  The IEqualityComparer to compare values. Optional.
Returns IAsyncEnumerable<TSource>
An IAsyncEnumerable that contains the elements from both input sequences, excluding duplicates.
- Defined in src/types/IAsyncEnumerable.ts:410

unionAsync

unionAsync(
second: AsyncIterable<TSource>,
comparer: IAsyncEqualityComparer<TSource>,
): IAsyncEnumerable<TSource>
Produces the set union of two sequences by using a specified IAsyncEqualityComparer.
Parameters
- second: AsyncIterable<TSource>
  An AsyncIterable whose distinct elements form the second set for the union.
- comparer: IAsyncEqualityComparer<TSource>
  The IAsyncEqualityComparer to compare values.
Returns IAsyncEnumerable<TSource>
An IAsyncEnumerable that contains the elements from both input sequences, excluding duplicates.
- Defined in src/types/IAsyncEnumerable.ts:417

where

where(
predicate: (x: TSource, index: number) => boolean,
): IAsyncEnumerable<TSource>
Filters a sequence of values based on a predicate. Each element's index is used in the logic of the predicate function.
Parameters
- predicate: (x: TSource, index: number) => boolean
  A function to test each source element for a condition; the second parameter of the function represents the index of the source element.
Returns IAsyncEnumerable<TSource>
An IAsyncEnumerable that contains elements from the input sequence that satisfy the condition.
- Defined in src/types/IAsyncEnumerable.ts:425

whereAsync

whereAsync(
predicate: (x: TSource, index: number) => Promise<boolean>,
): IAsyncEnumerable<TSource>
Filters a sequence of values based on a predicate. Each element's index is used in the logic of the predicate function.
Parameters
- predicate: (x: TSource, index: number) => Promise<boolean>
  A async function to test each source element for a condition; the second parameter of the function represents the index of the source element.
Returns IAsyncEnumerable<TSource>
An IAsyncEnumerable that contains elements from the input sequence that satisfy the condition.
- Defined in src/types/IAsyncEnumerable.ts:433

zip

zip<TSecond, TResult>(
second: AsyncIterable<TSecond>,
resultSelector: (x: TSource, y: TSecond) => TResult,
): IAsyncEnumerable<TResult>
Applies a specified function to the corresponding elements of two sequences, producing a sequence of the results.
Type Parameters
- TSecond
- TResult
Parameters
- second: AsyncIterable<TSecond>
  The second sequence to merge.
- resultSelector: (x: TSource, y: TSecond) => TResult
  A function that specifies how to merge the elements from the two sequences.
Returns IAsyncEnumerable<TResult>
An IAsyncEnumerable that contains merged elements of two input sequences.
- Defined in src/types/IAsyncEnumerable.ts:440
zip<TSecond>(
second: AsyncIterable<TSecond>,
): IAsyncEnumerable<[TSource, TSecond]>
Creates a tuple of corresponding elements of two sequences, producing a sequence of the results.
Type Parameters
- TSecond
Parameters
- second: AsyncIterable<TSecond>
  The second sequence to merge.
Returns IAsyncEnumerable<[TSource, TSecond]>
An IAsyncEnumerable<[T, Y]> that contains merged elements of two input sequences.
- Defined in src/types/IAsyncEnumerable.ts:448

zipAsync

zipAsync<TSecond, TResult>(
second: AsyncIterable<TSecond>,
resultSelector: (x: TSource, y: TSecond) => Promise<TResult>,
): IAsyncEnumerable<TResult>
Applies a specified async function to the corresponding elements of two sequences, producing a sequence of the results.
Type Parameters
- TSecond
- TResult
Parameters
- second: AsyncIterable<TSecond>
  The second sequence to merge.
- resultSelector: (x: TSource, y: TSecond) => Promise<TResult>
  An async function that specifies how to merge the elements from the two sequences.
Returns IAsyncEnumerable<TResult>
An IAsyncEnumerable that contains merged elements of two input sequences.
- Defined in src/types/IAsyncEnumerable.ts:456

Interface IAsyncEnumerable<TSource>

Type Parameters

Hierarchy (View Summary)

Index

Methods

Methods

[asyncIterator]

Returns AsyncIterableIterator<TSource>

aggregate

Parameters

Returns Promise<TSource>

Type Parameters

Parameters

Returns Promise<TAccumulate>

Type Parameters

Parameters

Returns Promise<TResult>

all

Parameters

Returns Promise<boolean>

allAsync

Parameters

Returns Promise<boolean>

any

Parameters

Returns Promise<boolean>

anyAsync

Parameters

Returns Promise<boolean>

append

Parameters

Returns IAsyncEnumerable<TSource>

asParallel

Returns IParallelEnumerable<TSource>

average

Parameters

Returns Promise<number>

Throws

Parameters

Returns Promise<number>

Throws

averageAsync

Parameters

Returns Promise<number>

Throws

chunk

Parameters

Returns IAsyncEnumerable<TSource[]>

concatenate

Parameters

Returns IAsyncEnumerable<TSource>

contains

Parameters

Returns Promise<boolean>

containsAsync

Parameters

Returns Promise<boolean>

count

Parameters

Returns Promise<number>

countAsync

Parameters

Returns Promise<number>

defaultIfEmpty

Parameters

Returns IAsyncEnumerable<TSource>

distinct

Parameters

Returns IAsyncEnumerable<TSource>

distinctAsync

Parameters

Returns IAsyncEnumerable<TSource>

each

Parameters

Returns IAsyncEnumerable<TSource>

eachAsync

Parameters

Returns IAsyncEnumerable<TSource>

elementAt

Parameters