diff --git a/src/async/impl.ts b/src/async/impl.ts
index f7022f6..ee85c95 100644
--- a/src/async/impl.ts
+++ b/src/async/impl.ts
@@ -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() {
diff --git a/src/async/types.ts b/src/async/types.ts
index 71e841c..767ffd9 100644
--- a/src/async/types.ts
+++ b/src/async/types.ts
@@ -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>;
diff --git a/src/comparer/async.ts b/src/comparer/async.ts
index ca9edfb..23c5408 100644
--- a/src/comparer/async.ts
+++ b/src/comparer/async.ts
@@ -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);
 }
 
diff --git a/src/comparer/sync.ts b/src/comparer/sync.ts
index f8227e4..f5cb18e 100644
--- a/src/comparer/sync.ts
+++ b/src/comparer/sync.ts
@@ -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>> {
diff --git a/src/equality-comparer/async.ts b/src/equality-comparer/async.ts
new file mode 100644
index 0000000..02fc651
--- /dev/null
+++ b/src/equality-comparer/async.ts
@@ -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();
+  }
+};
diff --git a/src/equality-comparer/sync.ts b/src/equality-comparer/sync.ts
index c2670f5..d1cf0f1 100644
--- a/src/equality-comparer/sync.ts
+++ b/src/equality-comparer/sync.ts
@@ -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);
diff --git a/src/equality-comparer/types.ts b/src/equality-comparer/types.ts
index 3c63b70..1fea91c 100644
--- a/src/equality-comparer/types.ts
+++ b/src/equality-comparer/types.ts
@@ -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>;
+
diff --git a/src/equality-map/impl.ts b/src/equality-map/impl.ts
index 5dacf8d..b2f6e8f 100644
--- a/src/equality-map/impl.ts
+++ b/src/equality-map/impl.ts
@@ -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];
       }
diff --git a/src/equality-map/index.ts b/src/equality-map/index.ts
index 1ef22f3..f7adea4 100644
--- a/src/equality-map/index.ts
+++ b/src/equality-map/index.ts
@@ -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>();
 }
diff --git a/src/equality-set/impl.ts b/src/equality-set/impl.ts
index 8eeae30..a98b244 100644
--- a/src/equality-set/impl.ts
+++ b/src/equality-set/impl.ts
@@ -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;
       }
diff --git a/src/equality-set/index.ts b/src/equality-set/index.ts
index f814368..43fd96a 100644
--- a/src/equality-set/index.ts
+++ b/src/equality-set/index.ts
@@ -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>();
 }
diff --git a/src/sync/impl.ts b/src/sync/impl.ts
index 312f2a6..e706638 100644
--- a/src/sync/impl.ts
+++ b/src/sync/impl.ts
@@ -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() {
diff --git a/src/sync/types.ts b/src/sync/types.ts
index bf791a3..b27bb0b 100644
--- a/src/sync/types.ts
+++ b/src/sync/types.ts
@@ -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;