hbecher/sequence-js
1
0
Fork 0
Code Activity

rename lib to sequence-js

Browse Source
This commit is contained in:
Hervé BECHER
2024-05-11 16:57:34 +02:00
parent 486abefba6
commit 05390027f8
9 changed files with 929 additions and 929 deletions
Download Patch File Download Diff File Expand all files Collapse all files

780
src/async/impl.ts
View File

File diff suppressed because it is too large Load Diff

56
src/async/index.ts
View File

@@ -1,16 +1,16 @@
import { wrap as wrapSync } from "../sync/index.js";
import { Enumerable } from "../sync/types.js";
import { Sequence } from "../sync/types.js";
import { MaybeAsyncIterable } from "../types.js";
import { isAsyncIterable } from "../utils.js";
import { WrappedEnumerable, WrappedAsyncIterable, EmptyAsyncEnumerable, WrappedObjectAsync, WrappedArrayAsync, WrappedArrayLikeAsync, FunctionAsyncEnumerable, GeneratorAsyncEnumerable, RangeAsyncEnumerable, RepeatForeverAsyncEnumerable, RepeatAsyncEnumerable, AsyncEnumerableMarker } from "./impl.js";
import { AsyncEnumerable } from "./types.js";
import { WrappedSequence, WrappedAsyncIterable, EmptyAsyncSequence, WrappedObjectAsync, WrappedArrayAsync, WrappedArrayLikeAsync, FunctionAsyncSequence, GeneratorAsyncSequence, RangeAsyncSequence, RepeatForeverAsyncSequence, RepeatAsyncSequence, AsyncSequenceMarker } from "./impl.js";
import { AsyncSequence } from "./types.js";
export function asAsync<T>(enumerable: Enumerable<T>): AsyncEnumerable<T> {
return new WrappedEnumerable(enumerable);
export function asAsync<T>(sequence: Sequence<T>): AsyncSequence<T> {
return new WrappedSequence(sequence);
}
export function wrap<T>(iterable: MaybeAsyncIterable<T>): AsyncEnumerable<T> {
if (isAsyncEnumerable<T>(iterable)) {
export function wrap<T>(iterable: MaybeAsyncIterable<T>): AsyncSequence<T> {
if (isAsyncSequence<T>(iterable)) {
return iterable;
}
@@ -21,27 +21,27 @@ export function wrap<T>(iterable: MaybeAsyncIterable<T>): AsyncEnumerable<T> {
return asAsync(wrapSync(iterable));
}
export function sequence<T>(iterable: AsyncIterable<T>): AsyncEnumerable<T> {
export function sequence<T>(iterable: AsyncIterable<T>): AsyncSequence<T> {
return new WrappedAsyncIterable(iterable);
}
export function empty<T>(): AsyncEnumerable<T> {
return EmptyAsyncEnumerable.INSTANCE;
export function empty<T>(): AsyncSequence<T> {
return EmptyAsyncSequence.INSTANCE;
}
export function single<T>(obj: T | PromiseLike<T>): AsyncEnumerable<T> {
export function single<T>(obj: T | PromiseLike<T>): AsyncSequence<T> {
return new WrappedObjectAsync(obj);
}
export function array<T>(array: (T | PromiseLike<T>)[]): AsyncEnumerable<T> {
export function array<T>(array: (T | PromiseLike<T>)[]): AsyncSequence<T> {
return new WrappedArrayAsync(array);
}
export function arrayLike<T>(arrayLike: ArrayLike<(T | PromiseLike<T>)>): AsyncEnumerable<T> {
export function arrayLike<T>(arrayLike: ArrayLike<(T | PromiseLike<T>)>): AsyncSequence<T> {
return new WrappedArrayLikeAsync(arrayLike);
}
export function of<T>(...elements: (T | PromiseLike<T>)[]): AsyncEnumerable<T> {
export function of<T>(...elements: (T | PromiseLike<T>)[]): AsyncSequence<T> {
switch (elements.length) {
case 0:
return empty();
@@ -52,18 +52,18 @@ export function of<T>(...elements: (T | PromiseLike<T>)[]): AsyncEnumerable<T> {
}
}
export function func<T>(f: () => Promise<T>): AsyncEnumerable<T> {
return new FunctionAsyncEnumerable(f);
export function func<T>(f: () => Promise<T>): AsyncSequence<T> {
return new FunctionAsyncSequence(f);
}
export function generator<T>(generator: () => AsyncGenerator<T>): AsyncEnumerable<T> {
return new GeneratorAsyncEnumerable(generator);
export function generator<T>(generator: () => AsyncGenerator<T>): AsyncSequence<T> {
return new GeneratorAsyncSequence(generator);
}
export function range(max: number): AsyncEnumerable<number>
export function range(min: number, max: number): AsyncEnumerable<number>
export function range(min: number, max: number, step: number): AsyncEnumerable<number>
export function range(a: number, b?: number, c?: number): AsyncEnumerable<number> {
export function range(max: number): AsyncSequence<number>
export function range(min: number, max: number): AsyncSequence<number>
export function range(min: number, max: number, step: number): AsyncSequence<number>
export function range(a: number, b?: number, c?: number): AsyncSequence<number> {
if (b === undefined) {
b = a;
a = 0;
@@ -73,12 +73,12 @@ export function range(a: number, b?: number, c?: number): AsyncEnumerable<number
c = 1;
}
return new RangeAsyncEnumerable(a, b, c);
return new RangeAsyncSequence(a, b, c);
}
export function repeat<T>(value: T, count?: number): AsyncEnumerable<T> {
export function repeat<T>(value: T, count?: number): AsyncSequence<T> {
if (count == undefined) {
return new RepeatForeverAsyncEnumerable(value);
return new RepeatForeverAsyncSequence(value);
}
if (count < 0) {
@@ -93,9 +93,9 @@ export function repeat<T>(value: T, count?: number): AsyncEnumerable<T> {
return new WrappedObjectAsync(value);
}
return new RepeatAsyncEnumerable(value, count);
return new RepeatAsyncSequence(value, count);
}
export function isAsyncEnumerable<T = any>(obj: any): obj is AsyncEnumerable<T> {
return obj instanceof AsyncEnumerableMarker;
export function isAsyncSequence<T = any>(obj: any): obj is AsyncSequence<T> {
return obj instanceof AsyncSequenceMarker;
}

90
src/async/types.ts
View File

@@ -2,41 +2,41 @@ import { Collector } from "../collector/types.js";
import { AsyncRandomOptions } from "../random/types.js";
import { MaybeAsyncPredicate, MaybeAsyncConverter, MaybeAsyncIterable, MaybeAsyncEquater, MaybeAsyncBiConverter, MaybeAsyncAccumulator, MaybeAsyncComparer, Predicate, MaybeAsyncAction } from "../types.js";
export interface AsyncEnumerable<TElement> extends AsyncIterable<Awaited<TElement>> {
export interface AsyncSequence<TElement> extends AsyncIterable<Awaited<TElement>> {
iterator(): AsyncIterator<Awaited<TElement>>;
apply<TResult>(pipeline: (enumerable: AsyncEnumerable<TElement>) => TResult): TResult;
apply<TResult>(pipeline: (sequence: AsyncSequence<TElement>) => TResult): TResult;
count(predicate?: MaybeAsyncPredicate<TElement>): Promise<number>;
nonEnumeratedCount(): Promise<number>;
fastCount(): Promise<number>;
maxCount(): Promise<number>;
select<TResult>(selector: MaybeAsyncConverter<TElement, TResult>): AsyncEnumerable<TResult>;
selectMany<TResult>(selector: MaybeAsyncConverter<TElement, MaybeAsyncIterable<TResult>>): AsyncEnumerable<TResult>;
select<TResult>(selector: MaybeAsyncConverter<TElement, TResult>): AsyncSequence<TResult>;
selectMany<TResult>(selector: MaybeAsyncConverter<TElement, MaybeAsyncIterable<TResult>>): AsyncSequence<TResult>;
where(predicate: MaybeAsyncPredicate<TElement>): AsyncEnumerable<TElement>;
where(predicate: MaybeAsyncPredicate<TElement>): AsyncSequence<TElement>;
groupBy<TKey>(keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector?: undefined, keyComparer?: MaybeAsyncEquater<TKey>): AsyncEnumerable<GroupedAsyncEnumerable<TKey, TElement>>;
groupBy<TKey, TResult>(keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector: MaybeAsyncConverter<TElement, TResult>, keyComparer?: MaybeAsyncEquater<TKey>): AsyncEnumerable<GroupedAsyncEnumerable<TKey, TResult>>;
groupBy<TKey>(keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector?: undefined, keyComparer?: MaybeAsyncEquater<TKey>): AsyncSequence<GroupedAsyncSequence<TKey, TElement>>;
groupBy<TKey, TResult>(keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector: MaybeAsyncConverter<TElement, TResult>, keyComparer?: MaybeAsyncEquater<TKey>): AsyncSequence<GroupedAsyncSequence<TKey, TResult>>;
join<TOther, TKey>(iterable: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector?: undefined, keyComparer?: MaybeAsyncEquater<TKey>): AsyncEnumerable<[Awaited<TElement>, Awaited<TOther>]>;
join<TOther, TKey, TResult>(iterable: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector: MaybeAsyncBiConverter<TElement, TOther, TResult>, keyComparer?: MaybeAsyncEquater<TKey>): AsyncEnumerable<TResult>;
join<TOther, TKey>(iterable: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector?: undefined, keyComparer?: MaybeAsyncEquater<TKey>): AsyncSequence<[Awaited<TElement>, Awaited<TOther>]>;
join<TOther, TKey, TResult>(iterable: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector: MaybeAsyncBiConverter<TElement, TOther, TResult>, keyComparer?: MaybeAsyncEquater<TKey>): AsyncSequence<TResult>;
groupJoin<TOther, TKey>(iterable: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector?: undefined, keyComparer?: MaybeAsyncEquater<TKey>): AsyncEnumerable<GroupedAsyncEnumerable<TElement, TOther>>;
groupJoin<TOther, TKey, TResult>(iterable: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector: MaybeAsyncBiConverter<TElement, AsyncEnumerable<TOther>, TResult>, keyComparer?: MaybeAsyncEquater<TKey>): AsyncEnumerable<TResult>;
groupJoin<TOther, TKey>(iterable: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector?: undefined, keyComparer?: MaybeAsyncEquater<TKey>): AsyncSequence<GroupedAsyncSequence<TElement, TOther>>;
groupJoin<TOther, TKey, TResult>(iterable: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector: MaybeAsyncBiConverter<TElement, AsyncSequence<TOther>, TResult>, keyComparer?: MaybeAsyncEquater<TKey>): AsyncSequence<TResult>;
contains(obj: TElement, equater?: MaybeAsyncEquater<TElement>): Promise<boolean>;
sequenceEquals(iterable: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEquater<TElement>): Promise<boolean>;
append(obj: TElement): AsyncEnumerable<TElement>;
append(obj: TElement): AsyncSequence<TElement>;
prepend(obj: TElement): AsyncEnumerable<TElement>;
prepend(obj: TElement): AsyncSequence<TElement>;
remove(obj: TElement, all?: boolean, equater?: MaybeAsyncEquater<TElement>): AsyncEnumerable<TElement>;
remove(obj: TElement, all?: boolean, equater?: MaybeAsyncEquater<TElement>): AsyncSequence<TElement>;
concat(...iterables: MaybeAsyncIterable<TElement>[]): AsyncEnumerable<TElement>;
concat(...iterables: MaybeAsyncIterable<TElement>[]): AsyncSequence<TElement>;
first(predicate?: MaybeAsyncPredicate<TElement>): Promise<TElement>;
firstOrDefault(predicate?: MaybeAsyncPredicate<TElement>, def?: TElement): Promise<TElement | undefined>;
@@ -60,23 +60,23 @@ export interface AsyncEnumerable<TElement> extends AsyncIterable<Awaited<TElemen
max(): Promise<TElement>;
maxBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>): Promise<TElement>;
order(comparer?: MaybeAsyncComparer<TElement>): AsyncEnumerable<TElement>;
orderBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparer<TBy>): AsyncEnumerable<TElement>;
order(comparer?: MaybeAsyncComparer<TElement>): AsyncSequence<TElement>;
orderBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparer<TBy>): AsyncSequence<TElement>;
orderDescending(comparer?: MaybeAsyncComparer<TElement>): AsyncEnumerable<TElement>;
orderByDescending<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparer<TBy>): AsyncEnumerable<TElement>;
orderDescending(comparer?: MaybeAsyncComparer<TElement>): AsyncSequence<TElement>;
orderByDescending<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparer<TBy>): AsyncSequence<TElement>;
distinct(equater?: MaybeAsyncEquater<TElement>): AsyncEnumerable<TElement>;
distinctBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncEnumerable<TElement>;
distinct(equater?: MaybeAsyncEquater<TElement>): AsyncSequence<TElement>;
distinctBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncSequence<TElement>;
union(iterable: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEquater<TElement>): AsyncEnumerable<TElement>;
unionBy<TBy>(iterable: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncEnumerable<TElement>;
union(iterable: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEquater<TElement>): AsyncSequence<TElement>;
unionBy<TBy>(iterable: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncSequence<TElement>;
except(iterable: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEquater<TElement>): AsyncEnumerable<TElement>;
exceptBy<TBy>(iterable: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncEnumerable<TElement>;
except(iterable: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEquater<TElement>): AsyncSequence<TElement>;
exceptBy<TBy>(iterable: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncSequence<TElement>;
intersect(iterable: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEquater<TElement>): AsyncEnumerable<TElement>;
intersectBy<TBy>(iterable: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncEnumerable<TElement>;
intersect(iterable: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEquater<TElement>): AsyncSequence<TElement>;
intersectBy<TBy>(iterable: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncSequence<TElement>;
all(predicate: MaybeAsyncPredicate<TElement>): Promise<boolean>;
any(predicate: MaybeAsyncPredicate<TElement>): Promise<boolean>;
@@ -84,29 +84,29 @@ export interface AsyncEnumerable<TElement> extends AsyncIterable<Awaited<TElemen
none(predicate: Predicate<TElement>): Promise<boolean>;
none(): Promise<boolean>;
skip(n: number): AsyncEnumerable<TElement>;
skipLast(n: number): AsyncEnumerable<TElement>;
skipWhile(condition: MaybeAsyncPredicate<TElement>): AsyncEnumerable<TElement>;
skip(n: number): AsyncSequence<TElement>;
skipLast(n: number): AsyncSequence<TElement>;
skipWhile(condition: MaybeAsyncPredicate<TElement>): AsyncSequence<TElement>;
take(n: number): AsyncEnumerable<TElement>;
takeLast(n: number): AsyncEnumerable<TElement>;
takeWhile(condition: MaybeAsyncPredicate<TElement>): AsyncEnumerable<TElement>;
take(n: number): AsyncSequence<TElement>;
takeLast(n: number): AsyncSequence<TElement>;
takeWhile(condition: MaybeAsyncPredicate<TElement>): AsyncSequence<TElement>;
peek(action: MaybeAsyncAction<TElement>): AsyncEnumerable<TElement>;
peek(action: MaybeAsyncAction<TElement>): AsyncSequence<TElement>;
forEach(action: MaybeAsyncAction<TElement>): Promise<void>;
zip<TOther>(iterable: MaybeAsyncIterable<TOther>): AsyncEnumerable<[Awaited<TElement>, Awaited<TOther>]>;
zip<TOther>(iterable: MaybeAsyncIterable<TOther>): AsyncSequence<[Awaited<TElement>, Awaited<TOther>]>;
indexex(): AsyncEnumerable<[number, Awaited<TElement>]>;
indexex(): AsyncSequence<[number, Awaited<TElement>]>;
reversed(): AsyncEnumerable<TElement>;
reversed(): AsyncSequence<TElement>;
chunked(size: number): AsyncEnumerable<TElement[]>;
chunked(size: number): AsyncSequence<TElement[]>;
random(options?: AsyncRandomOptions<TElement>): Promise<TElement | undefined>;
cached(): AsyncEnumerable<TElement>;
cached(): AsyncSequence<TElement>;
toArray(): Promise<TElement[]>;
toMap<TKey, TValue>(keySelector: MaybeAsyncConverter<TElement, TKey>, valueSelector: MaybeAsyncConverter<TElement, TValue>): Promise<Map<TKey, TValue>>;
@@ -116,18 +116,18 @@ export interface AsyncEnumerable<TElement> extends AsyncIterable<Awaited<TElemen
collect<TResult>(collector: Collector<TElement, any, TResult>): Promise<TResult>;
}
export interface GroupedAsyncEnumerable<TKey, TElement> extends AsyncEnumerable<TElement> {
export interface GroupedAsyncSequence<TKey, TElement> extends AsyncSequence<TElement> {
get key(): TKey;
}
export interface OrderedAsyncEnumerable<TElement> extends AsyncEnumerable<TElement> {
export interface OrderedAsyncSequence<TElement> extends AsyncSequence<TElement> {
get comparer(): MaybeAsyncComparer<TElement>;
thenSelf(comparer?: MaybeAsyncComparer<TElement>): OrderedAsyncEnumerable<TElement>;
thenSelf(comparer?: MaybeAsyncComparer<TElement>): OrderedAsyncSequence<TElement>;
thenBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparer<TBy>): OrderedAsyncEnumerable<TElement>;
thenBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparer<TBy>): OrderedAsyncSequence<TElement>;
thenSelfDescending(comparer?: MaybeAsyncComparer<TElement>): OrderedAsyncEnumerable<TElement>;
thenSelfDescending(comparer?: MaybeAsyncComparer<TElement>): OrderedAsyncSequence<TElement>;
thenByDescending<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparer<TBy>): OrderedAsyncEnumerable<TElement>;
thenByDescending<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparer<TBy>): OrderedAsyncSequence<TElement>;
}