2367 lines
70 KiB
TypeScript
2367 lines
70 KiB
TypeScript
import { Collector } from "../collector/types.js";
|
|
import { asAsyncComparer, combineAsyncComparers, createAsyncComparerUsing, defaultAsyncComparer } from "../comparer/async.js";
|
|
import { MaybeAsyncComparisonOrComparer, AsyncComparer } from "../comparer/types.js";
|
|
import { asAsyncEqualityComparer, defaultAsyncEqualityComparer } from "../equality-comparer/async.js";
|
|
import { AsyncEqualityComparer, MaybeAsyncEqualityComparisonOrComparer } from "../equality-comparer/types.js";
|
|
import { createAsyncEqualityMap } from "../equality-map/index.js";
|
|
import { createAsyncEqualitySet } from "../equality-set/index.js";
|
|
import { createQueue } from "../queue.js";
|
|
import { getRandomElementAsync } from "../random/index.js";
|
|
import { AsyncRandomOptions } from "../random/types.js";
|
|
import { selectionSorter } from "../sorting.js";
|
|
import { Sequence } from "../sync/types.js";
|
|
import { MaybeAsyncAnyPredicate, MaybeAsyncConverter, MaybeAsyncBiConverter, MaybeAsyncAccumulator, MaybeAsyncAction, MaybePromiseLike, MaybeAsyncGenerator, MaybePromise, MaybeAsyncIterable, MaybeAsyncTypePredicate } from "../types.js";
|
|
import { asAsyncIterable, FindElementResult, identity } from "../utils.js";
|
|
import { array, empty, wrap } from "./index.js";
|
|
import { AsyncSequence, AsyncSequencePipeline, GroupedAsyncSequence, OrderedAsyncSequence } from "./types.js";
|
|
|
|
export class AsyncSequenceMarker { }
|
|
|
|
export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker implements AsyncSequence<TElement> {
|
|
[Symbol.asyncIterator]() {
|
|
return this.iterator();
|
|
}
|
|
|
|
abstract iterator(): AsyncIterator<TElement>;
|
|
|
|
apply<TResult>(pipeline: AsyncSequencePipeline<TElement, TResult>): MaybePromise<TResult> {
|
|
return pipeline(this);
|
|
}
|
|
|
|
select<TResult>(converter: MaybeAsyncConverter<TElement, TResult>): AsyncSequence<TResult> {
|
|
return new SelectAsyncSequence<TElement, TResult>(this, converter);
|
|
}
|
|
|
|
selectMany<TResult>(converter: MaybeAsyncConverter<TElement, MaybeAsyncIterable<TResult>>): AsyncSequence<TResult> {
|
|
return new SelectManyAsyncSequence<TElement, TResult>(this, converter);
|
|
}
|
|
|
|
where<TFiltered extends TElement>(predicate: MaybeAsyncTypePredicate<TElement, TFiltered>): AsyncSequence<TFiltered>;
|
|
where(predicate: MaybeAsyncAnyPredicate<TElement>): AsyncSequence<TElement>;
|
|
where(predicate: any) {
|
|
return new WhereAsyncSequence<TElement, any>(this, predicate);
|
|
}
|
|
|
|
groupBy<TKey>(keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector?: undefined, keyComparer?: MaybeAsyncEqualityComparisonOrComparer<TKey> | undefined): AsyncSequence<GroupedAsyncSequence<TKey, TElement>>;
|
|
groupBy<TKey, TResult>(keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector: MaybeAsyncConverter<TElement, TResult>, keyComparer?: MaybeAsyncEqualityComparisonOrComparer<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>(sequence: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector?: undefined, keyComparer?: MaybeAsyncEqualityComparisonOrComparer<TKey> | undefined): AsyncSequence<[TElement, TOther]>;
|
|
join<TOther, TKey, TResult>(sequence: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector: MaybeAsyncBiConverter<TElement, TOther, TResult>, keyComparer?: MaybeAsyncEqualityComparisonOrComparer<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>(sequence: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector?: undefined, keyComparer?: MaybeAsyncEqualityComparisonOrComparer<TKey> | undefined): AsyncSequence<GroupedAsyncSequence<TElement, TOther>>;
|
|
groupJoin<TOther, TKey, TResult>(sequence: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector: MaybeAsyncBiConverter<TElement, MaybeAsyncIterable<TOther>, TResult>, keyComparer?: MaybeAsyncEqualityComparisonOrComparer<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?: MaybeAsyncEqualityComparisonOrComparer<TElement>) {
|
|
equater = equater ? asAsyncEqualityComparer(equater) : defaultAsyncEqualityComparer;
|
|
|
|
for await (const element of this) {
|
|
if (await equater.equals(element, obj)) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
async sequenceEquals(sequence: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEqualityComparisonOrComparer<TElement>) {
|
|
if (this === sequence) {
|
|
return true;
|
|
}
|
|
|
|
const that = wrap(sequence);
|
|
|
|
const thisCount = await this.nonEnumeratedCount();
|
|
const thatCount = await that.nonEnumeratedCount();
|
|
|
|
if (thisCount >= 0 && thatCount >= 0 && thisCount !== thatCount) {
|
|
return false;
|
|
}
|
|
|
|
equater = equater ? asAsyncEqualityComparer(equater) : defaultAsyncEqualityComparer;
|
|
|
|
const thisIterator = this.iterator();
|
|
const thatIterator = that.iterator();
|
|
|
|
while (true) {
|
|
const thisNext = await thisIterator.next();
|
|
const thatNext = await thatIterator.next();
|
|
|
|
if (thisNext.done) {
|
|
return thatNext.done === true;
|
|
}
|
|
|
|
if (thatNext.done) {
|
|
return false;
|
|
}
|
|
|
|
if (!await equater.equals(thisNext.value, thatNext.value)) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
append(obj: TElement): AsyncSequence<TElement> {
|
|
return new AppendAsyncSequence<TElement>(this, obj);
|
|
}
|
|
|
|
prepend(obj: TElement): AsyncSequence<TElement> {
|
|
return new PrependAsyncSequence<TElement>(this, obj);
|
|
}
|
|
|
|
remove(obj: TElement, all?: boolean, equater?: MaybeAsyncEqualityComparisonOrComparer<TElement>): AsyncSequence<TElement> {
|
|
return new RemoveAsyncSequence<TElement>(this, obj, all, equater);
|
|
}
|
|
|
|
concat(...sequences: MaybeAsyncIterable<TElement>[]): AsyncSequence<TElement> {
|
|
if (sequences.length === 0) {
|
|
return this;
|
|
}
|
|
|
|
const arr: AsyncSequence<TElement>[] = [this];
|
|
|
|
for (const sequence of sequences) {
|
|
arr.push(wrap(sequence));
|
|
}
|
|
|
|
return new ConcatAsyncSequence(arr);
|
|
}
|
|
|
|
async count(predicate?: MaybeAsyncAnyPredicate<TElement>) {
|
|
let count = 0;
|
|
|
|
if (predicate) {
|
|
for await (const element of this) {
|
|
if (await predicate(element)) {
|
|
count++;
|
|
}
|
|
}
|
|
} else {
|
|
const iterator = this.iterator();
|
|
|
|
while (!(await iterator.next()).done) {
|
|
count++;
|
|
}
|
|
}
|
|
|
|
return count;
|
|
}
|
|
|
|
async nonEnumeratedCount() {
|
|
return -1;
|
|
}
|
|
|
|
async fastCount() {
|
|
const n = await this.nonEnumeratedCount();
|
|
return n >= 0 ? n : await this.count();
|
|
}
|
|
|
|
async maxCount() {
|
|
const n = await this.nonEnumeratedCount();
|
|
return n >= 0 ? n : Infinity;
|
|
}
|
|
|
|
async #tryGetFirst(predicate?: MaybeAsyncAnyPredicate<TElement>): Promise<FindElementResult<TElement>> {
|
|
if (predicate) {
|
|
for await (const element of this) {
|
|
if (await predicate(element)) {
|
|
return {
|
|
found: true,
|
|
element
|
|
};
|
|
}
|
|
}
|
|
} else {
|
|
const next = await this.iterator().next();
|
|
|
|
if (!next.done) {
|
|
return {
|
|
found: true,
|
|
element: next.value
|
|
};
|
|
}
|
|
}
|
|
|
|
return {
|
|
found: false
|
|
};
|
|
}
|
|
|
|
async first(predicate?: MaybeAsyncAnyPredicate<TElement>) {
|
|
const result = await this.#tryGetFirst(predicate);
|
|
|
|
if (result.found) {
|
|
return result.element;
|
|
}
|
|
|
|
throw new Error("No element was found.");
|
|
}
|
|
|
|
async firstOrDefault(predicate?: MaybeAsyncAnyPredicate<TElement>, def?: TElement) {
|
|
const result = await this.#tryGetFirst(predicate);
|
|
|
|
return result.found ? result.element : def;
|
|
}
|
|
|
|
async #tryGetLast(predicate?: MaybeAsyncAnyPredicate<TElement>): Promise<FindElementResult<TElement>> {
|
|
let result: FindElementResult<TElement> = {
|
|
found: false
|
|
};
|
|
|
|
if (predicate) {
|
|
for await (const element of this) {
|
|
if (await predicate(element)) {
|
|
result = {
|
|
found: true,
|
|
element
|
|
};
|
|
}
|
|
}
|
|
} else {
|
|
for await (const element of this) {
|
|
result = {
|
|
found: true,
|
|
element
|
|
};
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
async last(predicate?: MaybeAsyncAnyPredicate<TElement>) {
|
|
const result = await this.#tryGetLast(predicate);
|
|
|
|
if (result.found) {
|
|
return result.element;
|
|
}
|
|
|
|
throw new Error("No element was found.");
|
|
}
|
|
|
|
async lastOrDefault(predicate?: MaybeAsyncAnyPredicate<TElement>, def?: TElement) {
|
|
const result = await this.#tryGetLast(predicate);
|
|
|
|
return result.found ? result.element : def;
|
|
}
|
|
|
|
async #tryGetSingle(predicate?: MaybeAsyncAnyPredicate<TElement>): Promise<FindElementResult<TElement>> {
|
|
if (predicate) {
|
|
let result: FindElementResult<TElement> | undefined = undefined;
|
|
|
|
for await (const element of this) {
|
|
if (await predicate(element)) {
|
|
if (result) {
|
|
return {
|
|
found: false,
|
|
reason: 2
|
|
};
|
|
}
|
|
|
|
result = {
|
|
found: true,
|
|
element
|
|
};
|
|
}
|
|
}
|
|
} else {
|
|
const iterator = this.iterator();
|
|
let next = await iterator.next();
|
|
|
|
if (!next.done) {
|
|
const result: FindElementResult<TElement> = {
|
|
found: true,
|
|
element: next.value
|
|
};
|
|
|
|
next = await iterator.next();
|
|
|
|
if (next.done) {
|
|
return result;
|
|
}
|
|
|
|
return {
|
|
found: false,
|
|
reason: 2
|
|
};
|
|
}
|
|
}
|
|
|
|
return {
|
|
found: false,
|
|
reason: 1
|
|
};
|
|
}
|
|
|
|
async single(predicate?: MaybeAsyncAnyPredicate<TElement>) {
|
|
const result = await this.#tryGetSingle(predicate);
|
|
|
|
if (result.found) {
|
|
return result.element;
|
|
}
|
|
|
|
let reason: string;
|
|
switch (result.reason) {
|
|
case 1:
|
|
reason = "No element was found.";
|
|
break;
|
|
case 2:
|
|
reason = "More than one element was found.";
|
|
break;
|
|
default:
|
|
reason = "";
|
|
}
|
|
throw new Error(reason);
|
|
}
|
|
|
|
async singleOrDefault(predicate?: MaybeAsyncAnyPredicate<TElement>, def?: TElement) {
|
|
const result = await this.#tryGetSingle(predicate);
|
|
|
|
return result.found ? result.element : def;
|
|
}
|
|
|
|
async #tryElementAt(index: number): Promise<FindElementResult<TElement>> {
|
|
let i = index;
|
|
|
|
for await (const element of this) {
|
|
if (i === 0) {
|
|
return {
|
|
found: true,
|
|
element
|
|
};
|
|
}
|
|
|
|
i--;
|
|
}
|
|
|
|
return {
|
|
found: false
|
|
};
|
|
}
|
|
|
|
async elementAt(index: number) {
|
|
const result = await this.#tryElementAt(index);
|
|
|
|
if (result.found) {
|
|
return result.element;
|
|
}
|
|
|
|
throw new Error("No element found at given index.");
|
|
}
|
|
|
|
async elementAtOrDefault(index: number, def?: TElement) {
|
|
const result = await this.#tryElementAt(index);
|
|
|
|
return result.found ? result.element : def;
|
|
}
|
|
|
|
async aggregate<TAccumulator, TResult>(accumulator: MaybeAsyncAccumulator<TElement, TAccumulator>, seed?: TAccumulator, resultSelector?: MaybeAsyncConverter<TAccumulator, TResult>) {
|
|
const iterator = this.iterator();
|
|
|
|
if (seed === undefined) {
|
|
const next = await iterator.next();
|
|
|
|
if (next.done) {
|
|
throw new Error("Aggregation requires at least one element.");
|
|
}
|
|
|
|
seed = next.value as unknown as TAccumulator;
|
|
}
|
|
|
|
let acc = seed;
|
|
|
|
while (true) {
|
|
const next = await iterator.next();
|
|
|
|
if (next.done) {
|
|
break;
|
|
}
|
|
|
|
acc = await accumulator(acc, next.value);
|
|
}
|
|
|
|
if (resultSelector) {
|
|
return await resultSelector(acc);
|
|
}
|
|
|
|
return acc as unknown as TResult;
|
|
}
|
|
|
|
async #find<TResult>(sorter: MaybeAsyncAnyPredicate<number>, selector?: MaybeAsyncConverter<TElement, TResult>, comparer?: MaybeAsyncComparisonOrComparer<TResult>) {
|
|
const iterator = this.iterator();
|
|
|
|
let next = await iterator.next();
|
|
|
|
if (next.done) {
|
|
throw new Error("Sequence contains no element.");
|
|
}
|
|
|
|
if (!selector) {
|
|
selector = identity as MaybeAsyncConverter<TElement, TResult>;
|
|
}
|
|
|
|
comparer = comparer ? asAsyncComparer(comparer) : defaultAsyncComparer;
|
|
|
|
let result = next.value;
|
|
let convertedResult = await selector(result);
|
|
|
|
while (true) {
|
|
next = await iterator.next();
|
|
|
|
if (next.done) {
|
|
break;
|
|
}
|
|
|
|
const value = next.value;
|
|
const convertedValue = await selector(value);
|
|
|
|
if (await sorter(await comparer.compare(convertedResult, convertedValue))) {
|
|
result = value;
|
|
convertedResult = convertedValue;
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
min(comparer?: MaybeAsyncComparisonOrComparer<TElement>) {
|
|
return this.#find(x => x > 0, undefined, comparer);
|
|
}
|
|
|
|
minBy<TBy>(converter: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparisonOrComparer<TBy>) {
|
|
return this.#find(x => x > 0, converter, comparer);
|
|
}
|
|
|
|
max(comparer?: MaybeAsyncComparisonOrComparer<TElement>) {
|
|
return this.#find(x => x < 0, undefined, comparer);
|
|
}
|
|
|
|
maxBy<TBy>(converter: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparisonOrComparer<TBy>) {
|
|
return this.#find(x => x < 0, converter, comparer);
|
|
}
|
|
|
|
async #findBounds<TResult>(selector?: MaybeAsyncConverter<TElement, TResult>, comparer?: MaybeAsyncComparisonOrComparer<TResult>): Promise<[min: TElement, max: TElement]> {
|
|
const iterator = this.iterator();
|
|
|
|
let next = await iterator.next();
|
|
|
|
if (next.done) {
|
|
throw new Error("Sequence contains no element.");
|
|
}
|
|
|
|
if (!selector) {
|
|
selector = identity as MaybeAsyncConverter<TElement, TResult>;
|
|
}
|
|
|
|
comparer = comparer ? asAsyncComparer(comparer) : defaultAsyncComparer;
|
|
|
|
let minBound = next.value, maxBound = minBound;
|
|
let convertedMinBound = await selector(minBound), convertedMaxBound = convertedMinBound;
|
|
|
|
while (true) {
|
|
next = await iterator.next();
|
|
|
|
if (next.done) {
|
|
break;
|
|
}
|
|
|
|
const value = next.value;
|
|
const convertedValue = await selector(value);
|
|
|
|
if (await comparer.compare(convertedMinBound, convertedValue) > 0) {
|
|
minBound = value;
|
|
convertedMinBound = convertedValue;
|
|
}
|
|
|
|
if (await comparer.compare(convertedMaxBound, convertedValue) < 0) {
|
|
maxBound = value;
|
|
convertedMaxBound = convertedValue;
|
|
}
|
|
}
|
|
|
|
return [minBound, maxBound];
|
|
}
|
|
|
|
bounds(comparer?: MaybeAsyncComparisonOrComparer<TElement>) {
|
|
return this.#findBounds(undefined, comparer);
|
|
}
|
|
|
|
boundsBy<TBy>(converter: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparisonOrComparer<TBy>) {
|
|
return this.#findBounds(converter, comparer);
|
|
}
|
|
|
|
order(comparer?: MaybeAsyncComparisonOrComparer<TElement>): OrderedAsyncSequence<TElement> {
|
|
return new OrderAsyncSequence<TElement>(this, false, comparer);
|
|
}
|
|
|
|
orderBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparisonOrComparer<TBy>): OrderedAsyncSequence<TElement> {
|
|
return new OrderByAsyncSequence<TElement, TBy>(this, false, selector, comparer);
|
|
}
|
|
|
|
orderDescending(comparer?: MaybeAsyncComparisonOrComparer<TElement>): OrderedAsyncSequence<TElement> {
|
|
return new OrderAsyncSequence<TElement>(this, true, comparer);
|
|
}
|
|
|
|
orderByDescending<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparisonOrComparer<TBy>): OrderedAsyncSequence<TElement> {
|
|
return new OrderByAsyncSequence<TElement, TBy>(this, true, selector, comparer);
|
|
}
|
|
|
|
partition(equater?: MaybeAsyncEqualityComparisonOrComparer<TElement>): AsyncSequence<AsyncSequence<TElement>> {
|
|
return new PartitionAsyncSequence<TElement>(this, equater);
|
|
}
|
|
|
|
partitionBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparisonOrComparer<TBy>): AsyncSequence<AsyncSequence<TElement>> {
|
|
return new PartitionByAsyncSequence<TElement, TBy>(this, selector, equater);
|
|
}
|
|
|
|
distinct(equater?: MaybeAsyncEqualityComparisonOrComparer<TElement>): AsyncSequence<TElement> {
|
|
return new DistinctAsyncSequence<TElement>(this, equater);
|
|
}
|
|
|
|
distinctBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparisonOrComparer<TBy>): AsyncSequence<TElement> {
|
|
return new DistinctByAsyncSequence<TElement, TBy>(this, selector, equater);
|
|
}
|
|
|
|
union(sequence: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEqualityComparisonOrComparer<TElement>): AsyncSequence<TElement> {
|
|
return new UnionAsyncSequence<TElement>(this, wrap(sequence), equater);
|
|
}
|
|
|
|
unionBy<TBy>(sequence: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparisonOrComparer<TBy>): AsyncSequence<TElement> {
|
|
return new UnionByAsyncSequence<TElement, TBy>(this, wrap(sequence), selector, equater);
|
|
}
|
|
|
|
except(sequence: MaybeAsyncIterable<TElement>): AsyncSequence<TElement> {
|
|
return new ExceptAsyncSequence<TElement>(this, wrap(sequence));
|
|
}
|
|
|
|
exceptBy<TBy>(sequence: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>): AsyncSequence<TElement> {
|
|
return new ExceptByAsyncSequence<TElement, TBy>(this, wrap(sequence), selector);
|
|
}
|
|
|
|
intersect(sequence: MaybeAsyncIterable<TElement>): AsyncSequence<TElement> {
|
|
return new IntersectAsyncSequence<TElement>(this, wrap(sequence));
|
|
}
|
|
|
|
intersectBy<TBy>(sequence: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>): AsyncSequence<TElement> {
|
|
return new IntersectByAsyncSequence<TElement, TBy>(this, wrap(sequence), selector);
|
|
}
|
|
|
|
async all(predicate: MaybeAsyncAnyPredicate<TElement>) {
|
|
const n = await this.nonEnumeratedCount();
|
|
|
|
if (n === 0) {
|
|
return false;
|
|
}
|
|
|
|
for await (const element of this) {
|
|
if (!await predicate(element)) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
async any(predicate?: MaybeAsyncAnyPredicate<TElement>) {
|
|
const n = await this.nonEnumeratedCount();
|
|
|
|
if (n === 0) {
|
|
return false;
|
|
}
|
|
|
|
if (predicate) {
|
|
for await (const element of this) {
|
|
if (await predicate(element)) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
return n < 0 ? !(await this.iterator().next()).done : n > 0;
|
|
}
|
|
|
|
async none(predicate?: MaybeAsyncAnyPredicate<TElement>) {
|
|
const n = await this.nonEnumeratedCount();
|
|
|
|
if (n === 0) {
|
|
return true;
|
|
}
|
|
|
|
if (predicate) {
|
|
for await (const element of this) {
|
|
if (predicate(element)) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
return n < 0 && (await this.iterator().next()).done === true;
|
|
}
|
|
|
|
skip(n: number): AsyncSequence<TElement> {
|
|
if (n < 0) {
|
|
throw new Error("Cannot skip a negative number of elements.");
|
|
}
|
|
|
|
return n === 0 ? this : new SkipAsyncSequence<TElement>(this, n);
|
|
}
|
|
|
|
skipLast(n: number): AsyncSequence<TElement> {
|
|
if (n < 0) {
|
|
throw new Error("Cannot skip a negative number of elements.");
|
|
}
|
|
|
|
return n === 0 ? this : new SkipLastAsyncSequence<TElement>(this, n);
|
|
}
|
|
|
|
skipWhile(predicate: MaybeAsyncAnyPredicate<TElement>): AsyncSequence<TElement> {
|
|
return new SkipWhileAsyncSequence<TElement>(this, predicate);
|
|
}
|
|
|
|
take(n: number): AsyncSequence<TElement> {
|
|
if (n < 0) {
|
|
throw new Error("Cannot take a negative number of elements.");
|
|
}
|
|
|
|
return n === 0 ? empty<TElement>() : new TakeAsyncSequence<TElement>(this, n);
|
|
}
|
|
|
|
takeLast(n: number): AsyncSequence<TElement> {
|
|
if (n < 0) {
|
|
throw new Error("Cannot take a negative number of elements.");
|
|
}
|
|
|
|
return n === 0 ? empty<TElement>() : new TakeLastAsyncSequence<TElement>(this, n);
|
|
}
|
|
|
|
takeWhile(predicate: MaybeAsyncAnyPredicate<TElement>): AsyncSequence<TElement> {
|
|
return new TakeWhileAsyncSequence<TElement>(this, predicate);
|
|
}
|
|
|
|
peek(action: MaybeAsyncAction<TElement>): AsyncSequence<TElement> {
|
|
return new PeekAsyncSequence(this, action);
|
|
}
|
|
|
|
async forEach(action: MaybeAsyncAction<TElement>) {
|
|
for await (const element of this) {
|
|
await action(element);
|
|
}
|
|
}
|
|
|
|
zip<TOther>(sequence: MaybeAsyncIterable<TOther>): AsyncSequence<[TElement, TOther]> {
|
|
return new ZippedAsyncSequence<TElement, TOther>(this, wrap(sequence));
|
|
}
|
|
|
|
cartesianProduct<TOther>(sequence: MaybeAsyncIterable<TOther>): AsyncSequence<[TElement, TOther]> {
|
|
return new CartesianProductAsyncSequence<TElement, TOther>(this, wrap(sequence));
|
|
}
|
|
|
|
indexed(): AsyncSequence<[number, TElement]> {
|
|
return new IndexedAsyncSequence<TElement>(this);
|
|
}
|
|
|
|
reversed(): AsyncSequence<TElement> {
|
|
return new ReversedAsyncSequence<TElement>(this);
|
|
}
|
|
|
|
chunked(size: number): AsyncSequence<AsyncSequence<TElement>>;
|
|
chunked<TResult>(size: number, transformer: AsyncSequencePipeline<TElement, TResult>): AsyncSequence<TResult>;
|
|
chunked<TResult>(size: number, transformer?: AsyncSequencePipeline<TElement, TResult>): AsyncSequence<AsyncSequence<TElement>> | AsyncSequence<TResult> {
|
|
if (size <= 0) {
|
|
throw new Error("Chunk size must be positive.");
|
|
}
|
|
|
|
const result = new ChunkedAsyncSequence<TElement>(this, size);
|
|
return transformer ? result.select(transformer) : result;
|
|
}
|
|
|
|
async random(options?: AsyncRandomOptions<TElement> | undefined): Promise<TElement | undefined> {
|
|
return (await getRandomElementAsync(this, options)).element;
|
|
}
|
|
|
|
cached(): AsyncSequence<TElement> {
|
|
return new CacheAsyncSequence<TElement>(this);
|
|
}
|
|
|
|
async asArray() {
|
|
return await Array.fromAsync(this);
|
|
}
|
|
|
|
async toArray() {
|
|
return await Array.fromAsync(this);
|
|
}
|
|
|
|
toMap<TKey>(keySelector: MaybeAsyncConverter<TElement, TKey>): Promise<Map<TKey, TElement>>;
|
|
toMap<TKey, TValue>(keySelector: MaybeAsyncConverter<TElement, TKey>, valueSelector: MaybeAsyncConverter<TElement, TValue>): Promise<Map<TKey, TValue>>;
|
|
async toMap<TKey>(keySelector: MaybeAsyncConverter<TElement, TKey>, valueSelector?: MaybeAsyncConverter<TElement, any>): Promise<Map<TKey, any>> {
|
|
valueSelector ??= identity;
|
|
|
|
const map = new Map<TKey, any>();
|
|
|
|
for await (const element of this) {
|
|
const key = await keySelector(element);
|
|
const value = await valueSelector(element);
|
|
|
|
map.set(key, value);
|
|
}
|
|
|
|
return map;
|
|
}
|
|
|
|
async toSet() {
|
|
const set = new Set<TElement>();
|
|
|
|
for await (const element of this) {
|
|
set.add(element);
|
|
}
|
|
|
|
return set;
|
|
}
|
|
|
|
toObject<TKey extends PropertyKey>(keySelector: MaybeAsyncConverter<TElement, TKey>): Promise<Record<TKey, TElement>>;
|
|
toObject<TKey extends PropertyKey, TValue>(keySelector: MaybeAsyncConverter<TElement, TKey>, valueSelector: MaybeAsyncConverter<TElement, TValue>): Promise<Record<TKey, TValue>>;
|
|
async toObject<TKey extends PropertyKey>(keySelector: MaybeAsyncConverter<TElement, TKey>, valueSelector?: MaybeAsyncConverter<TElement, any>): Promise<Record<TKey, any>> {
|
|
valueSelector ??= identity;
|
|
|
|
const obj: Record<PropertyKey, any> = {};
|
|
|
|
for await (const element of this) {
|
|
const key = await keySelector(element);
|
|
const value = await valueSelector(element);
|
|
|
|
obj[key] = value;
|
|
}
|
|
|
|
return obj;
|
|
}
|
|
|
|
async collect<TResult>(collector: Collector<TElement, any, TResult>) {
|
|
const acc = collector.initialize();
|
|
|
|
for await (const e of this) {
|
|
collector.accumulate(acc, e);
|
|
}
|
|
|
|
return collector.finalize(acc);
|
|
}
|
|
}
|
|
|
|
export class DelegatedAsyncSequence<TElement> extends AsyncSequenceMarker implements AsyncSequence<TElement> {
|
|
#sequence: AsyncSequence<TElement>;
|
|
|
|
constructor(sequence: AsyncSequence<TElement>) {
|
|
super();
|
|
|
|
this.#sequence = sequence;
|
|
}
|
|
|
|
get sequence() {
|
|
return this.#sequence;
|
|
}
|
|
|
|
[Symbol.asyncIterator]() {
|
|
return this.iterator();
|
|
}
|
|
|
|
iterator() {
|
|
return this.#sequence.iterator();
|
|
}
|
|
|
|
apply<TResult>(pipeline: AsyncSequencePipeline<TElement, TResult>) {
|
|
return this.#sequence.apply(pipeline);
|
|
}
|
|
|
|
count(predicate?: MaybeAsyncAnyPredicate<TElement> | undefined): Promise<number> {
|
|
return this.#sequence.count(predicate);
|
|
}
|
|
|
|
nonEnumeratedCount(): Promise<number> {
|
|
return this.#sequence.nonEnumeratedCount();
|
|
}
|
|
|
|
fastCount(): Promise<number> {
|
|
return this.#sequence.fastCount();
|
|
}
|
|
|
|
maxCount(): Promise<number> {
|
|
return this.#sequence.maxCount();
|
|
}
|
|
|
|
select<TResult>(selector: MaybeAsyncConverter<TElement, TResult>): AsyncSequence<TResult> {
|
|
return this.#sequence.select(selector);
|
|
}
|
|
|
|
selectMany<TResult>(selector: MaybeAsyncConverter<TElement, MaybeAsyncIterable<TResult>>): AsyncSequence<TResult> {
|
|
return this.#sequence.selectMany(selector);
|
|
}
|
|
|
|
where<TFiltered extends TElement>(predicate: MaybeAsyncTypePredicate<TElement, TFiltered>): AsyncSequence<TFiltered>;
|
|
where(predicate: MaybeAsyncAnyPredicate<TElement>): AsyncSequence<TElement>;
|
|
where(predicate: any) {
|
|
return this.#sequence.where(predicate);
|
|
}
|
|
|
|
groupBy<TKey>(keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector?: undefined, keyComparer?: MaybeAsyncEqualityComparisonOrComparer<TKey> | undefined): AsyncSequence<GroupedAsyncSequence<TKey, TElement>>;
|
|
groupBy<TKey, TResult>(keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector: MaybeAsyncConverter<TElement, TResult>, keyComparer?: MaybeAsyncEqualityComparisonOrComparer<TKey> | undefined): AsyncSequence<GroupedAsyncSequence<TKey, TResult>>;
|
|
groupBy(keySelector: any, elementSelector?: any, keyComparer?: any) {
|
|
return this.#sequence.groupBy(keySelector, elementSelector, keyComparer);
|
|
}
|
|
|
|
join<TOther, TKey>(sequence: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector?: undefined, keyComparer?: MaybeAsyncEqualityComparisonOrComparer<TKey> | undefined): AsyncSequence<[TElement, TOther]>;
|
|
join<TOther, TKey, TResult>(sequence: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector: MaybeAsyncBiConverter<TElement, TOther, TResult>, keyComparer?: MaybeAsyncEqualityComparisonOrComparer<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>(sequence: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector?: undefined, keyComparer?: MaybeAsyncEqualityComparisonOrComparer<TKey> | undefined): AsyncSequence<GroupedAsyncSequence<TElement, TOther>>;
|
|
groupJoin<TOther, TKey, TResult>(sequence: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector: MaybeAsyncBiConverter<TElement, MaybeAsyncIterable<TOther>, TResult>, keyComparer?: MaybeAsyncEqualityComparisonOrComparer<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?: MaybeAsyncEqualityComparisonOrComparer<TElement> | undefined): Promise<boolean> {
|
|
return this.#sequence.contains(obj, equater);
|
|
}
|
|
|
|
sequenceEquals(sequence: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEqualityComparisonOrComparer<TElement> | undefined): Promise<boolean> {
|
|
return this.#sequence.sequenceEquals(sequence, equater);
|
|
}
|
|
|
|
append(obj: TElement): AsyncSequence<TElement> {
|
|
return this.#sequence.append(obj);
|
|
}
|
|
|
|
prepend(obj: TElement): AsyncSequence<TElement> {
|
|
return this.#sequence.prepend(obj);
|
|
}
|
|
|
|
remove(obj: TElement, all?: boolean | undefined, equater?: MaybeAsyncEqualityComparisonOrComparer<TElement> | undefined): AsyncSequence<TElement> {
|
|
return this.#sequence.remove(obj, all, equater);
|
|
}
|
|
|
|
concat(...sequences: MaybeAsyncIterable<TElement>[]): AsyncSequence<TElement> {
|
|
return this.#sequence.concat(...sequences);
|
|
}
|
|
|
|
first(predicate?: MaybeAsyncAnyPredicate<TElement> | undefined): Promise<TElement> {
|
|
return this.#sequence.first(predicate);
|
|
}
|
|
|
|
firstOrDefault(predicate?: MaybeAsyncAnyPredicate<TElement> | undefined, def?: TElement | undefined): Promise<TElement | undefined> {
|
|
return this.#sequence.firstOrDefault(predicate, def);
|
|
}
|
|
|
|
last(predicate?: MaybeAsyncAnyPredicate<TElement> | undefined): Promise<TElement> {
|
|
return this.#sequence.last(predicate);
|
|
}
|
|
|
|
lastOrDefault(predicate?: MaybeAsyncAnyPredicate<TElement> | undefined, def?: TElement | undefined): Promise<TElement | undefined> {
|
|
return this.#sequence.lastOrDefault(predicate, def);
|
|
}
|
|
|
|
single(predicate?: MaybeAsyncAnyPredicate<TElement> | undefined): Promise<TElement> {
|
|
return this.#sequence.single(predicate);
|
|
}
|
|
|
|
singleOrDefault(predicate?: MaybeAsyncAnyPredicate<TElement> | undefined, def?: TElement | undefined): Promise<TElement | undefined> {
|
|
return this.#sequence.singleOrDefault(predicate, def);
|
|
}
|
|
|
|
elementAt(index: number): Promise<TElement> {
|
|
return this.#sequence.elementAt(index);
|
|
}
|
|
|
|
elementAtOrDefault(index: number, def?: TElement | undefined): Promise<TElement | undefined> {
|
|
return this.#sequence.elementAtOrDefault(index, def);
|
|
}
|
|
|
|
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);
|
|
}
|
|
|
|
min(): Promise<TElement> {
|
|
return this.#sequence.min();
|
|
}
|
|
|
|
minBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>): Promise<TElement> {
|
|
return this.#sequence.minBy(selector);
|
|
}
|
|
|
|
max(): Promise<TElement> {
|
|
return this.#sequence.max();
|
|
}
|
|
|
|
maxBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>): Promise<TElement> {
|
|
return this.#sequence.maxBy(selector);
|
|
}
|
|
|
|
bounds(comparer?: MaybeAsyncComparisonOrComparer<TElement> | undefined): Promise<[min: TElement, max: TElement]> {
|
|
return this.#sequence.bounds(comparer);
|
|
}
|
|
|
|
boundsBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparisonOrComparer<TBy> | undefined): Promise<[min: TElement, max: TElement]> {
|
|
return this.#sequence.boundsBy(selector, comparer);
|
|
}
|
|
|
|
order(comparer?: MaybeAsyncComparisonOrComparer<TElement> | undefined): OrderedAsyncSequence<TElement> {
|
|
return this.#sequence.order(comparer);
|
|
}
|
|
|
|
orderBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparisonOrComparer<TBy> | undefined): OrderedAsyncSequence<TElement> {
|
|
return this.#sequence.orderBy(selector, comparer);
|
|
}
|
|
|
|
orderDescending(comparer?: MaybeAsyncComparisonOrComparer<TElement> | undefined): OrderedAsyncSequence<TElement> {
|
|
return this.#sequence.orderDescending(comparer);
|
|
}
|
|
|
|
orderByDescending<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparisonOrComparer<TBy> | undefined): OrderedAsyncSequence<TElement> {
|
|
return this.#sequence.orderByDescending(selector, comparer);
|
|
}
|
|
|
|
partition(equater?: MaybeAsyncEqualityComparisonOrComparer<TElement> | undefined): AsyncSequence<AsyncSequence<TElement>> {
|
|
return this.#sequence.partition(equater);
|
|
}
|
|
|
|
partitionBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparisonOrComparer<TBy> | undefined): AsyncSequence<AsyncSequence<TElement>> {
|
|
return this.#sequence.partitionBy(selector, equater);
|
|
}
|
|
|
|
distinct(equater?: MaybeAsyncEqualityComparisonOrComparer<TElement> | undefined): AsyncSequence<TElement> {
|
|
return this.#sequence.distinct(equater);
|
|
}
|
|
|
|
distinctBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparisonOrComparer<TBy> | undefined): AsyncSequence<TElement> {
|
|
return this.#sequence.distinctBy(selector, equater);
|
|
}
|
|
|
|
union(sequence: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEqualityComparisonOrComparer<TElement> | undefined): AsyncSequence<TElement> {
|
|
return this.#sequence.union(wrap(sequence), equater);
|
|
}
|
|
|
|
unionBy<TBy>(sequence: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparisonOrComparer<TBy> | undefined): AsyncSequence<TElement> {
|
|
return this.#sequence.unionBy(wrap(sequence), selector, equater);
|
|
}
|
|
|
|
except(sequence: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEqualityComparisonOrComparer<TElement> | undefined): AsyncSequence<TElement> {
|
|
return this.#sequence.except(wrap(sequence), equater);
|
|
}
|
|
|
|
exceptBy<TBy>(sequence: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparisonOrComparer<TBy> | undefined): AsyncSequence<TElement> {
|
|
return this.#sequence.exceptBy(wrap(sequence), selector, equater);
|
|
}
|
|
|
|
intersect(sequence: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEqualityComparisonOrComparer<TElement> | undefined): AsyncSequence<TElement> {
|
|
return this.#sequence.intersect(wrap(sequence), equater);
|
|
}
|
|
|
|
intersectBy<TBy>(sequence: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparisonOrComparer<TBy> | undefined): AsyncSequence<TElement> {
|
|
return this.#sequence.intersectBy(wrap(sequence), selector, equater);
|
|
}
|
|
|
|
all(predicate: MaybeAsyncAnyPredicate<TElement>): Promise<boolean> {
|
|
return this.#sequence.all(predicate);
|
|
}
|
|
|
|
any(predicate: MaybeAsyncAnyPredicate<TElement>): Promise<boolean>;
|
|
any(): Promise<boolean>;
|
|
any(predicate?: any) {
|
|
return this.#sequence.any(predicate);
|
|
}
|
|
|
|
none(predicate: MaybeAsyncAnyPredicate<TElement>): Promise<boolean>;
|
|
none(): Promise<boolean>;
|
|
none(predicate?: any) {
|
|
return this.#sequence.none(predicate);
|
|
}
|
|
|
|
skip(n: number): AsyncSequence<TElement> {
|
|
return this.#sequence.skip(n);
|
|
}
|
|
|
|
skipLast(n: number): AsyncSequence<TElement> {
|
|
return this.#sequence.skipLast(n);
|
|
}
|
|
|
|
skipWhile(condition: MaybeAsyncAnyPredicate<TElement>): AsyncSequence<TElement> {
|
|
return this.#sequence.skipWhile(condition);
|
|
}
|
|
|
|
take(n: number): AsyncSequence<TElement> {
|
|
return this.#sequence.take(n);
|
|
}
|
|
|
|
takeLast(n: number): AsyncSequence<TElement> {
|
|
return this.#sequence.takeLast(n);
|
|
}
|
|
|
|
takeWhile(condition: MaybeAsyncAnyPredicate<TElement>): AsyncSequence<TElement> {
|
|
return this.#sequence.takeWhile(condition);
|
|
}
|
|
|
|
peek(action: MaybeAsyncAction<TElement>): AsyncSequence<TElement> {
|
|
return this.#sequence.peek(action);
|
|
}
|
|
|
|
forEach(action: MaybeAsyncAction<TElement>): Promise<void> {
|
|
return this.#sequence.forEach(action);
|
|
}
|
|
|
|
zip<TOther>(sequence: MaybeAsyncIterable<TOther>): AsyncSequence<[TElement, TOther]> {
|
|
return this.#sequence.zip(wrap(sequence));
|
|
}
|
|
|
|
cartesianProduct<TOther>(sequence: MaybeAsyncIterable<TOther>): AsyncSequence<[TElement, TOther]> {
|
|
return this.#sequence.cartesianProduct(wrap(sequence));
|
|
}
|
|
|
|
indexed(): AsyncSequence<[number, TElement]> {
|
|
return this.#sequence.indexed();
|
|
}
|
|
|
|
reversed(): AsyncSequence<TElement> {
|
|
return this.#sequence.reversed();
|
|
}
|
|
|
|
chunked(size: number): AsyncSequence<AsyncSequence<TElement>>;
|
|
chunked<TResult>(size: number, transformer: AsyncSequencePipeline<TElement, TResult>): AsyncSequence<TResult>;
|
|
chunked(size: number, transformer?: any): any {
|
|
return this.#sequence.chunked(size, transformer);
|
|
}
|
|
|
|
random(options?: AsyncRandomOptions<TElement> | undefined): Promise<TElement | undefined> {
|
|
return this.#sequence.random(options);
|
|
}
|
|
|
|
cached(): AsyncSequence<TElement> {
|
|
return this.#sequence.cached();
|
|
}
|
|
|
|
asArray(): Promise<TElement[]> {
|
|
return this.#sequence.asArray();
|
|
}
|
|
|
|
toArray(): Promise<TElement[]> {
|
|
return this.#sequence.toArray();
|
|
}
|
|
|
|
toMap<TKey>(keySelector: MaybeAsyncConverter<TElement, TKey>): Promise<Map<TKey, TElement>>;
|
|
toMap<TKey, TValue>(keySelector: MaybeAsyncConverter<TElement, TKey>, valueSelector: MaybeAsyncConverter<TElement, TValue>): Promise<Map<TKey, TValue>>;
|
|
toMap(keySelector: any, valueSelector?: any) {
|
|
return this.#sequence.toMap(keySelector, valueSelector);
|
|
}
|
|
|
|
toSet(): Promise<Set<TElement>> {
|
|
return this.#sequence.toSet();
|
|
}
|
|
|
|
toObject<TKey extends PropertyKey>(keySelector: MaybeAsyncConverter<TElement, TKey>): Promise<Record<TKey, TElement>>;
|
|
toObject<TKey extends PropertyKey, TValue>(keySelector: MaybeAsyncConverter<TElement, TKey>, valueSelector: MaybeAsyncConverter<TElement, TValue>): Promise<Record<TKey, TValue>>;
|
|
toObject(keySelector: any, valueSelector?: any) {
|
|
return this.#sequence.toObject(keySelector, valueSelector);
|
|
}
|
|
|
|
collect<TResult>(collector: Collector<TElement, any, TResult>): Promise<TResult> {
|
|
return this.#sequence.collect(collector);
|
|
}
|
|
}
|
|
|
|
export class GroupedAsyncSequenceImpl<TElement, TKey> extends DelegatedAsyncSequence<TElement> implements GroupedAsyncSequence<TKey, TElement> {
|
|
readonly #key: TKey;
|
|
|
|
constructor(key: TKey, grouping: AsyncSequence<TElement>) {
|
|
super(grouping);
|
|
|
|
this.#key = key;
|
|
}
|
|
|
|
public get key() {
|
|
return this.#key;
|
|
}
|
|
}
|
|
|
|
abstract class BaseOrderedAsyncSequence<TElement> extends BaseAsyncSequence<TElement> implements OrderedAsyncSequence<TElement> {
|
|
readonly #sequence: AsyncSequence<TElement>;
|
|
readonly #sorter: AsyncComparer<TElement>;
|
|
readonly #descending: boolean;
|
|
|
|
constructor(sequence: AsyncSequence<TElement>, sorter: MaybeAsyncComparisonOrComparer<TElement> | undefined, descending: boolean) {
|
|
super();
|
|
|
|
this.#sequence = sequence;
|
|
this.#sorter = sorter ? asAsyncComparer(sorter) : defaultAsyncComparer;
|
|
this.#descending = descending;
|
|
}
|
|
|
|
override async nonEnumeratedCount() {
|
|
return await this.#sequence.nonEnumeratedCount();
|
|
}
|
|
|
|
override async maxCount() {
|
|
return await this.#sequence.maxCount();
|
|
}
|
|
|
|
get comparer() {
|
|
return this.#sorter;
|
|
}
|
|
|
|
thenSelf(comparer?: MaybeAsyncComparisonOrComparer<TElement>): OrderedAsyncSequence<TElement> {
|
|
return new ThenOrderAsyncSequence(this, false, comparer);
|
|
}
|
|
|
|
thenBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparisonOrComparer<TBy>): OrderedAsyncSequence<TElement> {
|
|
return new ThenOrderByAsyncSequence<TElement, TBy>(this, false, selector, comparer);
|
|
}
|
|
|
|
thenSelfDescending(comparer?: MaybeAsyncComparisonOrComparer<TElement>): OrderedAsyncSequence<TElement> {
|
|
return new ThenOrderAsyncSequence(this, true, comparer);
|
|
}
|
|
|
|
thenByDescending<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparisonOrComparer<TBy>): OrderedAsyncSequence<TElement> {
|
|
return new ThenOrderByAsyncSequence<TElement, TBy>(this, true, selector, comparer);
|
|
}
|
|
|
|
override async *iterator() {
|
|
const arr = await Array.fromAsync(this.#sequence);
|
|
|
|
await selectionSorter.sort(arr, this.#descending, this.#sorter);
|
|
|
|
yield* arr;
|
|
}
|
|
}
|
|
|
|
class EmptyAsyncSequence<T> extends BaseAsyncSequence<T> {
|
|
override async nonEnumeratedCount() {
|
|
return 0;
|
|
}
|
|
|
|
override async *iterator() { }
|
|
}
|
|
|
|
export const EMPTY = new EmptyAsyncSequence<any>();
|
|
|
|
export class RangeAsyncSequence extends BaseAsyncSequence<number> {
|
|
readonly #min: number;
|
|
readonly #max: number;
|
|
readonly #step: number;
|
|
|
|
constructor(min: number, max: number, step: number) {
|
|
super();
|
|
|
|
this.#min = min;
|
|
this.#max = max;
|
|
this.#step = step;
|
|
}
|
|
|
|
override async nonEnumeratedCount() {
|
|
return Math.ceil((this.#max - this.#min) / this.#step);
|
|
}
|
|
|
|
override async *iterator() {
|
|
for (let i = this.#min; i < this.#max; i += this.#step) {
|
|
yield i;
|
|
}
|
|
}
|
|
}
|
|
|
|
export class RepeatAsyncSequence<T> extends BaseAsyncSequence<T> {
|
|
readonly #value: MaybePromiseLike<T>;
|
|
readonly #count: number;
|
|
|
|
constructor(value: MaybePromiseLike<T>, count: number) {
|
|
super();
|
|
|
|
this.#value = value;
|
|
this.#count = count;
|
|
}
|
|
|
|
override async nonEnumeratedCount() {
|
|
return this.#count;
|
|
}
|
|
|
|
override async *iterator() {
|
|
let i = this.#count;
|
|
|
|
while (i-- > 0) {
|
|
yield this.#value;
|
|
}
|
|
}
|
|
}
|
|
|
|
export class RepeatForeverAsyncSequence<T> extends BaseAsyncSequence<T> {
|
|
readonly #value: MaybePromiseLike<T>;
|
|
|
|
constructor(value: MaybePromiseLike<T>) {
|
|
super();
|
|
|
|
this.#value = value;
|
|
}
|
|
|
|
override async nonEnumeratedCount() {
|
|
return Infinity;
|
|
}
|
|
|
|
override async *iterator() {
|
|
while (true) {
|
|
yield this.#value;
|
|
}
|
|
}
|
|
}
|
|
|
|
export class WrappedObjectAsync<T> extends BaseAsyncSequence<T> {
|
|
readonly #obj: MaybePromiseLike<T>;
|
|
|
|
constructor(obj: MaybePromiseLike<T>) {
|
|
super();
|
|
|
|
this.#obj = obj;
|
|
}
|
|
|
|
override async nonEnumeratedCount() {
|
|
return 1;
|
|
}
|
|
|
|
override async *iterator() {
|
|
yield this.#obj;
|
|
}
|
|
}
|
|
|
|
export class WrappedPromise<T> extends BaseAsyncSequence<T> {
|
|
readonly #promise: Promise<MaybeAsyncIterable<T>>;
|
|
|
|
constructor(promise: Promise<MaybeAsyncIterable<T>>) {
|
|
super();
|
|
|
|
this.#promise = promise;
|
|
}
|
|
|
|
override async *iterator() {
|
|
yield* await this.#promise;
|
|
}
|
|
}
|
|
|
|
export class WrappedArrayAsync<T> extends BaseAsyncSequence<T> {
|
|
readonly #array: ReadonlyArray<MaybePromiseLike<T>>;
|
|
|
|
constructor(array: ReadonlyArray<MaybePromiseLike<T>>) {
|
|
super();
|
|
|
|
this.#array = array;
|
|
}
|
|
|
|
override async nonEnumeratedCount() {
|
|
return this.#array.length;
|
|
}
|
|
|
|
override async *iterator() {
|
|
yield* this.#array;
|
|
}
|
|
}
|
|
|
|
export class WrappedArrayLikeAsync<T> extends BaseAsyncSequence<T> {
|
|
readonly #arrayLike: ArrayLike<MaybePromiseLike<T>>;
|
|
|
|
constructor(arrayLike: ArrayLike<MaybePromiseLike<T>>) {
|
|
super();
|
|
|
|
this.#arrayLike = arrayLike;
|
|
}
|
|
|
|
override async nonEnumeratedCount() {
|
|
return this.#arrayLike.length;
|
|
}
|
|
|
|
override async *iterator() {
|
|
for (let i = 0; i < this.#arrayLike.length; i++) {
|
|
yield this.#arrayLike[i];
|
|
}
|
|
}
|
|
}
|
|
|
|
export class WrappedAsyncIterable<T> extends BaseAsyncSequence<T> {
|
|
readonly #iterable: AsyncIterable<MaybePromiseLike<T>>;
|
|
|
|
constructor(iterable: AsyncIterable<MaybePromiseLike<T>>) {
|
|
super();
|
|
|
|
this.#iterable = iterable;
|
|
}
|
|
|
|
override async *iterator() {
|
|
yield* this.#iterable;
|
|
}
|
|
}
|
|
|
|
export class GeneratorAsyncSequence<T> extends BaseAsyncSequence<T> {
|
|
readonly #generator: () => MaybeAsyncGenerator<MaybePromiseLike<T>>;
|
|
|
|
constructor(generator: () => MaybeAsyncGenerator<MaybePromiseLike<T>>) {
|
|
super();
|
|
|
|
this.#generator = generator;
|
|
}
|
|
|
|
override async *iterator() {
|
|
yield* this.#generator();
|
|
}
|
|
}
|
|
|
|
export class FunctionAsyncSequence<T> extends BaseAsyncSequence<T> {
|
|
readonly #f: () => MaybePromiseLike<T>;
|
|
|
|
constructor(f: () => MaybePromiseLike<T>) {
|
|
super();
|
|
|
|
this.#f = f;
|
|
}
|
|
|
|
override async nonEnumeratedCount() {
|
|
return Infinity;
|
|
}
|
|
|
|
override async *iterator() {
|
|
while (true) {
|
|
yield await this.#f();
|
|
}
|
|
}
|
|
}
|
|
|
|
export class WrappedSequence<T> extends BaseAsyncSequence<T> {
|
|
readonly #sequence: Sequence<MaybePromiseLike<T>>;
|
|
|
|
constructor(sequence: Sequence<MaybePromiseLike<T>>) {
|
|
super();
|
|
|
|
this.#sequence = sequence;
|
|
}
|
|
|
|
override async nonEnumeratedCount() {
|
|
return this.#sequence.nonEnumeratedCount();
|
|
}
|
|
|
|
override async fastCount() {
|
|
return this.#sequence.fastCount();
|
|
}
|
|
|
|
override async maxCount() {
|
|
return this.#sequence.maxCount();
|
|
}
|
|
|
|
override async *iterator() {
|
|
yield* this.#sequence;
|
|
}
|
|
}
|
|
|
|
export class ConcatAsyncSequence<T> extends BaseAsyncSequence<T> {
|
|
readonly #sequences: Iterable<AsyncSequence<T>>;
|
|
|
|
constructor(sequences: Iterable<AsyncSequence<T>>) {
|
|
super();
|
|
|
|
this.#sequences = sequences;
|
|
}
|
|
|
|
override async nonEnumeratedCount() {
|
|
let n = 0;
|
|
|
|
for (const sequence of this.#sequences) {
|
|
const m = await sequence.nonEnumeratedCount();
|
|
|
|
if (m < 0) {
|
|
return -1;
|
|
}
|
|
|
|
n += m;
|
|
}
|
|
|
|
return n;
|
|
}
|
|
|
|
override async *iterator() {
|
|
for (const sequence of this.#sequences) {
|
|
yield* sequence;
|
|
}
|
|
}
|
|
}
|
|
|
|
class DistinctAsyncSequence<T> extends BaseAsyncSequence<T> {
|
|
readonly #sequence: AsyncSequence<T>;
|
|
readonly #equater: MaybeAsyncEqualityComparisonOrComparer<T> | undefined;
|
|
|
|
constructor(sequence: AsyncSequence<T>, equater?: MaybeAsyncEqualityComparisonOrComparer<T>) {
|
|
super();
|
|
|
|
this.#sequence = sequence;
|
|
this.#equater = equater;
|
|
}
|
|
|
|
override async *iterator() {
|
|
const set = createAsyncEqualitySet(this.#equater);
|
|
|
|
for await (const obj of this.#sequence) {
|
|
if (await set.add(obj)) {
|
|
yield obj;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
class DistinctByAsyncSequence<T, U> extends BaseAsyncSequence<T> {
|
|
readonly #sequence: AsyncSequence<T>;
|
|
readonly #selector: MaybeAsyncConverter<T, U>;
|
|
readonly #equater: MaybeAsyncEqualityComparisonOrComparer<U> | undefined;
|
|
|
|
constructor(sequence: AsyncSequence<T>, selector: MaybeAsyncConverter<T, U>, equater?: MaybeAsyncEqualityComparisonOrComparer<U>) {
|
|
super();
|
|
|
|
this.#sequence = sequence;
|
|
this.#selector = selector;
|
|
this.#equater = equater;
|
|
}
|
|
|
|
override async *iterator() {
|
|
const set = createAsyncEqualitySet(this.#equater);
|
|
|
|
for await (const obj of this.#sequence) {
|
|
if (await set.add(await this.#selector(obj))) {
|
|
yield obj;
|
|
}
|
|
}
|
|
|
|
set.clear();
|
|
}
|
|
}
|
|
|
|
class WhereAsyncSequence<TElement, TFiltered extends TElement> extends BaseAsyncSequence<TFiltered> {
|
|
readonly #sequence: AsyncSequence<TElement>;
|
|
readonly #predicate: MaybeAsyncTypePredicate<TElement, TFiltered>;
|
|
|
|
constructor(sequence: AsyncSequence<TElement>, predicate: MaybeAsyncTypePredicate<TElement, TFiltered>) {
|
|
super();
|
|
|
|
this.#sequence = sequence;
|
|
this.#predicate = predicate;
|
|
}
|
|
|
|
override async *iterator() {
|
|
for await (const obj of this.#sequence) {
|
|
if (await this.#predicate(obj)) {
|
|
yield obj as TFiltered;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
class SelectManyAsyncSequence<T, U> extends BaseAsyncSequence<U> {
|
|
readonly #sequence: AsyncSequence<T>;
|
|
readonly #converter: MaybeAsyncConverter<T, MaybeAsyncIterable<U>>;
|
|
|
|
constructor(sequence: AsyncSequence<T>, converter: MaybeAsyncConverter<T, MaybeAsyncIterable<U>>) {
|
|
super();
|
|
|
|
this.#sequence = sequence;
|
|
this.#converter = converter;
|
|
}
|
|
|
|
override async *iterator() {
|
|
for await (const obj of this.#sequence) {
|
|
yield* await this.#converter(obj);
|
|
}
|
|
}
|
|
}
|
|
|
|
class IndexedAsyncSequence<T> extends BaseAsyncSequence<[number, T]> {
|
|
readonly #sequence: AsyncSequence<T>;
|
|
|
|
constructor(sequence: AsyncSequence<T>) {
|
|
super();
|
|
|
|
this.#sequence = sequence;
|
|
}
|
|
|
|
override async *iterator() {
|
|
let i = 0;
|
|
|
|
for await (const obj of this.#sequence) {
|
|
yield [i++, obj] as [number, T];
|
|
}
|
|
}
|
|
}
|
|
|
|
class SelectAsyncSequence<T, U> extends BaseAsyncSequence<U> {
|
|
readonly #sequence: AsyncSequence<T>;
|
|
readonly #converter: MaybeAsyncConverter<T, U>;
|
|
|
|
constructor(sequence: AsyncSequence<T>, converter: MaybeAsyncConverter<T, U>) {
|
|
super();
|
|
|
|
this.#sequence = sequence;
|
|
this.#converter = converter;
|
|
}
|
|
|
|
override async nonEnumeratedCount() {
|
|
return await this.#sequence.nonEnumeratedCount();
|
|
}
|
|
|
|
override async *iterator() {
|
|
for await (const obj of this.#sequence) {
|
|
yield await this.#converter(obj);
|
|
}
|
|
}
|
|
}
|
|
|
|
class SkipWhileAsyncSequence<T> extends BaseAsyncSequence<T> {
|
|
readonly #sequence: AsyncSequence<T>;
|
|
readonly #predicate: MaybeAsyncAnyPredicate<T>;
|
|
|
|
constructor(sequence: AsyncSequence<T>, predicate: MaybeAsyncAnyPredicate<T>) {
|
|
super();
|
|
|
|
this.#sequence = sequence;
|
|
this.#predicate = predicate;
|
|
}
|
|
|
|
override async *iterator() {
|
|
const iterator = this.#sequence.iterator();
|
|
|
|
while (true) {
|
|
const next = await iterator.next();
|
|
|
|
if (next.done) {
|
|
return;
|
|
}
|
|
|
|
if (await this.#predicate(next.value)) {
|
|
continue;
|
|
}
|
|
|
|
yield next.value;
|
|
break;
|
|
}
|
|
|
|
yield* asAsyncIterable(iterator);
|
|
}
|
|
}
|
|
|
|
class SkipLastAsyncSequence<T> extends BaseAsyncSequence<T> {
|
|
readonly #sequence: AsyncSequence<T>;
|
|
readonly #n: number;
|
|
|
|
constructor(sequence: AsyncSequence<T>, n: number) {
|
|
super();
|
|
|
|
this.#sequence = sequence;
|
|
this.#n = n;
|
|
}
|
|
|
|
override async nonEnumeratedCount() {
|
|
const n = await this.#sequence.nonEnumeratedCount();
|
|
return n < 0 ? -1 : Math.max(0, n - this.#n);
|
|
}
|
|
|
|
override async *iterator() {
|
|
const iterator = this.#sequence.iterator();
|
|
const buffer = new Array<T>(this.#n); // n > 0
|
|
let i = 0;
|
|
|
|
do {
|
|
const next = await iterator.next();
|
|
|
|
if (next.done) {
|
|
return;
|
|
}
|
|
|
|
buffer[i++] = next.value;
|
|
} while (i < this.#n);
|
|
|
|
i = 0;
|
|
|
|
for await (const obj of asAsyncIterable(iterator)) {
|
|
yield buffer[i];
|
|
buffer[i] = obj;
|
|
i = (i + 1) % this.#n;
|
|
}
|
|
}
|
|
}
|
|
|
|
class SkipAsyncSequence<T> extends BaseAsyncSequence<T> {
|
|
readonly #sequence: AsyncSequence<T>;
|
|
readonly #n: number;
|
|
|
|
constructor(sequence: AsyncSequence<T>, n: number) {
|
|
super();
|
|
|
|
this.#sequence = sequence;
|
|
this.#n = n;
|
|
}
|
|
|
|
override async nonEnumeratedCount() {
|
|
const n = await this.#sequence.nonEnumeratedCount();
|
|
return n < 0 ? -1 : Math.max(0, n - this.#n);
|
|
}
|
|
|
|
override async *iterator() {
|
|
const iterator = this.#sequence.iterator();
|
|
let i = 0;
|
|
|
|
do {
|
|
if ((await iterator.next()).done) {
|
|
return;
|
|
}
|
|
|
|
i++;
|
|
} while (i < this.#n);
|
|
|
|
yield* asAsyncIterable(iterator);
|
|
}
|
|
}
|
|
|
|
class TakeWhileAsyncSequence<T> extends BaseAsyncSequence<T> {
|
|
readonly #sequence: AsyncSequence<T>;
|
|
readonly #predicate: MaybeAsyncAnyPredicate<T>;
|
|
|
|
constructor(sequence: AsyncSequence<T>, predicate: MaybeAsyncAnyPredicate<T>) {
|
|
super();
|
|
|
|
this.#sequence = sequence;
|
|
this.#predicate = predicate;
|
|
}
|
|
|
|
override async *iterator() {
|
|
for await (const obj of this.#sequence) {
|
|
if (!await this.#predicate(obj)) {
|
|
return;
|
|
}
|
|
|
|
yield obj;
|
|
}
|
|
}
|
|
}
|
|
|
|
class TakeLastAsyncSequence<T> extends BaseAsyncSequence<T> {
|
|
readonly #sequence: AsyncSequence<T>;
|
|
readonly #n: number;
|
|
|
|
constructor(sequence: AsyncSequence<T>, n: number) {
|
|
super();
|
|
|
|
this.#sequence = sequence;
|
|
this.#n = n;
|
|
}
|
|
|
|
override async nonEnumeratedCount() {
|
|
const n = await this.#sequence.nonEnumeratedCount();
|
|
return n < 0 ? -1 : Math.min(this.#n, n);
|
|
}
|
|
|
|
override async *iterator() {
|
|
const queue = createQueue<T>(this.#n);
|
|
|
|
for await (const obj of this.#sequence) {
|
|
queue.enqueue(obj);
|
|
}
|
|
|
|
yield* queue;
|
|
}
|
|
}
|
|
|
|
class TakeAsyncSequence<T> extends BaseAsyncSequence<T> {
|
|
readonly #sequence: AsyncSequence<T>;
|
|
readonly #n: number;
|
|
|
|
constructor(sequence: AsyncSequence<T>, n: number) {
|
|
super();
|
|
|
|
this.#sequence = sequence;
|
|
this.#n = n;
|
|
}
|
|
|
|
override async nonEnumeratedCount() {
|
|
const n = await this.#sequence.nonEnumeratedCount();
|
|
return n < 0 ? -1 : Math.min(this.#n, n);
|
|
}
|
|
|
|
override async *iterator() {
|
|
const iterator = this.#sequence.iterator();
|
|
let i = this.#n;
|
|
|
|
while (i > 0) {
|
|
const next = await iterator.next();
|
|
|
|
if (next.done) {
|
|
return;
|
|
}
|
|
|
|
yield next.value;
|
|
i--;
|
|
}
|
|
}
|
|
}
|
|
|
|
class OrderAsyncSequence<T> extends BaseOrderedAsyncSequence<T> {
|
|
constructor(sequence: AsyncSequence<T>, descending: boolean, sorter?: MaybeAsyncComparisonOrComparer<T>) {
|
|
super(sequence, sorter, descending);
|
|
}
|
|
}
|
|
|
|
class OrderByAsyncSequence<T, U> extends BaseOrderedAsyncSequence<T> {
|
|
constructor(sequence: AsyncSequence<T>, descending: boolean, selector: MaybeAsyncConverter<T, U>, sorter?: MaybeAsyncComparisonOrComparer<U>) {
|
|
super(sequence, createAsyncComparerUsing(selector, sorter), descending);
|
|
}
|
|
}
|
|
|
|
class ThenOrderAsyncSequence<T> extends BaseOrderedAsyncSequence<T> {
|
|
constructor(sequence: OrderedAsyncSequence<T>, descending: boolean, sorter?: MaybeAsyncComparisonOrComparer<T>) {
|
|
super(sequence, combineAsyncComparers([sequence.comparer, sorter]), descending);
|
|
}
|
|
}
|
|
|
|
class ThenOrderByAsyncSequence<T, U> extends BaseOrderedAsyncSequence<T> {
|
|
constructor(sequence: OrderedAsyncSequence<T>, descending: boolean, selector: MaybeAsyncConverter<T, U>, sorter?: MaybeAsyncComparisonOrComparer<U>) {
|
|
super(sequence, combineAsyncComparers([sequence.comparer, createAsyncComparerUsing(selector, sorter)]), descending);
|
|
}
|
|
}
|
|
|
|
class AppendAsyncSequence<T> extends BaseAsyncSequence<T> {
|
|
readonly #sequence: AsyncSequence<T>;
|
|
readonly #obj: T;
|
|
|
|
constructor(sequence: AsyncSequence<T>, obj: T) {
|
|
super();
|
|
|
|
this.#sequence = sequence;
|
|
this.#obj = obj;
|
|
}
|
|
|
|
override async nonEnumeratedCount() {
|
|
const n = await this.#sequence.nonEnumeratedCount();
|
|
return n < 0 ? -1 : n + 1;
|
|
}
|
|
|
|
override async maxCount() {
|
|
return await this.#sequence.maxCount() + 1;
|
|
}
|
|
|
|
override async *iterator() {
|
|
yield* this.#sequence;
|
|
yield this.#obj;
|
|
}
|
|
}
|
|
|
|
class PrependAsyncSequence<T> extends BaseAsyncSequence<T> {
|
|
readonly #sequence: AsyncSequence<T>;
|
|
readonly #obj: T;
|
|
|
|
constructor(sequence: AsyncSequence<T>, obj: T) {
|
|
super();
|
|
|
|
this.#sequence = sequence;
|
|
this.#obj = obj;
|
|
}
|
|
|
|
override async nonEnumeratedCount() {
|
|
const n = await this.#sequence.nonEnumeratedCount();
|
|
return n < 0 ? -1 : n + 1;
|
|
}
|
|
|
|
override async maxCount() {
|
|
return await this.#sequence.maxCount() + 1;
|
|
}
|
|
|
|
override async *iterator() {
|
|
yield this.#obj;
|
|
yield* this.#sequence;
|
|
}
|
|
}
|
|
|
|
class PeekAsyncSequence<T> extends BaseAsyncSequence<T> {
|
|
readonly #sequence: AsyncSequence<T>;
|
|
readonly #action: MaybeAsyncAction<T>;
|
|
|
|
constructor(sequence: AsyncSequence<T>, action: MaybeAsyncAction<T>) {
|
|
super();
|
|
|
|
this.#sequence = sequence;
|
|
this.#action = action;
|
|
}
|
|
|
|
override async *iterator() {
|
|
for await (const obj of this.#sequence) {
|
|
await this.#action(obj);
|
|
yield obj;
|
|
}
|
|
}
|
|
}
|
|
|
|
class ZippedAsyncSequence<T, U> extends BaseAsyncSequence<[T, U]> {
|
|
readonly #first: AsyncSequence<T>;
|
|
readonly #second: AsyncSequence<U>;
|
|
|
|
constructor(first: AsyncSequence<T>, second: AsyncSequence<U>) {
|
|
super();
|
|
|
|
this.#first = first;
|
|
this.#second = second;
|
|
}
|
|
|
|
override async nonEnumeratedCount() {
|
|
const first = await this.#first.nonEnumeratedCount();
|
|
const second = await this.#second.nonEnumeratedCount();
|
|
|
|
return first < 0 || second < 0 ? -1 : Math.min(first, second);
|
|
}
|
|
|
|
override async *iterator() {
|
|
const firstIterator = this.#first.iterator();
|
|
const secondIterator = this.#second.iterator();
|
|
|
|
while (true) {
|
|
const firstNext = await firstIterator.next();
|
|
const secondNext = await secondIterator.next();
|
|
|
|
if (firstNext.done || secondNext.done) {
|
|
return;
|
|
}
|
|
|
|
yield [firstNext.value, secondNext.value] as [T, U];
|
|
}
|
|
}
|
|
}
|
|
|
|
export class CartesianProductAsyncSequence<T, U> extends BaseAsyncSequence<[T, U]> {
|
|
readonly #first: AsyncSequence<T>;
|
|
readonly #second: AsyncSequence<U>;
|
|
|
|
constructor(first: AsyncSequence<T>, second: AsyncSequence<U>) {
|
|
super();
|
|
|
|
this.#first = first;
|
|
this.#second = second;
|
|
}
|
|
|
|
override async nonEnumeratedCount() {
|
|
const n1 = await this.#first.nonEnumeratedCount();
|
|
|
|
if (n1 < 0) {
|
|
return -1;
|
|
}
|
|
|
|
const n2 = await this.#second.nonEnumeratedCount();
|
|
|
|
if (n2 < 0) {
|
|
return -1;
|
|
}
|
|
|
|
return n1 * n2;
|
|
}
|
|
|
|
override async maxCount() {
|
|
return await this.#first.maxCount() * await this.#second.maxCount();
|
|
}
|
|
|
|
override async *iterator() {
|
|
for await (const firstObj of this.#first) {
|
|
for await (const secondObj of this.#second) {
|
|
yield [firstObj, secondObj] as [T, U];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
class UnionAsyncSequence<T> extends BaseAsyncSequence<T> {
|
|
readonly #first: AsyncSequence<T>;
|
|
readonly #second: AsyncSequence<T>;
|
|
readonly #equater: MaybeAsyncEqualityComparisonOrComparer<T> | undefined;
|
|
|
|
constructor(first: AsyncSequence<T>, second: AsyncSequence<T>, equater?: MaybeAsyncEqualityComparisonOrComparer<T>) {
|
|
super();
|
|
|
|
this.#first = first;
|
|
this.#second = second;
|
|
this.#equater = equater;
|
|
}
|
|
|
|
override async *iterator() {
|
|
const set = createAsyncEqualitySet(this.#equater);
|
|
|
|
for await (const obj of this.#first) {
|
|
if (await set.add(obj)) {
|
|
yield obj;
|
|
}
|
|
}
|
|
|
|
for await (const obj of this.#second) {
|
|
if (await set.add(obj)) {
|
|
yield obj;
|
|
}
|
|
}
|
|
|
|
set.clear();
|
|
}
|
|
}
|
|
|
|
class UnionByAsyncSequence<T, U> extends BaseAsyncSequence<T> {
|
|
readonly #first: AsyncSequence<T>;
|
|
readonly #second: AsyncSequence<T>;
|
|
readonly #selector: MaybeAsyncConverter<T, U>;
|
|
readonly #equater: MaybeAsyncEqualityComparisonOrComparer<U> | undefined;
|
|
|
|
constructor(first: AsyncSequence<T>, second: AsyncSequence<T>, selector: MaybeAsyncConverter<T, U>, equater?: MaybeAsyncEqualityComparisonOrComparer<U>) {
|
|
super();
|
|
|
|
this.#first = first;
|
|
this.#second = second;
|
|
this.#selector = selector;
|
|
this.#equater = equater;
|
|
}
|
|
|
|
override async *iterator() {
|
|
const set = createAsyncEqualitySet(this.#equater);
|
|
|
|
for await (const obj of this.#first) {
|
|
if (await set.add(await this.#selector(obj))) {
|
|
yield obj;
|
|
}
|
|
}
|
|
|
|
for await (const obj of this.#second) {
|
|
if (await set.add(await this.#selector(obj))) {
|
|
yield obj;
|
|
}
|
|
}
|
|
|
|
set.clear();
|
|
}
|
|
}
|
|
|
|
class ExceptAsyncSequence<T> extends BaseAsyncSequence<T> {
|
|
readonly #first: AsyncSequence<T>;
|
|
readonly #second: AsyncSequence<T>;
|
|
readonly #equater: MaybeAsyncEqualityComparisonOrComparer<T> | undefined;
|
|
|
|
constructor(first: AsyncSequence<T>, second: AsyncSequence<T>, equater?: MaybeAsyncEqualityComparisonOrComparer<T>) {
|
|
super();
|
|
|
|
this.#first = first;
|
|
this.#second = second;
|
|
this.#equater = equater;
|
|
}
|
|
|
|
override async *iterator() {
|
|
const set = createAsyncEqualitySet(this.#equater);
|
|
|
|
for await (const obj of this.#second) {
|
|
await set.add(obj);
|
|
}
|
|
|
|
for await (const obj of this.#first) {
|
|
if (await set.add(obj)) {
|
|
yield obj;
|
|
}
|
|
}
|
|
|
|
set.clear();
|
|
}
|
|
}
|
|
|
|
class ExceptByAsyncSequence<T, U> extends BaseAsyncSequence<T> {
|
|
readonly #first: AsyncSequence<T>;
|
|
readonly #second: AsyncSequence<T>;
|
|
readonly #selector: MaybeAsyncConverter<T, U>;
|
|
readonly #equater: MaybeAsyncEqualityComparisonOrComparer<U> | undefined;
|
|
|
|
constructor(first: AsyncSequence<T>, second: AsyncSequence<T>, selector: MaybeAsyncConverter<T, U>, equater?: MaybeAsyncEqualityComparisonOrComparer<U>) {
|
|
super();
|
|
|
|
this.#first = first;
|
|
this.#second = second;
|
|
this.#selector = selector;
|
|
this.#equater = equater;
|
|
}
|
|
|
|
override async *iterator() {
|
|
const set = createAsyncEqualitySet(this.#equater);
|
|
|
|
for await (const obj of this.#second) {
|
|
await set.add(await this.#selector(obj));
|
|
}
|
|
|
|
for await (const obj of this.#first) {
|
|
if (await set.add(await this.#selector(obj))) {
|
|
yield obj;
|
|
}
|
|
}
|
|
|
|
set.clear();
|
|
}
|
|
}
|
|
|
|
class IntersectAsyncSequence<T> extends BaseAsyncSequence<T> {
|
|
readonly #first: AsyncSequence<T>;
|
|
readonly #second: AsyncSequence<T>;
|
|
readonly #equater: MaybeAsyncEqualityComparisonOrComparer<T> | undefined;
|
|
|
|
constructor(first: AsyncSequence<T>, second: AsyncSequence<T>, equater?: MaybeAsyncEqualityComparisonOrComparer<T>) {
|
|
super();
|
|
|
|
this.#first = first;
|
|
this.#second = second;
|
|
this.#equater = equater;
|
|
}
|
|
|
|
override async *iterator() {
|
|
const set = createAsyncEqualitySet(this.#equater);
|
|
|
|
for await (const obj of this.#second) {
|
|
await set.add(obj);
|
|
}
|
|
|
|
for await (const obj of this.#first) {
|
|
if (await set.remove(obj)) {
|
|
yield obj;
|
|
}
|
|
}
|
|
|
|
set.clear();
|
|
}
|
|
}
|
|
|
|
class IntersectByAsyncSequence<T, U> extends BaseAsyncSequence<T> {
|
|
readonly #first: AsyncSequence<T>;
|
|
readonly #second: AsyncSequence<T>;
|
|
readonly #selector: MaybeAsyncConverter<T, U>;
|
|
readonly #equater: MaybeAsyncEqualityComparisonOrComparer<U> | undefined;
|
|
|
|
constructor(first: AsyncSequence<T>, second: AsyncSequence<T>, selector: MaybeAsyncConverter<T, U>, equater?: MaybeAsyncEqualityComparisonOrComparer<U>) {
|
|
super();
|
|
|
|
this.#first = first;
|
|
this.#second = second;
|
|
this.#selector = selector;
|
|
this.#equater = equater;
|
|
}
|
|
|
|
override async *iterator() {
|
|
const set = createAsyncEqualitySet(this.#equater);
|
|
|
|
for await (const obj of this.#second) {
|
|
await set.add(await this.#selector(obj));
|
|
}
|
|
|
|
for await (const obj of this.#first) {
|
|
if (await set.remove(await this.#selector(obj))) {
|
|
yield obj;
|
|
}
|
|
}
|
|
|
|
set.clear();
|
|
}
|
|
}
|
|
|
|
class ReversedAsyncSequence<T> extends BaseAsyncSequence<T> {
|
|
readonly #sequence: AsyncSequence<T>;
|
|
|
|
constructor(sequence: AsyncSequence<T>) {
|
|
super();
|
|
|
|
this.#sequence = sequence;
|
|
}
|
|
|
|
override async *iterator() {
|
|
const buffer: T[] = [];
|
|
|
|
for await (const obj of this.#sequence) {
|
|
buffer.push(obj);
|
|
}
|
|
|
|
for (let i = buffer.length - 1; i >= 0; i--) {
|
|
yield buffer[i];
|
|
}
|
|
}
|
|
}
|
|
|
|
class GroupByAsyncSequence<TElement, TKey, TResult> extends BaseAsyncSequence<GroupedAsyncSequence<TKey, TResult>> {
|
|
readonly #sequence: AsyncSequence<TElement>;
|
|
readonly #keySelector: MaybeAsyncConverter<TElement, TKey>;
|
|
readonly #elementSelector: MaybeAsyncConverter<TElement, TResult>;
|
|
readonly #keyComparer: MaybeAsyncEqualityComparisonOrComparer<TKey> | undefined;
|
|
|
|
constructor(sequence: AsyncSequence<TElement>, keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector?: MaybeAsyncConverter<TElement, TResult>, keyComparer?: MaybeAsyncEqualityComparisonOrComparer<TKey>) {
|
|
super();
|
|
|
|
this.#sequence = sequence;
|
|
this.#keySelector = keySelector;
|
|
this.#elementSelector = elementSelector ?? identity as MaybeAsyncConverter<TElement, TResult>;
|
|
this.#keyComparer = keyComparer;
|
|
}
|
|
|
|
override async *iterator() {
|
|
const groupings = createAsyncEqualityMap<TKey, TResult[]>(this.#keyComparer);
|
|
|
|
for await (const obj of this.#sequence) {
|
|
const key = await this.#keySelector(obj);
|
|
const value = await this.#elementSelector(obj);
|
|
|
|
const grouping = await groupings.get(key);
|
|
|
|
if (grouping) {
|
|
grouping.push(value);
|
|
} else {
|
|
await groupings.set(key, [value]);
|
|
}
|
|
}
|
|
|
|
for (const entry of groupings) {
|
|
yield new GroupedAsyncSequenceImpl(entry[0], array(entry[1]));
|
|
}
|
|
}
|
|
}
|
|
|
|
class ChunkedAsyncSequence<T> extends BaseAsyncSequence<AsyncSequence<T>> {
|
|
readonly #sequence: AsyncSequence<T>;
|
|
readonly #size: number;
|
|
|
|
constructor(sequence: AsyncSequence<T>, size: number) {
|
|
super();
|
|
|
|
this.#sequence = sequence;
|
|
this.#size = size;
|
|
}
|
|
|
|
override async nonEnumeratedCount() {
|
|
const n = await this.#sequence.nonEnumeratedCount();
|
|
return n < 0 ? -1 : Math.ceil(n / this.#size);
|
|
}
|
|
|
|
override async *iterator() {
|
|
let chunk: T[] = [];
|
|
|
|
for await (const obj of this.#sequence) {
|
|
chunk.push(obj);
|
|
|
|
if (chunk.length === this.#size) {
|
|
yield array(chunk);
|
|
chunk = [];
|
|
}
|
|
}
|
|
|
|
if (chunk.length > 0) {
|
|
yield array(chunk);
|
|
}
|
|
}
|
|
}
|
|
|
|
class JoinAsyncSequence<TOuter, TInner, TKey, TResult> extends BaseAsyncSequence<TResult> {
|
|
readonly #first: AsyncSequence<TOuter>;
|
|
readonly #second: AsyncSequence<TInner>;
|
|
readonly #firstKeySelector: MaybeAsyncConverter<TOuter, TKey>;
|
|
readonly #secondKeySelector: MaybeAsyncConverter<TInner, TKey>;
|
|
readonly #resultSelector: MaybeAsyncBiConverter<TOuter, TInner, TResult>;
|
|
readonly #keyComparer: AsyncEqualityComparer<TKey>;
|
|
|
|
constructor(first: AsyncSequence<TOuter>, second: AsyncSequence<TInner>, firstKeySelector: MaybeAsyncConverter<TOuter, TKey>, secondKeySelector: MaybeAsyncConverter<TInner, TKey>, resultSelector?: MaybeAsyncBiConverter<TOuter, TInner, TResult>, keyComparer?: MaybeAsyncEqualityComparisonOrComparer<TKey>) {
|
|
super();
|
|
|
|
this.#first = first;
|
|
this.#second = second;
|
|
this.#firstKeySelector = firstKeySelector;
|
|
this.#secondKeySelector = secondKeySelector;
|
|
this.#resultSelector = resultSelector ?? identity as MaybeAsyncBiConverter<TOuter, TInner, TResult>;
|
|
this.#keyComparer = keyComparer ? asAsyncEqualityComparer(keyComparer) : defaultAsyncEqualityComparer;
|
|
}
|
|
|
|
override async *iterator() {
|
|
for await (const firstObj of this.#first) {
|
|
const firstKey = await this.#firstKeySelector(firstObj);
|
|
|
|
for await (const secondObj of this.#second) {
|
|
const secondKey = await this.#secondKeySelector(secondObj);
|
|
|
|
if (await this.#keyComparer.equals(firstKey, secondKey)) {
|
|
yield await this.#resultSelector(firstObj, secondObj);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
class GroupJoinAsyncSequence<TOuter, TInner, TKey, TResult> extends BaseAsyncSequence<TResult> {
|
|
readonly #first: AsyncSequence<TOuter>;
|
|
readonly #second: AsyncSequence<TInner>;
|
|
readonly #firstKeySelector: MaybeAsyncConverter<TOuter, TKey>;
|
|
readonly #secondKeySelector: MaybeAsyncConverter<TInner, TKey>;
|
|
readonly #resultSelector: MaybeAsyncBiConverter<TOuter, MaybeAsyncIterable<TInner>, TResult>;
|
|
readonly #keyComparer: AsyncEqualityComparer<TKey>;
|
|
|
|
constructor(first: AsyncSequence<TOuter>, second: AsyncSequence<TInner>, firstKeySelector: MaybeAsyncConverter<TOuter, TKey>, secondKeySelector: MaybeAsyncConverter<TInner, TKey>, resultSelector?: MaybeAsyncBiConverter<TOuter, MaybeAsyncIterable<TInner>, TResult>, keyComparer?: MaybeAsyncEqualityComparisonOrComparer<TKey>) {
|
|
super();
|
|
|
|
this.#first = first;
|
|
this.#second = second;
|
|
this.#firstKeySelector = firstKeySelector;
|
|
this.#secondKeySelector = secondKeySelector;
|
|
this.#resultSelector = resultSelector ?? GroupJoinAsyncSequence.#defaultResultSelector as MaybeAsyncBiConverter<TOuter, MaybeAsyncIterable<TInner>, TResult>;
|
|
this.#keyComparer = keyComparer ? asAsyncEqualityComparer(keyComparer) : defaultAsyncEqualityComparer;
|
|
}
|
|
|
|
static #defaultResultSelector<TOuter, TInner>(first: TOuter, second: AsyncSequence<TInner>) {
|
|
return new GroupedAsyncSequenceImpl(first, second);
|
|
}
|
|
|
|
override async *iterator() {
|
|
for await (const firstObj of this.#first) {
|
|
const firstKey = await this.#firstKeySelector(firstObj);
|
|
const secondObjs: TInner[] = [];
|
|
|
|
for await (const secondObj of this.#second) {
|
|
const secondKey = await this.#secondKeySelector(secondObj);
|
|
|
|
if (await this.#keyComparer.equals(firstKey, secondKey)) {
|
|
secondObjs.push(secondObj);
|
|
}
|
|
}
|
|
|
|
yield this.#resultSelector(firstObj, array(secondObjs));
|
|
}
|
|
}
|
|
}
|
|
|
|
class RemoveAsyncSequence<T> extends BaseAsyncSequence<T> {
|
|
readonly #sequence: AsyncSequence<T>;
|
|
readonly #obj: T;
|
|
readonly #all: boolean;
|
|
readonly #equater: AsyncEqualityComparer<T>;
|
|
|
|
constructor(sequence: AsyncSequence<T>, obj: T, all?: boolean, equater?: MaybeAsyncEqualityComparisonOrComparer<T>) {
|
|
super();
|
|
|
|
this.#sequence = sequence;
|
|
this.#obj = obj;
|
|
this.#all = all ?? false;
|
|
this.#equater = equater ? asAsyncEqualityComparer(equater) : defaultAsyncEqualityComparer;
|
|
}
|
|
|
|
override async *iterator() {
|
|
let gotOne = false;
|
|
|
|
for await (const obj of this.#sequence) {
|
|
if (await this.#equater.equals(this.#obj, obj)) {
|
|
if (this.#all) {
|
|
continue;
|
|
}
|
|
|
|
if (!gotOne) {
|
|
gotOne = true;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
yield obj;
|
|
}
|
|
}
|
|
}
|
|
|
|
class CacheAsyncSequence<T> extends BaseAsyncSequence<T> {
|
|
readonly #sequence: AsyncSequence<T>;
|
|
#cache: T[] | undefined;
|
|
|
|
constructor(sequence: AsyncSequence<T>) {
|
|
super();
|
|
|
|
this.#sequence = sequence;
|
|
}
|
|
|
|
override async *iterator() {
|
|
if (this.#cache) {
|
|
yield* this.#cache;
|
|
} else {
|
|
const cache = [];
|
|
|
|
for await (const e of this.#sequence) {
|
|
cache.push(e);
|
|
yield e;
|
|
}
|
|
|
|
this.#cache = cache;
|
|
}
|
|
}
|
|
}
|
|
|
|
class PartitionAsyncSequence<T> extends BaseAsyncSequence<AsyncSequence<T>> {
|
|
readonly #sequence: AsyncSequence<T>;
|
|
readonly #equater: MaybeAsyncEqualityComparisonOrComparer<T> | undefined;
|
|
|
|
constructor(sequence: AsyncSequence<T>, equater: MaybeAsyncEqualityComparisonOrComparer<T> | undefined) {
|
|
super();
|
|
|
|
this.#sequence = sequence;
|
|
this.#equater = equater;
|
|
}
|
|
|
|
override async *iterator() {
|
|
const partitions = createAsyncEqualityMap<T, T[]>(this.#equater);
|
|
|
|
for await (const obj of this.#sequence) {
|
|
const partition = await partitions.get(obj);
|
|
|
|
if (partition) {
|
|
partition.push(obj);
|
|
} else {
|
|
await partitions.set(obj, [obj]);
|
|
}
|
|
}
|
|
|
|
for (const partition of partitions.values()) {
|
|
yield array(partition);
|
|
}
|
|
}
|
|
}
|
|
|
|
class PartitionByAsyncSequence<TElement, TBy> extends BaseAsyncSequence<AsyncSequence<TElement>> {
|
|
readonly #sequence: AsyncSequence<TElement>;
|
|
readonly #selector: MaybeAsyncConverter<TElement, TBy>;
|
|
readonly #equater: MaybeAsyncEqualityComparisonOrComparer<TBy> | undefined;
|
|
|
|
constructor(sequence: AsyncSequence<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater: MaybeAsyncEqualityComparisonOrComparer<TBy> | undefined) {
|
|
super();
|
|
|
|
this.#sequence = sequence;
|
|
this.#selector = selector;
|
|
this.#equater = equater;
|
|
}
|
|
|
|
override async *iterator() {
|
|
const partitions = createAsyncEqualityMap<TBy, TElement[]>(this.#equater);
|
|
|
|
for await (const obj of this.#sequence) {
|
|
const key = await this.#selector(obj);
|
|
const partition = await partitions.get(key);
|
|
|
|
if (partition) {
|
|
partition.push(obj);
|
|
} else {
|
|
await partitions.set(key, [obj]);
|
|
}
|
|
}
|
|
|
|
for (const partition of partitions.values()) {
|
|
yield array(partition);
|
|
}
|
|
}
|
|
}
|