hbecher/sequence-js
1
0
Fork 0
Code Activity

add async equality comparer and broaden to comparison or comparer

Browse Source
This commit is contained in:
Hervé BECHER
2025-10-02 00:19:26 +02:00
parent c7a6d6880c
commit 955acc6c96
14 changed files with 426 additions and 250 deletions
Download Patch File Download Diff File Expand all files Collapse all files

156
src/async/impl.ts
View File

@@ -1,8 +1,8 @@
import { Collector } from "../collector/types.js";
import { asAsyncComparer, combineNullableAsyncComparers, createAsyncComparerUsing, defaultAsyncComparer } from "../comparer/async.js";
import { MaybeAsyncComparisonOrComparer, AsyncComparer } from "../comparer/types.js";
import { strictEquals } from "../equality-comparer/sync.js";
import { MaybeAsyncEqualityComparison } from "../equality-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";
@@ -42,31 +42,29 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
return new WhereAsyncSequence<TElement, any>(this, predicate);
}
groupBy<TKey>(keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector?: undefined, keyComparer?: MaybeAsyncEqualityComparison<TKey> | undefined): AsyncSequence<GroupedAsyncSequence<TKey, TElement>>;
groupBy<TKey, TResult>(keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector: MaybeAsyncConverter<TElement, TResult>, keyComparer?: MaybeAsyncEqualityComparison<TKey> | undefined): AsyncSequence<GroupedAsyncSequence<TKey, TResult>>;
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?: MaybeAsyncEqualityComparison<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?: MaybeAsyncEqualityComparison<TKey> | undefined): AsyncSequence<TResult>;
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?: MaybeAsyncEqualityComparison<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?: MaybeAsyncEqualityComparison<TKey> | undefined): AsyncSequence<TResult>;
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?: MaybeAsyncEqualityComparison<TElement>) {
if (!equater) {
equater = strictEquals;
}
async contains(obj: TElement, equater?: MaybeAsyncEqualityComparisonOrComparer<TElement>) {
equater = equater ? asAsyncEqualityComparer(equater) : defaultAsyncEqualityComparer;
for await (const element of this) {
if (await equater(element, obj)) {
if (await equater.equals(element, obj)) {
return true;
}
}
@@ -74,7 +72,7 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
return false;
}
async sequenceEquals(sequence: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEqualityComparison<TElement>) {
async sequenceEquals(sequence: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEqualityComparisonOrComparer<TElement>) {
if (this === sequence) {
return true;
}
@@ -88,9 +86,7 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
return false;
}
if (!equater) {
equater = strictEquals;
}
equater = equater ? asAsyncEqualityComparer(equater) : defaultAsyncEqualityComparer;
const thisIterator = this.iterator();
const thatIterator = that.iterator();
@@ -107,7 +103,7 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
return false;
}
if (!await equater(thisNext.value, thatNext.value)) {
if (!await equater.equals(thisNext.value, thatNext.value)) {
return false;
}
}
@@ -121,7 +117,7 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
return new PrependAsyncSequence<TElement>(this, obj);
}
remove(obj: TElement, all?: boolean, equater?: MaybeAsyncEqualityComparison<TElement>): AsyncSequence<TElement> {
remove(obj: TElement, all?: boolean, equater?: MaybeAsyncEqualityComparisonOrComparer<TElement>): AsyncSequence<TElement> {
return new RemoveAsyncSequence<TElement>(this, obj, all, equater);
}
@@ -518,27 +514,27 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
return new OrderByAsyncSequence<TElement, TBy>(this, true, selector, comparer);
}
partition(equater?: MaybeAsyncEqualityComparison<TElement>): AsyncSequence<AsyncSequence<TElement>> {
partition(equater?: MaybeAsyncEqualityComparisonOrComparer<TElement>): AsyncSequence<AsyncSequence<TElement>> {
return new PartitionAsyncSequence<TElement>(this, equater);
}
partitionBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparison<TBy>): AsyncSequence<AsyncSequence<TElement>> {
partitionBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparisonOrComparer<TBy>): AsyncSequence<AsyncSequence<TElement>> {
return new PartitionByAsyncSequence<TElement, TBy>(this, selector, equater);
}
distinct(equater?: MaybeAsyncEqualityComparison<TElement>): AsyncSequence<TElement> {
distinct(equater?: MaybeAsyncEqualityComparisonOrComparer<TElement>): AsyncSequence<TElement> {
return new DistinctAsyncSequence<TElement>(this, equater);
}
distinctBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparison<TBy>): AsyncSequence<TElement> {
distinctBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparisonOrComparer<TBy>): AsyncSequence<TElement> {
return new DistinctByAsyncSequence<TElement, TBy>(this, selector, equater);
}
union(sequence: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEqualityComparison<TElement>): AsyncSequence<TElement> {
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?: MaybeAsyncEqualityComparison<TBy>): AsyncSequence<TElement> {
unionBy<TBy>(sequence: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparisonOrComparer<TBy>): AsyncSequence<TElement> {
return new UnionByAsyncSequence<TElement, TBy>(this, wrap(sequence), selector, equater);
}
@@ -813,29 +809,29 @@ export class DelegatedAsyncSequence<TElement> extends AsyncSequenceMarker implem
return this.#sequence.where(predicate);
}
groupBy<TKey>(keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector?: undefined, keyComparer?: MaybeAsyncEqualityComparison<TKey> | undefined): AsyncSequence<GroupedAsyncSequence<TKey, TElement>>;
groupBy<TKey, TResult>(keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector: MaybeAsyncConverter<TElement, TResult>, keyComparer?: MaybeAsyncEqualityComparison<TKey> | undefined): AsyncSequence<GroupedAsyncSequence<TKey, TResult>>;
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?: MaybeAsyncEqualityComparison<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?: MaybeAsyncEqualityComparison<TKey> | undefined): AsyncSequence<TResult>;
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?: MaybeAsyncEqualityComparison<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?: MaybeAsyncEqualityComparison<TKey> | undefined): AsyncSequence<TResult>;
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?: MaybeAsyncEqualityComparison<TElement> | undefined): Promise<boolean> {
contains(obj: TElement, equater?: MaybeAsyncEqualityComparisonOrComparer<TElement> | undefined): Promise<boolean> {
return this.#sequence.contains(obj, equater);
}
sequenceEquals(sequence: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEqualityComparison<TElement> | undefined): Promise<boolean> {
sequenceEquals(sequence: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEqualityComparisonOrComparer<TElement> | undefined): Promise<boolean> {
return this.#sequence.sequenceEquals(sequence, equater);
}
@@ -847,7 +843,7 @@ export class DelegatedAsyncSequence<TElement> extends AsyncSequenceMarker implem
return this.#sequence.prepend(obj);
}
remove(obj: TElement, all?: boolean | undefined, equater?: MaybeAsyncEqualityComparison<TElement> | undefined): AsyncSequence<TElement> {
remove(obj: TElement, all?: boolean | undefined, equater?: MaybeAsyncEqualityComparisonOrComparer<TElement> | undefined): AsyncSequence<TElement> {
return this.#sequence.remove(obj, all, equater);
}
@@ -934,43 +930,43 @@ export class DelegatedAsyncSequence<TElement> extends AsyncSequenceMarker implem
return this.#sequence.orderByDescending(selector, comparer);
}
partition(equater?: MaybeAsyncEqualityComparison<TElement> | undefined): AsyncSequence<AsyncSequence<TElement>> {
partition(equater?: MaybeAsyncEqualityComparisonOrComparer<TElement> | undefined): AsyncSequence<AsyncSequence<TElement>> {
return this.#sequence.partition(equater);
}
partitionBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparison<TBy> | undefined): AsyncSequence<AsyncSequence<TElement>> {
partitionBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparisonOrComparer<TBy> | undefined): AsyncSequence<AsyncSequence<TElement>> {
return this.#sequence.partitionBy(selector, equater);
}
distinct(equater?: MaybeAsyncEqualityComparison<TElement> | undefined): AsyncSequence<TElement> {
distinct(equater?: MaybeAsyncEqualityComparisonOrComparer<TElement> | undefined): AsyncSequence<TElement> {
return this.#sequence.distinct(equater);
}
distinctBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparison<TBy> | undefined): AsyncSequence<TElement> {
distinctBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparisonOrComparer<TBy> | undefined): AsyncSequence<TElement> {
return this.#sequence.distinctBy(selector, equater);
}
union(sequence: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEqualityComparison<TElement> | undefined): AsyncSequence<TElement> {
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?: MaybeAsyncEqualityComparison<TBy> | undefined): AsyncSequence<TElement> {
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?: MaybeAsyncEqualityComparison<TElement> | undefined): AsyncSequence<TElement> {
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?: MaybeAsyncEqualityComparison<TBy> | undefined): AsyncSequence<TElement> {
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?: MaybeAsyncEqualityComparison<TElement> | undefined): AsyncSequence<TElement> {
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?: MaybeAsyncEqualityComparison<TBy> | undefined): AsyncSequence<TElement> {
intersectBy<TBy>(sequence: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparisonOrComparer<TBy> | undefined): AsyncSequence<TElement> {
return this.#sequence.intersectBy(wrap(sequence), selector, equater);
}
@@ -1383,9 +1379,9 @@ export class ConcatAsyncSequence<T> extends BaseAsyncSequence<T> {
class DistinctAsyncSequence<T> extends BaseAsyncSequence<T> {
readonly #sequence: AsyncSequence<T>;
readonly #equater: MaybeAsyncEqualityComparison<T> | undefined;
readonly #equater: MaybeAsyncEqualityComparisonOrComparer<T> | undefined;
constructor(sequence: AsyncSequence<T>, equater?: MaybeAsyncEqualityComparison<T>) {
constructor(sequence: AsyncSequence<T>, equater?: MaybeAsyncEqualityComparisonOrComparer<T>) {
super();
this.#sequence = sequence;
@@ -1406,9 +1402,9 @@ class DistinctAsyncSequence<T> extends BaseAsyncSequence<T> {
class DistinctByAsyncSequence<T, U> extends BaseAsyncSequence<T> {
readonly #sequence: AsyncSequence<T>;
readonly #selector: MaybeAsyncConverter<T, U>;
readonly #equater: MaybeAsyncEqualityComparison<U> | undefined;
readonly #equater: MaybeAsyncEqualityComparisonOrComparer<U> | undefined;
constructor(sequence: AsyncSequence<T>, selector: MaybeAsyncConverter<T, U>, equater?: MaybeAsyncEqualityComparison<U>) {
constructor(sequence: AsyncSequence<T>, selector: MaybeAsyncConverter<T, U>, equater?: MaybeAsyncEqualityComparisonOrComparer<U>) {
super();
this.#sequence = sequence;
@@ -1828,9 +1824,9 @@ class ZippedAsyncSequence<T, U> extends BaseAsyncSequence<[T, U]> {
class UnionAsyncSequence<T> extends BaseAsyncSequence<T> {
readonly #first: AsyncSequence<T>;
readonly #second: AsyncSequence<T>;
readonly #equater: MaybeAsyncEqualityComparison<T> | undefined;
readonly #equater: MaybeAsyncEqualityComparisonOrComparer<T> | undefined;
constructor(first: AsyncSequence<T>, second: AsyncSequence<T>, equater?: MaybeAsyncEqualityComparison<T>) {
constructor(first: AsyncSequence<T>, second: AsyncSequence<T>, equater?: MaybeAsyncEqualityComparisonOrComparer<T>) {
super();
this.#first = first;
@@ -1861,9 +1857,9 @@ class UnionByAsyncSequence<T, U> extends BaseAsyncSequence<T> {
readonly #first: AsyncSequence<T>;
readonly #second: AsyncSequence<T>;
readonly #selector: MaybeAsyncConverter<T, U>;
readonly #equater: MaybeAsyncEqualityComparison<U> | undefined;
readonly #equater: MaybeAsyncEqualityComparisonOrComparer<U> | undefined;
constructor(first: AsyncSequence<T>, second: AsyncSequence<T>, selector: MaybeAsyncConverter<T, U>, equater?: MaybeAsyncEqualityComparison<U>) {
constructor(first: AsyncSequence<T>, second: AsyncSequence<T>, selector: MaybeAsyncConverter<T, U>, equater?: MaybeAsyncEqualityComparisonOrComparer<U>) {
super();
this.#first = first;
@@ -1894,9 +1890,9 @@ class UnionByAsyncSequence<T, U> extends BaseAsyncSequence<T> {
class ExceptAsyncSequence<T> extends BaseAsyncSequence<T> {
readonly #first: AsyncSequence<T>;
readonly #second: AsyncSequence<T>;
readonly #equater: MaybeAsyncEqualityComparison<T> | undefined;
readonly #equater: MaybeAsyncEqualityComparisonOrComparer<T> | undefined;
constructor(first: AsyncSequence<T>, second: AsyncSequence<T>, equater?: MaybeAsyncEqualityComparison<T>) {
constructor(first: AsyncSequence<T>, second: AsyncSequence<T>, equater?: MaybeAsyncEqualityComparisonOrComparer<T>) {
super();
this.#first = first;
@@ -1925,9 +1921,9 @@ class ExceptByAsyncSequence<T, U> extends BaseAsyncSequence<T> {
readonly #first: AsyncSequence<T>;
readonly #second: AsyncSequence<T>;
readonly #selector: MaybeAsyncConverter<T, U>;
readonly #equater: MaybeAsyncEqualityComparison<U> | undefined;
readonly #equater: MaybeAsyncEqualityComparisonOrComparer<U> | undefined;
constructor(first: AsyncSequence<T>, second: AsyncSequence<T>, selector: MaybeAsyncConverter<T, U>, equater?: MaybeAsyncEqualityComparison<U>) {
constructor(first: AsyncSequence<T>, second: AsyncSequence<T>, selector: MaybeAsyncConverter<T, U>, equater?: MaybeAsyncEqualityComparisonOrComparer<U>) {
super();
this.#first = first;
@@ -1956,9 +1952,9 @@ class ExceptByAsyncSequence<T, U> extends BaseAsyncSequence<T> {
class IntersectAsyncSequence<T> extends BaseAsyncSequence<T> {
readonly #first: AsyncSequence<T>;
readonly #second: AsyncSequence<T>;
readonly #equater: MaybeAsyncEqualityComparison<T> | undefined;
readonly #equater: MaybeAsyncEqualityComparisonOrComparer<T> | undefined;
constructor(first: AsyncSequence<T>, second: AsyncSequence<T>, equater?: MaybeAsyncEqualityComparison<T>) {
constructor(first: AsyncSequence<T>, second: AsyncSequence<T>, equater?: MaybeAsyncEqualityComparisonOrComparer<T>) {
super();
this.#first = first;
@@ -1987,9 +1983,9 @@ class IntersectByAsyncSequence<T, U> extends BaseAsyncSequence<T> {
readonly #first: AsyncSequence<T>;
readonly #second: AsyncSequence<T>;
readonly #selector: MaybeAsyncConverter<T, U>;
readonly #equater: MaybeAsyncEqualityComparison<U> | undefined;
readonly #equater: MaybeAsyncEqualityComparisonOrComparer<U> | undefined;
constructor(first: AsyncSequence<T>, second: AsyncSequence<T>, selector: MaybeAsyncConverter<T, U>, equater?: MaybeAsyncEqualityComparison<U>) {
constructor(first: AsyncSequence<T>, second: AsyncSequence<T>, selector: MaybeAsyncConverter<T, U>, equater?: MaybeAsyncEqualityComparisonOrComparer<U>) {
super();
this.#first = first;
@@ -2041,9 +2037,9 @@ class GroupByAsyncSequence<TElement, TKey, TResult> extends BaseAsyncSequence<Gr
readonly #sequence: AsyncSequence<TElement>;
readonly #keySelector: MaybeAsyncConverter<TElement, TKey>;
readonly #elementSelector: MaybeAsyncConverter<TElement, TResult>;
readonly #keyComparer: MaybeAsyncEqualityComparison<TKey> | undefined;
readonly #keyComparer: MaybeAsyncEqualityComparisonOrComparer<TKey> | undefined;
constructor(sequence: AsyncSequence<TElement>, keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector?: MaybeAsyncConverter<TElement, TResult>, keyComparer?: MaybeAsyncEqualityComparison<TKey>) {
constructor(sequence: AsyncSequence<TElement>, keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector?: MaybeAsyncConverter<TElement, TResult>, keyComparer?: MaybeAsyncEqualityComparisonOrComparer<TKey>) {
super();
this.#sequence = sequence;
@@ -2114,9 +2110,9 @@ class JoinAsyncSequence<TOuter, TInner, TKey, TResult> extends BaseAsyncSequence
readonly #firstKeySelector: MaybeAsyncConverter<TOuter, TKey>;
readonly #secondKeySelector: MaybeAsyncConverter<TInner, TKey>;
readonly #resultSelector: MaybeAsyncBiConverter<TOuter, TInner, TResult>;
readonly #keyComparer: MaybeAsyncEqualityComparison<TKey>;
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?: MaybeAsyncEqualityComparison<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;
@@ -2124,7 +2120,7 @@ class JoinAsyncSequence<TOuter, TInner, TKey, TResult> extends BaseAsyncSequence
this.#firstKeySelector = firstKeySelector;
this.#secondKeySelector = secondKeySelector;
this.#resultSelector = resultSelector ?? identity as MaybeAsyncBiConverter<TOuter, TInner, TResult>;
this.#keyComparer = keyComparer ?? strictEquals;
this.#keyComparer = keyComparer ? asAsyncEqualityComparer(keyComparer) : defaultAsyncEqualityComparer;
}
override async *iterator() {
@@ -2134,7 +2130,7 @@ class JoinAsyncSequence<TOuter, TInner, TKey, TResult> extends BaseAsyncSequence
for await (const secondObj of this.#second) {
const secondKey = await this.#secondKeySelector(secondObj);
if (await this.#keyComparer(firstKey, secondKey)) {
if (await this.#keyComparer.equals(firstKey, secondKey)) {
yield await this.#resultSelector(firstObj, secondObj);
}
}
@@ -2148,9 +2144,9 @@ class GroupJoinAsyncSequence<TOuter, TInner, TKey, TResult> extends BaseAsyncSeq
readonly #firstKeySelector: MaybeAsyncConverter<TOuter, TKey>;
readonly #secondKeySelector: MaybeAsyncConverter<TInner, TKey>;
readonly #resultSelector: MaybeAsyncBiConverter<TOuter, MaybeAsyncIterable<TInner>, TResult>;
readonly #keyComparer: MaybeAsyncEqualityComparison<TKey>;
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?: MaybeAsyncEqualityComparison<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;
@@ -2158,7 +2154,7 @@ class GroupJoinAsyncSequence<TOuter, TInner, TKey, TResult> extends BaseAsyncSeq
this.#firstKeySelector = firstKeySelector;
this.#secondKeySelector = secondKeySelector;
this.#resultSelector = resultSelector ?? GroupJoinAsyncSequence.#defaultResultSelector as MaybeAsyncBiConverter<TOuter, MaybeAsyncIterable<TInner>, TResult>;
this.#keyComparer = keyComparer ?? strictEquals;
this.#keyComparer = keyComparer ? asAsyncEqualityComparer(keyComparer) : defaultAsyncEqualityComparer;
}
static #defaultResultSelector<TOuter, TInner>(first: TOuter, second: AsyncSequence<TInner>) {
@@ -2173,7 +2169,7 @@ class GroupJoinAsyncSequence<TOuter, TInner, TKey, TResult> extends BaseAsyncSeq
for await (const secondObj of this.#second) {
const secondKey = await this.#secondKeySelector(secondObj);
if (await this.#keyComparer(firstKey, secondKey)) {
if (await this.#keyComparer.equals(firstKey, secondKey)) {
secondObjs.push(secondObj);
}
}
@@ -2187,22 +2183,22 @@ class RemoveAsyncSequence<T> extends BaseAsyncSequence<T> {
readonly #sequence: AsyncSequence<T>;
readonly #obj: T;
readonly #all: boolean;
readonly #equater: MaybeAsyncEqualityComparison<T>;
readonly #equater: AsyncEqualityComparer<T>;
constructor(sequence: AsyncSequence<T>, obj: T, all?: boolean, equater?: MaybeAsyncEqualityComparison<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 ?? strictEquals;
this.#equater = equater ? asAsyncEqualityComparer(equater) : defaultAsyncEqualityComparer;
}
override async *iterator() {
let gotOne = false;
for await (const obj of this.#sequence) {
if (await this.#equater(this.#obj, obj)) {
if (await this.#equater.equals(this.#obj, obj)) {
if (this.#all) {
continue;
}
@@ -2246,13 +2242,13 @@ class CacheAsyncSequence<T> extends BaseAsyncSequence<T> {
class PartitionAsyncSequence<T> extends BaseAsyncSequence<AsyncSequence<T>> {
readonly #sequence: AsyncSequence<T>;
readonly #equater: MaybeAsyncEqualityComparison<T>;
readonly #equater: MaybeAsyncEqualityComparisonOrComparer<T> | undefined;
constructor(sequence: AsyncSequence<T>, equater: MaybeAsyncEqualityComparison<T> | undefined) {
constructor(sequence: AsyncSequence<T>, equater: MaybeAsyncEqualityComparisonOrComparer<T> | undefined) {
super();
this.#sequence = sequence;
this.#equater = equater ?? strictEquals;
this.#equater = equater;
}
override async *iterator() {
@@ -2277,14 +2273,14 @@ class PartitionAsyncSequence<T> extends BaseAsyncSequence<AsyncSequence<T>> {
class PartitionByAsyncSequence<TElement, TBy> extends BaseAsyncSequence<AsyncSequence<TElement>> {
readonly #sequence: AsyncSequence<TElement>;
readonly #selector: MaybeAsyncConverter<TElement, TBy>;
readonly #equater: MaybeAsyncEqualityComparison<TBy>;
readonly #equater: MaybeAsyncEqualityComparisonOrComparer<TBy> | undefined;
constructor(sequence: AsyncSequence<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater: MaybeAsyncEqualityComparison<TBy> | undefined) {
constructor(sequence: AsyncSequence<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater: MaybeAsyncEqualityComparisonOrComparer<TBy> | undefined) {
super();
this.#sequence = sequence;
this.#selector = selector;
this.#equater = equater ?? strictEquals;
this.#equater = equater;
}
override async *iterator() {