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);

26
src/async/index.ts
View File

@@ -1,15 +1,15 @@
import { wrap as wrapSync } from "../sync/index.js";
import { Sequence } from "../sync/types.js";
import { MaybeAsyncIterable } from "../types.js";
import { MaybeAsyncGenerator, MaybeAsyncIterable, MaybeAsyncSequence, MaybePromiseLike } from "../types.js";
import { isAsyncIterable } from "../utils.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>(sequence: Sequence<T>): AsyncSequence<T> {
export function asAsync<T>(sequence: Sequence<MaybePromiseLike<T>>): AsyncSequence<T> {
return new WrappedSequence(sequence);
}
export function wrap<T>(iterable: MaybeAsyncIterable<T>): AsyncSequence<T> {
export function wrap<T>(iterable: MaybeAsyncIterable<MaybePromiseLike<T>>): AsyncSequence<T> {
if (isAsyncSequence<T>(iterable)) {
return iterable;
}
@@ -21,27 +21,29 @@ export function wrap<T>(iterable: MaybeAsyncIterable<T>): AsyncSequence<T> {
return asAsync(wrapSync(iterable));
}
export function sequence<T>(iterable: AsyncIterable<T>): AsyncSequence<T> {
export function sequence<T>(iterable: AsyncIterable<MaybePromiseLike<T>>): AsyncSequence<T> {
return new WrappedAsyncIterable(iterable);
}
export const EMPTY = new EmptyAsyncSequence<any>();
export function empty<T>(): AsyncSequence<T> {
return EmptyAsyncSequence.INSTANCE;
return EMPTY;
}
export function single<T>(obj: T | PromiseLike<T>): AsyncSequence<T> {
export function single<T>(obj: MaybePromiseLike<T>): AsyncSequence<T> {
return new WrappedObjectAsync(obj);
}
export function array<T>(array: (T | PromiseLike<T>)[]): AsyncSequence<T> {
export function array<T>(array: MaybePromiseLike<T>[]): AsyncSequence<T> {
return new WrappedArrayAsync(array);
}
export function arrayLike<T>(arrayLike: ArrayLike<(T | PromiseLike<T>)>): AsyncSequence<T> {
export function arrayLike<T>(arrayLike: ArrayLike<MaybePromiseLike<T>>): AsyncSequence<T> {
return new WrappedArrayLikeAsync(arrayLike);
}
export function of<T>(...elements: (T | PromiseLike<T>)[]): AsyncSequence<T> {
export function of<T>(...elements: MaybePromiseLike<T>[]): AsyncSequence<T> {
switch (elements.length) {
case 0:
return empty();
@@ -52,11 +54,11 @@ export function of<T>(...elements: (T | PromiseLike<T>)[]): AsyncSequence<T> {
}
}
export function func<T>(f: () => Promise<T>): AsyncSequence<T> {
export function func<T>(f: () => MaybePromiseLike<T>): AsyncSequence<T> {
return new FunctionAsyncSequence(f);
}
export function generator<T>(generator: () => AsyncGenerator<T>): AsyncSequence<T> {
export function generator<T>(generator: () => MaybeAsyncGenerator<MaybePromiseLike<T>>): AsyncSequence<T> {
return new GeneratorAsyncSequence(generator);
}
@@ -76,7 +78,7 @@ export function range(a: number, b?: number, c?: number): AsyncSequence<number>
return new RangeAsyncSequence(a, b, c);
}
export function repeat<T>(value: T, count?: number): AsyncSequence<T> {
export function repeat<T>(value: MaybePromiseLike<T>, count?: number): AsyncSequence<T> {
if (count == undefined) {
return new RepeatForeverAsyncSequence(value);
}

44
src/async/types.ts
View File

@@ -1,9 +1,9 @@
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";
import { MaybeAsyncPredicate, MaybeAsyncConverter, MaybeAsyncEquater, MaybeAsyncBiConverter, MaybeAsyncAccumulator, MaybeAsyncComparer, MaybeAsyncAction, MaybeAsyncSequence } from "../types.js";
export interface AsyncSequence<TElement> extends AsyncIterable<Awaited<TElement>> {
iterator(): AsyncIterator<Awaited<TElement>>;
export interface AsyncSequence<TElement> extends AsyncIterable<TElement> {
iterator(): AsyncIterator<TElement>;
apply<TResult>(pipeline: (sequence: AsyncSequence<TElement>) => TResult): TResult;
@@ -13,22 +13,22 @@ export interface AsyncSequence<TElement> extends AsyncIterable<Awaited<TElement>
maxCount(): Promise<number>;
select<TResult>(selector: MaybeAsyncConverter<TElement, TResult>): AsyncSequence<TResult>;
selectMany<TResult>(selector: MaybeAsyncConverter<TElement, MaybeAsyncIterable<TResult>>): AsyncSequence<TResult>;
selectMany<TResult>(selector: MaybeAsyncConverter<TElement, MaybeAsyncSequence<TResult>>): AsyncSequence<TResult>;
where(predicate: MaybeAsyncPredicate<TElement>): AsyncSequence<TElement>;
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>): 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>;
join<TOther, TKey>(sequence: MaybeAsyncSequence<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector?: undefined, keyComparer?: MaybeAsyncEquater<TKey>): 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>): AsyncSequence<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>;
groupJoin<TOther, TKey>(sequence: MaybeAsyncSequence<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector?: undefined, keyComparer?: MaybeAsyncEquater<TKey>): 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>): AsyncSequence<TResult>;
contains(obj: TElement, equater?: MaybeAsyncEquater<TElement>): Promise<boolean>;
sequenceEquals(iterable: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEquater<TElement>): Promise<boolean>;
sequenceEquals(sequence: MaybeAsyncSequence<TElement>, equater?: MaybeAsyncEquater<TElement>): Promise<boolean>;
append(obj: TElement): AsyncSequence<TElement>;
@@ -36,7 +36,7 @@ export interface AsyncSequence<TElement> extends AsyncIterable<Awaited<TElement>
remove(obj: TElement, all?: boolean, equater?: MaybeAsyncEquater<TElement>): AsyncSequence<TElement>;
concat(...iterables: MaybeAsyncIterable<TElement>[]): AsyncSequence<TElement>;
concat(...sequences: MaybeAsyncSequence<TElement>[]): AsyncSequence<TElement>;
first(predicate?: MaybeAsyncPredicate<TElement>): Promise<TElement>;
firstOrDefault(predicate?: MaybeAsyncPredicate<TElement>, def?: TElement): Promise<TElement | undefined>;
@@ -66,25 +66,25 @@ export interface AsyncSequence<TElement> extends AsyncIterable<Awaited<TElement>
orderDescending(comparer?: MaybeAsyncComparer<TElement>): AsyncSequence<TElement>;
orderByDescending<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparer<TBy>): AsyncSequence<TElement>;
partition(equater?: MaybeAsyncEquater<TElement>): AsyncSequence<Awaited<TElement>[]>;
partitionBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncSequence<Awaited<TElement>[]>;
partition(equater?: MaybeAsyncEquater<TElement>): AsyncSequence<TElement[]>;
partitionBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncSequence<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>): AsyncSequence<TElement>;
unionBy<TBy>(iterable: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncSequence<TElement>;
union(sequence: MaybeAsyncSequence<TElement>, equater?: MaybeAsyncEquater<TElement>): AsyncSequence<TElement>;
unionBy<TBy>(sequence: MaybeAsyncSequence<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncSequence<TElement>;
except(iterable: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEquater<TElement>): AsyncSequence<TElement>;
exceptBy<TBy>(iterable: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncSequence<TElement>;
except(sequence: MaybeAsyncSequence<TElement>, equater?: MaybeAsyncEquater<TElement>): AsyncSequence<TElement>;
exceptBy<TBy>(sequence: MaybeAsyncSequence<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncSequence<TElement>;
intersect(iterable: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEquater<TElement>): AsyncSequence<TElement>;
intersectBy<TBy>(iterable: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncSequence<TElement>;
intersect(sequence: MaybeAsyncSequence<TElement>, equater?: MaybeAsyncEquater<TElement>): AsyncSequence<TElement>;
intersectBy<TBy>(sequence: MaybeAsyncSequence<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncSequence<TElement>;
all(predicate: MaybeAsyncPredicate<TElement>): Promise<boolean>;
any(predicate: MaybeAsyncPredicate<TElement>): Promise<boolean>;
any(): Promise<boolean>;
none(predicate: Predicate<TElement>): Promise<boolean>;
none(predicate: MaybeAsyncPredicate<TElement>): Promise<boolean>;
none(): Promise<boolean>;
skip(n: number): AsyncSequence<TElement>;
@@ -99,9 +99,9 @@ export interface AsyncSequence<TElement> extends AsyncIterable<Awaited<TElement>
forEach(action: MaybeAsyncAction<TElement>): Promise<void>;
zip<TOther>(iterable: MaybeAsyncIterable<TOther>): AsyncSequence<[Awaited<TElement>, Awaited<TOther>]>;
zip<TOther>(sequence: MaybeAsyncSequence<TOther>): AsyncSequence<[TElement, TOther]>;
indexex(): AsyncSequence<[number, Awaited<TElement>]>;
indexex(): AsyncSequence<[number, TElement]>;
reversed(): AsyncSequence<TElement>;
@@ -111,6 +111,8 @@ export interface AsyncSequence<TElement> extends AsyncIterable<Awaited<TElement>
cached(): AsyncSequence<TElement>;
asArray(): Promise<TElement[]>;
toArray(): Promise<TElement[]>;
toMap<TKey, TValue>(keySelector: MaybeAsyncConverter<TElement, TKey>, valueSelector: MaybeAsyncConverter<TElement, TValue>): Promise<Map<TKey, TValue>>;
toSet(): Promise<Set<TElement>>;

153
src/sync/impl.ts
View File

@@ -6,7 +6,7 @@ import { getRandomElement } from "../random/index.js";
import { RandomOptions } from "../random/types.js";
import { Converter, FilterPredicate, Equater, BiConverter, Predicate, Accumulator, Comparer, Action } from "../types.js";
import { strictEquals, identity, operatorCompare, reverseComparer, wrapAsIterable, defaultArrayComparer, combineComparers } from "../utils.js";
import { array, empty, wrap } from "./index.js";
import { array, empty } from "./index.js";
import { Sequence, GroupedSequence, OrderedSequence } from "./types.js";
export class SequenceMarker { }
@@ -26,7 +26,7 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
return new SelectSequence<TElement, TResult>(this, converter);
}
selectMany<TResult>(converter: Converter<TElement, Iterable<TResult>>): Sequence<TResult> {
selectMany<TResult>(converter: Converter<TElement, Sequence<TResult>>): Sequence<TResult> {
return new SelectManySequence<TElement, TResult>(this, converter);
}
@@ -38,12 +38,12 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
return new GroupBySequence<TElement, TKey, TResult>(this, keySelector, elementSelector, keyComparer);
}
join<TOther, TKey, TResult>(iterable: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: BiConverter<TElement, TOther, TResult>, keyComparer?: Equater<TKey>): Sequence<TResult> {
return new JoinSequence<TElement, TOther, TKey, TResult>(this, wrap(iterable), firstKeySelector, secondKeySelector, resultSelector, keyComparer);
join<TOther, TKey, TResult>(sequence: Sequence<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: BiConverter<TElement, TOther, TResult>, keyComparer?: Equater<TKey>): Sequence<TResult> {
return new JoinSequence<TElement, TOther, TKey, TResult>(this, sequence, firstKeySelector, secondKeySelector, resultSelector, keyComparer);
}
groupJoin<TOther, TKey, TResult>(iterable: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: BiConverter<TElement, Sequence<TOther>, TResult>, keyComparer?: Equater<TKey>): Sequence<TResult> {
return new GroupJoinSequence<TElement, TOther, TKey, TResult>(this, wrap(iterable), firstKeySelector, secondKeySelector, resultSelector, keyComparer);
groupJoin<TOther, TKey, TResult>(sequence: Sequence<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: BiConverter<TElement, Sequence<TOther>, TResult>, keyComparer?: Equater<TKey>): Sequence<TResult> {
return new GroupJoinSequence<TElement, TOther, TKey, TResult>(this, sequence, firstKeySelector, secondKeySelector, resultSelector, keyComparer);
}
contains(obj: TElement, equater?: Equater<TElement>) {
@@ -60,15 +60,13 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
return false;
}
sequenceEquals(iterable: Iterable<TElement>, equater?: Equater<TElement>) {
if (this === iterable) {
sequenceEquals(sequence: Sequence<TElement>, equater?: Equater<TElement>) {
if (this === sequence) {
return true;
}
const that = wrap(iterable);
const thisCount = this.nonEnumeratedCount();
const thatCount = that.nonEnumeratedCount();
const thatCount = sequence.nonEnumeratedCount();
if (thisCount >= 0 && thatCount >= 0 && thisCount !== thatCount) {
return false;
@@ -79,7 +77,7 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
}
const thisIterator = this.iterator();
const thatIterator = that.iterator();
const thatIterator = sequence.iterator();
while (true) {
const thisNext = thisIterator.next();
@@ -111,15 +109,15 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
return new RemoveSequence<TElement>(this, obj, all, equater);
}
concat(...iterables: Iterable<TElement>[]) {
if (iterables.length === 0) {
concat(...sequences: Sequence<TElement>[]) {
if (sequences.length === 0) {
return this;
}
const arr: Sequence<TElement>[] = [this];
for (const iterable of iterables) {
arr.push(wrap(iterable));
for (const sequence of sequences) {
arr.push(sequence);
}
return new ConcatSequence(arr);
@@ -470,28 +468,28 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
return new DistinctBySequence<TElement, TBy>(this, selector, equater);
}
union(iterable: Iterable<TElement>, equater?: Equater<TElement>): Sequence<TElement> {
return new UnionSequence<TElement>(this, wrap(iterable), equater);
union(sequence: Sequence<TElement>, equater?: Equater<TElement>): Sequence<TElement> {
return new UnionSequence<TElement>(this, sequence, equater);
}
unionBy<TBy>(iterable: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: Equater<TBy>): Sequence<TElement> {
return new UnionBySequence<TElement, TBy>(this, wrap(iterable), selector, equater);
unionBy<TBy>(sequence: Sequence<TElement>, selector: Converter<TElement, TBy>, equater?: Equater<TBy>): Sequence<TElement> {
return new UnionBySequence<TElement, TBy>(this, sequence, selector, equater);
}
except(iterable: Iterable<TElement>): Sequence<TElement> {
return new ExceptSequence<TElement>(this, wrap(iterable));
except(sequence: Sequence<TElement>): Sequence<TElement> {
return new ExceptSequence<TElement>(this, sequence);
}
exceptBy<TBy>(iterable: Iterable<TElement>, selector: Converter<TElement, TBy>): Sequence<TElement> {
return new ExceptBySequence<TElement, TBy>(this, wrap(iterable), selector);
exceptBy<TBy>(sequence: Sequence<TElement>, selector: Converter<TElement, TBy>): Sequence<TElement> {
return new ExceptBySequence<TElement, TBy>(this, sequence, selector);
}
intersect(iterable: Iterable<TElement>): Sequence<TElement> {
return new IntersectSequence<TElement>(this, wrap(iterable));
intersect(sequence: Sequence<TElement>): Sequence<TElement> {
return new IntersectSequence<TElement>(this, sequence);
}
intersectBy<TBy>(iterable: Iterable<TElement>, selector: Converter<TElement, TBy>): Sequence<TElement> {
return new IntersectBySequence<TElement, TBy>(this, wrap(iterable), selector);
intersectBy<TBy>(sequence: Sequence<TElement>, selector: Converter<TElement, TBy>): Sequence<TElement> {
return new IntersectBySequence<TElement, TBy>(this, sequence, selector);
}
all(predicate: Predicate<TElement>) {
@@ -600,8 +598,8 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
}
}
zip<TOther>(iterable: Iterable<TOther>): Sequence<[TElement, TOther]> {
return new ZippedSequence<TElement, TOther>(this, wrap(iterable));
zip<TOther>(sequence: Sequence<TOther>): Sequence<[TElement, TOther]> {
return new ZippedSequence<TElement, TOther>(this, sequence);
}
indexed(): Sequence<[number, TElement]> {
@@ -726,7 +724,7 @@ export class DelegatedSequence<TElement> extends SequenceMarker implements Seque
return this.#sequence.select(selector);
}
selectMany<TResult>(selector: Converter<TElement, Iterable<TResult>>) {
selectMany<TResult>(selector: Converter<TElement, Sequence<TResult>>) {
return this.#sequence.selectMany(selector);
}
@@ -734,27 +732,30 @@ export class DelegatedSequence<TElement> extends SequenceMarker implements Seque
return this.#sequence.where(predicate);
}
groupBy<TKey, TResult>(keySelector: Converter<TElement, TKey>, elementSelector?: Converter<TElement, TResult>, keyComparer?: Equater<TKey>) {
//@ts-ignore
groupBy<TKey>(keySelector: Converter<TElement, TKey>, elementSelector?: undefined, keyComparer?: Equater<TKey> | undefined): Sequence<GroupedSequence<TKey, TElement>>;
groupBy<TKey, TResult>(keySelector: Converter<TElement, TKey>, elementSelector: Converter<TElement, TResult>, keyComparer?: Equater<TKey> | undefined): Sequence<GroupedSequence<TKey, TResult>>;
groupBy(keySelector: any, elementSelector?: any, keyComparer?: any) {
return this.#sequence.groupBy(keySelector, elementSelector, keyComparer);
}
join<TOther, TKey, TResult>(iterable: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: BiConverter<TElement, TOther, TResult>, keyComparer?: Equater<TKey>) {
//@ts-ignore
return this.#sequence.join(iterable, firstKeySelector, secondKeySelector, resultSelector, keyComparer);
join<TOther, TKey>(sequence: Sequence<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: undefined, keyComparer?: Equater<TKey> | undefined): Sequence<[TElement, TOther]>;
join<TOther, TKey, TResult>(sequence: Sequence<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector: BiConverter<TElement, TOther, TResult>, keyComparer?: Equater<TKey> | undefined): Sequence<TResult>;
join(sequence: any, firstKeySelector: any, secondKeySelector: any, resultSelector?: any, keyComparer?: any) {
return this.#sequence.join(sequence, firstKeySelector, secondKeySelector, resultSelector, keyComparer);
}
groupJoin<TOther, TKey, TResult>(iterable: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: BiConverter<TElement, Sequence<TOther>, TResult>, keyComparer?: Equater<TKey>) {
//@ts-ignore
return this.#sequence.groupJoin(iterable, firstKeySelector, secondKeySelector, resultSelector, keyComparer);
groupJoin<TOther, TKey>(sequence: Sequence<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: undefined, keyComparer?: Equater<TKey> | undefined): Sequence<GroupedSequence<TElement, TOther>>;
groupJoin<TOther, TKey, TResult>(sequence: Sequence<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector: BiConverter<TElement, Sequence<TOther>, TResult>, keyComparer?: Equater<TKey> | undefined): Sequence<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?: Equater<TElement>) {
return this.#sequence.contains(obj, equater);
}
sequenceEquals(iterable: Iterable<TElement>, equater?: Equater<TElement>) {
return this.#sequence.sequenceEquals(iterable, equater);
sequenceEquals(sequence: Sequence<TElement>, equater?: Equater<TElement>) {
return this.#sequence.sequenceEquals(sequence, equater);
}
append(obj: TElement) {
@@ -769,8 +770,8 @@ export class DelegatedSequence<TElement> extends SequenceMarker implements Seque
return this.#sequence.remove(obj, all, equater);
}
concat(...iterables: Iterable<TElement>[]) {
return this.#sequence.concat(...iterables);
concat(...sequences: Sequence<TElement>[]) {
return this.#sequence.concat(...sequences);
}
first(predicate?: Predicate<TElement>) {
@@ -857,41 +858,43 @@ export class DelegatedSequence<TElement> extends SequenceMarker implements Seque
return this.#sequence.distinctBy(selector, equater);
}
union(iterable: Iterable<TElement>, equater?: Equater<TElement>) {
return this.#sequence.union(iterable, equater);
union(sequence: Sequence<TElement>, equater?: Equater<TElement>) {
return this.#sequence.union(sequence, equater);
}
unionBy<TBy>(iterable: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: Equater<TBy>) {
return this.#sequence.unionBy(iterable, selector, equater);
unionBy<TBy>(sequence: Sequence<TElement>, selector: Converter<TElement, TBy>, equater?: Equater<TBy>) {
return this.#sequence.unionBy(sequence, selector, equater);
}
except(iterable: Iterable<TElement>, equater?: Equater<TElement>) {
return this.#sequence.except(iterable, equater);
except(sequence: Sequence<TElement>, equater?: Equater<TElement>) {
return this.#sequence.except(sequence, equater);
}
exceptBy<TBy>(iterable: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: Equater<TBy>) {
return this.#sequence.exceptBy(iterable, selector, equater);
exceptBy<TBy>(sequence: Sequence<TElement>, selector: Converter<TElement, TBy>, equater?: Equater<TBy>) {
return this.#sequence.exceptBy(sequence, selector, equater);
}
intersect(iterable: Iterable<TElement>, equater?: Equater<TElement>) {
return this.#sequence.intersect(iterable, equater);
intersect(sequence: Sequence<TElement>, equater?: Equater<TElement>) {
return this.#sequence.intersect(sequence, equater);
}
intersectBy<TBy>(iterable: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: Equater<TBy>) {
return this.#sequence.intersectBy(iterable, selector, equater);
intersectBy<TBy>(sequence: Sequence<TElement>, selector: Converter<TElement, TBy>, equater?: Equater<TBy>) {
return this.#sequence.intersectBy(sequence, selector, equater);
}
all(predicate: Predicate<TElement>) {
return this.#sequence.all(predicate);
}
any(predicate?: Predicate<TElement>) {
//@ts-ignore
any(predicate: Predicate<TElement>): boolean;
any(): boolean;
any(predicate?: any) {
return this.#sequence.any(predicate);
}
none(predicate?: Predicate<TElement>) {
//@ts-ignore
none(predicate: Predicate<TElement>): boolean;
none(): boolean;
none(predicate?: any) {
return this.#sequence.none(predicate);
}
@@ -927,8 +930,8 @@ export class DelegatedSequence<TElement> extends SequenceMarker implements Seque
this.#sequence.forEach(action);
}
zip<TOther>(iterable: Iterable<TOther>) {
return this.#sequence.zip(iterable);
zip<TOther>(sequence: Sequence<TOther>) {
return this.#sequence.zip(sequence);
}
indexed() {
@@ -951,6 +954,10 @@ export class DelegatedSequence<TElement> extends SequenceMarker implements Seque
return this.#sequence.cached();
}
// awaited(): AsyncSequence<Awaited<TElement>> {
// return this.#sequence.awaited();
// }
asArray() {
return this.#sequence.asArray();
}
@@ -1053,16 +1060,10 @@ export abstract class BaseOrderedSequence<TElement> extends BaseSequence<TElemen
}
export class EmptySequence<T> extends BaseSequence<T> {
static readonly INSTANCE = new EmptySequence<any>();
override nonEnumeratedCount() {
return 0;
}
override maxCount() {
return 0;
}
override *iterator() { }
}
@@ -1552,9 +1553,9 @@ class WhereSequence<TElement, TFiltered extends TElement> extends BaseSequence<T
class SelectManySequence<T, U> extends BaseSequence<U> {
readonly #sequence: Sequence<T>;
readonly #converter: Converter<T, Iterable<U>>;
readonly #converter: Converter<T, Sequence<U>>;
constructor(sequence: Sequence<T>, converter: Converter<T, Iterable<U>>) {
constructor(sequence: Sequence<T>, converter: Converter<T, Sequence<U>>) {
super();
this.#sequence = sequence;
@@ -2479,3 +2480,17 @@ class PartitionBySequence<TElement, TBy> extends BaseSequence<TElement[]> {
yield* partitions.values();
}
}
// class AwaitedSequence<T> extends BaseAsyncSequence<Awaited<T>> {
// readonly #sequence: Sequence<T>;
// constructor(sequence: Sequence<T>) {
// super();
// this.#sequence = sequence;
// }
// override async *iterator() {
// yield* this.#sequence;
// }
// }

4
src/sync/index.ts
View File

@@ -27,8 +27,10 @@ export function sequence<T>(iterable: Iterable<T>): Sequence<T> {
return new WrappedIterable(iterable);
}
export const EMPTY = new EmptySequence<any>();
export function empty<T>(): Sequence<T> {
return EmptySequence.INSTANCE;
return EMPTY;
}
export function single<T>(obj: T): Sequence<T> {

30
src/sync/types.ts
View File

@@ -13,7 +13,7 @@ export interface Sequence<TElement> extends Iterable<TElement> {
maxCount(): number;
select<TResult>(selector: Converter<TElement, TResult>): Sequence<TResult>;
selectMany<TResult>(selector: Converter<TElement, Iterable<TResult>>): Sequence<TResult>;
selectMany<TResult>(selector: Converter<TElement, Sequence<TResult>>): Sequence<TResult>;
where<TFiltered extends TElement>(predicate: FilterPredicate<TElement, TFiltered>): Sequence<TFiltered>;
where(predicate: Predicate<TElement>): Sequence<TElement>;
@@ -21,15 +21,15 @@ export interface Sequence<TElement> extends Iterable<TElement> {
groupBy<TKey>(keySelector: Converter<TElement, TKey>, elementSelector?: undefined, keyComparer?: Equater<TKey>): Sequence<GroupedSequence<TKey, TElement>>;
groupBy<TKey, TResult>(keySelector: Converter<TElement, TKey>, elementSelector: Converter<TElement, TResult>, keyComparer?: Equater<TKey>): Sequence<GroupedSequence<TKey, TResult>>;
join<TOther, TKey>(iterable: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: undefined, keyComparer?: Equater<TKey>): Sequence<[TElement, TOther]>;
join<TOther, TKey, TResult>(iterable: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector: BiConverter<TElement, TOther, TResult>, keyComparer?: Equater<TKey>): Sequence<TResult>;
join<TOther, TKey>(sequence: Sequence<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: undefined, keyComparer?: Equater<TKey>): Sequence<[TElement, TOther]>;
join<TOther, TKey, TResult>(sequence: Sequence<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector: BiConverter<TElement, TOther, TResult>, keyComparer?: Equater<TKey>): Sequence<TResult>;
groupJoin<TOther, TKey>(iterable: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: undefined, keyComparer?: Equater<TKey>): Sequence<GroupedSequence<TElement, TOther>>;
groupJoin<TOther, TKey, TResult>(iterable: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector: BiConverter<TElement, Sequence<TOther>, TResult>, keyComparer?: Equater<TKey>): Sequence<TResult>;
groupJoin<TOther, TKey>(sequence: Sequence<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: undefined, keyComparer?: Equater<TKey>): Sequence<GroupedSequence<TElement, TOther>>;
groupJoin<TOther, TKey, TResult>(sequence: Sequence<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector: BiConverter<TElement, Sequence<TOther>, TResult>, keyComparer?: Equater<TKey>): Sequence<TResult>;
contains(obj: TElement, equater?: Equater<TElement>): boolean;
sequenceEquals(iterable: Iterable<TElement>, equater?: Equater<TElement>): boolean;
sequenceEquals(sequence: Sequence<TElement>, equater?: Equater<TElement>): boolean;
append(obj: TElement): Sequence<TElement>;
@@ -37,7 +37,7 @@ export interface Sequence<TElement> extends Iterable<TElement> {
remove(obj: TElement, all?: boolean, equater?: Equater<TElement>): Sequence<TElement>;
concat(...iterables: Iterable<TElement>[]): Sequence<TElement>;
concat(...sequences: Sequence<TElement>[]): Sequence<TElement>;
first(predicate?: Predicate<TElement>): TElement;
firstOrDefault(predicate?: Predicate<TElement>, def?: TElement): TElement | undefined;
@@ -73,14 +73,14 @@ export interface Sequence<TElement> extends Iterable<TElement> {
distinct(equater?: Equater<TElement>): Sequence<TElement>;
distinctBy<TBy>(selector: Converter<TElement, TBy>, equater?: Equater<TBy>): Sequence<TElement>;
union(iterable: Iterable<TElement>, equater?: Equater<TElement>): Sequence<TElement>;
unionBy<TBy>(iterable: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: Equater<TBy>): Sequence<TElement>;
union(sequence: Sequence<TElement>, equater?: Equater<TElement>): Sequence<TElement>;
unionBy<TBy>(sequence: Sequence<TElement>, selector: Converter<TElement, TBy>, equater?: Equater<TBy>): Sequence<TElement>;
except(iterable: Iterable<TElement>, equater?: Equater<TElement>): Sequence<TElement>;
exceptBy<TBy>(iterable: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: Equater<TBy>): Sequence<TElement>;
except(sequence: Sequence<TElement>, equater?: Equater<TElement>): Sequence<TElement>;
exceptBy<TBy>(sequence: Sequence<TElement>, selector: Converter<TElement, TBy>, equater?: Equater<TBy>): Sequence<TElement>;
intersect(iterable: Iterable<TElement>, equater?: Equater<TElement>): Sequence<TElement>;
intersectBy<TBy>(iterable: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: Equater<TBy>): Sequence<TElement>;
intersect(sequence: Sequence<TElement>, equater?: Equater<TElement>): Sequence<TElement>;
intersectBy<TBy>(sequence: Sequence<TElement>, selector: Converter<TElement, TBy>, equater?: Equater<TBy>): Sequence<TElement>;
all(predicate: Predicate<TElement>): boolean;
any(predicate: Predicate<TElement>): boolean;
@@ -100,7 +100,7 @@ export interface Sequence<TElement> extends Iterable<TElement> {
forEach(action: Action<TElement>): void;
zip<TOther>(iterable: Iterable<TOther>): Sequence<[TElement, TOther]>;
zip<TOther>(sequence: Sequence<TOther>): Sequence<[TElement, TOther]>;
indexed(): Sequence<[number, TElement]>;
@@ -112,6 +112,8 @@ export interface Sequence<TElement> extends Iterable<TElement> {
cached(): Sequence<TElement>;
// awaited(): AsyncSequence<Awaited<TElement>>;
asArray(): TElement[];
toArray(): TElement[];
toMap<TKey, TValue>(keySelector: Converter<TElement, TKey>, valueSelector: Converter<TElement, TValue>): Map<TKey, TValue>;

7
src/types.ts
View File

@@ -1,3 +1,6 @@
import { AsyncSequence } from "./async/types.js";
import { Sequence } from "./sync/types.js";
export type Predicate<T> = (obj: T) => boolean;
export type FilterPredicate<TElement, TFiltered extends TElement> = (obj: TElement) => obj is TFiltered;
export type Converter<TFrom, TTo> = (obj: TFrom) => TTo;
@@ -9,10 +12,12 @@ export type Equater<T> = (first: T, second: T) => boolean;
export type MaybeAsyncIterable<T> = Iterable<T> | AsyncIterable<T>;
export type MaybeAsyncIterator<T> = Iterator<T> | AsyncIterator<T>;
export type MaybeAsyncGenerator<T> = Generator<T> | AsyncGenerator<T>;
export type AsyncFunction<TFunc extends (...args: any) => any> = TFunc extends (...args: infer P) => infer R ? (...args: P) => Promise<Awaited<R>> : never;
export type MaybePromise<T> = T | Promise<T>;
export type MaybePromiseLike<T> = T | PromiseLike<T>;
export type MaybeAsyncFunction<TFunc extends (...args: any) => any> = TFunc extends (...args: infer P) => infer R ? (...args: P) => MaybePromise<R> : never;
export type MaybeAsyncSequence<T> = Sequence<T> | AsyncSequence<T>;
export type AsyncPredicate<T> = AsyncFunction<Predicate<T>>;
export type MaybeAsyncPredicate<T> = MaybeAsyncFunction<Predicate<T>>;