Interface IParallelEnumerable<TSource>

Parallel Async Iterable type with methods from LINQ.

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

Type Parameters

TSource

Hierarchy

IAsyncParallel<TSource>
- IParallelEnumerable
  - IOrderedParallelEnumerable

Index

Properties

dataFunc

Methods

[asyncIterator] aggregate all allAsync any anyAsync append asAsync 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

Properties

`Readonly` dataFunc

dataFunc: TypedData<TSource>

Used for processing.

Methods

[asyncIterator]

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

aggregate

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

all

all(predicate): Promise<boolean>
Determines whether all elements of a sequence satisfy a condition.
Parameters
- predicate: ((x) => boolean)
  A function to test each element for a condition.
  - - (x): boolean
    - Parameters
      x: TSource
      Returns boolean
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): Promise<boolean>
Determines whether all elements of a sequence satisfy a condition.
Parameters
- predicate: ((x) => Promise<boolean>)
  An async function to test each element for a condition.
  - - (x): Promise<boolean>
    - Parameters
      x: TSource
      Returns Promise<boolean>
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?): Promise<boolean>
Determines whether a sequence contains any elements. If predicate is specified, determines whether any element of a sequence satisfies a condition.
Parameters
- Optional predicate: ((x) => boolean)
  A function to test each element for a condition.
  - - (x): boolean
    - Parameters
      x: TSource
      Returns boolean
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): Promise<boolean>
Determines whether any element of a sequence satisfies a condition.
Parameters
- predicate: ((x) => Promise<boolean>)
  An async function to test each element for a condition.
  - - (x): Promise<boolean>
    - Parameters
      x: TSource
      Returns Promise<boolean>
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): IParallelEnumerable<TSource>
Appends a value to the end of the sequence.
Parameters
- element: TSource
  The value to append to the sequence.
Returns IParallelEnumerable<TSource>
An IParallelEnumerable that ends with the specified element.
- Defined in src/types/IParallelEnumerable.ts:28

asAsync

asAsync(): IAsyncEnumerable<TSource>
Converts the parallel iterable to an

Returns IAsyncEnumerable<TSource>
An IAsyncEnumerable

See
- Defined in src/types/IParallelEnumerable.ts:33

average

average(this): 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): 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) => number)
  A transform function to apply to each element.
  - - (x): number
    - Parameters
      x: TSource
      Returns 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:74

averageAsync

averageAsync(selector): 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) => Promise<number>)
  An async transform function to apply to each element.
  - - (x): Promise<number>
    - Parameters
      x: TSource
      Returns Promise<number>
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): IParallelEnumerable<TSource[]>
Splits the elements of a sequence into chunks of size at most size.
Parameters
- size: number
  The maximum size of each chunk.
Returns IParallelEnumerable<TSource[]>
An IParallelEnumerable that contains the elements the input sequence split into chunks of size size.
- Defined in src/types/IParallelEnumerable.ts:39

concatenate

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

contains

contains(value, comparer?): 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.
- Optional comparer: 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, comparer): 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?): 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
- Optional predicate: ((x) => boolean)
  A function to test each element for a condition. Optional.
  - - (x): boolean
    - Parameters
      x: TSource
      Returns boolean
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): 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) => Promise<boolean>)
  A function to test each element for a condition.
  - - (x): Promise<boolean>
    - Parameters
      x: TSource
      Returns Promise<boolean>
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): IParallelEnumerable<TSource>
Returns the elements of an IParallelEnumerable, 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 IParallelEnumerable<TSource>
An IParallelEnumerable that contains defaultValue if source is empty; otherwise, source.
- Defined in src/types/IParallelEnumerable.ts:51

distinct

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

distinctAsync

distinctAsync(comparer): IParallelEnumerable<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 IParallelEnumerable<TSource>
An IParallelEnumerable that contains distinct elements from the source sequence.
- Defined in src/types/IParallelEnumerable.ts:63

each

each(action): IParallelEnumerable<TSource>
Performs a specified action on each element of the IParallelEnumerable. The order of execution is not guaranteed.
Parameters
- action: ((x) => void)
  The action to take an each element
  - - (x): void
    - Parameters
      x: TSource
      Returns void
