alinq v1.0.21

alinq

asynchronous linq

Usage

for more use case see ./test/test.js

let linq = require('alinq');
let iter = linq.from(1, 2, 3);
let ret = await iter.toArray();
console.log(ret);

API

see ./dist/index.d.ts

declare type PromisifyType<TSource> = TSource | Promise<TSource>;
declare type IterableType<TSource> = TSource[] | Iterable<TSource> | Generator<TSource>;
declare type AsyncIterableType<TSource> = AsyncIterable<TSource> | AsyncGenerator<TSource>;
declare type YieldableType<TSource> = IterableType<TSource> | AsyncIterableType<TSource> | IEnumerable<TSource>;
declare type CollectionType<TSource> = PromisifyType<YieldableType<TSource>>;
declare type PredicateFunc<TSource> = (element: TSource, index?: number) => PromisifyType<boolean>;
declare type ActionFunc<TSource> = (element: TSource, index?: number) => PromisifyType<void>;
declare type EqualsFunc<TSource> = (a: TSource, b: TSource) => PromisifyType<boolean>;
declare type SelectorFunc<TSource, TResult> = (element: TSource, index?: number) => PromisifyType<TResult>;
export declare function from<TSource>(obj: CollectionType<TSource>): IEnumerable<TSource>;
export declare function from<TSource>(...arr: TSource[]): IEnumerable<TSource>;
export declare function empty<TSource>(): IEnumerable<TSource>;
export declare function range(start: number, count: number): IEnumerable<number>;
export declare function repeat<TSource>(element: TSource, count: number): IEnumerable<number>;
export declare function concat<TSource>(...sequences: CollectionType<TSource>[]): IEnumerable<TSource>;
export interface IEnumerator<TSource> {
    current: TSource;
    moveNext(): Promise<boolean>;
}
export interface IEnumerable<TSource> {
    getEnumerator(): IEnumerator<TSource>;
    toArray(): Promise<TSource[]>;
    count(predicate?: PredicateFunc<TSource>): Promise<number>;
    any(predicate?: PredicateFunc<TSource>): Promise<boolean>;
    all(predicate: PredicateFunc<TSource>): Promise<boolean>;
    forEach(action: ActionFunc<TSource>): Promise<void>;
    first(predicate?: PredicateFunc<TSource>): Promise<TSource>;
    last(predicate?: PredicateFunc<TSource>): Promise<TSource>;
    single(predicate?: PredicateFunc<TSource>): Promise<TSource>;
    elementAt(index: number): Promise<TSource>;
    contains(value: TSource, equals?: EqualsFunc<TSource>): Promise<boolean>;
    sum<TResult>(selector?: SelectorFunc<TSource, TResult>): Promise<TResult>;
    min<TResult>(selector?: SelectorFunc<TSource, TResult>): Promise<TResult>;
    max<TResult>(selector?: SelectorFunc<TSource, TResult>): Promise<TResult>;
    where(predicate: PredicateFunc<TSource>): IEnumerable<TSource>;
    take(count: number): IEnumerable<TSource>;
    takeWhile(predicate: PredicateFunc<TSource>): IEnumerable<TSource>;
    skip(count: number): IEnumerable<TSource>;
    skipWhile(predicate: PredicateFunc<TSource>): IEnumerable<TSource>;
    select<TResult>(selector: SelectorFunc<TSource, TResult>): IEnumerable<TResult>;
    selectMany<TResult>(selector: SelectorFunc<TSource, CollectionType<TResult>>): IEnumerable<TResult>;
    concat(...sequences: CollectionType<TSource>[]): IEnumerable<TSource>;
}