nowjs-core/lib/linq/MemoryParallelQueryableProvider.d.ts

NowCanDo Javascript Core [nowjs-core] is a library written by TypeScript code maintains under Apache 2.0 licence

import { IParallelOrderedQueryable } from './IParallelOrderedQueryable';
import { ICollection } from '../collections/ICollection';
import { IList } from '../collections/IList';
import { IGroup } from './IGroup';
import { IAsyncEnumerable } from '../core/IAsyncEnumerable';
import { IParallelQueryable } from './IParallelQueryable';
import { IParallelQueryableProvider } from './IParallelQueryableProvider';
export declare class MemoryParallelQueryableProvider<T> implements IParallelQueryableProvider<T> {
    get name(): string;
    aggregate(action: (seed: T, item: T, index?: number, source?: IAsyncEnumerable<T>) => T, seed?: T): Promise<T>;
    all(predicate?: (arg: T) => boolean): Promise<boolean>;
    any(predicate?: (arg: T) => boolean): Promise<boolean>;
    first(predicate?: (arg: T) => boolean, defValue?: T): Promise<T>;
    last(predicate?: (arg: T) => boolean, defValue?: T): Promise<T>;
    single(predicate: (arg: T) => boolean, defValue?: T): Promise<T>;
    contains(item: T): Promise<boolean>;
    isEmpty(): Promise<boolean>;
    skip(count: number): IParallelQueryable<T>;
    skipWhile(predicate: (arg: T) => boolean): IParallelQueryable<T>;
    take(count: number): IParallelQueryable<T>;
    takeWhile(predicate: (arg: T) => boolean): IParallelQueryable<T>;
    distinct(): IParallelQueryable<T>;
    reverse(): IParallelQueryable<T>;
    shuffles(count?: number): IParallelQueryable<T>;
    asParallelEnumerable(): IAsyncEnumerable<T>;
    select<TResult>(selector?: (arg: T) => TResult): IParallelQueryable<TResult>;
    selectMany<TResult>(selector: (arg: T) => IAsyncEnumerable<TResult>): IParallelQueryable<TResult>;
    selectMany<TCollection, TResult>(selector: (arg: T) => IAsyncEnumerable<TResult>, collectionSelector?: (arg: TCollection) => TResult): IParallelQueryable<TResult>;
    join<TOuter, TInner, TKey, TResult>(inner: IAsyncEnumerable<TInner>, outerSelector: (arg: TOuter) => TKey, innerSelector: (arg: TInner) => TKey, resultSelector: (innerItem: TInner, outerItem: TOuter) => TResult): IParallelQueryable<TResult>;
    where(predicate: (arg: T) => boolean): IParallelQueryable<T>;
    except(predicate: (arg: T) => boolean): IParallelQueryable<T>;
    orderBy<TSelected>(selector: (arg: T) => TSelected, comparator?: (a: T, b: T) => number): IParallelOrderedQueryable<T>;
    orderByDesc<TSelected>(selector: (arg: T) => TSelected, comparator?: (a: T, b: T) => number): IParallelOrderedQueryable<T>;
    groupBy<TKey>(keySelector: (arg: T) => TKey): IParallelQueryable<IGroup<TKey, T>>;
    count(predicate?: (arg: T) => boolean): Promise<number>;
    average(selector?: (arg: T) => number, predicate?: (arg: T) => boolean): Promise<number>;
    max(selector?: (arg: T) => number, predicate?: (arg: T) => boolean): Promise<number>;
    min(selector?: (arg: T) => number, predicate?: (arg: T) => boolean): Promise<number>;
    sum(selector?: (arg: T) => number, predicate?: (arg: T) => boolean): Promise<number>;
    stdDev(selector?: (arg: T) => number, predicate?: (arg: T) => boolean): Promise<number>;
    stdDevP(selector?: (arg: T) => number, predicate?: (arg: T) => boolean): Promise<number>;
    variance(selector?: (arg: T) => number, predicate?: (arg: T) => boolean): Promise<number>;
    range(selector?: (arg: T) => number, predicate?: (arg: T) => boolean): Promise<number>;
    varianceP(selector?: (arg: T) => number, predicate?: (arg: T) => boolean): Promise<number>;
    percentile(percentile: number, selector?: (arg: T) => number, predicate?: (arg: T) => boolean): Promise<number>;
    percentileInclusive(percentile: number, selector?: (arg: T) => number, predicate?: (arg: T) => boolean): Promise<number>;
    percentileExclusive(percentile: number, selector?: (arg: T) => number, predicate?: (arg: T) => boolean): Promise<number>;
    percentRank(value: number, selector?: (arg: T) => number, predicate?: (arg: T) => boolean): Promise<number>;
    mean(selector?: (arg: T) => number, predicate?: (arg: T) => boolean): Promise<number>;
    median(selector?: (arg: T) => number, predicate?: (arg: T) => boolean): Promise<number>;
    mode(selector?: (arg: T) => number, predicate?: (arg: T) => boolean): Promise<number>;
    covariance(other: IParallelQueryable<T>, selector?: (arg: T) => number, predicate?: (arg: T) => boolean): Promise<number>;
    pearson(other: IParallelQueryable<T>, selector?: (arg: T) => number, predicate?: (arg: T) => boolean): Promise<number>;
    rootMeanSquare(selector?: (arg: T) => number, predicate?: (arg: T) => boolean): Promise<number>;
    forEach(action: (element: T, index: number) => void): Promise<void>;
    toArray(): Promise<T[]>;
    toList(): Promise<IList<T>>;
    toCollection(): Promise<ICollection<T>>;
    intersect(source: IAsyncEnumerable<T>, equalityComparator?: (a: T, b: T) => number): IParallelQueryable<T>;
    subtract(source: IAsyncEnumerable<T>, equalityComparator?: (a: T, b: T) => number): IParallelQueryable<T>;
    union(source: IAsyncEnumerable<T>, equalityComparator?: (a: T, b: T) => number): IParallelQueryable<T>;
    zip<TSecond, TResult>(second: IAsyncEnumerable<TSecond>, selector: (tfirst: T, tsecond: TSecond) => TResult): IParallelQueryable<TResult>;
    [Symbol.asyncIterator](): AsyncIterator<T>;
}