Returns IParallelEnumerable<TSource>
A new IParallelEnumerable that executes the action provided.
- Defined in src/types/IParallelEnumerable.ts:70

eachAsync

eachAsync(action): IParallelEnumerable<TSource>
Performs a specified action on each element of the IParallelEnumerable. The order of execution is not guaranteed.
Parameters
- action: ((x) => Promise<void>)
  The async action to take an each element
  - - (x): Promise<void>
    - Parameters
      x: TSource
      Returns Promise<void>
Returns IParallelEnumerable<TSource>
A new IParallelEnumerable that executes the action provided.
- Defined in src/types/IParallelEnumerable.ts:77

elementAt

elementAt(index): 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): 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, comparer?): IParallelEnumerable<TSource>
Produces the set difference of two sequences by using the comparer provided or EqualityComparer to compare values.
Parameters
- second: IAsyncParallel<TSource>
  An IAsyncParallel whose elements that also occur in the first sequence will cause those elements to be removed from the returned sequence.
- Optional comparer: IEqualityComparer<TSource>
  An IEqualityComparer to compare values. Optional.
Returns IParallelEnumerable<TSource>
A sequence that contains the set difference of the elements of two sequences.
- Defined in src/types/IParallelEnumerable.ts:86

exceptAsync

exceptAsync(second, comparer): IParallelEnumerable<TSource>
Produces the set difference of two sequences by using the comparer provided to compare values.
Parameters
- second: IAsyncParallel<TSource>
  An IAsyncParallel 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 IParallelEnumerable<TSource>
A sequence that contains the set difference of the elements of two sequences.
- Defined in src/types/IParallelEnumerable.ts:95

first

first(predicate?): Promise<TSource>
Parameters
- Optional predicate: ((x) => boolean)
  - - (x): boolean
    - Parameters
      x: TSource
      Returns 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): Promise<TSource>
Returns the first element in a sequence that satisfies a specified condition.
Parameters
- predicate: ((x) => Promise<boolean>)
  A function to test each element for a condition.
  - - (x): Promise<boolean>
    - Parameters
      x: TSource
      Returns Promise<boolean>
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?): 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
- Optional predicate: ((x) => boolean)
  A function to test each element for a condition. Optional.
  - - (x): boolean
    - Parameters
      x: TSource
      Returns boolean
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): 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) => Promise<boolean>)
  An async function to test each element for a condition.
  - - (x): Promise<boolean>
    - Parameters
      x: TSource
      Returns Promise<boolean>
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>(keySelector): IParallelEnumerable<IGrouping<TKey, TSource>>
Groups the elements of a sequence according to a specified key selector function.
Type Parameters
- TKey extends SelectorKeyType
Parameters
- keySelector: ((x) => TKey)
  A function to extract the key for each element.
  - - (x): TKey
    - Parameters
      x: TSource
      Returns TKey
Returns IParallelEnumerable<IGrouping<TKey, TSource>>
An IParallelEnumerable<IGrouping<TKey, TSource>> where each IGrouping<TKey,TElement> object contains a sequence of objects and a key.
- Defined in src/types/IParallelEnumerable.ts:103
groupBy<TKey>(keySelector, comparer): IParallelEnumerable<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) => TKey)
  A function to extract the key for each element.
  - - (x): TKey
    - Parameters
      x: TSource
      Returns TKey
- comparer: IEqualityComparer<TKey>
  An IEqualityComparer to compare keys.
Returns IParallelEnumerable<IGrouping<TKey, TSource>>
An IParallelEnumerable<IGrouping<TKey, TSource>> where each IGrouping<TKey,TElement> object contains a sequence of objects and a key.
- Defined in src/types/IParallelEnumerable.ts:113

groupByAsync

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

groupByWithSel

groupByWithSel<TElement, TKey>(keySelector, elementSelector): IParallelEnumerable<IGrouping<TKey, TElement>>
Type Parameters
- TElement
- TKey extends SelectorKeyType
Parameters
- keySelector: ((x) => TKey)
  - - (x): TKey
    - Parameters
      x: TSource
      Returns TKey
