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() {

40
src/async/types.ts
View File

@@ -1,6 +1,6 @@
import { Collector } from "../collector/types.js";
import { MaybeAsyncComparisonOrComparer, AsyncComparer } from "../comparer/types.js";
import { MaybeAsyncEqualityComparison } from "../equality-comparer/types.js";
import { MaybeAsyncEqualityComparisonOrComparer } from "../equality-comparer/types.js";
import { AsyncRandomOptions } from "../random/types.js";
import { MaybeAsyncAnyPredicate, MaybeAsyncConverter, MaybeAsyncBiConverter, MaybeAsyncAccumulator, MaybeAsyncAction, MaybeAsyncFunction, MaybePromise, MaybeAsyncIterable } from "../types.js";
@@ -22,24 +22,24 @@ export interface AsyncSequence<TElement> extends AsyncIterable<TElement> {
where<TFiltered extends TElement>(predicate: MaybeAsyncAnyPredicate<TElement>): AsyncSequence<TFiltered>;
where(predicate: MaybeAsyncAnyPredicate<TElement>): AsyncSequence<TElement>;
groupBy<TKey>(keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector?: undefined, keyComparer?: MaybeAsyncEqualityComparison<TKey>): AsyncSequence<GroupedAsyncSequence<TKey, TElement>>;
groupBy<TKey, TResult>(keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector: MaybeAsyncConverter<TElement, TResult>, keyComparer?: MaybeAsyncEqualityComparison<TKey>): AsyncSequence<GroupedAsyncSequence<TKey, TResult>>;
groupBy<TKey>(keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector?: undefined, keyComparer?: MaybeAsyncEqualityComparisonOrComparer<TKey>): AsyncSequence<GroupedAsyncSequence<TKey, TElement>>;
groupBy<TKey, TResult>(keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector: MaybeAsyncConverter<TElement, TResult>, keyComparer?: MaybeAsyncEqualityComparisonOrComparer<TKey>): AsyncSequence<GroupedAsyncSequence<TKey, TResult>>;
join<TOther, TKey>(sequence: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector?: undefined, keyComparer?: MaybeAsyncEqualityComparison<TKey>): 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>): AsyncSequence<TResult>;
join<TOther, TKey>(sequence: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector?: undefined, keyComparer?: MaybeAsyncEqualityComparisonOrComparer<TKey>): 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>): AsyncSequence<TResult>;
groupJoin<TOther, TKey>(sequence: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector?: undefined, keyComparer?: MaybeAsyncEqualityComparison<TKey>): 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>): AsyncSequence<TResult>;
groupJoin<TOther, TKey>(sequence: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector?: undefined, keyComparer?: MaybeAsyncEqualityComparisonOrComparer<TKey>): 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>): AsyncSequence<TResult>;
contains(obj: TElement, equater?: MaybeAsyncEqualityComparison<TElement>): Promise<boolean>;
contains(obj: TElement, equater?: MaybeAsyncEqualityComparisonOrComparer<TElement>): Promise<boolean>;
sequenceEquals(sequence: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEqualityComparison<TElement>): Promise<boolean>;
sequenceEquals(sequence: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEqualityComparisonOrComparer<TElement>): Promise<boolean>;
append(obj: TElement): AsyncSequence<TElement>;
prepend(obj: TElement): AsyncSequence<TElement>;
remove(obj: TElement, all?: boolean, equater?: MaybeAsyncEqualityComparison<TElement>): AsyncSequence<TElement>;
remove(obj: TElement, all?: boolean, equater?: MaybeAsyncEqualityComparisonOrComparer<TElement>): AsyncSequence<TElement>;
concat(...sequences: MaybeAsyncIterable<TElement>[]): AsyncSequence<TElement>;
@@ -74,20 +74,20 @@ export interface AsyncSequence<TElement> extends AsyncIterable<TElement> {
orderDescending(comparer?: MaybeAsyncComparisonOrComparer<TElement>): AsyncSequence<TElement>;
orderByDescending<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparisonOrComparer<TBy>): AsyncSequence<TElement>;
partition(equater?: MaybeAsyncEqualityComparison<TElement>): AsyncSequence<AsyncSequence<TElement>>;
partitionBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparison<TBy>): AsyncSequence<AsyncSequence<TElement>>;
partition(equater?: MaybeAsyncEqualityComparisonOrComparer<TElement>): AsyncSequence<AsyncSequence<TElement>>;
partitionBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparisonOrComparer<TBy>): AsyncSequence<AsyncSequence<TElement>>;
distinct(equater?: MaybeAsyncEqualityComparison<TElement>): AsyncSequence<TElement>;
distinctBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparison<TBy>): AsyncSequence<TElement>;
distinct(equater?: MaybeAsyncEqualityComparisonOrComparer<TElement>): AsyncSequence<TElement>;
distinctBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparisonOrComparer<TBy>): AsyncSequence<TElement>;
union(sequence: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEqualityComparison<TElement>): AsyncSequence<TElement>;
unionBy<TBy>(sequence: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparison<TBy>): AsyncSequence<TElement>;
union(sequence: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEqualityComparisonOrComparer<TElement>): AsyncSequence<TElement>;
unionBy<TBy>(sequence: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparisonOrComparer<TBy>): AsyncSequence<TElement>;
except(sequence: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEqualityComparison<TElement>): AsyncSequence<TElement>;
exceptBy<TBy>(sequence: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparison<TBy>): AsyncSequence<TElement>;
except(sequence: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEqualityComparisonOrComparer<TElement>): AsyncSequence<TElement>;
exceptBy<TBy>(sequence: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparisonOrComparer<TBy>): AsyncSequence<TElement>;
intersect(sequence: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEqualityComparison<TElement>): AsyncSequence<TElement>;
intersectBy<TBy>(sequence: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparison<TBy>): AsyncSequence<TElement>;
intersect(sequence: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEqualityComparisonOrComparer<TElement>): AsyncSequence<TElement>;
intersectBy<TBy>(sequence: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparisonOrComparer<TBy>): AsyncSequence<TElement>;
all(predicate: MaybeAsyncAnyPredicate<TElement>): Promise<boolean>;
any(predicate: MaybeAsyncAnyPredicate<TElement>): Promise<boolean>;

6
src/comparer/async.ts
View File

