hbecher/sequence-js
1
0
Fork 0
Code Activity

sequence type fixes and refactor

Browse Source
This commit is contained in:
Hervé BECHER
2024-05-17 22:12:16 +02:00
parent 85033018cf
commit 595d9fd5fc
7 changed files with 287 additions and 249 deletions
Download Patch File Download Diff File Expand all files Collapse all files

272
src/async/impl.ts
View File

@@ -6,7 +6,7 @@ import { getRandomElementAsync } from "../random/index.js";
import { AsyncRandomOptions } from "../random/types.js";
import { selectionSorter } from "../sorting.js";
import { Sequence } from "../sync/types.js";
import { MaybeAsyncConverter, MaybeAsyncIterable, MaybeAsyncPredicate, MaybeAsyncEquater, MaybeAsyncBiConverter, MaybeAsyncAccumulator, MaybeAsyncComparer, MaybeAsyncAction, MaybePromise, Predicate } from "../types.js";
import { MaybeAsyncConverter, MaybeAsyncPredicate, MaybeAsyncEquater, MaybeAsyncBiConverter, MaybeAsyncAccumulator, MaybeAsyncComparer, MaybeAsyncAction, MaybePromiseLike, MaybeAsyncGenerator, MaybeAsyncSequence } from "../types.js";
import { strictEquals, identity, operatorCompare, asAsyncGenerator, defaultArrayComparer, combineAsyncComparers } from "../utils.js";
import { array, empty, wrap } from "./index.js";
import { AsyncSequence, GroupedAsyncSequence, OrderedAsyncSequence } from "./types.js";
@@ -18,7 +18,7 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
return this.iterator();
}
abstract iterator(): AsyncIterator<Awaited<TElement>>;
abstract iterator(): AsyncIterator<TElement>;
apply<TResult>(pipeline: (sequence: AsyncSequence<TElement>) => TResult): TResult {
return pipeline(this);
@@ -28,7 +28,7 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
return new MapperAsyncSequence<TElement, TResult>(this, converter);
}
selectMany<TResult>(converter: MaybeAsyncConverter<TElement, MaybeAsyncIterable<TResult>>): AsyncSequence<TResult> {
selectMany<TResult>(converter: MaybeAsyncConverter<TElement, MaybeAsyncSequence<TResult>>): AsyncSequence<TResult> {
return new FlatMapperAsyncSequence<TElement, TResult>(this, converter);
}
@@ -36,16 +36,22 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
return new FilterAsyncSequence<TElement>(this, predicate);
}
groupBy<TKey, TResult>(keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector?: MaybeAsyncConverter<TElement, TResult>, keyComparer?: MaybeAsyncEquater<TKey>): AsyncSequence<GroupedAsyncSequence<TKey, TResult>> {
return new GroupByAsyncSequence<TElement, TKey, TResult>(this, keySelector, elementSelector, keyComparer);
groupBy<TKey>(keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector?: undefined, keyComparer?: MaybeAsyncEquater<TKey> | undefined): AsyncSequence<GroupedAsyncSequence<TKey, TElement>>;
groupBy<TKey, TResult>(keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector: MaybeAsyncConverter<TElement, TResult>, keyComparer?: MaybeAsyncEquater<TKey> | undefined): AsyncSequence<GroupedAsyncSequence<TKey, TResult>>;
groupBy(keySelector: any, elementSelector?: any, keyComparer?: any) {
return new GroupByAsyncSequence<any, any, any>(this, keySelector, elementSelector, keyComparer);
}
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> {
return new JoinAsyncSequence<TElement, TOther, TKey, TResult>(this, wrap(iterable), firstKeySelector, secondKeySelector, resultSelector, keyComparer);
join<TOther, TKey>(sequence: MaybeAsyncSequence<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector?: undefined, keyComparer?: MaybeAsyncEquater<TKey> | undefined): AsyncSequence<[TElement, TOther]>;
join<TOther, TKey, TResult>(sequence: MaybeAsyncSequence<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector: MaybeAsyncBiConverter<TElement, TOther, TResult>, keyComparer?: MaybeAsyncEquater<TKey> | undefined): AsyncSequence<TResult>;
join(sequence: any, firstKeySelector: any, secondKeySelector: any, resultSelector?: any, keyComparer?: any) {
return new JoinAsyncSequence<any, any, any, any>(this, wrap(sequence), firstKeySelector, secondKeySelector, resultSelector, keyComparer);
}
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> {
return new GroupJoinAsyncSequence<TElement, TOther, TKey, TResult>(this, wrap(iterable), firstKeySelector, secondKeySelector, resultSelector, keyComparer);
groupJoin<TOther, TKey>(sequence: MaybeAsyncSequence<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector?: undefined, keyComparer?: MaybeAsyncEquater<TKey> | undefined): AsyncSequence<GroupedAsyncSequence<TElement, TOther>>;
groupJoin<TOther, TKey, TResult>(sequence: MaybeAsyncSequence<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector: MaybeAsyncBiConverter<TElement, AsyncSequence<TOther>, TResult>, keyComparer?: MaybeAsyncEquater<TKey> | undefined): AsyncSequence<TResult>;
groupJoin(sequence: any, firstKeySelector: any, secondKeySelector: any, resultSelector?: any, keyComparer?: any) {
return new GroupJoinAsyncSequence<any, any, any, any>(this, wrap(sequence), firstKeySelector, secondKeySelector, resultSelector, keyComparer);
}
async contains(obj: TElement, equater?: MaybeAsyncEquater<TElement>) {
@@ -62,12 +68,12 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
return false;
}
async sequenceEquals(iterable: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEquater<TElement>) {
if (this === iterable) {
async sequenceEquals(sequence: MaybeAsyncSequence<TElement>, equater?: MaybeAsyncEquater<TElement>) {
if (this === sequence) {
return true;
}
const that = wrap(iterable);
const that = wrap(sequence);
const thisCount = await this.nonEnumeratedCount();
const thatCount = await that.nonEnumeratedCount();
@@ -113,15 +119,15 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
return new RemoveAsyncSequence<TElement>(this, obj, all, equater);
}
concat(...iterables: MaybeAsyncIterable<TElement>[]): AsyncSequence<TElement> {
if (iterables.length === 0) {
concat(...sequences: MaybeAsyncSequence<TElement>[]): AsyncSequence<TElement> {
if (sequences.length === 0) {
return this;
}
const arr: AsyncSequence<TElement>[] = [this];
for (const iterable of iterables) {
arr.push(wrap(iterable));
for (const sequence of sequences) {
arr.push(wrap(sequence));
}
return new ConcatAsyncSequence(arr);
@@ -456,11 +462,11 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
return new OrderByAsyncSequence<TElement, TBy>(this, true, selector, comparer);
}
partition(equater?: MaybeAsyncEquater<TElement>): AsyncSequence<Awaited<TElement>[]> {
partition(equater?: MaybeAsyncEquater<TElement>): AsyncSequence<TElement[]> {
return new PartitionAsyncSequence<TElement>(this, equater);
}
partitionBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncSequence<Awaited<TElement>[]> {
partitionBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncSequence<TElement[]> {
return new PartitionByAsyncSequence<TElement, TBy>(this, selector, equater);
}
@@ -472,28 +478,28 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
return new DistinctByAsyncSequence<TElement, TBy>(this, selector, equater);
}
union(iterable: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEquater<TElement>): AsyncSequence<TElement> {
return new UnionAsyncSequence<TElement>(this, wrap(iterable), equater);
union(sequence: MaybeAsyncSequence<TElement>, equater?: MaybeAsyncEquater<TElement>): AsyncSequence<TElement> {
return new UnionAsyncSequence<TElement>(this, wrap(sequence), equater);
}
unionBy<TBy>(iterable: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncSequence<TElement> {
return new UnionByAsyncSequence<TElement, TBy>(this, wrap(iterable), selector, equater);
unionBy<TBy>(sequence: MaybeAsyncSequence<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncSequence<TElement> {
return new UnionByAsyncSequence<TElement, TBy>(this, wrap(sequence), selector, equater);
}
except(iterable: MaybeAsyncIterable<TElement>): AsyncSequence<TElement> {
return new ExceptAsyncSequence<TElement>(this, wrap(iterable));
except(sequence: MaybeAsyncSequence<TElement>): AsyncSequence<TElement> {
return new ExceptAsyncSequence<TElement>(this, wrap(sequence));
}
exceptBy<TBy>(iterable: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>): AsyncSequence<TElement> {
return new ExceptByAsyncSequence<TElement, TBy>(this, wrap(iterable), selector);
exceptBy<TBy>(sequence: MaybeAsyncSequence<TElement>, selector: MaybeAsyncConverter<TElement, TBy>): AsyncSequence<TElement> {
return new ExceptByAsyncSequence<TElement, TBy>(this, wrap(sequence), selector);
}
intersect(iterable: MaybeAsyncIterable<TElement>): AsyncSequence<TElement> {
return new IntersectAsyncSequence<TElement>(this, wrap(iterable));
intersect(sequence: MaybeAsyncSequence<TElement>): AsyncSequence<TElement> {
return new IntersectAsyncSequence<TElement>(this, wrap(sequence));
}
intersectBy<TBy>(iterable: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>): AsyncSequence<TElement> {
return new IntersectByAsyncSequence<TElement, TBy>(this, wrap(iterable), selector);
intersectBy<TBy>(sequence: MaybeAsyncSequence<TElement>, selector: MaybeAsyncConverter<TElement, TBy>): AsyncSequence<TElement> {
return new IntersectByAsyncSequence<TElement, TBy>(this, wrap(sequence), selector);
}
async all(predicate: MaybeAsyncPredicate<TElement>) {
@@ -602,11 +608,11 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
}
}
zip<TOther>(iterable: MaybeAsyncIterable<TOther>): AsyncSequence<[Awaited<TElement>, Awaited<TOther>]> {
return new ZippedAsyncSequence<TElement, TOther>(this, wrap(iterable));
zip<TOther>(sequence: MaybeAsyncSequence<TOther>): AsyncSequence<[TElement, TOther]> {
return new ZippedAsyncSequence<TElement, TOther>(this, wrap(sequence));
}
indexex(): AsyncSequence<[number, Awaited<TElement>]> {
indexex(): AsyncSequence<[number, TElement]> {
return new IndexedAsyncSequence<TElement>(this);
}
@@ -630,6 +636,10 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
return new CacheAsyncSequence<TElement>(this);
}
async asArray(): Promise<TElement[]> {
return await this.toArray();
}
async toArray() {
const array: TElement[] = [];
@@ -716,7 +726,7 @@ export class DelegatedAsyncSequence<TElement> extends AsyncSequenceMarker implem
return this.#sequence.apply(pipeline);
}
count(predicate?: ((obj: TElement) => MaybePromise<boolean>) | undefined): Promise<number> {
count(predicate?: MaybeAsyncPredicate<TElement> | undefined): Promise<number> {
return this.#sequence.count(predicate);
}
@@ -732,42 +742,42 @@ export class DelegatedAsyncSequence<TElement> extends AsyncSequenceMarker implem
return this.#sequence.maxCount();
}
select<TResult>(selector: (obj: TElement) => MaybePromise<TResult>): AsyncSequence<TResult> {
select<TResult>(selector: MaybeAsyncConverter<TElement, TResult>): AsyncSequence<TResult> {
return this.#sequence.select(selector);
}
selectMany<TResult>(selector: (obj: TElement) => MaybePromise<MaybeAsyncIterable<TResult>>): AsyncSequence<TResult> {
selectMany<TResult>(selector: MaybeAsyncConverter<TElement, MaybeAsyncSequence<TResult>>): AsyncSequence<TResult> {
return this.#sequence.selectMany(selector);
}
where(predicate: (obj: TElement) => MaybePromise<boolean>): AsyncSequence<TElement> {
where(predicate: MaybeAsyncPredicate<TElement>): AsyncSequence<TElement> {
return this.#sequence.where(predicate);
}
groupBy<TKey>(keySelector: (obj: TElement) => MaybePromise<TKey>, elementSelector?: undefined, keyComparer?: ((first: TKey, second: TKey) => MaybePromise<boolean>) | undefined): AsyncSequence<GroupedAsyncSequence<TKey, TElement>>;
groupBy<TKey, TResult>(keySelector: (obj: TElement) => MaybePromise<TKey>, elementSelector: (obj: TElement) => MaybePromise<TResult>, keyComparer?: ((first: TKey, second: TKey) => MaybePromise<boolean>) | undefined): AsyncSequence<GroupedAsyncSequence<TKey, TResult>>;
groupBy<TKey>(keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector?: undefined, keyComparer?: MaybeAsyncEquater<TKey> | undefined): AsyncSequence<GroupedAsyncSequence<TKey, TElement>>;
groupBy<TKey, TResult>(keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector: MaybeAsyncConverter<TElement, TResult>, keyComparer?: MaybeAsyncEquater<TKey> | undefined): AsyncSequence<GroupedAsyncSequence<TKey, TResult>>;
groupBy(keySelector: any, elementSelector?: any, keyComparer?: any) {
return this.#sequence.groupBy(keySelector, elementSelector, keyComparer);
}
join<TOther, TKey>(iterable: MaybeAsyncIterable<TOther>, firstKeySelector: (obj: TElement) => MaybePromise<TKey>, secondKeySelector: (obj: TOther) => MaybePromise<TKey>, resultSelector?: undefined, keyComparer?: ((first: TKey, second: TKey) => MaybePromise<boolean>) | undefined): AsyncSequence<[Awaited<TElement>, Awaited<TOther>]>;
join<TOther, TKey, TResult>(iterable: MaybeAsyncIterable<TOther>, firstKeySelector: (obj: TElement) => MaybePromise<TKey>, secondKeySelector: (obj: TOther) => MaybePromise<TKey>, resultSelector: (first: TElement, second: TOther) => MaybePromise<TResult>, keyComparer?: ((first: TKey, second: TKey) => MaybePromise<boolean>) | undefined): AsyncSequence<TResult>;
join(iterable: any, firstKeySelector: any, secondKeySelector: any, resultSelector?: any, keyComparer?: any) {
return this.#sequence.join(iterable, firstKeySelector, secondKeySelector, resultSelector, keyComparer);
join<TOther, TKey>(sequence: MaybeAsyncSequence<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector?: undefined, keyComparer?: MaybeAsyncEquater<TKey> | undefined): AsyncSequence<[TElement, TOther]>;
join<TOther, TKey, TResult>(sequence: MaybeAsyncSequence<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector: MaybeAsyncBiConverter<TElement, TOther, TResult>, keyComparer?: MaybeAsyncEquater<TKey> | undefined): AsyncSequence<TResult>;
join(sequence: any, firstKeySelector: any, secondKeySelector: any, resultSelector?: any, keyComparer?: any) {
return this.#sequence.join(sequence, firstKeySelector, secondKeySelector, resultSelector, keyComparer);
}
groupJoin<TOther, TKey>(iterable: MaybeAsyncIterable<TOther>, firstKeySelector: (obj: TElement) => MaybePromise<TKey>, secondKeySelector: (obj: TOther) => MaybePromise<TKey>, resultSelector?: undefined, keyComparer?: ((first: TKey, second: TKey) => MaybePromise<boolean>) | undefined): AsyncSequence<GroupedAsyncSequence<TElement, TOther>>;
groupJoin<TOther, TKey, TResult>(iterable: MaybeAsyncIterable<TOther>, firstKeySelector: (obj: TElement) => MaybePromise<TKey>, secondKeySelector: (obj: TOther) => MaybePromise<TKey>, resultSelector: (first: TElement, second: AsyncSequence<TOther>) => MaybePromise<TResult>, keyComparer?: ((first: TKey, second: TKey) => MaybePromise<boolean>) | undefined): AsyncSequence<TResult>;
groupJoin(iterable: any, firstKeySelector: any, secondKeySelector: any, resultSelector?: any, keyComparer?: any) {
return this.#sequence.groupJoin(iterable, firstKeySelector, secondKeySelector, resultSelector, keyComparer);
groupJoin<TOther, TKey>(sequence: MaybeAsyncSequence<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector?: undefined, keyComparer?: MaybeAsyncEquater<TKey> | undefined): AsyncSequence<GroupedAsyncSequence<TElement, TOther>>;
groupJoin<TOther, TKey, TResult>(sequence: MaybeAsyncSequence<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector: MaybeAsyncBiConverter<TElement, AsyncSequence<TOther>, TResult>, keyComparer?: MaybeAsyncEquater<TKey> | undefined): AsyncSequence<TResult>;
groupJoin(sequence: any, firstKeySelector: any, secondKeySelector: any, resultSelector?: any, keyComparer?: any) {
return this.#sequence.groupJoin(sequence, firstKeySelector, secondKeySelector, resultSelector, keyComparer);
}
contains(obj: TElement, equater?: ((first: TElement, second: TElement) => MaybePromise<boolean>) | undefined): Promise<boolean> {
contains(obj: TElement, equater?: MaybeAsyncEquater<TElement> | undefined): Promise<boolean> {
return this.#sequence.contains(obj, equater);
}
sequenceEquals(iterable: MaybeAsyncIterable<TElement>, equater?: ((first: TElement, second: TElement) => MaybePromise<boolean>) | undefined): Promise<boolean> {
return this.#sequence.sequenceEquals(iterable, equater);
sequenceEquals(sequence: MaybeAsyncSequence<TElement>, equater?: MaybeAsyncEquater<TElement> | undefined): Promise<boolean> {
return this.#sequence.sequenceEquals(sequence, equater);
}
append(obj: TElement): AsyncSequence<TElement> {
@@ -778,35 +788,35 @@ export class DelegatedAsyncSequence<TElement> extends AsyncSequenceMarker implem
return this.#sequence.prepend(obj);
}
remove(obj: TElement, all?: boolean | undefined, equater?: ((first: TElement, second: TElement) => MaybePromise<boolean>) | undefined): AsyncSequence<TElement> {
remove(obj: TElement, all?: boolean | undefined, equater?: MaybeAsyncEquater<TElement> | undefined): AsyncSequence<TElement> {
return this.#sequence.remove(obj, all, equater);
}
concat(...iterables: MaybeAsyncIterable<TElement>[]): AsyncSequence<TElement> {
return this.#sequence.concat(...iterables);
concat(...sequences: MaybeAsyncSequence<TElement>[]): AsyncSequence<TElement> {
return this.#sequence.concat(...sequences);
}
first(predicate?: ((obj: TElement) => MaybePromise<boolean>) | undefined): Promise<TElement> {
first(predicate?: MaybeAsyncPredicate<TElement> | undefined): Promise<TElement> {
return this.#sequence.first(predicate);
}
firstOrDefault(predicate?: ((obj: TElement) => MaybePromise<boolean>) | undefined, def?: TElement | undefined): Promise<TElement | undefined> {
firstOrDefault(predicate?: MaybeAsyncPredicate<TElement> | undefined, def?: TElement | undefined): Promise<TElement | undefined> {
return this.#sequence.firstOrDefault(predicate, def);
}
last(predicate?: ((obj: TElement) => MaybePromise<boolean>) | undefined): Promise<TElement> {
last(predicate?: MaybeAsyncPredicate<TElement> | undefined): Promise<TElement> {
return this.#sequence.last(predicate);
}
lastOrDefault(predicate?: ((obj: TElement) => MaybePromise<boolean>) | undefined, def?: TElement | undefined): Promise<TElement | undefined> {
lastOrDefault(predicate?: MaybeAsyncPredicate<TElement> | undefined, def?: TElement | undefined): Promise<TElement | undefined> {
return this.#sequence.lastOrDefault(predicate, def);
}
single(predicate?: ((obj: TElement) => MaybePromise<boolean>) | undefined): Promise<TElement> {
single(predicate?: MaybeAsyncPredicate<TElement> | undefined): Promise<TElement> {
return this.#sequence.single(predicate);
}
singleOrDefault(predicate?: ((obj: TElement) => MaybePromise<boolean>) | undefined, def?: TElement | undefined): Promise<TElement | undefined> {
singleOrDefault(predicate?: MaybeAsyncPredicate<TElement> | undefined, def?: TElement | undefined): Promise<TElement | undefined> {
return this.#sequence.singleOrDefault(predicate, def);
}
@@ -818,9 +828,9 @@ export class DelegatedAsyncSequence<TElement> extends AsyncSequenceMarker implem
return this.#sequence.elementAtOrDefault(index, def);
}
aggregate(accumulator: (acc: TElement, obj: TElement) => MaybePromise<TElement>): Promise<TElement>;
aggregate<TAccumulator>(accumulator: (acc: TAccumulator, obj: TElement) => MaybePromise<TAccumulator>, seed?: TAccumulator | undefined): Promise<TAccumulator>;
aggregate<TAccumulator, TResult>(accumulator: (acc: TAccumulator, obj: TElement) => MaybePromise<TAccumulator>, seed?: TAccumulator | undefined, resultSelector?: ((obj: TAccumulator) => MaybePromise<TResult>) | undefined): Promise<TResult>;
aggregate(accumulator: MaybeAsyncAccumulator<TElement, TElement>): Promise<TElement>;
aggregate<TAccumulator>(accumulator: MaybeAsyncAccumulator<TElement, TAccumulator>, seed?: TAccumulator | undefined): Promise<TAccumulator>;
aggregate<TAccumulator, TResult>(accumulator: MaybeAsyncAccumulator<TElement, TAccumulator>, seed?: TAccumulator | undefined, resultSelector?: MaybeAsyncConverter<TAccumulator, TResult> | undefined): Promise<TResult>;
aggregate(accumulator: any, seed?: any, resultSelector?: any) {
return this.#sequence.aggregate(accumulator, seed, resultSelector);
}
@@ -829,7 +839,7 @@ export class DelegatedAsyncSequence<TElement> extends AsyncSequenceMarker implem
return this.#sequence.min();
}
minBy<TBy>(selector: (obj: TElement) => MaybePromise<TBy>): Promise<TElement> {
minBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>): Promise<TElement> {
return this.#sequence.minBy(selector);
}
@@ -837,77 +847,77 @@ export class DelegatedAsyncSequence<TElement> extends AsyncSequenceMarker implem
return this.#sequence.max();
}
maxBy<TBy>(selector: (obj: TElement) => MaybePromise<TBy>): Promise<TElement> {
maxBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>): Promise<TElement> {
return this.#sequence.maxBy(selector);
}
order(comparer?: ((first: TElement, second: TElement) => MaybePromise<number>) | undefined): AsyncSequence<TElement> {
order(comparer?: MaybeAsyncComparer<TElement> | undefined): AsyncSequence<TElement> {
return this.#sequence.order(comparer);
}
orderBy<TBy>(selector: (obj: TElement) => MaybePromise<TBy>, comparer?: ((first: TBy, second: TBy) => MaybePromise<number>) | undefined): AsyncSequence<TElement> {
orderBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparer<TBy> | undefined): AsyncSequence<TElement> {
return this.#sequence.orderBy(selector, comparer);
}
orderDescending(comparer?: ((first: TElement, second: TElement) => MaybePromise<number>) | undefined): AsyncSequence<TElement> {
orderDescending(comparer?: MaybeAsyncComparer<TElement> | undefined): AsyncSequence<TElement> {
return this.#sequence.orderDescending(comparer);
}
orderByDescending<TBy>(selector: (obj: TElement) => MaybePromise<TBy>, comparer?: ((first: TBy, second: TBy) => MaybePromise<number>) | undefined): AsyncSequence<TElement> {
orderByDescending<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparer<TBy> | undefined): AsyncSequence<TElement> {
return this.#sequence.orderByDescending(selector, comparer);
}
partition(equater?: MaybeAsyncEquater<TElement> | undefined): AsyncSequence<Awaited<TElement>[]> {
partition(equater?: MaybeAsyncEquater<TElement> | undefined): AsyncSequence<TElement[]> {
return this.#sequence.partition(equater);
}
partitionBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy> | undefined): AsyncSequence<Awaited<TElement>[]> {
partitionBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy> | undefined): AsyncSequence<TElement[]> {
return this.#sequence.partitionBy(selector, equater);
}
distinct(equater?: ((first: TElement, second: TElement) => MaybePromise<boolean>) | undefined): AsyncSequence<TElement> {
distinct(equater?: MaybeAsyncEquater<TElement> | undefined): AsyncSequence<TElement> {
return this.#sequence.distinct(equater);
}
distinctBy<TBy>(selector: (obj: TElement) => MaybePromise<TBy>, equater?: ((first: TBy, second: TBy) => MaybePromise<boolean>) | undefined): AsyncSequence<TElement> {
distinctBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy> | undefined): AsyncSequence<TElement> {
return this.#sequence.distinctBy(selector, equater);
}
union(iterable: MaybeAsyncIterable<TElement>, equater?: ((first: TElement, second: TElement) => MaybePromise<boolean>) | undefined): AsyncSequence<TElement> {
return this.#sequence.union(iterable, equater);
union(sequence: MaybeAsyncSequence<TElement>, equater?: MaybeAsyncEquater<TElement> | undefined): AsyncSequence<TElement> {
return this.#sequence.union(wrap(sequence), equater);
}
unionBy<TBy>(iterable: MaybeAsyncIterable<TElement>, selector: (obj: TElement) => MaybePromise<TBy>, equater?: ((first: TBy, second: TBy) => MaybePromise<boolean>) | undefined): AsyncSequence<TElement> {
return this.#sequence.unionBy(iterable, selector, equater);
unionBy<TBy>(sequence: MaybeAsyncSequence<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy> | undefined): AsyncSequence<TElement> {
return this.#sequence.unionBy(wrap(sequence), selector, equater);
}
except(iterable: MaybeAsyncIterable<TElement>, equater?: ((first: TElement, second: TElement) => MaybePromise<boolean>) | undefined): AsyncSequence<TElement> {
return this.#sequence.except(iterable, equater);
except(sequence: MaybeAsyncSequence<TElement>, equater?: MaybeAsyncEquater<TElement> | undefined): AsyncSequence<TElement> {
return this.#sequence.except(wrap(sequence), equater);
}
exceptBy<TBy>(iterable: MaybeAsyncIterable<TElement>, selector: (obj: TElement) => MaybePromise<TBy>, equater?: ((first: TBy, second: TBy) => MaybePromise<boolean>) | undefined): AsyncSequence<TElement> {
return this.#sequence.exceptBy(iterable, selector, equater);
exceptBy<TBy>(sequence: MaybeAsyncSequence<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy> | undefined): AsyncSequence<TElement> {
return this.#sequence.exceptBy(wrap(sequence), selector, equater);
}
intersect(iterable: MaybeAsyncIterable<TElement>, equater?: ((first: TElement, second: TElement) => MaybePromise<boolean>) | undefined): AsyncSequence<TElement> {
return this.#sequence.intersect(iterable, equater);
intersect(sequence: MaybeAsyncSequence<TElement>, equater?: MaybeAsyncEquater<TElement> | undefined): AsyncSequence<TElement> {
return this.#sequence.intersect(wrap(sequence), equater);
}
intersectBy<TBy>(iterable: MaybeAsyncIterable<TElement>, selector: (obj: TElement) => MaybePromise<TBy>, equater?: ((first: TBy, second: TBy) => MaybePromise<boolean>) | undefined): AsyncSequence<TElement> {
return this.#sequence.intersectBy(iterable, selector, equater);
intersectBy<TBy>(sequence: MaybeAsyncSequence<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy> | undefined): AsyncSequence<TElement> {
return this.#sequence.intersectBy(wrap(sequence), selector, equater);
}
all(predicate: (obj: TElement) => MaybePromise<boolean>): Promise<boolean> {
all(predicate: MaybeAsyncPredicate<TElement>): Promise<boolean> {
return this.#sequence.all(predicate);
}
any(predicate: (obj: TElement) => MaybePromise<boolean>): Promise<boolean>;
any(predicate: MaybeAsyncPredicate<TElement>): Promise<boolean>;
any(): Promise<boolean>;
any(predicate?: any) {
return this.#sequence.any(predicate);
}
none(predicate: Predicate<TElement>): Promise<boolean>;
none(predicate: MaybeAsyncPredicate<TElement>): Promise<boolean>;
none(): Promise<boolean>;
none(predicate?: any) {
return this.#sequence.none(predicate);
@@ -921,7 +931,7 @@ export class DelegatedAsyncSequence<TElement> extends AsyncSequenceMarker implem
return this.#sequence.skipLast(n);
}
skipWhile(condition: (obj: TElement) => MaybePromise<boolean>): AsyncSequence<TElement> {
skipWhile(condition: MaybeAsyncPredicate<TElement>): AsyncSequence<TElement> {
return this.#sequence.skipWhile(condition);
}
@@ -933,23 +943,23 @@ export class DelegatedAsyncSequence<TElement> extends AsyncSequenceMarker implem
return this.#sequence.takeLast(n);
}
takeWhile(condition: (obj: TElement) => MaybePromise<boolean>): AsyncSequence<TElement> {
takeWhile(condition: MaybeAsyncPredicate<TElement>): AsyncSequence<TElement> {
return this.#sequence.takeWhile(condition);
}
peek(action: (obj: TElement) => MaybePromise<void>): AsyncSequence<TElement> {
peek(action: MaybeAsyncAction<TElement>): AsyncSequence<TElement> {
return this.#sequence.peek(action);
}
forEach(action: (obj: TElement) => MaybePromise<void>): Promise<void> {
forEach(action: MaybeAsyncAction<TElement>): Promise<void> {
return this.#sequence.forEach(action);
}
zip<TOther>(iterable: MaybeAsyncIterable<TOther>): AsyncSequence<[Awaited<TElement>, Awaited<TOther>]> {
return this.#sequence.zip(iterable);
zip<TOther>(sequence: MaybeAsyncSequence<TOther>): AsyncSequence<[TElement, TOther]> {
return this.#sequence.zip(wrap(sequence));
}
indexex(): AsyncSequence<[number, Awaited<TElement>]> {
indexex(): AsyncSequence<[number, TElement]> {
return this.#sequence.indexex();
}
@@ -969,11 +979,15 @@ export class DelegatedAsyncSequence<TElement> extends AsyncSequenceMarker implem
return this.#sequence.cached();
}
asArray(): Promise<TElement[]> {
return this.#sequence.asArray();
}
toArray(): Promise<TElement[]> {
return this.#sequence.toArray();
}
toMap<TKey, TValue>(keySelector: (obj: TElement) => MaybePromise<TKey>, valueSelector: (obj: TElement) => MaybePromise<TValue>): Promise<Map<TKey, TValue>> {
toMap<TKey, TValue>(keySelector: MaybeAsyncConverter<TElement, TKey>, valueSelector: MaybeAsyncConverter<TElement, TValue>): Promise<Map<TKey, TValue>> {
return this.#sequence.toMap(keySelector, valueSelector);
}
@@ -981,7 +995,7 @@ export class DelegatedAsyncSequence<TElement> extends AsyncSequenceMarker implem
return this.#sequence.toSet();
}
toObject<TValue>(keySelector: (obj: TElement) => MaybePromise<PropertyKey>, valueSelector: (obj: TElement) => MaybePromise<TValue>): Promise<Record<PropertyKey, TValue>> {
toObject<TKey extends PropertyKey, TValue>(keySelector: MaybeAsyncConverter<TElement, TKey>, valueSelector: MaybeAsyncConverter<TElement, TValue>): Promise<Record<TKey, TValue>> {
return this.#sequence.toObject(keySelector, valueSelector);
}
@@ -1059,15 +1073,11 @@ abstract class BaseOrderedAsyncSequence<TElement> extends BaseAsyncSequence<TEle
}
export class EmptyAsyncSequence<T> extends BaseAsyncSequence<T> {
static readonly INSTANCE = new EmptyAsyncSequence<any>();
override async nonEnumeratedCount() {
return 0;
}
override async *iterator() {
}
override async *iterator() { }
}
export class RangeAsyncSequence extends BaseAsyncSequence<number> {
@@ -1095,10 +1105,10 @@ export class RangeAsyncSequence extends BaseAsyncSequence<number> {
}
export class RepeatAsyncSequence<T> extends BaseAsyncSequence<T> {
readonly #value: T;
readonly #value: MaybePromiseLike<T>;
readonly #count: number;
constructor(value: T, count: number) {
constructor(value: MaybePromiseLike<T>, count: number) {
super();
this.#value = value;
@@ -1119,9 +1129,9 @@ export class RepeatAsyncSequence<T> extends BaseAsyncSequence<T> {
}
export class RepeatForeverAsyncSequence<T> extends BaseAsyncSequence<T> {
readonly #value: T;
readonly #value: MaybePromiseLike<T>;
constructor(value: T) {
constructor(value: MaybePromiseLike<T>) {
super();
this.#value = value;
@@ -1139,9 +1149,9 @@ export class RepeatForeverAsyncSequence<T> extends BaseAsyncSequence<T> {
}
export class WrappedObjectAsync<T> extends BaseAsyncSequence<T> {
readonly #obj: T | PromiseLike<T>;
readonly #obj: MaybePromiseLike<T>;
constructor(obj: T | PromiseLike<T>) {
constructor(obj: MaybePromiseLike<T>) {
super();
this.#obj = obj;
@@ -1157,9 +1167,9 @@ export class WrappedObjectAsync<T> extends BaseAsyncSequence<T> {
}
export class WrappedArrayAsync<T> extends BaseAsyncSequence<T> {
readonly #array: (T | PromiseLike<T>)[];
readonly #array: MaybePromiseLike<T>[];
constructor(array: (T | PromiseLike<T>)[]) {
constructor(array: MaybePromiseLike<T>[]) {
super();
this.#array = array;
@@ -1175,9 +1185,9 @@ export class WrappedArrayAsync<T> extends BaseAsyncSequence<T> {
}
export class WrappedArrayLikeAsync<T> extends BaseAsyncSequence<T> {
readonly #arrayLike: ArrayLike<T | PromiseLike<T>>;
readonly #arrayLike: ArrayLike<MaybePromiseLike<T>>;
constructor(arrayLike: ArrayLike<T | PromiseLike<T>>) {
constructor(arrayLike: ArrayLike<MaybePromiseLike<T>>) {
super();
this.#arrayLike = arrayLike;
@@ -1195,9 +1205,9 @@ export class WrappedArrayLikeAsync<T> extends BaseAsyncSequence<T> {
}
export class WrappedAsyncIterable<T> extends BaseAsyncSequence<T> {
readonly #iterable: AsyncIterable<T>;
readonly #iterable: AsyncIterable<MaybePromiseLike<T>>;
constructor(iterable: AsyncIterable<T>) {
constructor(iterable: AsyncIterable<MaybePromiseLike<T>>) {
super();
this.#iterable = iterable;
@@ -1209,9 +1219,9 @@ export class WrappedAsyncIterable<T> extends BaseAsyncSequence<T> {
}
export class GeneratorAsyncSequence<T> extends BaseAsyncSequence<T> {
readonly #generator: () => AsyncGenerator<T>;
readonly #generator: () => MaybeAsyncGenerator<MaybePromiseLike<T>>;
constructor(generator: () => AsyncGenerator<T>) {
constructor(generator: () => MaybeAsyncGenerator<MaybePromiseLike<T>>) {
super();
this.#generator = generator;
@@ -1223,9 +1233,9 @@ export class GeneratorAsyncSequence<T> extends BaseAsyncSequence<T> {
}
export class FunctionAsyncSequence<T> extends BaseAsyncSequence<T> {
readonly #f: () => MaybePromise<T>;
readonly #f: () => MaybePromiseLike<T>;
constructor(f: () => MaybePromise<T>) {
constructor(f: () => MaybePromiseLike<T>) {
super();
this.#f = f;
@@ -1243,9 +1253,9 @@ export class FunctionAsyncSequence<T> extends BaseAsyncSequence<T> {
}
export class WrappedSequence<T> extends BaseAsyncSequence<T> {
readonly #sequence: Sequence<T>;
readonly #sequence: Sequence<MaybePromiseLike<T>>;
constructor(sequence: Sequence<T>) {
constructor(sequence: Sequence<MaybePromiseLike<T>>) {
super();
this.#sequence = sequence;
@@ -1280,8 +1290,8 @@ export class ConcatAsyncSequence<T> extends BaseAsyncSequence<T> {
override async nonEnumeratedCount() {
let n = 0;
for (const iterable of this.#sequences) {
const m = await iterable.nonEnumeratedCount();
for (const sequence of this.#sequences) {
const m = await sequence.nonEnumeratedCount();
if (m < 0) {
return -1;
@@ -1370,9 +1380,9 @@ class FilterAsyncSequence<T> extends BaseAsyncSequence<T> {
class FlatMapperAsyncSequence<T, U> extends BaseAsyncSequence<U> {
readonly #sequence: AsyncSequence<T>;
readonly #converter: MaybeAsyncConverter<T, MaybeAsyncIterable<U>>;
readonly #converter: MaybeAsyncConverter<T, MaybeAsyncSequence<U>>;
constructor(sequence: AsyncSequence<T>, converter: MaybeAsyncConverter<T, MaybeAsyncIterable<U>>) {
constructor(sequence: AsyncSequence<T>, converter: MaybeAsyncConverter<T, MaybeAsyncSequence<U>>) {
super();
this.#sequence = sequence;
@@ -1386,7 +1396,7 @@ class FlatMapperAsyncSequence<T, U> extends BaseAsyncSequence<U> {
}
}
class IndexedAsyncSequence<T> extends BaseAsyncSequence<[number, Awaited<T>]> {
class IndexedAsyncSequence<T> extends BaseAsyncSequence<[number, T]> {
readonly #sequence: AsyncSequence<T>;
constructor(sequence: AsyncSequence<T>) {
@@ -1399,7 +1409,7 @@ class IndexedAsyncSequence<T> extends BaseAsyncSequence<[number, Awaited<T>]> {
let i = 0;
for await (const obj of this.#sequence) {
yield [i++, obj] as [number, Awaited<T>];
yield [i++, obj] as [number, T];
}
}
}
@@ -1716,7 +1726,7 @@ class PeekAsyncSequence<T> extends BaseAsyncSequence<T> {
}
}
class ZippedAsyncSequence<T, U> extends BaseAsyncSequence<[Awaited<T>, Awaited<U>]> {
class ZippedAsyncSequence<T, U> extends BaseAsyncSequence<[T, U]> {
readonly #first: AsyncSequence<T>;
readonly #second: AsyncSequence<U>;
@@ -1746,7 +1756,7 @@ class ZippedAsyncSequence<T, U> extends BaseAsyncSequence<[Awaited<T>, Awaited<U
return;
}
yield [firstNext.value, secondNext.value] as [Awaited<T>, Awaited<U>];
yield [firstNext.value, secondNext.value] as [T, U];
}
}
}
@@ -2158,7 +2168,7 @@ class CacheAsyncSequence<T> extends BaseAsyncSequence<T> {
}
}
class PartitionAsyncSequence<T> extends BaseAsyncSequence<Awaited<T>[]> {
class PartitionAsyncSequence<T> extends BaseAsyncSequence<T[]> {
readonly #sequence: AsyncSequence<T>;
readonly #equater: MaybeAsyncEquater<T>;
@@ -2170,7 +2180,7 @@ class PartitionAsyncSequence<T> extends BaseAsyncSequence<Awaited<T>[]> {
}
override async *iterator() {
const partitions = createAsyncEqualityMap<T, Awaited<T>[]>(this.#equater);
const partitions = createAsyncEqualityMap<T, T[]>(this.#equater);
for await (const obj of this.#sequence) {
const partition = await partitions.get(obj);
@@ -2186,7 +2196,7 @@ class PartitionAsyncSequence<T> extends BaseAsyncSequence<Awaited<T>[]> {
}
}
class PartitionByAsyncSequence<TElement, TBy> extends BaseAsyncSequence<Awaited<TElement>[]> {
class PartitionByAsyncSequence<TElement, TBy> extends BaseAsyncSequence<TElement[]> {
readonly #sequence: AsyncSequence<TElement>;
readonly #selector: MaybeAsyncConverter<TElement, TBy>;
readonly #equater: MaybeAsyncEquater<TBy>;
@@ -2200,7 +2210,7 @@ class PartitionByAsyncSequence<TElement, TBy> extends BaseAsyncSequence<Awaited<
}
override async *iterator() {
const partitions = createAsyncEqualityMap<TBy, Awaited<TElement>[]>(this.#equater);
const partitions = createAsyncEqualityMap<TBy, TElement[]>(this.#equater);
for await (const obj of this.#sequence) {
const key = await this.#selector(obj);