- elementSelector: ((x) => TElement)
  - - (x): TElement
    - Parameters
      x: TSource
      Returns TElement
Returns IParallelEnumerable<IGrouping<TKey, TElement>>
- Defined in src/types/IParallelEnumerable.ts:136
groupByWithSel<TKey, TElement>(keySelector, elementSelector, comparer): IParallelEnumerable<IGrouping<TKey, TElement>>
Type Parameters
- TKey
- TElement
Parameters
- keySelector: ((x) => TKey)
  - - (x): TKey
    - Parameters
      x: TSource
      Returns TKey
- elementSelector: ((x) => TElement)
  - - (x): TElement
    - Parameters
      x: TSource
      Returns TElement
- comparer: IEqualityComparer<TKey>
Returns IParallelEnumerable<IGrouping<TKey, TElement>>
- Defined in src/types/IParallelEnumerable.ts:139

groupJoin

groupJoin<TInner, TKey, TResult>(inner, outerKeySelector, innerKeySelector, resultSelector, comparer?): IParallelEnumerable<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> | AsyncIterable<TInner>
  The sequence to join to the first sequence.
- outerKeySelector: ((value) => TKey)
  The sequence to join to the first sequence.
  - - (value): TKey
    - Parameters
      value: TSource
      Returns TKey
- innerKeySelector: ((value) => TKey)
  A function to extract the join key from each element of the second sequence.
  - - (value): TKey
    - Parameters
      value: TInner
      Returns TKey