@@ -1,16 +1,16 @@
import { MaybeAsyncConverter } from "../types.js";
import { Nullable } from "../utils.js";
import { AsyncComparer, MaybeAsyncComparisonOrComparer, Comparer, MaybeAsyncComparison, AsyncComparison } from "./types.js";
import { AsyncComparer, AsyncComparison, Comparer, MaybeAsyncComparison, MaybeAsyncComparisonOrComparer } from "./types.js";
export function isAsyncComparer<T>(obj: any): obj is AsyncComparer<T> {
return obj instanceof BaseAsyncComparer;
}
export function asAsyncComparer<T>(comparer: MaybeAsyncComparisonOrComparer<T>): AsyncComparer<T> {
return typeof comparer === "function" ? createAsyncComparer(comparer) : isAsyncComparer<T>(comparer) ? comparer : new WrappedAsyncComparer(comparer);
return typeof comparer === "function" ? createAsyncComparer(comparer) : isAsyncComparer<T>(comparer) ? comparer : fromSyncComparer(comparer);
}
export function fromSync<T>(comparer: Comparer<T>): AsyncComparer<T> {
export function fromSyncComparer<T>(comparer: Comparer<T>): AsyncComparer<T> {
return new WrappedAsyncComparer(comparer);
}

4
src/comparer/sync.ts
View File

@@ -1,6 +1,6 @@
import { Converter } from "../types.js";
import { Nullable } from "../utils.js";
import { fromSync } from "./async.js";
import { fromSyncComparer } from "./async.js";
import { Comparer, ComparisonOrComparer, Comparison, AsyncComparer } from "./types.js";
export function isComparer<T>(obj: any): obj is Comparer<T> {
@@ -67,7 +67,7 @@ export abstract class BaseComparer<T> implements Comparer<T> {
}
public toAsync(): AsyncComparer<T> {
return fromSync<T>(this);
return fromSyncComparer<T>(this);
}
public nullAwareComparer(): Comparer<Nullable<T>> {

173
src/equality-comparer/async.ts Normal file
View File

@@ -0,0 +1,173 @@
import { MaybeAsyncConverter } from "../types.js";
import { Nullable } from "../utils.js";
import { AsyncEqualityComparer, AsyncEqualityComparison, EqualityComparer, MaybeAsyncEqualityComparison, MaybeAsyncEqualityComparisonOrComparer } from "./types.js";
export function isAsyncEqualityComparer<T>(obj: any): obj is AsyncEqualityComparer<T> {
return obj instanceof BaseAsyncEqualityComparer;
}
export function asAsyncEqualityComparer<T>(equalityComparer: MaybeAsyncEqualityComparisonOrComparer<T>): AsyncEqualityComparer<T> {
return typeof equalityComparer === "function" ? createAsyncEqualityComparer(equalityComparer) : isAsyncEqualityComparer<T>(equalityComparer) ? equalityComparer : fromSyncEqualityComparer(equalityComparer);
}
export function fromSyncEqualityComparer<T>(equalityComparer: EqualityComparer<T>): AsyncEqualityComparer<T> {
return new WrappedAsyncEqualityComparer(equalityComparer);
}
export function createAsyncEqualityComparer<T = any>(equalityComparison: MaybeAsyncEqualityComparison<T>): AsyncEqualityComparer<T> {
return new SimpleAsyncEqualityComparer(equalityComparison);
}
export function createAsyncEqualityComparerUsing<T = any, U = any>(projection: MaybeAsyncConverter<T, U>, equalityComparison?: MaybeAsyncEqualityComparisonOrComparer<U>): AsyncEqualityComparer<T> {
return new MappedAsyncEqualityComparer(projection, equalityComparison);
}
export function combineNullableAsyncEqualityComparers<T>(equalityComparers: Nullable<MaybeAsyncEqualityComparisonOrComparer<T>>[]) {
let result = defaultAsyncEqualityComparer;
for (const equalityComparer of equalityComparers) {
if (!equalityComparer) {
continue;
}
result = result.then(asAsyncEqualityComparer(equalityComparer));
}
return result === defaultAsyncEqualityComparer ? undefined : result;
}
export abstract class BaseAsyncEqualityComparer<T> implements AsyncEqualityComparer<T> {
#cachedBoundEqualityComparison: AsyncEqualityComparison<T> | undefined;
public abstract equals(a: T, b: T): Promise<boolean>;
public equalityComparison(): AsyncEqualityComparison<T> {
return this.#cachedBoundEqualityComparison ??= this.equals.bind(this);
}
public opposite(): AsyncEqualityComparer<T> {
return new OppositeAsyncEqualityComparer(this);
}
public then(equalityComparer: AsyncEqualityComparer<T>): AsyncEqualityComparer<T> {
return new ThenAsyncEqualityComparer(this, equalityComparer);
}
public thenEquals(equalityComparison: MaybeAsyncEqualityComparison<T>): AsyncEqualityComparer<T> {
return this.then(createAsyncEqualityComparer(equalityComparison));
}
public thenEqualsUsing<U>(projection: MaybeAsyncConverter<T, U>, equalityComparison?: MaybeAsyncEqualityComparisonOrComparer<U>): AsyncEqualityComparer<T> {
return this.then(createAsyncEqualityComparerUsing(projection, equalityComparison));
}
}
class WrappedAsyncEqualityComparer<T> extends BaseAsyncEqualityComparer<T> {
readonly #base: EqualityComparer<T>;
constructor(base: EqualityComparer<T>) {
super();
this.#base = base;
}
public override async equals(a: T, b: T) {
return this.#base.equals(a, b);
}
}
class SimpleAsyncEqualityComparer<T> extends BaseAsyncEqualityComparer<T> {
readonly #equalityComparison: MaybeAsyncEqualityComparison<T>;
public constructor(equalityComparison: MaybeAsyncEqualityComparison<T>) {
super();
this.#equalityComparison = equalityComparison;
}
public override async equals(a: T, b: T): Promise<boolean> {
return await this.#equalityComparison(a, b);
}
}
class MappedAsyncEqualityComparer<T, U> extends BaseAsyncEqualityComparer<T> {
readonly #projection: MaybeAsyncConverter<T, U>;
readonly #equalityComparison: AsyncEqualityComparer<U>;
public constructor(projection: MaybeAsyncConverter<T, U>, equalityComparison?: MaybeAsyncEqualityComparisonOrComparer<U>) {
super();
this.#projection = projection;
this.#equalityComparison = equalityComparison ? asAsyncEqualityComparer(equalityComparison) : defaultAsyncEqualityComparer;
}
public override async equals(a: T, b: T): Promise<boolean> {
return await this.#equalityComparison.equals(await this.#projection(a), await this.#projection(b));
}
}
class OppositeAsyncEqualityComparer<T> extends BaseAsyncEqualityComparer<T> {
readonly #base: AsyncEqualityComparer<T>;
public constructor(base: AsyncEqualityComparer<T>) {
super();
this.#base = base;
}
public override async equals(a: T, b: T): Promise<boolean> {
return !(await this.#base.equals(a, b));
}
public override opposite(): AsyncEqualityComparer<T> {
return this.#base;
}
}
class ThenAsyncEqualityComparer<T> extends BaseAsyncEqualityComparer<T> {
readonly #base: AsyncEqualityComparer<T>;
readonly #equalityComparer: AsyncEqualityComparer<T>;
public constructor(base: AsyncEqualityComparer<T>, equalityComparer: AsyncEqualityComparer<T>) {
super();
this.#base = base;
this.#equalityComparer = equalityComparer;
}
public override async equals(a: T, b: T) {
return await this.#base.equals(a, b) && await this.#equalityComparer.equals(a, b);
}
}
export const looseAsyncEqualityComparer: AsyncEqualityComparer<any> = new class LooseAsyncEqualityComparer extends BaseAsyncEqualityComparer<any> {
public override async equals(a: any, b: any): Promise<boolean> {
return a == b;
}
};
export const strictAsyncEqualityComparer: AsyncEqualityComparer<any> = new class StrictAsyncEqualityComparer extends BaseAsyncEqualityComparer<any> {
public override async equals(a: any, b: any): Promise<boolean> {
return a === b;
}
};
export const sameValueAsyncEqualityComparer: AsyncEqualityComparer<any> = new class SameValueAsyncEqualityComparer extends BaseAsyncEqualityComparer<any> {
public override async equals(a: any, b: any): Promise<boolean> {
return Object.is(a, b);
}
};
export const defaultAsyncEqualityComparer: AsyncEqualityComparer<any> = new class DefaultAsyncEqualityComparer extends BaseAsyncEqualityComparer<any> {
public override async equals(a: any, b: any): Promise<boolean> {
return a === b;
}
};
export function getDefaultAsyncEqualityComparer<T>(): AsyncEqualityComparer<T> {
return defaultAsyncEqualityComparer;
}
export const dateAsyncEqualityComparer: AsyncEqualityComparer<Date> = new class DateAsyncEqualityComparer extends BaseAsyncEqualityComparer<Date> {
public override async equals(a: Date, b: Date): Promise<boolean> {
return a.getTime() === b.getTime();
}
};

42
src/equality-comparer/sync.ts
View File

@@ -2,30 +2,14 @@ import { Converter } from "../types.js";
import { Nullable } from "../utils.js";
import { EqualityComparer, EqualityComparison, EqualityComparisonOrComparer } from "./types.js";
export function looseEquals(a: any, b: any) {
return a == b;
}
export function strictEquals(a: any, b: any) {
return a === b;
}
export function sameValue(a: any, b: any) {
return Object.is(a, b);
}
export function isEqualityComparer<T>(obj: any): obj is EqualityComparer<T> {
return obj instanceof BaseEqualityComparer;
}
export function asEqualityComparer<T>(equalityComparer: EqualityComparisonOrComparer<T>) {
export function asEqualityComparer<T>(equalityComparer: EqualityComparisonOrComparer<T>): EqualityComparer<T> {
return typeof equalityComparer === "function" ? createEqualityComparer(equalityComparer) : equalityComparer;
}
export function asEqualityComparison<T>(equalityComparer: EqualityComparisonOrComparer<T>) {
return typeof equalityComparer === "function" ? equalityComparer : equalityComparer.equalityComparison();
}
export function createEqualityComparer<T = any>(equalityComparison: EqualityComparison<T>): EqualityComparer<T> {
return new SimpleEqualityComparer(equalityComparison);
}
@@ -34,10 +18,6 @@ export function createEqualityComparerUsing<T = any, U = any>(projection: Conver
return new MappedEqualityComparer(projection, equalityComparison);
}
export function oppositeEqualityComparison<T>(equalityComparison: EqualityComparison<T>): EqualityComparison<T> {
return (a, b) => !equalityComparison(a, b);
}
export function combineNullableEqualityComparers<T>(equalityComparers: Nullable<EqualityComparisonOrComparer<T>>[]) {
let result = defaultEqualityComparer;
@@ -146,6 +126,22 @@ class ThenEqualityComparer<T> extends BaseEqualityComparer<T> {
}
}
export const looseEqualityComparer: EqualityComparer<any> = new class LooseEqualityComparer extends BaseEqualityComparer<any> {
public override equals(a: any, b: any): boolean {
return a == b;
}
};
export const strictEqualityComparer: EqualityComparer<any> = new class StrictEqualityComparer extends BaseEqualityComparer<any> {
public override equals(a: any, b: any): boolean {
return a === b;
}
};
export const sameValueEqualityComparer: EqualityComparer<any> = new class SameValueEqualityComparer extends BaseEqualityComparer<any> {
public override equals(a: any, b: any): boolean {
return Object.is(a, b);
}
};
export const defaultEqualityComparer: EqualityComparer<any> = new class DefaultEqualityComparer extends BaseEqualityComparer<any> {
public override equals(a: any, b: any): boolean {
return a === b;
@@ -161,7 +157,3 @@ export const dateEqualityComparer: EqualityComparer<Date> = new class DateEquali
return a.getTime() === b.getTime();
}
};
export const looseEqualityComparer: EqualityComparer<any> = new SimpleEqualityComparer<any>(looseEquals);
export const strictEqualityComparer: EqualityComparer<any> = new SimpleEqualityComparer<any>(strictEquals);
export const sameValueEqualityComparer: EqualityComparer<any> = new SimpleEqualityComparer<any>(sameValue);

15
src/equality-comparer/types.ts
View File

@@ -1,4 +1,4 @@
import { Converter, MaybeAsyncFunction } from "../types.js";
import { AsyncFunction, Converter, MaybeAsyncConverter, MaybeAsyncFunction } from "../types.js";
export interface EqualityComparer<T> {
equals(a: T, b: T): boolean;
@@ -9,7 +9,20 @@ export interface EqualityComparer<T> {
thenEqualsUsing<U>(projection: Converter<T, U>, equalityComparison?: EqualityComparisonOrComparer<U>): EqualityComparer<T>;
}
export interface AsyncEqualityComparer<T> {
equals(a: T, b: T): Promise<boolean>;
equalityComparison(): AsyncEqualityComparison<T>;
opposite(): AsyncEqualityComparer<T>;
then(equalityComparer: AsyncEqualityComparer<T>): AsyncEqualityComparer<T>;
thenEquals(equalityComparison: AsyncEqualityComparison<T>): AsyncEqualityComparer<T>;
thenEqualsUsing<U>(projection: MaybeAsyncConverter<T, U>, equalityComparison?: AsyncEqualityComparisonOrComparer<U>): AsyncEqualityComparer<T>;
}
export type EqualityComparison<T> = (first: T, second: T) => boolean;
export type EqualityComparisonOrComparer<T> = EqualityComparison<T> | EqualityComparer<T>;
export type AsyncEqualityComparison<T> = AsyncFunction<EqualityComparison<T>>;
export type MaybeAsyncEqualityComparison<T> = MaybeAsyncFunction<EqualityComparison<T>>;
export type AsyncEqualityComparisonOrComparer<T> = AsyncEqualityComparison<T> | AsyncEqualityComparer<T>;
export type MaybeAsyncEqualityComparisonOrComparer<T> = MaybeAsyncEqualityComparison<T> | EqualityComparer<T> | AsyncEqualityComparer<T>;

17
src/equality-map/impl.ts
View File

@@ -1,5 +1,6 @@
import { asAsyncEqualityComparer } from "../equality-comparer/async.js";
import { asEqualityComparer } from "../equality-comparer/sync.js";
import { EqualityComparer, EqualityComparisonOrComparer, MaybeAsyncEqualityComparison } from "../equality-comparer/types.js";
import { AsyncEqualityComparer, EqualityComparer, EqualityComparisonOrComparer, MaybeAsyncEqualityComparisonOrComparer } from "../equality-comparer/types.js";
import { MaybeAsyncIterable } from "../types.js";
import { AsyncEqualityMap, EqualityMap, EqualityMapEntry } from "./types.js";
@@ -203,10 +204,10 @@ export class NativeAsyncEqualityMap<K, V> implements AsyncEqualityMap<K, V> {
export class CustomAsyncEqualityMap<K, V> implements AsyncEqualityMap<K, V> {
readonly #list: EqualityMapEntry<K, V>[] = [];
readonly #keyComparer: MaybeAsyncEqualityComparison<K>;
readonly #keyComparer: AsyncEqualityComparer<K>;
constructor(keyComparer: MaybeAsyncEqualityComparison<K>) {
this.#keyComparer = keyComparer;
constructor(keyComparer: MaybeAsyncEqualityComparisonOrComparer<K>) {
this.#keyComparer = asAsyncEqualityComparer(keyComparer);
}
get size() {
@@ -215,7 +216,7 @@ export class CustomAsyncEqualityMap<K, V> implements AsyncEqualityMap<K, V> {
async get(key: K) {
for (const entry of this.#list) {
if (await this.#keyComparer(key, entry[0])) {
if (await this.#keyComparer.equals(key, entry[0])) {
return entry[1];
}
}
@@ -225,7 +226,7 @@ export class CustomAsyncEqualityMap<K, V> implements AsyncEqualityMap<K, V> {
async set(key: K, value: V) {
for (const entry of this.#list) {
if (await this.#keyComparer(key, entry[0])) {
if (await this.#keyComparer.equals(key, entry[0])) {
const previous = entry[1];
entry[1] = value;
return previous;
@@ -245,7 +246,7 @@ export class CustomAsyncEqualityMap<K, V> implements AsyncEqualityMap<K, V> {
async contains(key: K) {
for (const entry of this.#list) {
if (await this.#keyComparer(key, entry[0])) {
if (await this.#keyComparer.equals(key, entry[0])) {
return true;
}
}
@@ -255,7 +256,7 @@ export class CustomAsyncEqualityMap<K, V> implements AsyncEqualityMap<K, V> {
async remove(key: K) {
for (let i = 0; i < this.#list.length; i++) {
if (await this.#keyComparer(key, this.#list[i][0])) {
if (await this.#keyComparer.equals(key, this.#list[i][0])) {
const removed = this.#list.splice(i, 1);
return removed[0][1];
}

4
src/equality-map/index.ts
View File

@@ -1,4 +1,4 @@
import { EqualityComparisonOrComparer, MaybeAsyncEqualityComparison } from "../equality-comparer/types.js";
import { EqualityComparisonOrComparer, MaybeAsyncEqualityComparisonOrComparer } from "../equality-comparer/types.js";
import { CustomAsyncEqualityMap, CustomEqualityMap, NativeAsyncEqualityMap, NativeEqualityMap } from "./impl.js";
import { AsyncEqualityMap, EqualityMap } from "./types.js";
@@ -6,6 +6,6 @@ export function createEqualityMap<K, V>(keyComparer?: EqualityComparisonOrCompar
return keyComparer ? new CustomEqualityMap<K, V>(keyComparer) : new NativeEqualityMap<K, V>();
}
export function createAsyncEqualityMap<K, V>(keyComparer?: MaybeAsyncEqualityComparison<K>): AsyncEqualityMap<K, V> {
export function createAsyncEqualityMap<K, V>(keyComparer?: MaybeAsyncEqualityComparisonOrComparer<K>): AsyncEqualityMap<K, V> {
return keyComparer ? new CustomAsyncEqualityMap<K, V>(keyComparer) : new NativeAsyncEqualityMap<K, V>();
}

13
src/equality-set/impl.ts
View File

@@ -1,5 +1,6 @@
import { asAsyncEqualityComparer } from "../equality-comparer/async.js";
import { asEqualityComparer } from "../equality-comparer/sync.js";
import { EqualityComparer, EqualityComparisonOrComparer, MaybeAsyncEqualityComparison } from "../equality-comparer/types.js";
import { AsyncEqualityComparer, EqualityComparer, EqualityComparisonOrComparer, MaybeAsyncEqualityComparisonOrComparer } from "../equality-comparer/types.js";
import { MaybeAsyncIterable } from "../types.js";
import { AsyncEqualitySet, EqualitySet } from "./types.js";
@@ -167,10 +168,10 @@ export class NativeAsyncEqualitySet<T> implements AsyncEqualitySet<T> {
export class CustomAsyncEqualitySet<T> implements AsyncEqualitySet<T> {
readonly #list: T[] = [];
readonly #equater: MaybeAsyncEqualityComparison<T>;
readonly #equater: AsyncEqualityComparer<T>;
constructor(equater: MaybeAsyncEqualityComparison<T>) {
this.#equater = equater;
constructor(equater: MaybeAsyncEqualityComparisonOrComparer<T>) {
this.#equater = asAsyncEqualityComparer(equater);
}
get size() {
@@ -201,7 +202,7 @@ export class CustomAsyncEqualitySet<T> implements AsyncEqualitySet<T> {
async contains(value: T) {
for (const val of this.#list) {
if (await this.#equater(value, val)) {
if (await this.#equater.equals(value, val)) {
return true;
}
}
@@ -213,7 +214,7 @@ export class CustomAsyncEqualitySet<T> implements AsyncEqualitySet<T> {
const length = this.#list.length;
for (let i = 0; i < length; i++) {
if (await this.#equater(value, this.#list[i])) {
if (await this.#equater.equals(value, this.#list[i])) {
this.#list.splice(i, 1);
return true;
}

4
src/equality-set/index.ts
View File

@@ -1,4 +1,4 @@
import { EqualityComparisonOrComparer, MaybeAsyncEqualityComparison } from "../equality-comparer/types.js";
import { EqualityComparisonOrComparer, MaybeAsyncEqualityComparisonOrComparer } from "../equality-comparer/types.js";
import { CustomAsyncEqualitySet, CustomEqualitySet, NativeAsyncEqualitySet, NativeEqualitySet } from "./impl.js";
import { AsyncEqualitySet, EqualitySet } from "./types.js";
@@ -6,6 +6,6 @@ export function createEqualitySet<T>(equater?: EqualityComparisonOrComparer<T>):
return equater ? new CustomEqualitySet(equater) : new NativeEqualitySet<T>();
}
export function createAsyncEqualitySet<T>(equater?: MaybeAsyncEqualityComparison<T>): AsyncEqualitySet<T> {
export function createAsyncEqualitySet<T>(equater?: MaybeAsyncEqualityComparisonOrComparer<T>): AsyncEqualitySet<T> {
return equater ? new CustomAsyncEqualitySet(equater) : new NativeAsyncEqualitySet<T>();
}

3
src/index.ts
View File

@@ -15,7 +15,10 @@ export * as Comparers from "./comparer/sync.js";
export { BaseAsyncComparer } from "./comparer/async.js";
export * as AsyncComparers from "./comparer/async.js";
export * from "./comparer/types.js";
export { BaseEqualityComparer } from "./equality-comparer/sync.js";
export * as EqualityComparers from "./equality-comparer/sync.js";
export { BaseAsyncEqualityComparer } from "./equality-comparer/async.js";
export * as AsyncEqualityComparers from "./equality-comparer/async.js";
export * from "./equality-comparer/types.js";
export * as EqualityMaps from "./equality-map/index.js";
export * from "./equality-map/types.js";

159
src/sync/impl.ts
View File

@@ -3,8 +3,8 @@ import { AsyncSequence } from "../async/types.js";
import { Collector } from "../collector/types.js";
import { asComparer, combineNullableComparers, createComparerUsing, defaultComparer } from "../comparer/sync.js";
import { ComparisonOrComparer, Comparer } from "../comparer/types.js";
import { strictEquals } from "../equality-comparer/sync.js";
import { EqualityComparison } from "../equality-comparer/types.js";
import { asEqualityComparer, defaultEqualityComparer } from "../equality-comparer/sync.js";
import { EqualityComparer, EqualityComparisonOrComparer } from "../equality-comparer/types.js";
import { createEqualityMap } from "../equality-map/index.js";
import { createEqualitySet } from "../equality-set/index.js";
import { createQueue } from "../queue.js";
@@ -50,25 +50,23 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
return new WhereSequence<TElement, any>(this, predicate);
}
groupBy<TKey, TResult>(keySelector: Converter<TElement, TKey>, elementSelector?: Converter<TElement, TResult>, keyComparer?: EqualityComparison<TKey>): Sequence<GroupedSequence<TKey, TResult>> {
groupBy<TKey, TResult>(keySelector: Converter<TElement, TKey>, elementSelector?: Converter<TElement, TResult>, keyComparer?: EqualityComparisonOrComparer<TKey>): Sequence<GroupedSequence<TKey, TResult>> {
return new GroupBySequence<TElement, TKey, TResult>(this, keySelector, elementSelector, keyComparer);
}
join<TOther, TKey, TResult>(sequence: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: BiConverter<TElement, TOther, TResult>, keyComparer?: EqualityComparison<TKey>): Sequence<TResult> {
join<TOther, TKey, TResult>(sequence: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: BiConverter<TElement, TOther, TResult>, keyComparer?: EqualityComparisonOrComparer<TKey>): Sequence<TResult> {
return new JoinSequence<TElement, TOther, TKey, TResult>(this, wrap(sequence), firstKeySelector, secondKeySelector, resultSelector, keyComparer);
}
groupJoin<TOther, TKey, TResult>(sequence: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: BiConverter<TElement, Iterable<TOther>, TResult>, keyComparer?: EqualityComparison<TKey>): Sequence<TResult> {
groupJoin<TOther, TKey, TResult>(sequence: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: BiConverter<TElement, Iterable<TOther>, TResult>, keyComparer?: EqualityComparisonOrComparer<TKey>): Sequence<TResult> {
return new GroupJoinSequence<TElement, TOther, TKey, TResult>(this, wrap(sequence), firstKeySelector, secondKeySelector, resultSelector, keyComparer);
}
contains(obj: TElement, equater?: EqualityComparison<TElement>) {
if (!equater) {
equater = strictEquals;
}
contains(obj: TElement, equater?: EqualityComparisonOrComparer<TElement>) {
equater = equater ? asEqualityComparer(equater) : defaultEqualityComparer;
for (const element of this) {
if (equater(element, obj)) {
if (equater.equals(element, obj)) {
return true;
}
}
@@ -76,7 +74,7 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
return false;
}
sequenceEquals(sequence: Iterable<TElement>, equater?: EqualityComparison<TElement>) {
sequenceEquals(sequence: Iterable<TElement>, equater?: EqualityComparisonOrComparer<TElement>) {
if (this === sequence) {
return true;
}
@@ -90,9 +88,7 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
return false;
}
if (!equater) {
equater = strictEquals;
}
equater = equater ? asEqualityComparer(equater) : defaultEqualityComparer;
const thisIterator = this.iterator();
const thatIterator = other.iterator();
@@ -109,7 +105,7 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
return false;
}
if (!equater(thisNext.value, thatNext.value)) {
if (!equater.equals(thisNext.value, thatNext.value)) {
return false;
}
}
@@ -123,7 +119,7 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
return new PrependSequence<TElement>(this, obj);
}
remove(obj: TElement, all?: boolean, equater?: EqualityComparison<TElement>): Sequence<TElement> {
remove(obj: TElement, all?: boolean, equater?: EqualityComparisonOrComparer<TElement>): Sequence<TElement> {
return new RemoveSequence<TElement>(this, obj, all, equater);
}
@@ -527,27 +523,27 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
return new OrderBySequence<TElement, TBy>(this, true, selector, comparer);
}
partition(equater?: EqualityComparison<TElement>): Sequence<Sequence<TElement>> {
partition(equater?: EqualityComparisonOrComparer<TElement>): Sequence<Sequence<TElement>> {
return new PartitionSequence<TElement>(this, equater);
}
partitionBy<TBy>(selector: Converter<TElement, TBy>, equater?: EqualityComparison<TBy>): Sequence<Sequence<TElement>> {
partitionBy<TBy>(selector: Converter<TElement, TBy>, equater?: EqualityComparisonOrComparer<TBy>): Sequence<Sequence<TElement>> {
return new PartitionBySequence<TElement, TBy>(this, selector, equater);
}
distinct(equater?: EqualityComparison<TElement>): Sequence<TElement> {
distinct(equater?: EqualityComparisonOrComparer<TElement>): Sequence<TElement> {
return new DistinctSequence<TElement>(this, equater);
}
distinctBy<TBy>(selector: Converter<TElement, TBy>, equater?: EqualityComparison<TBy>): Sequence<TElement> {
distinctBy<TBy>(selector: Converter<TElement, TBy>, equater?: EqualityComparisonOrComparer<TBy>): Sequence<TElement> {
return new DistinctBySequence<TElement, TBy>(this, selector, equater);
}
union(sequence: Iterable<TElement>, equater?: EqualityComparison<TElement>): Sequence<TElement> {
union(sequence: Iterable<TElement>, equater?: EqualityComparisonOrComparer<TElement>): Sequence<TElement> {
return new UnionSequence<TElement>(this, wrap(sequence), equater);
}
unionBy<TBy>(sequence: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: EqualityComparison<TBy>): Sequence<TElement> {
unionBy<TBy>(sequence: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: EqualityComparisonOrComparer<TBy>): Sequence<TElement> {
return new UnionBySequence<TElement, TBy>(this, wrap(sequence), selector, equater);
}
@@ -833,29 +829,29 @@ export class DelegatedSequence<TElement> extends SequenceMarker implements Seque
return this.#sequence.where(predicate);
}
groupBy<TKey>(keySelector: Converter<TElement, TKey>, elementSelector?: undefined, keyComparer?: EqualityComparison<TKey> | undefined): Sequence<GroupedSequence<TKey, TElement>>;
groupBy<TKey, TResult>(keySelector: Converter<TElement, TKey>, elementSelector: Converter<TElement, TResult>, keyComparer?: EqualityComparison<TKey> | undefined): Sequence<GroupedSequence<TKey, TResult>>;
groupBy<TKey>(keySelector: Converter<TElement, TKey>, elementSelector?: undefined, keyComparer?: EqualityComparisonOrComparer<TKey> | undefined): Sequence<GroupedSequence<TKey, TElement>>;
groupBy<TKey, TResult>(keySelector: Converter<TElement, TKey>, elementSelector: Converter<TElement, TResult>, keyComparer?: EqualityComparisonOrComparer<TKey> | undefined): Sequence<GroupedSequence<TKey, TResult>>;
groupBy(keySelector: any, elementSelector?: any, keyComparer?: any) {
return this.#sequence.groupBy(keySelector, elementSelector, keyComparer);
}
join<TOther, TKey>(sequence: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: undefined, keyComparer?: EqualityComparison<TKey> | undefined): Sequence<[TElement, TOther]>;
join<TOther, TKey, TResult>(sequence: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector: BiConverter<TElement, TOther, TResult>, keyComparer?: EqualityComparison<TKey> | undefined): Sequence<TResult>;
join<TOther, TKey>(sequence: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: undefined, keyComparer?: EqualityComparisonOrComparer<TKey> | undefined): Sequence<[TElement, TOther]>;
join<TOther, TKey, TResult>(sequence: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector: BiConverter<TElement, TOther, TResult>, keyComparer?: EqualityComparisonOrComparer<TKey> | undefined): Sequence<TResult>;
join(sequence: any, firstKeySelector: any, secondKeySelector: any, resultSelector?: any, keyComparer?: any) {
return this.#sequence.join(sequence, firstKeySelector, secondKeySelector, resultSelector, keyComparer);
}
groupJoin<TOther, TKey>(sequence: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: undefined, keyComparer?: EqualityComparison<TKey> | undefined): Sequence<GroupedSequence<TElement, TOther>>;
groupJoin<TOther, TKey, TResult>(sequence: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector: BiConverter<TElement, Iterable<TOther>, TResult>, keyComparer?: EqualityComparison<TKey> | undefined): Sequence<TResult>;
groupJoin<TOther, TKey>(sequence: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: undefined, keyComparer?: EqualityComparisonOrComparer<TKey> | undefined): Sequence<GroupedSequence<TElement, TOther>>;
groupJoin<TOther, TKey, TResult>(sequence: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector: BiConverter<TElement, Iterable<TOther>, TResult>, keyComparer?: EqualityComparisonOrComparer<TKey> | undefined): Sequence<TResult>;
groupJoin(sequence: any, firstKeySelector: any, secondKeySelector: any, resultSelector?: any, keyComparer?: any) {
return this.#sequence.groupJoin(sequence, firstKeySelector, secondKeySelector, resultSelector, keyComparer);
}
contains(obj: TElement, equater?: EqualityComparison<TElement>) {
contains(obj: TElement, equater?: EqualityComparisonOrComparer<TElement>) {
return this.#sequence.contains(obj, equater);
}
sequenceEquals(sequence: Iterable<TElement>, equater?: EqualityComparison<TElement>) {
sequenceEquals(sequence: Iterable<TElement>, equater?: EqualityComparisonOrComparer<TElement>) {
return this.#sequence.sequenceEquals(sequence, equater);
}
@@ -867,7 +863,7 @@ export class DelegatedSequence<TElement> extends SequenceMarker implements Seque
return this.#sequence.prepend(obj);
}
remove(obj: TElement, all?: boolean, equater?: EqualityComparison<TElement>) {
remove(obj: TElement, all?: boolean, equater?: EqualityComparisonOrComparer<TElement>) {
return this.#sequence.remove(obj, all, equater);
}
@@ -951,43 +947,43 @@ export class DelegatedSequence<TElement> extends SequenceMarker implements Seque
return this.#sequence.orderByDescending(selector, comparer);
}
partition(equater?: EqualityComparison<TElement> | undefined): Sequence<Sequence<TElement>> {
partition(equater?: EqualityComparisonOrComparer<TElement> | undefined): Sequence<Sequence<TElement>> {
return this.#sequence.partition(equater);
}
partitionBy<TBy>(selector: Converter<TElement, TBy>, equater?: EqualityComparison<TBy> | undefined): Sequence<Sequence<TElement>> {
partitionBy<TBy>(selector: Converter<TElement, TBy>, equater?: EqualityComparisonOrComparer<TBy> | undefined): Sequence<Sequence<TElement>> {
return this.#sequence.partitionBy(selector, equater);
}
distinct(equater?: EqualityComparison<TElement>) {
distinct(equater?: EqualityComparisonOrComparer<TElement>) {
return this.#sequence.distinct(equater);
}
distinctBy<TBy>(selector: Converter<TElement, TBy>, equater?: EqualityComparison<TBy>) {
distinctBy<TBy>(selector: Converter<TElement, TBy>, equater?: EqualityComparisonOrComparer<TBy>) {
return this.#sequence.distinctBy(selector, equater);
}
union(sequence: Iterable<TElement>, equater?: EqualityComparison<TElement>) {
union(sequence: Iterable<TElement>, equater?: EqualityComparisonOrComparer<TElement>) {
return this.#sequence.union(sequence, equater);
}
unionBy<TBy>(sequence: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: EqualityComparison<TBy>) {
unionBy<TBy>(sequence: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: EqualityComparisonOrComparer<TBy>) {
return this.#sequence.unionBy(sequence, selector, equater);
}
except(sequence: Iterable<TElement>, equater?: EqualityComparison<TElement>) {
except(sequence: Iterable<TElement>, equater?: EqualityComparisonOrComparer<TElement>) {
return this.#sequence.except(sequence, equater);
}
exceptBy<TBy>(sequence: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: EqualityComparison<TBy>) {
exceptBy<TBy>(sequence: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: EqualityComparisonOrComparer<TBy>) {
return this.#sequence.exceptBy(sequence, selector, equater);
}
intersect(sequence: Iterable<TElement>, equater?: EqualityComparison<TElement>) {
intersect(sequence: Iterable<TElement>, equater?: EqualityComparisonOrComparer<TElement>) {
return this.#sequence.intersect(sequence, equater);
}
intersectBy<TBy>(sequence: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: EqualityComparison<TBy>) {
intersectBy<TBy>(sequence: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: EqualityComparisonOrComparer<TBy>) {
return this.#sequence.intersectBy(sequence, selector, equater);
}
@@ -1370,9 +1366,10 @@ export class WrappedArray<T> extends BaseSequence<T> {
return this.#array.length;
}
override contains(obj: T, equater?: EqualityComparison<T>): boolean {
override contains(obj: T, equater?: EqualityComparisonOrComparer<T>): boolean {
if (equater) {
return this.#array.some(x => equater(x, obj));
const equalityComparer = asEqualityComparer(equater);
return this.#array.some(x => equalityComparer.equals(x, obj));
}
return this.#array.includes(obj);
@@ -1466,7 +1463,7 @@ export class WrappedSet<T> extends BaseSequence<T> {
return this.#set.size;
}
override contains(obj: T, equater?: EqualityComparison<T>) {
override contains(obj: T, equater?: EqualityComparisonOrComparer<T>) {
if (equater) {
return super.contains(obj, equater);
}
@@ -1496,7 +1493,7 @@ export class WrappedMap<K, V> extends BaseSequence<[K, V]> {
return this.#map.size;
}
override contains(obj: [K, V], equater?: EqualityComparison<[K, V]>) {
override contains(obj: [K, V], equater?: EqualityComparisonOrComparer<[K, V]>) {
if (equater) {
return super.contains(obj, equater);
}
@@ -1605,9 +1602,9 @@ export class ConcatSequence<T> extends BaseSequence<T> {
class DistinctSequence<T> extends BaseSequence<T> {
readonly #sequence: Sequence<T>;
readonly #equater: EqualityComparison<T> | undefined;
readonly #equater: EqualityComparisonOrComparer<T> | undefined;
constructor(sequence: Sequence<T>, equater?: EqualityComparison<T>) {
constructor(sequence: Sequence<T>, equater?: EqualityComparisonOrComparer<T>) {
super();
this.#sequence = sequence;
@@ -1632,9 +1629,9 @@ class DistinctSequence<T> extends BaseSequence<T> {
class DistinctBySequence<T, U> extends BaseSequence<T> {
readonly #sequence: Sequence<T>;
readonly #converter: Converter<T, U>;
readonly #equater: EqualityComparison<U> | undefined;
readonly #equater: EqualityComparisonOrComparer<U> | undefined;
constructor(sequence: Sequence<T>, converter: Converter<T, U>, equater?: EqualityComparison<U>) {
constructor(sequence: Sequence<T>, converter: Converter<T, U>, equater?: EqualityComparisonOrComparer<U>) {
super();
this.#sequence = sequence;
@@ -2100,9 +2097,9 @@ export class ZippedSequence<T, U> extends BaseSequence<[T, U]> {
class UnionSequence<T> extends BaseSequence<T> {
readonly #first: Sequence<T>;
readonly #second: Sequence<T>;
readonly #equater: EqualityComparison<T> | undefined;
readonly #equater: EqualityComparisonOrComparer<T> | undefined;
constructor(first: Sequence<T>, second: Sequence<T>, equater?: EqualityComparison<T>) {
constructor(first: Sequence<T>, second: Sequence<T>, equater?: EqualityComparisonOrComparer<T>) {
super();
this.#first = first;
@@ -2134,9 +2131,9 @@ class UnionBySequence<T, U> extends BaseSequence<T> {
readonly #first: Sequence<T>;
readonly #second: Sequence<T>;
readonly #selector: Converter<T, U>;
readonly #equater: EqualityComparison<U> | undefined;
readonly #equater: EqualityComparisonOrComparer<U> | undefined;
constructor(first: Sequence<T>, second: Sequence<T>, selector: Converter<T, U>, equater?: EqualityComparison<U>) {
constructor(first: Sequence<T>, second: Sequence<T>, selector: Converter<T, U>, equater?: EqualityComparisonOrComparer<U>) {
super();
this.#first = first;
@@ -2168,9 +2165,9 @@ class UnionBySequence<T, U> extends BaseSequence<T> {
class ExceptSequence<T> extends BaseSequence<T> {
readonly #first: Sequence<T>;
readonly #second: Sequence<T>;
readonly #equater: EqualityComparison<T> | undefined;
readonly #equater: EqualityComparisonOrComparer<T> | undefined;
constructor(first: Sequence<T>, second: Sequence<T>, equater?: EqualityComparison<T>) {
constructor(first: Sequence<T>, second: Sequence<T>, equater?: EqualityComparisonOrComparer<T>) {
super();
this.#first = first;
@@ -2201,9 +2198,9 @@ class ExceptBySequence<T, U> extends BaseSequence<T> {
readonly #first: Sequence<T>;
readonly #second: Sequence<T>;
readonly #selector: Converter<T, U>;
readonly #equater: EqualityComparison<U> | undefined;
readonly #equater: EqualityComparisonOrComparer<U> | undefined;
constructor(first: Sequence<T>, second: Sequence<T>, selector: Converter<T, U>, equater?: EqualityComparison<U>) {
constructor(first: Sequence<T>, second: Sequence<T>, selector: Converter<T, U>, equater?: EqualityComparisonOrComparer<U>) {
super();
this.#first = first;
@@ -2234,9 +2231,9 @@ class ExceptBySequence<T, U> extends BaseSequence<T> {
class IntersectSequence<T> extends BaseSequence<T> {
readonly #first: Sequence<T>;
readonly #second: Sequence<T>;
readonly #equater: EqualityComparison<T> | undefined;
readonly #equater: EqualityComparisonOrComparer<T> | undefined;
constructor(first: Sequence<T>, second: Sequence<T>, equater?: EqualityComparison<T>) {
constructor(first: Sequence<T>, second: Sequence<T>, equater?: EqualityComparisonOrComparer<T>) {
super();
this.#first = first;
@@ -2265,9 +2262,9 @@ class IntersectBySequence<T, U> extends BaseSequence<T> {
readonly #first: Sequence<T>;
readonly #second: Sequence<T>;
readonly #selector: Converter<T, U>;
readonly #equater: EqualityComparison<U> | undefined;
readonly #equater: EqualityComparisonOrComparer<U> | undefined;
constructor(first: Sequence<T>, second: Sequence<T>, selector: Converter<T, U>, equater?: EqualityComparison<U>) {
constructor(first: Sequence<T>, second: Sequence<T>, selector: Converter<T, U>, equater?: EqualityComparisonOrComparer<U>) {
super();
this.#first = first;
@@ -2329,9 +2326,9 @@ class GroupBySequence<TElement, TKey, TResult> extends BaseSequence<GroupedSeque
readonly #sequence: Sequence<TElement>;
readonly #keySelector: Converter<TElement, TKey>;
readonly #elementSelector: Converter<TElement, TResult>;
readonly #keyEquater: EqualityComparison<TKey> | undefined;
readonly #keyEquater: EqualityComparisonOrComparer<TKey> | undefined;
constructor(sequence: Sequence<TElement>, keySelector: Converter<TElement, TKey>, elementSelector?: Converter<TElement, TResult>, keyEquater?: EqualityComparison<TKey>) {
constructor(sequence: Sequence<TElement>, keySelector: Converter<TElement, TKey>, elementSelector?: Converter<TElement, TResult>, keyEquater?: EqualityComparisonOrComparer<TKey>) {
super();
this.#sequence = sequence;
@@ -2448,9 +2445,9 @@ class JoinSequence<TOuter, TInner, TKey, TResult> extends BaseSequence<TResult>
readonly #firstKeySelector: Converter<TOuter, TKey>;
readonly #secondKeySelector: Converter<TInner, TKey>;
readonly #resultSelector: BiConverter<TOuter, TInner, TResult>;
readonly #keyEquater: EqualityComparison<TKey>;
readonly #keyEquater: EqualityComparer<TKey>;
constructor(first: Sequence<TOuter>, second: Sequence<TInner>, firstKeySelector: Converter<TOuter, TKey>, secondKeySelector: Converter<TInner, TKey>, resultSelector?: BiConverter<TOuter, TInner, TResult>, keyEquater?: EqualityComparison<TKey>) {
constructor(first: Sequence<TOuter>, second: Sequence<TInner>, firstKeySelector: Converter<TOuter, TKey>, secondKeySelector: Converter<TInner, TKey>, resultSelector?: BiConverter<TOuter, TInner, TResult>, keyEquater?: EqualityComparisonOrComparer<TKey>) {
super();
this.#first = first;
@@ -2458,7 +2455,7 @@ class JoinSequence<TOuter, TInner, TKey, TResult> extends BaseSequence<TResult>
this.#firstKeySelector = firstKeySelector;
this.#secondKeySelector = secondKeySelector;
this.#resultSelector = resultSelector ?? JoinSequence.#defaultResultSelector as BiConverter<TOuter, TInner, TResult>;
this.#keyEquater = keyEquater ?? strictEquals;
this.#keyEquater = keyEquater ? asEqualityComparer(keyEquater) : defaultEqualityComparer;
}
static #defaultResultSelector<TOuter, TInner>(first: TOuter, second: TInner): [TOuter, TInner] {
@@ -2476,7 +2473,7 @@ class JoinSequence<TOuter, TInner, TKey, TResult> extends BaseSequence<TResult>
for (const secondObj of this.#second) {
const secondKey = this.#secondKeySelector(secondObj);
if (this.#keyEquater(firstKey, secondKey)) {
if (this.#keyEquater.equals(firstKey, secondKey)) {
yield this.#resultSelector(firstObj, secondObj);
}
}
@@ -2490,9 +2487,9 @@ class GroupJoinSequence<TOuter, TInner, TKey, TResult> extends BaseSequence<TRes
readonly #firstKeySelector: Converter<TOuter, TKey>;
readonly #secondKeySelector: Converter<TInner, TKey>;
readonly #resultSelector: BiConverter<TOuter, Sequence<TInner>, TResult>;
readonly #keyEquater: EqualityComparison<TKey>;
readonly #keyEquater: EqualityComparer<TKey>;
constructor(first: Sequence<TOuter>, second: Sequence<TInner>, firstKeySelector: Converter<TOuter, TKey>, secondKeySelector: Converter<TInner, TKey>, resultSelector?: BiConverter<TOuter, Sequence<TInner>, TResult>, keyEquater?: EqualityComparison<TKey>) {
constructor(first: Sequence<TOuter>, second: Sequence<TInner>, firstKeySelector: Converter<TOuter, TKey>, secondKeySelector: Converter<TInner, TKey>, resultSelector?: BiConverter<TOuter, Sequence<TInner>, TResult>, keyEquater?: EqualityComparisonOrComparer<TKey>) {
super();
this.#first = first;
@@ -2500,7 +2497,7 @@ class GroupJoinSequence<TOuter, TInner, TKey, TResult> extends BaseSequence<TRes
this.#firstKeySelector = firstKeySelector;
this.#secondKeySelector = secondKeySelector;
this.#resultSelector = resultSelector ?? GroupJoinSequence.#defaultResultSelector as BiConverter<TOuter, Sequence<TInner>, TResult>;
this.#keyEquater = keyEquater ?? strictEquals;
this.#keyEquater = keyEquater ? asEqualityComparer(keyEquater) : defaultEqualityComparer;
}
static #defaultResultSelector<TOuter, TInner>(first: TOuter, second: Sequence<TInner>) {
@@ -2523,7 +2520,7 @@ class GroupJoinSequence<TOuter, TInner, TKey, TResult> extends BaseSequence<TRes
for (const secondObj of this.#second) {
const secondKey = this.#secondKeySelector(secondObj);
if (this.#keyEquater(firstKey, secondKey)) {
if (this.#keyEquater.equals(firstKey, secondKey)) {
secondObjs.push(secondObj);
}
}
@@ -2537,15 +2534,15 @@ class RemoveSequence<T> extends BaseSequence<T> {
readonly #sequence: Sequence<T>;
readonly #obj: T;
readonly #all: boolean;
readonly #equater: EqualityComparison<T>;
readonly #equater: EqualityComparer<T>;
constructor(sequence: Sequence<T>, obj: T, all?: boolean, equater?: EqualityComparison<T>) {
constructor(sequence: Sequence<T>, obj: T, all?: boolean, equater?: EqualityComparisonOrComparer<T>) {
super();
this.#sequence = sequence;
this.#obj = obj;
this.#all = all ?? false;
this.#equater = equater ?? strictEquals;
this.#equater = equater ? asEqualityComparer(equater) : defaultEqualityComparer;
}
override maxCount() {
@@ -2556,7 +2553,7 @@ class RemoveSequence<T> extends BaseSequence<T> {
let gotOne = false;
for (const obj of this.#sequence) {
if (this.#equater(this.#obj, obj)) {
if (this.#equater.equals(this.#obj, obj)) {
if (this.#all) {
continue;
}
@@ -2600,13 +2597,13 @@ class CacheSequence<T> extends BaseSequence<T> {
class PartitionSequence<T> extends BaseSequence<Sequence<T>> {
readonly #sequence: Sequence<T>;
readonly #equater: EqualityComparison<T>;
readonly #equater: EqualityComparisonOrComparer<T> | undefined;
constructor(sequence: Sequence<T>, equater: EqualityComparison<T> | undefined) {
constructor(sequence: Sequence<T>, equater: EqualityComparisonOrComparer<T> | undefined) {
super();
this.#sequence = sequence;
this.#equater = equater ?? strictEquals;
this.#equater = equater;
}
override *iterator() {
@@ -2631,14 +2628,14 @@ class PartitionSequence<T> extends BaseSequence<Sequence<T>> {
class PartitionBySequence<TElement, TBy> extends BaseSequence<Sequence<TElement>> {
readonly #sequence: Sequence<TElement>;
readonly #selector: Converter<TElement, TBy>;
readonly #equater: EqualityComparison<TBy>;
readonly #equater: EqualityComparisonOrComparer<TBy> | undefined;
constructor(sequence: Sequence<TElement>, selector: Converter<TElement, TBy>, equater: EqualityComparison<TBy> | undefined) {
constructor(sequence: Sequence<TElement>, selector: Converter<TElement, TBy>, equater: EqualityComparisonOrComparer<TBy> | undefined) {
super();
this.#sequence = sequence;
this.#selector = selector;
this.#equater = equater ?? strictEquals;
this.#equater = equater;
}
override *iterator() {

40
src/sync/types.ts
View File

@@ -1,7 +1,7 @@
import { AsyncSequence } from "../async/types.js";
import { Collector } from "../collector/types.js";
import { ComparisonOrComparer, Comparer } from "../comparer/types.js";
import { EqualityComparison } from "../equality-comparer/types.js";
import { EqualityComparisonOrComparer } from "../equality-comparer/types.js";
import { RandomOptions } from "../random/types.js";
import { AnyPredicate, Converter, TypePredicate, BiConverter, Accumulator, Action } from "../types.js";
@@ -25,24 +25,24 @@ export interface Sequence<TElement> extends Iterable<TElement> {
where<TFiltered extends TElement>(predicate: TypePredicate<TElement, TFiltered>): Sequence<TFiltered>;
where(predicate: AnyPredicate<TElement>): Sequence<TElement>;
groupBy<TKey>(keySelector: Converter<TElement, TKey>, elementSelector?: undefined, keyComparer?: EqualityComparison<TKey>): Sequence<GroupedSequence<TKey, TElement>>;
groupBy<TKey, TResult>(keySelector: Converter<TElement, TKey>, elementSelector: Converter<TElement, TResult>, keyComparer?: EqualityComparison<TKey>): Sequence<GroupedSequence<TKey, TResult>>;
groupBy<TKey>(keySelector: Converter<TElement, TKey>, elementSelector?: undefined, keyComparer?: EqualityComparisonOrComparer<TKey>): Sequence<GroupedSequence<TKey, TElement>>;
groupBy<TKey, TResult>(keySelector: Converter<TElement, TKey>, elementSelector: Converter<TElement, TResult>, keyComparer?: EqualityComparisonOrComparer<TKey>): Sequence<GroupedSequence<TKey, TResult>>;
join<TOther, TKey>(sequence: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: undefined, keyComparer?: EqualityComparison<TKey>): Sequence<[TElement, TOther]>;
join<TOther, TKey, TResult>(sequence: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector: BiConverter<TElement, TOther, TResult>, keyComparer?: EqualityComparison<TKey>): Sequence<TResult>;
join<TOther, TKey>(sequence: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: undefined, keyComparer?: EqualityComparisonOrComparer<TKey>): Sequence<[TElement, TOther]>;
join<TOther, TKey, TResult>(sequence: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector: BiConverter<TElement, TOther, TResult>, keyComparer?: EqualityComparisonOrComparer<TKey>): Sequence<TResult>;
groupJoin<TOther, TKey>(sequence: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: undefined, keyComparer?: EqualityComparison<TKey>): Sequence<GroupedSequence<TElement, TOther>>;
groupJoin<TOther, TKey, TResult>(sequence: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector: BiConverter<TElement, Iterable<TOther>, TResult>, keyComparer?: EqualityComparison<TKey>): Sequence<TResult>;
groupJoin<TOther, TKey>(sequence: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: undefined, keyComparer?: EqualityComparisonOrComparer<TKey>): Sequence<GroupedSequence<TElement, TOther>>;
groupJoin<TOther, TKey, TResult>(sequence: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector: BiConverter<TElement, Iterable<TOther>, TResult>, keyComparer?: EqualityComparisonOrComparer<TKey>): Sequence<TResult>;
contains(obj: TElement, equater?: EqualityComparison<TElement>): boolean;
contains(obj: TElement, equater?: EqualityComparisonOrComparer<TElement>): boolean;
sequenceEquals(sequence: Iterable<TElement>, equater?: EqualityComparison<TElement>): boolean;
sequenceEquals(sequence: Iterable<TElement>, equater?: EqualityComparisonOrComparer<TElement>): boolean;
append(obj: TElement): Sequence<TElement>;
prepend(obj: TElement): Sequence<TElement>;
remove(obj: TElement, all?: boolean, equater?: EqualityComparison<TElement>): Sequence<TElement>;
remove(obj: TElement, all?: boolean, equater?: EqualityComparisonOrComparer<TElement>): Sequence<TElement>;
concat(...sequences: Iterable<TElement>[]): Sequence<TElement>;
@@ -77,20 +77,20 @@ export interface Sequence<TElement> extends Iterable<TElement> {
orderDescending(comparer?: ComparisonOrComparer<TElement>): OrderedSequence<TElement>;
orderByDescending<TBy>(selector: Converter<TElement, TBy>, comparer?: ComparisonOrComparer<TBy>): OrderedSequence<TElement>;
partition(equater?: EqualityComparison<TElement>): Sequence<Sequence<TElement>>;
partitionBy<TBy>(selector: Converter<TElement, TBy>, equater?: EqualityComparison<TBy>): Sequence<Sequence<TElement>>;
partition(equater?: EqualityComparisonOrComparer<TElement>): Sequence<Sequence<TElement>>;
partitionBy<TBy>(selector: Converter<TElement, TBy>, equater?: EqualityComparisonOrComparer<TBy>): Sequence<Sequence<TElement>>;
distinct(equater?: EqualityComparison<TElement>): Sequence<TElement>;
distinctBy<TBy>(selector: Converter<TElement, TBy>, equater?: EqualityComparison<TBy>): Sequence<TElement>;
distinct(equater?: EqualityComparisonOrComparer<TElement>): Sequence<TElement>;
distinctBy<TBy>(selector: Converter<TElement, TBy>, equater?: EqualityComparisonOrComparer<TBy>): Sequence<TElement>;
union(sequence: Iterable<TElement>, equater?: EqualityComparison<TElement>): Sequence<TElement>;
unionBy<TBy>(sequence: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: EqualityComparison<TBy>): Sequence<TElement>;
union(sequence: Iterable<TElement>, equater?: EqualityComparisonOrComparer<TElement>): Sequence<TElement>;
unionBy<TBy>(sequence: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: EqualityComparisonOrComparer<TBy>): Sequence<TElement>;
except(sequence: Iterable<TElement>, equater?: EqualityComparison<TElement>): Sequence<TElement>;
exceptBy<TBy>(sequence: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: EqualityComparison<TBy>): Sequence<TElement>;
except(sequence: Iterable<TElement>, equater?: EqualityComparisonOrComparer<TElement>): Sequence<TElement>;
exceptBy<TBy>(sequence: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: EqualityComparisonOrComparer<TBy>): Sequence<TElement>;
intersect(sequence: Iterable<TElement>, equater?: EqualityComparison<TElement>): Sequence<TElement>;
intersectBy<TBy>(sequence: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: EqualityComparison<TBy>): Sequence<TElement>;
intersect(sequence: Iterable<TElement>, equater?: EqualityComparisonOrComparer<TElement>): Sequence<TElement>;
intersectBy<TBy>(sequence: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: EqualityComparisonOrComparer<TBy>): Sequence<TElement>;
all(predicate: AnyPredicate<TElement>): boolean;
any(predicate: AnyPredicate<TElement>): boolean;