properly implement comparer and equality comparer combination

src/equality-comparer/async.ts

@@ -22,8 +22,8 @@ export function createAsyncEqualityComparerUsing<T = any, U = any>(projection: M
   return new MappedAsyncEqualityComparer(projection, equalityComparison);
 }
 
-export function combineNullableAsyncEqualityComparers<T>(equalityComparers: Nullable<MaybeAsyncEqualityComparisonOrComparer<T>>[]) {
-  let result = defaultAsyncEqualityComparer;
+export function combineAsyncEqualityComparers<T>(equalityComparers: Iterable<Nullable<MaybeAsyncEqualityComparisonOrComparer<T>>>) {
+  let result: AsyncEqualityComparer<T> = alwaysTrueAsyncEqualityComparer;
 
   for (const equalityComparer of equalityComparers) {
     if (!equalityComparer) {
@@ -33,7 +33,7 @@ export function combineNullableAsyncEqualityComparers<T>(equalityComparers: Null
     result = result.then(asAsyncEqualityComparer(equalityComparer));
   }
 
-  return result === defaultAsyncEqualityComparer ? undefined : result;
+  return result === alwaysTrueAsyncEqualityComparer ? undefined : result;
 }
 
 export abstract class BaseAsyncEqualityComparer<T> implements AsyncEqualityComparer<T> {
@@ -140,6 +140,50 @@ class ThenAsyncEqualityComparer<T> extends BaseAsyncEqualityComparer<T> {
   }
 }
 
+export const alwaysAsyncFalseEqualityComparer = new class AlwaysFalseAsyncEqualityComparer extends BaseAsyncEqualityComparer<any> {
+  public override async equals(_a: any, _b: any): Promise<boolean> {
+    return false;
+  }
+
+  public override opposite(): AsyncEqualityComparer<any> {
+    return alwaysTrueAsyncEqualityComparer;
+  }
+
+  public override then(_equalityComparer: AsyncEqualityComparer<any>): AsyncEqualityComparer<any> {
+    return this;
+  }
+
+  public override thenEquals(_equalityComparison: MaybeAsyncEqualityComparison<any>): AsyncEqualityComparer<any> {
+    return this;
+  }
+
+  public override thenEqualsUsing<U>(_projection: MaybeAsyncConverter<any, U>, _equalityComparison?: MaybeAsyncEqualityComparisonOrComparer<U> | undefined): AsyncEqualityComparer<any> {
+    return this;
+  }
+};
+
+export const alwaysTrueAsyncEqualityComparer = new class AlwaysTrueAsyncEqualityComparer extends BaseAsyncEqualityComparer<any> {
+  public override async equals(_a: any, _b: any): Promise<boolean> {
+    return true;
+  }
+
+  public override opposite(): AsyncEqualityComparer<any> {
+    return alwaysAsyncFalseEqualityComparer;
+  }
+
+  public override then(equalityComparer: AsyncEqualityComparer<any>): AsyncEqualityComparer<any> {
+    return equalityComparer;
+  }
+
+  public override thenEquals(equalityComparison: MaybeAsyncEqualityComparison<any>): AsyncEqualityComparer<any> {
+    return createAsyncEqualityComparer(equalityComparison);
+  }
+
+  public override thenEqualsUsing<U>(projection: MaybeAsyncConverter<any, U>, equalityComparison?: MaybeAsyncEqualityComparisonOrComparer<U> | undefined): AsyncEqualityComparer<any> {
+    return createAsyncEqualityComparerUsing(projection, equalityComparison);
+  }
+};
+
 export const looseAsyncEqualityComparer: AsyncEqualityComparer<any> = new class LooseAsyncEqualityComparer extends BaseAsyncEqualityComparer<any> {
   public override async equals(a: any, b: any): Promise<boolean> {
     return a == b;

src/equality-comparer/sync.ts

@@ -18,8 +18,8 @@ export function createEqualityComparerUsing<T = any, U = any>(projection: Conver
   return new MappedEqualityComparer(projection, equalityComparison);
 }
 
-export function combineNullableEqualityComparers<T>(equalityComparers: Nullable<EqualityComparisonOrComparer<T>>[]) {
-  let result = defaultEqualityComparer;
+export function combineEqualityComparers<T>(equalityComparers: Iterable<Nullable<EqualityComparisonOrComparer<T>>>) {
+  let result: EqualityComparer<T> = alwaysTrueEqualityComparer;
 
   for (const equalityComparer of equalityComparers) {
     if (!equalityComparer) {
@@ -29,7 +29,7 @@ export function combineNullableEqualityComparers<T>(equalityComparers: Nullable<
     result = result.then(asEqualityComparer(equalityComparer));
   }
 
-  return result === defaultEqualityComparer ? undefined : result;
+  return result === alwaysTrueEqualityComparer ? undefined : result;
 }
 
 export abstract class BaseEqualityComparer<T> implements EqualityComparer<T> {
@@ -126,6 +126,50 @@ class ThenEqualityComparer<T> extends BaseEqualityComparer<T> {
   }
 }
 
+export const alwaysFalseEqualityComparer = new class AlwaysFalseEqualityComparer extends BaseEqualityComparer<any> {
+  public override equals(_a: any, _b: any): boolean {
+    return false;
+  }
+
+  public override opposite(): EqualityComparer<any> {
+    return alwaysTrueEqualityComparer;
+  }
+
+  public override then(_equalityComparer: EqualityComparer<any>): EqualityComparer<any> {
+    return this;
+  }
+
+  public override thenEquals(_equalityComparison: EqualityComparison<any>): EqualityComparer<any> {
+    return this;
+  }
+
+  public override thenEqualsUsing<U>(_projection: Converter<any, U>, _equalityComparison?: EqualityComparisonOrComparer<U> | undefined): EqualityComparer<any> {
+    return this;
+  }
+};
+
+export const alwaysTrueEqualityComparer = new class AlwaysTrueEqualityComparer extends BaseEqualityComparer<any> {
+  public override equals(_a: any, _b: any): boolean {
+    return true;
+  }
+
+  public override opposite(): EqualityComparer<any> {
+    return alwaysFalseEqualityComparer;
+  }
+
+  public override then(equalityComparer: EqualityComparer<any>): EqualityComparer<any> {
+    return equalityComparer;
+  }
+
+  public override thenEquals(equalityComparison: EqualityComparison<any>): EqualityComparer<any> {
+    return createEqualityComparer(equalityComparison);
+  }
+
+  public override thenEqualsUsing<U>(projection: Converter<any, U>, equalityComparison?: EqualityComparisonOrComparer<U> | undefined): EqualityComparer<any> {
+    return createEqualityComparerUsing(projection, equalityComparison);
+  }
+};
+
 export const looseEqualityComparer: EqualityComparer<any> = new class LooseEqualityComparer extends BaseEqualityComparer<any> {
   public override equals(a: any, b: any): boolean {
     return a == b;