- resultSelector: ((element, collection) => 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.
  - - (element, collection): TResult
    - Parameters
      element: TSource
      collection: TInner[]
      Returns TResult
- Optional comparer: IEqualityComparer<TKey>
  To compare keys. Optional.
Returns IParallelEnumerable<TResult>
An IParallelEnumerable that contains elements of type TResult that are obtained by performing a grouped join on two sequences.
- Defined in src/types/IParallelEnumerable.ts:152

groupJoinAsync

groupJoinAsync<TInner, TKey, TResult>(inner, outerKeySelector, innerKeySelector, resultSelector, comparer?): IParallelEnumerable<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> | AsyncIterable<TInner>
  The sequence to join to the first sequence. Can be async.
- outerKeySelector: ((value) => TKey | Promise<TKey>)
  The sequence to join to the first sequence. Can be async.
  - - (value): TKey | Promise<TKey>
    - Parameters
      value: TSource
      Returns TKey | Promise<TKey>
- innerKeySelector: ((value) => TKey | Promise<TKey>)
  A function to extract the join key from each element of the second sequence.
  - - (value): TKey | Promise<TKey>
    - Parameters
      value: TInner
      Returns TKey | Promise<TKey>
- resultSelector: ((element, collection) => 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.
  - - (element, collection): TResult | Promise<TResult>
    - Parameters
      element: TSource
      collection: TInner[]
      Returns TResult | Promise<TResult>
- Optional comparer: IEqualityComparer<TKey>
  To compare keys. Optional.
Returns IParallelEnumerable<TResult>
An IParallelEnumerable that contains elements of type TResult that are obtained by performing a grouped join on two sequences.
- Defined in src/types/IParallelEnumerable.ts:167

intersect

intersect(second, comparer?): IParallelEnumerable<TSource>
Parameters
- second: IAsyncParallel<TSource>
- Optional comparer: IEqualityComparer<TSource>
Returns IParallelEnumerable<TSource>
- Defined in src/types/IParallelEnumerable.ts:174

intersectAsync

intersectAsync(second, comparer): IParallelEnumerable<TSource>
Parameters
- second: IAsyncParallel<TSource>
- comparer: IAsyncEqualityComparer<TSource>
Returns IParallelEnumerable<TSource>
- Defined in src/types/IParallelEnumerable.ts:176

joinByKey

joinByKey<TInner, TKey, TResult>(inner, outerKeySelector, innerKeySelector, resultSelector, comparer?): IParallelEnumerable<TResult>
Type Parameters
- TInner
- TKey
- TResult
Parameters
- inner: IAsyncParallel<TInner>
- outerKeySelector: ((x) => TKey)
  - - (x): TKey
    - Parameters
      x: TSource
      Returns TKey
- innerKeySelector: ((x) => TKey)
  - - (x): TKey
    - Parameters
      x: TInner
      Returns TKey
- resultSelector: ((x, y) => TResult)
  - - (x, y): TResult
    - Parameters
      x: TSource
      y: TInner
      Returns TResult
- Optional comparer: IEqualityComparer<TKey>
Returns IParallelEnumerable<TResult>
- Defined in src/types/IParallelEnumerable.ts:179

last

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

lastOrDefaultAsync

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

max

max(this): Promise<number>
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:175
max(selector): Promise<number>
Parameters
- selector: ((x) => number)
  - - (x): number
    - Parameters
      x: TSource
      Returns number
Returns Promise<number>
Throws
Sequence contains no elements
Inherited from IAsyncParallel.max
- Defined in src/types/IAsyncParallel.ts:179

maxAsync

maxAsync(selector): Promise<number>
Parameters
- selector: ((x) => Promise<number>)
  - - (x): Promise<number>
    - Parameters
      x: TSource
      Returns Promise<number>
Returns Promise<number>
Throws
Sequence contains no elements
Inherited from IAsyncParallel.maxAsync
- Defined in src/types/IAsyncParallel.ts:183

min

min(this): Promise<number>
Parameters
- this: IAsyncParallel<number>
Returns Promise<number>
Throws
Sequence contains no elements
Inherited from IAsyncParallel.min
- Defined in src/types/IAsyncParallel.ts:187
min(selector): Promise<number>
Parameters
- selector: ((x) => number)
  - - (x): number
    - Parameters
      x: TSource
      Returns number
Returns Promise<number>
Throws
Sequence contains no elements
Inherited from IAsyncParallel.min
- Defined in src/types/IAsyncParallel.ts:191

minAsync

minAsync(selector): Promise<number>
Parameters
- selector: ((x) => Promise<number>)
  - - (x): Promise<number>
    - Parameters
      x: TSource
      Returns Promise<number>
Returns Promise<number>
Throws
Sequence contains no elements
Inherited from IAsyncParallel.minAsync
- Defined in src/types/IAsyncParallel.ts:195

ofType

ofType<TType>(type): IParallelEnumerable<InferType<TType>>
Type Parameters
- TType extends OfType
Parameters
- type: TType
Returns IParallelEnumerable<InferType<TType>>
- Defined in src/types/IParallelEnumerable.ts:185

order

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

orderBy

orderBy<TKey>(predicate, comparer?): IOrderedParallelEnumerable<TSource>
Type Parameters
- TKey
Parameters
- predicate: ((x) => TKey)
  - - (x): TKey
    - Parameters
      x: TSource
      Returns TKey
- Optional comparer: IComparer<TKey>
Returns IOrderedParallelEnumerable<TSource>
- Defined in src/types/IParallelEnumerable.ts:193

orderByAsync

orderByAsync<TKey>(predicate, comparer?): IOrderedParallelEnumerable<TSource>
Type Parameters
- TKey
Parameters
- predicate: ((x) => Promise<TKey>)
  - - (x): Promise<TKey>
    - Parameters
      x: TSource
      Returns Promise<TKey>
- Optional comparer: IComparer<TKey>
Returns IOrderedParallelEnumerable<TSource>
- Defined in src/types/IParallelEnumerable.ts:196

orderByDescending

orderByDescending<TKey>(predicate, comparer?): IParallelEnumerable<TSource>
Type Parameters
- TKey
Parameters
- predicate: ((x) => TKey)
  - - (x): TKey
    - Parameters
      x: TSource
      Returns TKey
- Optional comparer: IComparer<TKey>
Returns IParallelEnumerable<TSource>
- Defined in src/types/IParallelEnumerable.ts:199

orderByDescendingAsync

orderByDescendingAsync<TKey>(predicate, comparer?): IParallelEnumerable<TSource>
Type Parameters
- TKey
Parameters
- predicate: ((x) => Promise<TKey>)
  - - (x): Promise<TKey>
    - Parameters
      x: TSource
      Returns Promise<TKey>
- Optional comparer: IComparer<TKey>
Returns IParallelEnumerable<TSource>
- Defined in src/types/IParallelEnumerable.ts:202

orderDescending

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

partition

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

partitionAsync

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

prepend

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

reverse

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

Returns IParallelEnumerable<TSource>
A sequence whose elements correspond to those of the input sequence in reverse order.
- Defined in src/types/IParallelEnumerable.ts:222

select

select<TResult>(selector): IParallelEnumerable<TResult>
Type Parameters
- TResult
Parameters
- selector: ((x, index) => TResult)
  - - (x, index): TResult
    - Parameters
      x: TSource
      index: number
      Returns TResult
Returns IParallelEnumerable<TResult>
- Defined in src/types/IParallelEnumerable.ts:223
select<TKey>(key): IParallelEnumerable<TSource[TKey]>
Type Parameters
- TKey extends string | number | symbol
Parameters
- key: TKey
Returns IParallelEnumerable<TSource[TKey]>
- Defined in src/types/IParallelEnumerable.ts:224

selectAsync

selectAsync<TResult>(selector): IParallelEnumerable<TResult>
Type Parameters
- TResult
Parameters
- selector: ((x, index) => Promise<TResult>)
  - - (x, index): Promise<TResult>
    - Parameters
      x: TSource
      index: number
      Returns Promise<TResult>
Returns IParallelEnumerable<TResult>
- Defined in src/types/IParallelEnumerable.ts:225
selectAsync<TKey, TResult>(this, selector): IParallelEnumerable<TResult>
Type Parameters
- TKey extends string | number | symbol
- TResult
Parameters
- this: IParallelEnumerable<{
  [key: string]: Promise<TResult>;
  }>
- selector: TKey
Returns IParallelEnumerable<TResult>
- Defined in src/types/IParallelEnumerable.ts:227

selectMany

selectMany<TResult>(selector): IParallelEnumerable<TResult>
Type Parameters
- TResult
Parameters
- selector: ((x, index) => Iterable<TResult>)
  - - (x, index): Iterable<TResult>
    - Parameters
      x: TSource
      index: number
      Returns Iterable<TResult>
Returns IParallelEnumerable<TResult>
- Defined in src/types/IParallelEnumerable.ts:230
selectMany<TBindedSource, TOut>(this, selector): IParallelEnumerable<TOut>
Type Parameters
- TBindedSource extends {
  [key: string]: Iterable<TOut>;
  }
- TOut
Parameters
- this: IParallelEnumerable<TBindedSource>
- selector: keyof TBindedSource
Returns IParallelEnumerable<TOut>
- Defined in src/types/IParallelEnumerable.ts:231

selectManyAsync

selectManyAsync<TResult>(selector): IParallelEnumerable<TResult>
Type Parameters
- TResult
Parameters
- selector: ((x, index) => Promise<Iterable<TResult>>)
  - - (x, index): Promise<Iterable<TResult>>
    - Parameters
      x: TSource
      index: number
      Returns Promise<Iterable<TResult>>
Returns IParallelEnumerable<TResult>
- Defined in src/types/IParallelEnumerable.ts:234

sequenceEquals

sequenceEquals(second, comparer?): Promise<boolean>
Parameters
- second: IAsyncParallel<TSource>
- Optional comparer: IEqualityComparer<TSource>
Returns Promise<boolean>
- Defined in src/types/IParallelEnumerable.ts:236

sequenceEqualsAsync

sequenceEqualsAsync(second, comparer?): Promise<boolean>
Parameters
- second: IAsyncParallel<TSource>
- Optional comparer: IAsyncEqualityComparer<TSource>
Returns Promise<boolean>
- Defined in src/types/IParallelEnumerable.ts:238

single

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

singleAsync

singleAsync(predicate): Promise<TSource>
Parameters
- predicate: ((x) => Promise<boolean>)
  - - (x): Promise<boolean>
    - Parameters
      x: TSource
      Returns 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:220

singleOrDefault

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

singleOrDefaultAsync

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

skip

skip(count): IParallelEnumerable<TSource>
Parameters
- count: number
Returns IParallelEnumerable<TSource>
- Defined in src/types/IParallelEnumerable.ts:240

skipWhile

skipWhile(predicate): IParallelEnumerable<TSource>
Parameters
- predicate: ((x, index) => boolean)
  - - (x, index): boolean
    - Parameters
      x: TSource
      index: number
      Returns boolean
Returns IParallelEnumerable<TSource>
- Defined in src/types/IParallelEnumerable.ts:241

skipWhileAsync

skipWhileAsync(predicate): IParallelEnumerable<TSource>
Parameters
- predicate: ((x, index) => Promise<boolean>)
  - - (x, index): Promise<boolean>
    - Parameters
      x: TSource
      index: number
      Returns Promise<boolean>
Returns IParallelEnumerable<TSource>
- Defined in src/types/IParallelEnumerable.ts:242

sum

sum(this): 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:233
sum(selector): 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) => number)
  A transform function to apply to each element.
  - - (x): number
    - Parameters
      x: TSource
      Returns number
