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 e57f2900df
commit 1fb91deabd
14 changed files with 426 additions and 250 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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