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

44
src/async/types.ts
View File

@@ -1,9 +1,9 @@
import { Collector } from "../collector/types.js"; import { Collector } from "../collector/types.js";
import { AsyncRandomOptions } from "../random/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>> { export interface AsyncSequence<TElement> extends AsyncIterable<TElement> {
iterator(): AsyncIterator<Awaited<TElement>>; iterator(): AsyncIterator<TElement>;
apply<TResult>(pipeline: (sequence: AsyncSequence<TElement>) => TResult): TResult; apply<TResult>(pipeline: (sequence: AsyncSequence<TElement>) => TResult): TResult;
@@ -13,22 +13,22 @@ export interface AsyncSequence<TElement> extends AsyncIterable<Awaited<TElement>
maxCount(): Promise<number>; maxCount(): Promise<number>;
select<TResult>(selector: MaybeAsyncConverter<TElement, TResult>): AsyncSequence<TResult>; 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>; where(predicate: MaybeAsyncPredicate<TElement>): AsyncSequence<TElement>;
groupBy<TKey>(keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector?: undefined, keyComparer?: MaybeAsyncEquater<TKey>): AsyncSequence<GroupedAsyncSequence<TKey, 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>>; 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>(sequence: MaybeAsyncSequence<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector?: undefined, keyComparer?: MaybeAsyncEquater<TKey>): AsyncSequence<[TElement, 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, 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>(sequence: MaybeAsyncSequence<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, 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>; 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>; 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>; 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>; first(predicate?: MaybeAsyncPredicate<TElement>): Promise<TElement>;
firstOrDefault(predicate?: MaybeAsyncPredicate<TElement>, def?: TElement): Promise<TElement | undefined>; 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>; orderDescending(comparer?: MaybeAsyncComparer<TElement>): AsyncSequence<TElement>;
orderByDescending<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparer<TBy>): AsyncSequence<TElement>; orderByDescending<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparer<TBy>): AsyncSequence<TElement>;
partition(equater?: MaybeAsyncEquater<TElement>): AsyncSequence<Awaited<TElement>[]>; partition(equater?: MaybeAsyncEquater<TElement>): AsyncSequence<TElement[]>;
partitionBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncSequence<Awaited<TElement>[]>; partitionBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncSequence<TElement[]>;
distinct(equater?: MaybeAsyncEquater<TElement>): AsyncSequence<TElement>; distinct(equater?: MaybeAsyncEquater<TElement>): AsyncSequence<TElement>;
distinctBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncSequence<TElement>; distinctBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncSequence<TElement>;
union(iterable: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEquater<TElement>): AsyncSequence<TElement>; union(sequence: MaybeAsyncSequence<TElement>, equater?: MaybeAsyncEquater<TElement>): AsyncSequence<TElement>;
unionBy<TBy>(iterable: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): 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>; except(sequence: MaybeAsyncSequence<TElement>, equater?: MaybeAsyncEquater<TElement>): AsyncSequence<TElement>;
exceptBy<TBy>(iterable: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): 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>; intersect(sequence: MaybeAsyncSequence<TElement>, equater?: MaybeAsyncEquater<TElement>): AsyncSequence<TElement>;
intersectBy<TBy>(iterable: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncSequence<TElement>; intersectBy<TBy>(sequence: MaybeAsyncSequence<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncSequence<TElement>;
all(predicate: MaybeAsyncPredicate<TElement>): Promise<boolean>; all(predicate: MaybeAsyncPredicate<TElement>): Promise<boolean>;
any(predicate: MaybeAsyncPredicate<TElement>): Promise<boolean>; any(predicate: MaybeAsyncPredicate<TElement>): Promise<boolean>;
any(): Promise<boolean>; any(): Promise<boolean>;
none(predicate: Predicate<TElement>): Promise<boolean>; none(predicate: MaybeAsyncPredicate<TElement>): Promise<boolean>;
none(): Promise<boolean>; none(): Promise<boolean>;
skip(n: number): AsyncSequence<TElement>; skip(n: number): AsyncSequence<TElement>;
@@ -99,9 +99,9 @@ export interface AsyncSequence<TElement> extends AsyncIterable<Awaited<TElement>
forEach(action: MaybeAsyncAction<TElement>): Promise<void>; 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>; reversed(): AsyncSequence<TElement>;
@@ -111,6 +111,8 @@ export interface AsyncSequence<TElement> extends AsyncIterable<Awaited<TElement>
cached(): AsyncSequence<TElement>; cached(): AsyncSequence<TElement>;
asArray(): Promise<TElement[]>;
toArray(): Promise<TElement[]>; toArray(): Promise<TElement[]>;
toMap<TKey, TValue>(keySelector: MaybeAsyncConverter<TElement, TKey>, valueSelector: MaybeAsyncConverter<TElement, TValue>): Promise<Map<TKey, TValue>>; toMap<TKey, TValue>(keySelector: MaybeAsyncConverter<TElement, TKey>, valueSelector: MaybeAsyncConverter<TElement, TValue>): Promise<Map<TKey, TValue>>;
toSet(): Promise<Set<TElement>>; 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 { RandomOptions } from "../random/types.js";
import { Converter, FilterPredicate, Equater, BiConverter, Predicate, Accumulator, Comparer, Action } from "../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 { 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"; import { Sequence, GroupedSequence, OrderedSequence } from "./types.js";
export class SequenceMarker { } export class SequenceMarker { }
@@ -26,7 +26,7 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
return new SelectSequence<TElement, TResult>(this, converter); 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); 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); 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> { 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, wrap(iterable), firstKeySelector, secondKeySelector, resultSelector, keyComparer); 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> { 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, wrap(iterable), firstKeySelector, secondKeySelector, resultSelector, keyComparer); return new GroupJoinSequence<TElement, TOther, TKey, TResult>(this, sequence, firstKeySelector, secondKeySelector, resultSelector, keyComparer);
} }
contains(obj: TElement, equater?: Equater<TElement>) { contains(obj: TElement, equater?: Equater<TElement>) {
@@ -60,15 +60,13 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
return false; return false;
} }
sequenceEquals(iterable: Iterable<TElement>, equater?: Equater<TElement>) { sequenceEquals(sequence: Sequence<TElement>, equater?: Equater<TElement>) {
if (this === iterable) { if (this === sequence) {
return true; return true;
} }
const that = wrap(iterable);
const thisCount = this.nonEnumeratedCount(); const thisCount = this.nonEnumeratedCount();
const thatCount = that.nonEnumeratedCount(); const thatCount = sequence.nonEnumeratedCount();
if (thisCount >= 0 && thatCount >= 0 && thisCount !== thatCount) { if (thisCount >= 0 && thatCount >= 0 && thisCount !== thatCount) {
return false; return false;
@@ -79,7 +77,7 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
} }
const thisIterator = this.iterator(); const thisIterator = this.iterator();
const thatIterator = that.iterator(); const thatIterator = sequence.iterator();
while (true) { while (true) {
const thisNext = thisIterator.next(); 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); return new RemoveSequence<TElement>(this, obj, all, equater);
} }
concat(...iterables: Iterable<TElement>[]) { concat(...sequences: Sequence<TElement>[]) {
if (iterables.length === 0) { if (sequences.length === 0) {
return this; return this;
} }
const arr: Sequence<TElement>[] = [this]; const arr: Sequence<TElement>[] = [this];
for (const iterable of iterables) { for (const sequence of sequences) {
arr.push(wrap(iterable)); arr.push(sequence);
} }
return new ConcatSequence(arr); 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); return new DistinctBySequence<TElement, TBy>(this, selector, equater);
} }
union(iterable: Iterable<TElement>, equater?: Equater<TElement>): Sequence<TElement> { union(sequence: Sequence<TElement>, equater?: Equater<TElement>): Sequence<TElement> {
return new UnionSequence<TElement>(this, wrap(iterable), equater); return new UnionSequence<TElement>(this, sequence, equater);
} }
unionBy<TBy>(iterable: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: Equater<TBy>): Sequence<TElement> { unionBy<TBy>(sequence: Sequence<TElement>, selector: Converter<TElement, TBy>, equater?: Equater<TBy>): Sequence<TElement> {
return new UnionBySequence<TElement, TBy>(this, wrap(iterable), selector, equater); return new UnionBySequence<TElement, TBy>(this, sequence, selector, equater);
} }
except(iterable: Iterable<TElement>): Sequence<TElement> { except(sequence: Sequence<TElement>): Sequence<TElement> {
return new ExceptSequence<TElement>(this, wrap(iterable)); return new ExceptSequence<TElement>(this, sequence);
} }
exceptBy<TBy>(iterable: Iterable<TElement>, selector: Converter<TElement, TBy>): Sequence<TElement> { exceptBy<TBy>(sequence: Sequence<TElement>, selector: Converter<TElement, TBy>): Sequence<TElement> {
return new ExceptBySequence<TElement, TBy>(this, wrap(iterable), selector); return new ExceptBySequence<TElement, TBy>(this, sequence, selector);
} }
intersect(iterable: Iterable<TElement>): Sequence<TElement> { intersect(sequence: Sequence<TElement>): Sequence<TElement> {
return new IntersectSequence<TElement>(this, wrap(iterable)); return new IntersectSequence<TElement>(this, sequence);
} }
intersectBy<TBy>(iterable: Iterable<TElement>, selector: Converter<TElement, TBy>): Sequence<TElement> { intersectBy<TBy>(sequence: Sequence<TElement>, selector: Converter<TElement, TBy>): Sequence<TElement> {
return new IntersectBySequence<TElement, TBy>(this, wrap(iterable), selector); return new IntersectBySequence<TElement, TBy>(this, sequence, selector);
} }
all(predicate: Predicate<TElement>) { 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]> { zip<TOther>(sequence: Sequence<TOther>): Sequence<[TElement, TOther]> {
return new ZippedSequence<TElement, TOther>(this, wrap(iterable)); return new ZippedSequence<TElement, TOther>(this, sequence);
} }
indexed(): Sequence<[number, TElement]> { indexed(): Sequence<[number, TElement]> {
@@ -726,7 +724,7 @@ export class DelegatedSequence<TElement> extends SequenceMarker implements Seque
return this.#sequence.select(selector); return this.#sequence.select(selector);
} }
selectMany<TResult>(selector: Converter<TElement, Iterable<TResult>>) { selectMany<TResult>(selector: Converter<TElement, Sequence<TResult>>) {
return this.#sequence.selectMany(selector); return this.#sequence.selectMany(selector);
} }
@@ -734,27 +732,30 @@ export class DelegatedSequence<TElement> extends SequenceMarker implements Seque
return this.#sequence.where(predicate); return this.#sequence.where(predicate);
} }
groupBy<TKey, TResult>(keySelector: Converter<TElement, TKey>, elementSelector?: Converter<TElement, TResult>, keyComparer?: Equater<TKey>) { groupBy<TKey>(keySelector: Converter<TElement, TKey>, elementSelector?: undefined, keyComparer?: Equater<TKey> | undefined): Sequence<GroupedSequence<TKey, TElement>>;
//@ts-ignore 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); 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>) { join<TOther, TKey>(sequence: Sequence<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: undefined, keyComparer?: Equater<TKey> | undefined): Sequence<[TElement, TOther]>;
//@ts-ignore 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>;
return this.#sequence.join(iterable, firstKeySelector, secondKeySelector, resultSelector, keyComparer); 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>) { groupJoin<TOther, TKey>(sequence: Sequence<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: undefined, keyComparer?: Equater<TKey> | undefined): Sequence<GroupedSequence<TElement, TOther>>;
//@ts-ignore 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>;
return this.#sequence.groupJoin(iterable, firstKeySelector, secondKeySelector, resultSelector, keyComparer); 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>) { contains(obj: TElement, equater?: Equater<TElement>) {
return this.#sequence.contains(obj, equater); return this.#sequence.contains(obj, equater);
} }
sequenceEquals(iterable: Iterable<TElement>, equater?: Equater<TElement>) { sequenceEquals(sequence: Sequence<TElement>, equater?: Equater<TElement>) {
return this.#sequence.sequenceEquals(iterable, equater); return this.#sequence.sequenceEquals(sequence, equater);
} }
append(obj: TElement) { append(obj: TElement) {
@@ -769,8 +770,8 @@ export class DelegatedSequence<TElement> extends SequenceMarker implements Seque
return this.#sequence.remove(obj, all, equater); return this.#sequence.remove(obj, all, equater);
} }
concat(...iterables: Iterable<TElement>[]) { concat(...sequences: Sequence<TElement>[]) {
return this.#sequence.concat(...iterables); return this.#sequence.concat(...sequences);
} }
first(predicate?: Predicate<TElement>) { first(predicate?: Predicate<TElement>) {
@@ -857,41 +858,43 @@ export class DelegatedSequence<TElement> extends SequenceMarker implements Seque
return this.#sequence.distinctBy(selector, equater); return this.#sequence.distinctBy(selector, equater);
} }
union(iterable: Iterable<TElement>, equater?: Equater<TElement>) { union(sequence: Sequence<TElement>, equater?: Equater<TElement>) {
return this.#sequence.union(iterable, equater); return this.#sequence.union(sequence, equater);
} }
unionBy<TBy>(iterable: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: Equater<TBy>) { unionBy<TBy>(sequence: Sequence<TElement>, selector: Converter<TElement, TBy>, equater?: Equater<TBy>) {
return this.#sequence.unionBy(iterable, selector, equater); return this.#sequence.unionBy(sequence, selector, equater);
} }
except(iterable: Iterable<TElement>, equater?: Equater<TElement>) { except(sequence: Sequence<TElement>, equater?: Equater<TElement>) {
return this.#sequence.except(iterable, equater); return this.#sequence.except(sequence, equater);
} }
exceptBy<TBy>(iterable: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: Equater<TBy>) { exceptBy<TBy>(sequence: Sequence<TElement>, selector: Converter<TElement, TBy>, equater?: Equater<TBy>) {
return this.#sequence.exceptBy(iterable, selector, equater); return this.#sequence.exceptBy(sequence, selector, equater);
} }
intersect(iterable: Iterable<TElement>, equater?: Equater<TElement>) { intersect(sequence: Sequence<TElement>, equater?: Equater<TElement>) {
return this.#sequence.intersect(iterable, equater); return this.#sequence.intersect(sequence, equater);
} }
intersectBy<TBy>(iterable: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: Equater<TBy>) { intersectBy<TBy>(sequence: Sequence<TElement>, selector: Converter<TElement, TBy>, equater?: Equater<TBy>) {
return this.#sequence.intersectBy(iterable, selector, equater); return this.#sequence.intersectBy(sequence, selector, equater);
} }
all(predicate: Predicate<TElement>) { all(predicate: Predicate<TElement>) {
return this.#sequence.all(predicate); return this.#sequence.all(predicate);
} }
any(predicate?: Predicate<TElement>) { any(predicate: Predicate<TElement>): boolean;
//@ts-ignore any(): boolean;
any(predicate?: any) {
return this.#sequence.any(predicate); return this.#sequence.any(predicate);
} }
none(predicate?: Predicate<TElement>) { none(predicate: Predicate<TElement>): boolean;
//@ts-ignore none(): boolean;
none(predicate?: any) {
return this.#sequence.none(predicate); return this.#sequence.none(predicate);
} }
@@ -927,8 +930,8 @@ export class DelegatedSequence<TElement> extends SequenceMarker implements Seque
this.#sequence.forEach(action); this.#sequence.forEach(action);
} }
zip<TOther>(iterable: Iterable<TOther>) { zip<TOther>(sequence: Sequence<TOther>) {
return this.#sequence.zip(iterable); return this.#sequence.zip(sequence);
} }
indexed() { indexed() {
@@ -951,6 +954,10 @@ export class DelegatedSequence<TElement> extends SequenceMarker implements Seque
return this.#sequence.cached(); return this.#sequence.cached();
} }
// awaited(): AsyncSequence<Awaited<TElement>> {
// return this.#sequence.awaited();
// }
asArray() { asArray() {
return this.#sequence.asArray(); return this.#sequence.asArray();
} }
@@ -1053,16 +1060,10 @@ export abstract class BaseOrderedSequence<TElement> extends BaseSequence<TElemen
} }
export class EmptySequence<T> extends BaseSequence<T> { export class EmptySequence<T> extends BaseSequence<T> {
static readonly INSTANCE = new EmptySequence<any>();
override nonEnumeratedCount() { override nonEnumeratedCount() {
return 0; return 0;
} }
override maxCount() {
return 0;
}
override *iterator() { } override *iterator() { }
} }
@@ -1552,9 +1553,9 @@ class WhereSequence<TElement, TFiltered extends TElement> extends BaseSequence<T
class SelectManySequence<T, U> extends BaseSequence<U> { class SelectManySequence<T, U> extends BaseSequence<U> {
readonly #sequence: Sequence<T>; 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(); super();
this.#sequence = sequence; this.#sequence = sequence;
@@ -2479,3 +2480,17 @@ class PartitionBySequence<TElement, TBy> extends BaseSequence<TElement[]> {
yield* partitions.values(); 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); return new WrappedIterable(iterable);
} }
export const EMPTY = new EmptySequence<any>();
export function empty<T>(): Sequence<T> { export function empty<T>(): Sequence<T> {
return EmptySequence.INSTANCE; return EMPTY;
} }
export function single<T>(obj: T): Sequence<T> { 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; maxCount(): number;
select<TResult>(selector: Converter<TElement, TResult>): Sequence<TResult>; 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<TFiltered extends TElement>(predicate: FilterPredicate<TElement, TFiltered>): Sequence<TFiltered>;
where(predicate: Predicate<TElement>): Sequence<TElement>; 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>(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>>; 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>(sequence: Sequence<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, 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>(sequence: Sequence<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, 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; 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>; 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>; 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; first(predicate?: Predicate<TElement>): TElement;
firstOrDefault(predicate?: Predicate<TElement>, def?: TElement): TElement | undefined; 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>; distinct(equater?: Equater<TElement>): Sequence<TElement>;
distinctBy<TBy>(selector: Converter<TElement, TBy>, equater?: Equater<TBy>): Sequence<TElement>; distinctBy<TBy>(selector: Converter<TElement, TBy>, equater?: Equater<TBy>): Sequence<TElement>;
union(iterable: Iterable<TElement>, equater?: Equater<TElement>): Sequence<TElement>; union(sequence: Sequence<TElement>, equater?: Equater<TElement>): Sequence<TElement>;
unionBy<TBy>(iterable: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: Equater<TBy>): 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>; except(sequence: Sequence<TElement>, equater?: Equater<TElement>): Sequence<TElement>;
exceptBy<TBy>(iterable: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: Equater<TBy>): 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>; intersect(sequence: Sequence<TElement>, equater?: Equater<TElement>): Sequence<TElement>;
intersectBy<TBy>(iterable: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: Equater<TBy>): Sequence<TElement>; intersectBy<TBy>(sequence: Sequence<TElement>, selector: Converter<TElement, TBy>, equater?: Equater<TBy>): Sequence<TElement>;
all(predicate: Predicate<TElement>): boolean; all(predicate: Predicate<TElement>): boolean;
any(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; 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]>; indexed(): Sequence<[number, TElement]>;
@@ -112,6 +112,8 @@ export interface Sequence<TElement> extends Iterable<TElement> {
cached(): Sequence<TElement>; cached(): Sequence<TElement>;
// awaited(): AsyncSequence<Awaited<TElement>>;
asArray(): TElement[]; asArray(): TElement[];
toArray(): TElement[]; toArray(): TElement[];
toMap<TKey, TValue>(keySelector: Converter<TElement, TKey>, valueSelector: Converter<TElement, TValue>): Map<TKey, TValue>; 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 Predicate<T> = (obj: T) => boolean;
export type FilterPredicate<TElement, TFiltered extends TElement> = (obj: TElement) => obj is TFiltered; export type FilterPredicate<TElement, TFiltered extends TElement> = (obj: TElement) => obj is TFiltered;
export type Converter<TFrom, TTo> = (obj: TFrom) => TTo; 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 MaybeAsyncIterable<T> = Iterable<T> | AsyncIterable<T>;
export type MaybeAsyncIterator<T> = Iterator<T> | AsyncIterator<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 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 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 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 AsyncPredicate<T> = AsyncFunction<Predicate<T>>;
export type MaybeAsyncPredicate<T> = MaybeAsyncFunction<Predicate<T>>; export type MaybeAsyncPredicate<T> = MaybeAsyncFunction<Predicate<T>>;