Returns Promise<number>
A promise of the sum of the projected values.
Inherited from IAsyncParallel.sum
- Defined in src/types/IAsyncParallel.ts:240

sumAsync

sumAsync(selector): 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) => Promise<number>)
  An async transform function to apply to each element.
  - - (x): Promise<number>
    - Parameters
      x: TSource
      Returns Promise<number>
Returns Promise<number>
A promise of the sum of the projected values.
Inherited from IAsyncParallel.sumAsync
- Defined in src/types/IAsyncParallel.ts:247

take

take(amount): IParallelEnumerable<TSource>
Parameters
- amount: number
Returns IParallelEnumerable<TSource>
- Defined in src/types/IParallelEnumerable.ts:243

takeWhile

takeWhile(predicate): IParallelEnumerable<TSource>
Parameters
- predicate: ((x, index) => boolean)
  - - (x, index): boolean
    - Parameters
      x: TSource
      index: number
      Returns boolean
Returns IParallelEnumerable<TSource>
- Defined in src/types/IParallelEnumerable.ts:244

takeWhileAsync

takeWhileAsync(predicate): IParallelEnumerable<TSource>
Parameters
- predicate: ((x, index) => Promise<boolean>)
  - - (x, index): Promise<boolean>
    - Parameters
      x: TSource
      index: number
      Returns Promise<boolean>
Returns IParallelEnumerable<TSource>
- Defined in src/types/IParallelEnumerable.ts:245

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:252

toMap

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

toMapAsync

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

toObject

toObject<TKey>(selector): 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) => TKey)
  A function to determine the Key based on the value.
  - - (x): TKey
    - Parameters
      x: TSource
      Returns TKey
Returns Promise<Record<TKey, TSource>>
Promise of KVP Object
Inherited from IAsyncParallel.toObject
- Defined in src/types/IAsyncParallel.ts:270

toObjectAsync

toObjectAsync<TKey>(selector): 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) => Promise<TKey>)
  An async function to determine the Key based on the value.
  - - (x): Promise<TKey>
    - Parameters
      x: TSource
      Returns Promise<TKey>
Returns Promise<Record<TKey, TSource>>
Promise of KVP Object
Inherited from IAsyncParallel.toObjectAsync
- Defined in src/types/IAsyncParallel.ts:276

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:281

union

union(second, comparer?): IParallelEnumerable<TSource>
Parameters
- second: IAsyncParallel<TSource>
- Optional comparer: IEqualityComparer<TSource>
Returns IParallelEnumerable<TSource>
- Defined in src/types/IParallelEnumerable.ts:246

unionAsync

unionAsync(second, comparer?): IParallelEnumerable<TSource>
Parameters
- second: IAsyncParallel<TSource>
- Optional comparer: IAsyncEqualityComparer<TSource>
Returns IParallelEnumerable<TSource>
- Defined in src/types/IParallelEnumerable.ts:248

where

where(predicate): IParallelEnumerable<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, index) => boolean)
  A function to test each source element for a condition; the second parameter of the function represents the index of the source element.
  - - (x, index): boolean
    - Parameters
      x: TSource
      index: number
      Returns boolean
Returns IParallelEnumerable<TSource>
An IParallelEnumerable that contains elements from the input sequence that satisfy the condition.
- Defined in src/types/IParallelEnumerable.ts:257

whereAsync

whereAsync(predicate): IParallelEnumerable<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, index) => 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.
  - - (x, index): Promise<boolean>
    - Parameters
      x: TSource
      index: number
      Returns Promise<boolean>
Returns IParallelEnumerable<TSource>
An IParallelEnumerable that contains elements from the input sequence that satisfy the condition.
- Defined in src/types/IParallelEnumerable.ts:265

zip

zip<TSecond, TResult>(second, resultSelector): IParallelEnumerable<TResult>
Type Parameters
- TSecond
- TResult
Parameters
- second: IAsyncParallel<TSecond>
- resultSelector: ((x, y) => TResult)
  - - (x, y): TResult
    - Parameters
      x: TSource
      y: TSecond
      Returns TResult
Returns IParallelEnumerable<TResult>
- Defined in src/types/IParallelEnumerable.ts:266
zip<TSecond>(second): IParallelEnumerable<[TSource, TSecond]>
Type Parameters
- TSecond
Parameters
- second: IAsyncParallel<TSecond>
Returns IParallelEnumerable<[TSource, TSecond]>
- Defined in src/types/IParallelEnumerable.ts:269

zipAsync

zipAsync<TSecond, TResult>(second, resultSelector): IParallelEnumerable<TResult>
Type Parameters
- TSecond
- TResult
Parameters
- second: IAsyncParallel<TSecond>
- resultSelector: ((x, y) => Promise<TResult>)
  - - (x, y): Promise<TResult>
    - Parameters
      x: TSource
      y: TSecond
      Returns Promise<TResult>
Returns IParallelEnumerable<TResult>
- Defined in src/types/IParallelEnumerable.ts:271

Interface IParallelEnumerable<TSource>

Type Parameters

TSource

Hierarchy

Index

Properties

Methods

Properties

Readonly dataFunc

Methods

[asyncIterator]

Returns AsyncIterableIterator<TSource>

aggregate

Parameters

func: ((x, y) => TSource)

Parameters

x: TSource

y: TSource

Returns TSource

Returns Promise<TSource>

Type Parameters

TAccumulate

Parameters

seed: TAccumulate

func: ((x, y) => TAccumulate)

Parameters

x: TAccumulate

y: TSource

Returns TAccumulate

Returns Promise<TAccumulate>

Type Parameters

TAccumulate

TResult

Parameters

seed: TAccumulate

func: ((x, y) => TAccumulate)

Parameters

x: TAccumulate

y: TSource

Returns TAccumulate

resultSelector: ((x) => TResult)

Parameters

x: TAccumulate

Returns TResult

Returns Promise<TResult>

all

Parameters

predicate: ((x) => boolean)

Parameters

x: TSource

Returns boolean

Returns Promise<boolean>

allAsync

Parameters

predicate: ((x) => Promise<boolean>)

Parameters

x: TSource

Returns Promise<boolean>

Returns Promise<boolean>

any

Parameters

Optional predicate: ((x) => boolean)

Parameters

x: TSource

Returns boolean

Returns Promise<boolean>

anyAsync

Parameters

predicate: ((x) => Promise<boolean>)

Parameters

x: TSource

Returns Promise<boolean>

Returns Promise<boolean>

append

Parameters

element: TSource

Returns IParallelEnumerable<TSource>

asAsync

Returns IAsyncEnumerable<TSource>

See

`Readonly` dataFunc

`Optional` predicate: ((x) => boolean)

`Optional` comparer: IEqualityComparer<TSource>

`Optional` predicate: ((x) => boolean)

`Optional` comparer: IEqualityComparer<TSource>