sync

src/async/impl.ts

@@ -1,4 +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, identity } from "../equality-comparer/index.js";
+import { MaybeAsyncEqualityComparison } from "../equality-comparer/types.js";
 import { createAsyncEqualityMap } from "../equality-map.js";
 import { createAsyncEqualitySet } from "../equality-set.js";
 import { createQueue } from "../queue.js";
@@ -6,8 +10,8 @@ import { getRandomElementAsync } from "../random/index.js";
 import { AsyncRandomOptions } from "../random/types.js";
 import { selectionSorter } from "../sorting.js";
 import { Sequence } from "../sync/types.js";
-import { MaybeAsyncAnyPredicate, MaybeAsyncConverter, MaybeAsyncEquater, MaybeAsyncBiConverter, MaybeAsyncAccumulator, MaybeAsyncComparer, MaybeAsyncAction, MaybePromiseLike, MaybeAsyncGenerator, MaybeAsyncSequence, MaybePromise } from "../types.js";
-import { strictEquals, identity, operatorCompare, defaultArrayComparer, combineAsyncComparers, asAsyncIterable } from "../utils.js";
+import { MaybeAsyncAnyPredicate, MaybeAsyncConverter, MaybeAsyncBiConverter, MaybeAsyncAccumulator, MaybeAsyncAction, MaybePromiseLike, MaybeAsyncGenerator, MaybePromise, MaybeAsyncIterable, MaybeAsyncTypePredicate } from "../types.js";
+import { asAsyncIterable } from "../utils.js";
 import { array, empty, wrap } from "./index.js";
 import { AsyncSequence, AsyncSequencePipeline, GroupedAsyncSequence, OrderedAsyncSequence } from "./types.js";
 
@@ -28,33 +32,35 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
     return new SelectAsyncSequence<TElement, TResult>(this, converter);
   }
 
-  selectMany<TResult>(converter: MaybeAsyncConverter<TElement, MaybeAsyncSequence<TResult>>): AsyncSequence<TResult> {
+  selectMany<TResult>(converter: MaybeAsyncConverter<TElement, MaybeAsyncIterable<TResult>>): AsyncSequence<TResult> {
     return new SelectManyAsyncSequence<TElement, TResult>(this, converter);
   }
 
-  where(predicate: MaybeAsyncAnyPredicate<TElement>): AsyncSequence<TElement> {
-    return new WhereAsyncSequence<TElement>(this, predicate);
+  where<TFiltered extends TElement>(predicate: MaybeAsyncTypePredicate<TElement, TFiltered>): AsyncSequence<TFiltered>;
+  where(predicate: MaybeAsyncAnyPredicate<TElement>): AsyncSequence<TElement>;
+  where(predicate: any) {
+    return new WhereAsyncSequence<TElement, any>(this, predicate);
   }
 
-  groupBy<TKey>(keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector?: undefined, keyComparer?: MaybeAsyncEquater<TKey> | undefined): AsyncSequence<GroupedAsyncSequence<TKey, TElement>>;
-  groupBy<TKey, TResult>(keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector: MaybeAsyncConverter<TElement, TResult>, keyComparer?: MaybeAsyncEquater<TKey> | undefined): AsyncSequence<GroupedAsyncSequence<TKey, TResult>>;
+  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(keySelector: any, elementSelector?: any, keyComparer?: any) {
     return new GroupByAsyncSequence<any, any, any>(this, keySelector, elementSelector, keyComparer);
   }
 
-  join<TOther, TKey>(sequence: MaybeAsyncSequence<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector?: undefined, keyComparer?: MaybeAsyncEquater<TKey> | undefined): AsyncSequence<[TElement, TOther]>;
-  join<TOther, TKey, TResult>(sequence: MaybeAsyncSequence<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector: MaybeAsyncBiConverter<TElement, TOther, TResult>, keyComparer?: MaybeAsyncEquater<TKey> | undefined): AsyncSequence<TResult>;
+  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(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: MaybeAsyncSequence<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector?: undefined, keyComparer?: MaybeAsyncEquater<TKey> | undefined): AsyncSequence<GroupedAsyncSequence<TElement, TOther>>;
-  groupJoin<TOther, TKey, TResult>(sequence: MaybeAsyncSequence<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector: MaybeAsyncBiConverter<TElement, AsyncSequence<TOther>, TResult>, keyComparer?: MaybeAsyncEquater<TKey> | undefined): AsyncSequence<TResult>;
+  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(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?: MaybeAsyncEquater<TElement>) {
+  async contains(obj: TElement, equater?: MaybeAsyncEqualityComparison<TElement>) {
     if (!equater) {
       equater = strictEquals;
     }
@@ -68,7 +74,7 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
     return false;
   }
 
-  async sequenceEquals(sequence: MaybeAsyncSequence<TElement>, equater?: MaybeAsyncEquater<TElement>) {
+  async sequenceEquals(sequence: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEqualityComparison<TElement>) {
     if (this === sequence) {
       return true;
     }
@@ -115,11 +121,11 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
     return new PrependAsyncSequence<TElement>(this, obj);
   }
 
-  remove(obj: TElement, all?: boolean, equater?: MaybeAsyncEquater<TElement>): AsyncSequence<TElement> {
+  remove(obj: TElement, all?: boolean, equater?: MaybeAsyncEqualityComparison<TElement>): AsyncSequence<TElement> {
     return new RemoveAsyncSequence<TElement>(this, obj, all, equater);
   }
 
-  concat(...sequences: MaybeAsyncSequence<TElement>[]): AsyncSequence<TElement> {
+  concat(...sequences: MaybeAsyncIterable<TElement>[]): AsyncSequence<TElement> {
     if (sequences.length === 0) {
       return this;
     }
@@ -391,7 +397,7 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
     return acc as unknown as TResult;
   }
 
-  async #find<TResult>(sorter: MaybeAsyncAnyPredicate<number>, selector?: MaybeAsyncConverter<TElement, TResult>, comparer?: MaybeAsyncComparer<TResult>) {
+  async #find<TResult>(sorter: MaybeAsyncAnyPredicate<number>, selector?: MaybeAsyncConverter<TElement, TResult>, comparer?: MaybeAsyncComparisonOrComparer<TResult>) {
     const iterator = this.iterator();
 
     let next = await iterator.next();
@@ -404,9 +410,7 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
       selector = identity as MaybeAsyncConverter<TElement, TResult>;
     }
 
-    if (!comparer) {
-      comparer = operatorCompare;
-    }
+    comparer = comparer ? asAsyncComparer(comparer) : defaultAsyncComparer;
 
     let result = next.value;
     let convertedResult = await selector(result);
@@ -421,7 +425,7 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
       const value = next.value;
       const convertedValue = await selector(value);
 
-      if (await sorter(await comparer(convertedResult, convertedValue))) {
+      if (await sorter(await comparer.compare(convertedResult, convertedValue))) {
         result = value;
         convertedResult = convertedValue;
       }
@@ -430,75 +434,125 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
     return result;
   }
 
-  min(comparer?: MaybeAsyncComparer<TElement>) {
+  min(comparer?: MaybeAsyncComparisonOrComparer<TElement>) {
     return this.#find(x => x > 0, undefined, comparer);
   }
 
-  minBy<TBy>(converter: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparer<TBy>) {
+  minBy<TBy>(converter: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparisonOrComparer<TBy>) {
     return this.#find(x => x > 0, converter, comparer);
   }
 
-  max(comparer?: MaybeAsyncComparer<TElement>) {
+  max(comparer?: MaybeAsyncComparisonOrComparer<TElement>) {
     return this.#find(x => x < 0, undefined, comparer);
   }
 
-  maxBy<TBy>(converter: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparer<TBy>) {
+  maxBy<TBy>(converter: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparisonOrComparer<TBy>) {
     return this.#find(x => x < 0, converter, comparer);
   }
 
-  order(comparer?: MaybeAsyncComparer<TElement>): OrderedAsyncSequence<TElement> {
+  async #findBounds<TResult>(selector?: MaybeAsyncConverter<TElement, TResult>, comparer?: MaybeAsyncComparisonOrComparer<TResult>): Promise<[min: TElement, max: TElement]> {
+    const iterator = this.iterator();
+
+    let next = await iterator.next();
+
+    if (next.done) {
+      throw new Error("Sequence contains no element.");
+    }
+
+    if (!selector) {
+      selector = identity as MaybeAsyncConverter<TElement, TResult>;
+    }
+
+    comparer = comparer ? asAsyncComparer(comparer) : defaultAsyncComparer;
+
+    let minBound = next.value, maxBound = minBound;
+    let convertedMinBound = await selector(minBound), convertedMaxBound = convertedMinBound;
+
+    while (true) {
+      next = await iterator.next();
+
+      if (next.done) {
+        break;
+      }
+
+      const value = next.value;
+      const convertedValue = await selector(value);
+
+      if (await comparer.compare(convertedMinBound, convertedValue) > 0) {
+        minBound = value;
+        convertedMinBound = convertedValue;
+      }
+
+      if (await comparer.compare(convertedMaxBound, convertedValue) < 0) {
+        maxBound = value;
+        convertedMaxBound = convertedValue;
+      }
+    }
+
+    return [minBound, maxBound];
+  }
+
+  bounds(comparer?: MaybeAsyncComparisonOrComparer<TElement>) {
+    return this.#findBounds(undefined, comparer);
+  }
+
+  boundsBy<TBy>(converter: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparisonOrComparer<TBy>) {
+    return this.#findBounds(converter, comparer);
+  }
+
+  order(comparer?: MaybeAsyncComparisonOrComparer<TElement>): OrderedAsyncSequence<TElement> {
     return new OrderAsyncSequence<TElement>(this, false, comparer);
   }
 
-  orderBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparer<TBy>): OrderedAsyncSequence<TElement> {
+  orderBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparisonOrComparer<TBy>): OrderedAsyncSequence<TElement> {
     return new OrderByAsyncSequence<TElement, TBy>(this, false, selector, comparer);
   }
 
-  orderDescending(comparer?: MaybeAsyncComparer<TElement>): OrderedAsyncSequence<TElement> {
+  orderDescending(comparer?: MaybeAsyncComparisonOrComparer<TElement>): OrderedAsyncSequence<TElement> {
     return new OrderAsyncSequence<TElement>(this, true, comparer);
   }
 
-  orderByDescending<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparer<TBy>): OrderedAsyncSequence<TElement> {
+  orderByDescending<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparisonOrComparer<TBy>): OrderedAsyncSequence<TElement> {
     return new OrderByAsyncSequence<TElement, TBy>(this, true, selector, comparer);
   }
 
-  partition(equater?: MaybeAsyncEquater<TElement>): AsyncSequence<AsyncSequence<TElement>> {
+  partition(equater?: MaybeAsyncEqualityComparison<TElement>): AsyncSequence<AsyncSequence<TElement>> {
     return new PartitionAsyncSequence<TElement>(this, equater);
   }
 
-  partitionBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncSequence<AsyncSequence<TElement>> {
+  partitionBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparison<TBy>): AsyncSequence<AsyncSequence<TElement>> {
     return new PartitionByAsyncSequence<TElement, TBy>(this, selector, equater);
   }
 
-  distinct(equater?: MaybeAsyncEquater<TElement>): AsyncSequence<TElement> {
+  distinct(equater?: MaybeAsyncEqualityComparison<TElement>): AsyncSequence<TElement> {
     return new DistinctAsyncSequence<TElement>(this, equater);
   }
 
-  distinctBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncSequence<TElement> {
+  distinctBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparison<TBy>): AsyncSequence<TElement> {
     return new DistinctByAsyncSequence<TElement, TBy>(this, selector, equater);
   }
 
-  union(sequence: MaybeAsyncSequence<TElement>, equater?: MaybeAsyncEquater<TElement>): AsyncSequence<TElement> {
+  union(sequence: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEqualityComparison<TElement>): AsyncSequence<TElement> {
     return new UnionAsyncSequence<TElement>(this, wrap(sequence), equater);
   }
 
-  unionBy<TBy>(sequence: MaybeAsyncSequence<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncSequence<TElement> {
+  unionBy<TBy>(sequence: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparison<TBy>): AsyncSequence<TElement> {
     return new UnionByAsyncSequence<TElement, TBy>(this, wrap(sequence), selector, equater);
   }
 
-  except(sequence: MaybeAsyncSequence<TElement>): AsyncSequence<TElement> {
+  except(sequence: MaybeAsyncIterable<TElement>): AsyncSequence<TElement> {
     return new ExceptAsyncSequence<TElement>(this, wrap(sequence));
   }
 
-  exceptBy<TBy>(sequence: MaybeAsyncSequence<TElement>, selector: MaybeAsyncConverter<TElement, TBy>): AsyncSequence<TElement> {
+  exceptBy<TBy>(sequence: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>): AsyncSequence<TElement> {
     return new ExceptByAsyncSequence<TElement, TBy>(this, wrap(sequence), selector);
   }
 
-  intersect(sequence: MaybeAsyncSequence<TElement>): AsyncSequence<TElement> {
+  intersect(sequence: MaybeAsyncIterable<TElement>): AsyncSequence<TElement> {
     return new IntersectAsyncSequence<TElement>(this, wrap(sequence));
   }
 
-  intersectBy<TBy>(sequence: MaybeAsyncSequence<TElement>, selector: MaybeAsyncConverter<TElement, TBy>): AsyncSequence<TElement> {
+  intersectBy<TBy>(sequence: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>): AsyncSequence<TElement> {
     return new IntersectByAsyncSequence<TElement, TBy>(this, wrap(sequence), selector);
   }
 
@@ -608,7 +662,7 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
     }
   }
 
-  zip<TOther>(sequence: MaybeAsyncSequence<TOther>): AsyncSequence<[TElement, TOther]> {
+  zip<TOther>(sequence: MaybeAsyncIterable<TOther>): AsyncSequence<[TElement, TOther]> {
     return new ZippedAsyncSequence<TElement, TOther>(this, wrap(sequence));
   }
 
@@ -753,37 +807,39 @@ export class DelegatedAsyncSequence<TElement> extends AsyncSequenceMarker implem
     return this.#sequence.select(selector);
   }
 
-  selectMany<TResult>(selector: MaybeAsyncConverter<TElement, MaybeAsyncSequence<TResult>>): AsyncSequence<TResult> {
+  selectMany<TResult>(selector: MaybeAsyncConverter<TElement, MaybeAsyncIterable<TResult>>): AsyncSequence<TResult> {
     return this.#sequence.selectMany(selector);
   }
 
-  where(predicate: MaybeAsyncAnyPredicate<TElement>): AsyncSequence<TElement> {
+  where<TFiltered extends TElement>(predicate: MaybeAsyncTypePredicate<TElement, TFiltered>): AsyncSequence<TFiltered>;
+  where(predicate: MaybeAsyncAnyPredicate<TElement>): AsyncSequence<TElement>;
+  where(predicate: any) {
     return this.#sequence.where(predicate);
   }
 
-  groupBy<TKey>(keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector?: undefined, keyComparer?: MaybeAsyncEquater<TKey> | undefined): AsyncSequence<GroupedAsyncSequence<TKey, TElement>>;
-  groupBy<TKey, TResult>(keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector: MaybeAsyncConverter<TElement, TResult>, keyComparer?: MaybeAsyncEquater<TKey> | undefined): AsyncSequence<GroupedAsyncSequence<TKey, TResult>>;
+  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(keySelector: any, elementSelector?: any, keyComparer?: any) {
     return this.#sequence.groupBy(keySelector, elementSelector, keyComparer);
   }
 
-  join<TOther, TKey>(sequence: MaybeAsyncSequence<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector?: undefined, keyComparer?: MaybeAsyncEquater<TKey> | undefined): AsyncSequence<[TElement, TOther]>;
-  join<TOther, TKey, TResult>(sequence: MaybeAsyncSequence<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector: MaybeAsyncBiConverter<TElement, TOther, TResult>, keyComparer?: MaybeAsyncEquater<TKey> | undefined): AsyncSequence<TResult>;
+  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(sequence: any, firstKeySelector: any, secondKeySelector: any, resultSelector?: any, keyComparer?: any) {
     return this.#sequence.join(sequence, firstKeySelector, secondKeySelector, resultSelector, keyComparer);
   }
 
-  groupJoin<TOther, TKey>(sequence: MaybeAsyncSequence<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector?: undefined, keyComparer?: MaybeAsyncEquater<TKey> | undefined): AsyncSequence<GroupedAsyncSequence<TElement, TOther>>;
-  groupJoin<TOther, TKey, TResult>(sequence: MaybeAsyncSequence<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector: MaybeAsyncBiConverter<TElement, AsyncSequence<TOther>, TResult>, keyComparer?: MaybeAsyncEquater<TKey> | undefined): AsyncSequence<TResult>;
+  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(sequence: any, firstKeySelector: any, secondKeySelector: any, resultSelector?: any, keyComparer?: any) {
     return this.#sequence.groupJoin(sequence, firstKeySelector, secondKeySelector, resultSelector, keyComparer);
   }
 
-  contains(obj: TElement, equater?: MaybeAsyncEquater<TElement> | undefined): Promise<boolean> {
+  contains(obj: TElement, equater?: MaybeAsyncEqualityComparison<TElement> | undefined): Promise<boolean> {
     return this.#sequence.contains(obj, equater);
   }
 
-  sequenceEquals(sequence: MaybeAsyncSequence<TElement>, equater?: MaybeAsyncEquater<TElement> | undefined): Promise<boolean> {
+  sequenceEquals(sequence: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEqualityComparison<TElement> | undefined): Promise<boolean> {
     return this.#sequence.sequenceEquals(sequence, equater);
   }
 
@@ -795,11 +851,11 @@ export class DelegatedAsyncSequence<TElement> extends AsyncSequenceMarker implem
     return this.#sequence.prepend(obj);
   }
 
-  remove(obj: TElement, all?: boolean | undefined, equater?: MaybeAsyncEquater<TElement> | undefined): AsyncSequence<TElement> {
+  remove(obj: TElement, all?: boolean | undefined, equater?: MaybeAsyncEqualityComparison<TElement> | undefined): AsyncSequence<TElement> {
     return this.#sequence.remove(obj, all, equater);
   }
 
-  concat(...sequences: MaybeAsyncSequence<TElement>[]): AsyncSequence<TElement> {
+  concat(...sequences: MaybeAsyncIterable<TElement>[]): AsyncSequence<TElement> {
     return this.#sequence.concat(...sequences);
   }
 
@@ -858,59 +914,67 @@ export class DelegatedAsyncSequence<TElement> extends AsyncSequenceMarker implem
     return this.#sequence.maxBy(selector);
   }
 
-  order(comparer?: MaybeAsyncComparer<TElement> | undefined): AsyncSequence<TElement> {
+  bounds(comparer?: MaybeAsyncComparisonOrComparer<TElement> | undefined): Promise<[min: TElement, max: TElement]> {
+    return this.#sequence.bounds(comparer);
+  }
+
+  boundsBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparisonOrComparer<TBy> | undefined): Promise<[min: TElement, max: TElement]> {
+    return this.#sequence.boundsBy(selector, comparer);
+  }
+
+  order(comparer?: MaybeAsyncComparisonOrComparer<TElement> | undefined): AsyncSequence<TElement> {
     return this.#sequence.order(comparer);
   }
 
-  orderBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparer<TBy> | undefined): AsyncSequence<TElement> {
+  orderBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparisonOrComparer<TBy> | undefined): AsyncSequence<TElement> {
     return this.#sequence.orderBy(selector, comparer);
   }
 
-  orderDescending(comparer?: MaybeAsyncComparer<TElement> | undefined): AsyncSequence<TElement> {
+  orderDescending(comparer?: MaybeAsyncComparisonOrComparer<TElement> | undefined): AsyncSequence<TElement> {
     return this.#sequence.orderDescending(comparer);
   }
 
-  orderByDescending<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparer<TBy> | undefined): AsyncSequence<TElement> {
+  orderByDescending<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparisonOrComparer<TBy> | undefined): AsyncSequence<TElement> {
     return this.#sequence.orderByDescending(selector, comparer);
   }
 
-  partition(equater?: MaybeAsyncEquater<TElement> | undefined): AsyncSequence<AsyncSequence<TElement>> {
+  partition(equater?: MaybeAsyncEqualityComparison<TElement> | undefined): AsyncSequence<AsyncSequence<TElement>> {
     return this.#sequence.partition(equater);
   }
 
-  partitionBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy> | undefined): AsyncSequence<AsyncSequence<TElement>> {
+  partitionBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparison<TBy> | undefined): AsyncSequence<AsyncSequence<TElement>> {
     return this.#sequence.partitionBy(selector, equater);
   }
 
-  distinct(equater?: MaybeAsyncEquater<TElement> | undefined): AsyncSequence<TElement> {
+  distinct(equater?: MaybeAsyncEqualityComparison<TElement> | undefined): AsyncSequence<TElement> {
     return this.#sequence.distinct(equater);
   }
 
-  distinctBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy> | undefined): AsyncSequence<TElement> {
+  distinctBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparison<TBy> | undefined): AsyncSequence<TElement> {
     return this.#sequence.distinctBy(selector, equater);
   }
 
-  union(sequence: MaybeAsyncSequence<TElement>, equater?: MaybeAsyncEquater<TElement> | undefined): AsyncSequence<TElement> {
+  union(sequence: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEqualityComparison<TElement> | undefined): AsyncSequence<TElement> {
     return this.#sequence.union(wrap(sequence), equater);
   }
 
-  unionBy<TBy>(sequence: MaybeAsyncSequence<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy> | undefined): AsyncSequence<TElement> {
+  unionBy<TBy>(sequence: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparison<TBy> | undefined): AsyncSequence<TElement> {
     return this.#sequence.unionBy(wrap(sequence), selector, equater);
   }
 
-  except(sequence: MaybeAsyncSequence<TElement>, equater?: MaybeAsyncEquater<TElement> | undefined): AsyncSequence<TElement> {
+  except(sequence: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEqualityComparison<TElement> | undefined): AsyncSequence<TElement> {
     return this.#sequence.except(wrap(sequence), equater);
   }
 
-  exceptBy<TBy>(sequence: MaybeAsyncSequence<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy> | undefined): AsyncSequence<TElement> {
+  exceptBy<TBy>(sequence: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparison<TBy> | undefined): AsyncSequence<TElement> {
     return this.#sequence.exceptBy(wrap(sequence), selector, equater);
   }
 
-  intersect(sequence: MaybeAsyncSequence<TElement>, equater?: MaybeAsyncEquater<TElement> | undefined): AsyncSequence<TElement> {
+  intersect(sequence: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEqualityComparison<TElement> | undefined): AsyncSequence<TElement> {
     return this.#sequence.intersect(wrap(sequence), equater);
   }
 
-  intersectBy<TBy>(sequence: MaybeAsyncSequence<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy> | undefined): AsyncSequence<TElement> {
+  intersectBy<TBy>(sequence: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparison<TBy> | undefined): AsyncSequence<TElement> {
     return this.#sequence.intersectBy(wrap(sequence), selector, equater);
   }
 
@@ -962,7 +1026,7 @@ export class DelegatedAsyncSequence<TElement> extends AsyncSequenceMarker implem
     return this.#sequence.forEach(action);
   }
 
-  zip<TOther>(sequence: MaybeAsyncSequence<TOther>): AsyncSequence<[TElement, TOther]> {
+  zip<TOther>(sequence: MaybeAsyncIterable<TOther>): AsyncSequence<[TElement, TOther]> {
     return this.#sequence.zip(wrap(sequence));
   }
 
@@ -1033,14 +1097,14 @@ export class GroupedAsyncSequenceImpl<TElement, TKey> extends DelegatedAsyncSequ
 
 abstract class BaseOrderedAsyncSequence<TElement> extends BaseAsyncSequence<TElement> implements OrderedAsyncSequence<TElement> {
   readonly #sequence: AsyncSequence<TElement>;
-  readonly #sorter: MaybeAsyncComparer<TElement>;
+  readonly #sorter: AsyncComparer<TElement>;
   readonly #descending: boolean;
 
-  constructor(sequence: AsyncSequence<TElement>, sorter: MaybeAsyncComparer<TElement>, descending: boolean) {
+  constructor(sequence: AsyncSequence<TElement>, sorter: MaybeAsyncComparisonOrComparer<TElement> | undefined, descending: boolean) {
     super();
 
     this.#sequence = sequence;
-    this.#sorter = sorter;
+    this.#sorter = sorter ? asAsyncComparer(sorter) : defaultAsyncComparer;
     this.#descending = descending;
   }
 
@@ -1056,19 +1120,19 @@ abstract class BaseOrderedAsyncSequence<TElement> extends BaseAsyncSequence<TEle
     return this.#sorter;
   }
 
-  thenSelf(comparer?: MaybeAsyncComparer<TElement>): OrderedAsyncSequence<TElement> {
+  thenSelf(comparer?: MaybeAsyncComparisonOrComparer<TElement>): OrderedAsyncSequence<TElement> {
     return new ThenOrderAsyncSequence(this, false, comparer);
   }
 
-  thenBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparer<TBy>): OrderedAsyncSequence<TElement> {
+  thenBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparisonOrComparer<TBy>): OrderedAsyncSequence<TElement> {
     return new ThenOrderByAsyncSequence<TElement, TBy>(this, false, selector, comparer);
   }
 
-  thenSelfDescending(comparer?: MaybeAsyncComparer<TElement>): OrderedAsyncSequence<TElement> {
+  thenSelfDescending(comparer?: MaybeAsyncComparisonOrComparer<TElement>): OrderedAsyncSequence<TElement> {
     return new ThenOrderAsyncSequence(this, true, comparer);
   }
 
-  thenByDescending<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparer<TBy>): OrderedAsyncSequence<TElement> {
+  thenByDescending<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparisonOrComparer<TBy>): OrderedAsyncSequence<TElement> {
     return new ThenOrderByAsyncSequence<TElement, TBy>(this, true, selector, comparer);
   }
 
@@ -1079,7 +1143,7 @@ abstract class BaseOrderedAsyncSequence<TElement> extends BaseAsyncSequence<TEle
       arr.push(obj);
     }
 
-    await selectionSorter.sort(arr, this.#descending, this.#sorter);
+    await selectionSorter.sort(arr, this.#descending, this.#sorter.comparison());
 
     yield* arr;
   }
@@ -1327,9 +1391,9 @@ export class ConcatAsyncSequence<T> extends BaseAsyncSequence<T> {
 
 class DistinctAsyncSequence<T> extends BaseAsyncSequence<T> {
   readonly #sequence: AsyncSequence<T>;
-  readonly #equater: MaybeAsyncEquater<T> | undefined;
+  readonly #equater: MaybeAsyncEqualityComparison<T> | undefined;
 
-  constructor(sequence: AsyncSequence<T>, equater?: MaybeAsyncEquater<T>) {
+  constructor(sequence: AsyncSequence<T>, equater?: MaybeAsyncEqualityComparison<T>) {
     super();
 
     this.#sequence = sequence;
@@ -1350,9 +1414,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: MaybeAsyncEquater<U> | undefined;
+  readonly #equater: MaybeAsyncEqualityComparison<U> | undefined;
 
-  constructor(sequence: AsyncSequence<T>, selector: MaybeAsyncConverter<T, U>, equater?: MaybeAsyncEquater<U>) {
+  constructor(sequence: AsyncSequence<T>, selector: MaybeAsyncConverter<T, U>, equater?: MaybeAsyncEqualityComparison<U>) {
     super();
 
     this.#sequence = sequence;
@@ -1373,11 +1437,11 @@ class DistinctByAsyncSequence<T, U> extends BaseAsyncSequence<T> {
   }
 }
 
-class WhereAsyncSequence<T> extends BaseAsyncSequence<T> {
-  readonly #sequence: AsyncSequence<T>;
-  readonly #predicate: MaybeAsyncAnyPredicate<T>;
+class WhereAsyncSequence<TElement, TFiltered extends TElement> extends BaseAsyncSequence<TFiltered> {
+  readonly #sequence: AsyncSequence<TElement>;
+  readonly #predicate: MaybeAsyncTypePredicate<TElement, TFiltered>;
 
-  constructor(sequence: AsyncSequence<T>, predicate: MaybeAsyncAnyPredicate<T>) {
+  constructor(sequence: AsyncSequence<TElement>, predicate: MaybeAsyncTypePredicate<TElement, TFiltered>) {
     super();
 
     this.#sequence = sequence;
@@ -1387,7 +1451,7 @@ class WhereAsyncSequence<T> extends BaseAsyncSequence<T> {
   override async *iterator() {
     for await (const obj of this.#sequence) {
       if (await this.#predicate(obj)) {
-        yield obj;
+        yield obj as TFiltered;
       }
     }
   }
@@ -1395,9 +1459,9 @@ class WhereAsyncSequence<T> extends BaseAsyncSequence<T> {
 
 class SelectManyAsyncSequence<T, U> extends BaseAsyncSequence<U> {
   readonly #sequence: AsyncSequence<T>;
-  readonly #converter: MaybeAsyncConverter<T, MaybeAsyncSequence<U>>;
+  readonly #converter: MaybeAsyncConverter<T, MaybeAsyncIterable<U>>;
 
-  constructor(sequence: AsyncSequence<T>, converter: MaybeAsyncConverter<T, MaybeAsyncSequence<U>>) {
+  constructor(sequence: AsyncSequence<T>, converter: MaybeAsyncConverter<T, MaybeAsyncIterable<U>>) {
     super();
 
     this.#sequence = sequence;
@@ -1640,37 +1704,26 @@ class TakeAsyncSequence<T> extends BaseAsyncSequence<T> {
 }
 
 class OrderAsyncSequence<T> extends BaseOrderedAsyncSequence<T> {
-  constructor(sequence: AsyncSequence<T>, descending: boolean, sorter?: MaybeAsyncComparer<T>) {
-    super(sequence, sorter ?? defaultArrayComparer, descending);
+  constructor(sequence: AsyncSequence<T>, descending: boolean, sorter?: MaybeAsyncComparisonOrComparer<T>) {
+    super(sequence, sorter, descending);
   }
 }
 
 class OrderByAsyncSequence<T, U> extends BaseOrderedAsyncSequence<T> {
-  constructor(sequence: AsyncSequence<T>, descending: boolean, selector: MaybeAsyncConverter<T, U>, sorter?: MaybeAsyncComparer<U>) {
-    super(sequence, OrderByAsyncSequence.#createSorter(selector, sorter), descending);
-  }
-
-  static #createSorter<T, U>(selector: MaybeAsyncConverter<T, U>, sorter?: MaybeAsyncComparer<U>) {
-    sorter ??= defaultArrayComparer;
-    return async (a: T, b: T) => sorter(await selector(a), await selector(b));
+  constructor(sequence: AsyncSequence<T>, descending: boolean, selector: MaybeAsyncConverter<T, U>, sorter?: MaybeAsyncComparisonOrComparer<U>) {
+    super(sequence, createAsyncComparerUsing(selector, sorter), descending);
   }
 }
 
 class ThenOrderAsyncSequence<T> extends BaseOrderedAsyncSequence<T> {
-  constructor(sequence: OrderedAsyncSequence<T>, descending: boolean, sorter?: MaybeAsyncComparer<T>) {
-    super(sequence, combineAsyncComparers(sequence.comparer ?? defaultArrayComparer, sorter ?? defaultArrayComparer), descending);
+  constructor(sequence: OrderedAsyncSequence<T>, descending: boolean, sorter?: MaybeAsyncComparisonOrComparer<T>) {
+    super(sequence, combineNullableAsyncComparers([sequence.comparer, sorter]), descending);
   }
 }
 
 class ThenOrderByAsyncSequence<T, U> extends BaseOrderedAsyncSequence<T> {
-  constructor(sequence: OrderedAsyncSequence<T>, descending: boolean, selector: MaybeAsyncConverter<T, U>, sorter?: MaybeAsyncComparer<U>) {
-    super(sequence, ThenOrderByAsyncSequence.#createCombinedSorter(sequence.comparer, selector, sorter), descending);
-  }
-
-  static #createCombinedSorter<T, U>(baseSorter: MaybeAsyncComparer<T>, selector: MaybeAsyncConverter<T, U>, sorter?: MaybeAsyncComparer<U>) {
-    baseSorter ??= defaultArrayComparer;
-    sorter ??= defaultArrayComparer;
-    return combineAsyncComparers(baseSorter, async (a: T, b: T) => sorter(await selector(a), await selector(b)));
+  constructor(sequence: OrderedAsyncSequence<T>, descending: boolean, selector: MaybeAsyncConverter<T, U>, sorter?: MaybeAsyncComparisonOrComparer<U>) {
+    super(sequence, combineNullableAsyncComparers([sequence.comparer, createAsyncComparerUsing(selector, sorter)]), descending);
   }
 }
 
@@ -1783,9 +1836,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: MaybeAsyncEquater<T> | undefined;
+  readonly #equater: MaybeAsyncEqualityComparison<T> | undefined;
 
-  constructor(first: AsyncSequence<T>, second: AsyncSequence<T>, equater?: MaybeAsyncEquater<T>) {
+  constructor(first: AsyncSequence<T>, second: AsyncSequence<T>, equater?: MaybeAsyncEqualityComparison<T>) {
     super();
 
     this.#first = first;
@@ -1816,9 +1869,9 @@ class UnionByAsyncSequence<T, U> extends BaseAsyncSequence<T> {
   readonly #first: AsyncSequence<T>;
   readonly #second: AsyncSequence<T>;
   readonly #selector: MaybeAsyncConverter<T, U>;
-  readonly #equater: MaybeAsyncEquater<U> | undefined;
+  readonly #equater: MaybeAsyncEqualityComparison<U> | undefined;
 
-  constructor(first: AsyncSequence<T>, second: AsyncSequence<T>, selector: MaybeAsyncConverter<T, U>, equater?: MaybeAsyncEquater<U>) {
+  constructor(first: AsyncSequence<T>, second: AsyncSequence<T>, selector: MaybeAsyncConverter<T, U>, equater?: MaybeAsyncEqualityComparison<U>) {
     super();
 
     this.#first = first;
@@ -1849,9 +1902,9 @@ class UnionByAsyncSequence<T, U> extends BaseAsyncSequence<T> {
 class ExceptAsyncSequence<T> extends BaseAsyncSequence<T> {
   readonly #first: AsyncSequence<T>;
   readonly #second: AsyncSequence<T>;
-  readonly #equater: MaybeAsyncEquater<T> | undefined;
+  readonly #equater: MaybeAsyncEqualityComparison<T> | undefined;
 
-  constructor(first: AsyncSequence<T>, second: AsyncSequence<T>, equater?: MaybeAsyncEquater<T>) {
+  constructor(first: AsyncSequence<T>, second: AsyncSequence<T>, equater?: MaybeAsyncEqualityComparison<T>) {
     super();
 
     this.#first = first;
@@ -1880,9 +1933,9 @@ class ExceptByAsyncSequence<T, U> extends BaseAsyncSequence<T> {
   readonly #first: AsyncSequence<T>;
   readonly #second: AsyncSequence<T>;
   readonly #selector: MaybeAsyncConverter<T, U>;
-  readonly #equater: MaybeAsyncEquater<U> | undefined;
+  readonly #equater: MaybeAsyncEqualityComparison<U> | undefined;
 
-  constructor(first: AsyncSequence<T>, second: AsyncSequence<T>, selector: MaybeAsyncConverter<T, U>, equater?: MaybeAsyncEquater<U>) {
+  constructor(first: AsyncSequence<T>, second: AsyncSequence<T>, selector: MaybeAsyncConverter<T, U>, equater?: MaybeAsyncEqualityComparison<U>) {
     super();
 
     this.#first = first;
@@ -1911,9 +1964,9 @@ class ExceptByAsyncSequence<T, U> extends BaseAsyncSequence<T> {
 class IntersectAsyncSequence<T> extends BaseAsyncSequence<T> {
   readonly #first: AsyncSequence<T>;
   readonly #second: AsyncSequence<T>;
-  readonly #equater: MaybeAsyncEquater<T> | undefined;
+  readonly #equater: MaybeAsyncEqualityComparison<T> | undefined;
 
-  constructor(first: AsyncSequence<T>, second: AsyncSequence<T>, equater?: MaybeAsyncEquater<T>) {
+  constructor(first: AsyncSequence<T>, second: AsyncSequence<T>, equater?: MaybeAsyncEqualityComparison<T>) {
     super();
 
     this.#first = first;
@@ -1942,9 +1995,9 @@ class IntersectByAsyncSequence<T, U> extends BaseAsyncSequence<T> {
   readonly #first: AsyncSequence<T>;
   readonly #second: AsyncSequence<T>;
   readonly #selector: MaybeAsyncConverter<T, U>;
-  readonly #equater: MaybeAsyncEquater<U> | undefined;
+  readonly #equater: MaybeAsyncEqualityComparison<U> | undefined;
 
-  constructor(first: AsyncSequence<T>, second: AsyncSequence<T>, selector: MaybeAsyncConverter<T, U>, equater?: MaybeAsyncEquater<U>) {
+  constructor(first: AsyncSequence<T>, second: AsyncSequence<T>, selector: MaybeAsyncConverter<T, U>, equater?: MaybeAsyncEqualityComparison<U>) {
     super();
 
     this.#first = first;
@@ -1996,9 +2049,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: MaybeAsyncEquater<TKey> | undefined;
+  readonly #keyComparer: MaybeAsyncEqualityComparison<TKey> | undefined;
 
-  constructor(sequence: AsyncSequence<TElement>, keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector?: MaybeAsyncConverter<TElement, TResult>, keyComparer?: MaybeAsyncEquater<TKey>) {
+  constructor(sequence: AsyncSequence<TElement>, keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector?: MaybeAsyncConverter<TElement, TResult>, keyComparer?: MaybeAsyncEqualityComparison<TKey>) {
     super();
 
     this.#sequence = sequence;
@@ -2069,9 +2122,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: MaybeAsyncEquater<TKey>;
+  readonly #keyComparer: MaybeAsyncEqualityComparison<TKey>;
 
-  constructor(first: AsyncSequence<TOuter>, second: AsyncSequence<TInner>, firstKeySelector: MaybeAsyncConverter<TOuter, TKey>, secondKeySelector: MaybeAsyncConverter<TInner, TKey>, resultSelector?: MaybeAsyncBiConverter<TOuter, TInner, TResult>, keyComparer?: MaybeAsyncEquater<TKey>) {
+  constructor(first: AsyncSequence<TOuter>, second: AsyncSequence<TInner>, firstKeySelector: MaybeAsyncConverter<TOuter, TKey>, secondKeySelector: MaybeAsyncConverter<TInner, TKey>, resultSelector?: MaybeAsyncBiConverter<TOuter, TInner, TResult>, keyComparer?: MaybeAsyncEqualityComparison<TKey>) {
     super();
 
     this.#first = first;
@@ -2102,17 +2155,17 @@ class GroupJoinAsyncSequence<TOuter, TInner, TKey, TResult> extends BaseAsyncSeq
   readonly #second: AsyncSequence<TInner>;
   readonly #firstKeySelector: MaybeAsyncConverter<TOuter, TKey>;
   readonly #secondKeySelector: MaybeAsyncConverter<TInner, TKey>;
-  readonly #resultSelector: MaybeAsyncBiConverter<TOuter, AsyncSequence<TInner>, TResult>;
-  readonly #keyComparer: MaybeAsyncEquater<TKey>;
+  readonly #resultSelector: MaybeAsyncBiConverter<TOuter, MaybeAsyncIterable<TInner>, TResult>;
+  readonly #keyComparer: MaybeAsyncEqualityComparison<TKey>;
 
-  constructor(first: AsyncSequence<TOuter>, second: AsyncSequence<TInner>, firstKeySelector: MaybeAsyncConverter<TOuter, TKey>, secondKeySelector: MaybeAsyncConverter<TInner, TKey>, resultSelector?: MaybeAsyncBiConverter<TOuter, AsyncSequence<TInner>, TResult>, keyComparer?: MaybeAsyncEquater<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>) {
     super();
 
     this.#first = first;
     this.#second = second;
     this.#firstKeySelector = firstKeySelector;
     this.#secondKeySelector = secondKeySelector;
-    this.#resultSelector = resultSelector ?? GroupJoinAsyncSequence.#defaultResultSelector as MaybeAsyncBiConverter<TOuter, AsyncSequence<TInner>, TResult>;
+    this.#resultSelector = resultSelector ?? GroupJoinAsyncSequence.#defaultResultSelector as MaybeAsyncBiConverter<TOuter, MaybeAsyncIterable<TInner>, TResult>;
     this.#keyComparer = keyComparer ?? strictEquals;
   }
 
@@ -2133,7 +2186,6 @@ class GroupJoinAsyncSequence<TOuter, TInner, TKey, TResult> extends BaseAsyncSeq
         }
       }
 
-      // yield this.#resultSelector(firstObj, this.#second.where(secondObj => this.#keyComparer(firstKey, this.#secondKeySelector(secondObj))));
       yield this.#resultSelector(firstObj, array(secondObjs));
     }
   }
@@ -2143,9 +2195,9 @@ class RemoveAsyncSequence<T> extends BaseAsyncSequence<T> {
   readonly #sequence: AsyncSequence<T>;
   readonly #obj: T;
   readonly #all: boolean;
-  readonly #equater: MaybeAsyncEquater<T>;
+  readonly #equater: MaybeAsyncEqualityComparison<T>;
 
-  constructor(sequence: AsyncSequence<T>, obj: T, all?: boolean, equater?: MaybeAsyncEquater<T>) {
+  constructor(sequence: AsyncSequence<T>, obj: T, all?: boolean, equater?: MaybeAsyncEqualityComparison<T>) {
     super();
 
     this.#sequence = sequence;
@@ -2202,9 +2254,9 @@ class CacheAsyncSequence<T> extends BaseAsyncSequence<T> {
 
 class PartitionAsyncSequence<T> extends BaseAsyncSequence<AsyncSequence<T>> {
   readonly #sequence: AsyncSequence<T>;
-  readonly #equater: MaybeAsyncEquater<T>;
+  readonly #equater: MaybeAsyncEqualityComparison<T>;
 
-  constructor(sequence: AsyncSequence<T>, equater: MaybeAsyncEquater<T> | undefined) {
+  constructor(sequence: AsyncSequence<T>, equater: MaybeAsyncEqualityComparison<T> | undefined) {
     super();
 
     this.#sequence = sequence;
@@ -2233,9 +2285,9 @@ 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: MaybeAsyncEquater<TBy>;
+  readonly #equater: MaybeAsyncEqualityComparison<TBy>;
 
-  constructor(sequence: AsyncSequence<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater: MaybeAsyncEquater<TBy> | undefined) {
+  constructor(sequence: AsyncSequence<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater: MaybeAsyncEqualityComparison<TBy> | undefined) {
     super();
 
     this.#sequence = sequence;

src/async/types.ts

@@ -1,6 +1,8 @@
 import { Collector } from "../collector/types.js";
+import { MaybeAsyncComparisonOrComparer, AsyncComparer } from "../comparer/types.js";
+import { MaybeAsyncEqualityComparison } from "../equality-comparer/types.js";
 import { AsyncRandomOptions } from "../random/types.js";
-import { MaybeAsyncAnyPredicate, MaybeAsyncConverter, MaybeAsyncEquater, MaybeAsyncBiConverter, MaybeAsyncAccumulator, MaybeAsyncComparer, MaybeAsyncAction, MaybeAsyncSequence, MaybeAsyncFunction, MaybePromise } from "../types.js";
+import { MaybeAsyncAnyPredicate, MaybeAsyncConverter, MaybeAsyncBiConverter, MaybeAsyncAccumulator, MaybeAsyncAction, MaybeAsyncFunction, MaybePromise, MaybeAsyncIterable } from "../types.js";
 
 export type AsyncSequencePipeline<TElement, TResult> = MaybeAsyncFunction<(sequence: AsyncSequence<TElement>) => TResult>;
 
@@ -15,30 +17,31 @@ export interface AsyncSequence<TElement> extends AsyncIterable<TElement> {
   maxCount(): Promise<number>;
 
   select<TResult>(selector: MaybeAsyncConverter<TElement, TResult>): AsyncSequence<TResult>;
-  selectMany<TResult>(selector: MaybeAsyncConverter<TElement, MaybeAsyncSequence<TResult>>): AsyncSequence<TResult>;
+  selectMany<TResult>(selector: MaybeAsyncConverter<TElement, MaybeAsyncIterable<TResult>>): AsyncSequence<TResult>;
 
+  where<TFiltered extends TElement>(predicate: MaybeAsyncAnyPredicate<TElement>): AsyncSequence<TFiltered>;
   where(predicate: MaybeAsyncAnyPredicate<TElement>): AsyncSequence<TElement>;
 
-  groupBy<TKey>(keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector?: undefined, keyComparer?: MaybeAsyncEquater<TKey>): AsyncSequence<GroupedAsyncSequence<TKey, TElement>>;
-  groupBy<TKey, TResult>(keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector: MaybeAsyncConverter<TElement, TResult>, keyComparer?: MaybeAsyncEquater<TKey>): AsyncSequence<GroupedAsyncSequence<TKey, TResult>>;
+  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>>;
 
-  join<TOther, TKey>(sequence: MaybeAsyncSequence<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector?: undefined, keyComparer?: MaybeAsyncEquater<TKey>): AsyncSequence<[TElement, TOther]>;
-  join<TOther, TKey, TResult>(sequence: MaybeAsyncSequence<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector: MaybeAsyncBiConverter<TElement, TOther, TResult>, keyComparer?: MaybeAsyncEquater<TKey>): AsyncSequence<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>;
 
-  groupJoin<TOther, TKey>(sequence: MaybeAsyncSequence<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector?: undefined, keyComparer?: MaybeAsyncEquater<TKey>): AsyncSequence<GroupedAsyncSequence<TElement, TOther>>;
-  groupJoin<TOther, TKey, TResult>(sequence: MaybeAsyncSequence<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector: MaybeAsyncBiConverter<TElement, AsyncSequence<TOther>, TResult>, keyComparer?: MaybeAsyncEquater<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>;
 
-  contains(obj: TElement, equater?: MaybeAsyncEquater<TElement>): Promise<boolean>;
+  contains(obj: TElement, equater?: MaybeAsyncEqualityComparison<TElement>): Promise<boolean>;
 
-  sequenceEquals(sequence: MaybeAsyncSequence<TElement>, equater?: MaybeAsyncEquater<TElement>): Promise<boolean>;
+  sequenceEquals(sequence: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEqualityComparison<TElement>): Promise<boolean>;
 
   append(obj: TElement): AsyncSequence<TElement>;
 
   prepend(obj: TElement): AsyncSequence<TElement>;
 
-  remove(obj: TElement, all?: boolean, equater?: MaybeAsyncEquater<TElement>): AsyncSequence<TElement>;
+  remove(obj: TElement, all?: boolean, equater?: MaybeAsyncEqualityComparison<TElement>): AsyncSequence<TElement>;
 
-  concat(...sequences: MaybeAsyncSequence<TElement>[]): AsyncSequence<TElement>;
+  concat(...sequences: MaybeAsyncIterable<TElement>[]): AsyncSequence<TElement>;
 
   first(predicate?: MaybeAsyncAnyPredicate<TElement>): Promise<TElement>;
   firstOrDefault(predicate?: MaybeAsyncAnyPredicate<TElement>, def?: TElement): Promise<TElement | undefined>;
@@ -62,26 +65,29 @@ export interface AsyncSequence<TElement> extends AsyncIterable<TElement> {
   max(): Promise<TElement>;
   maxBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>): Promise<TElement>;
 
-  order(comparer?: MaybeAsyncComparer<TElement>): AsyncSequence<TElement>;
-  orderBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparer<TBy>): AsyncSequence<TElement>;
+  bounds(comparer?: MaybeAsyncComparisonOrComparer<TElement>): Promise<[min: TElement, max: TElement]>;
+  boundsBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparisonOrComparer<TBy>): Promise<[min: TElement, max: TElement]>;
 
-  orderDescending(comparer?: MaybeAsyncComparer<TElement>): AsyncSequence<TElement>;
-  orderByDescending<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparer<TBy>): AsyncSequence<TElement>;
+  order(comparer?: MaybeAsyncComparisonOrComparer<TElement>): AsyncSequence<TElement>;
+  orderBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparisonOrComparer<TBy>): AsyncSequence<TElement>;
 
-  partition(equater?: MaybeAsyncEquater<TElement>): AsyncSequence<AsyncSequence<TElement>>;
-  partitionBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncSequence<AsyncSequence<TElement>>;
+  orderDescending(comparer?: MaybeAsyncComparisonOrComparer<TElement>): AsyncSequence<TElement>;
+  orderByDescending<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparisonOrComparer<TBy>): AsyncSequence<TElement>;
 
-  distinct(equater?: MaybeAsyncEquater<TElement>): AsyncSequence<TElement>;
-  distinctBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncSequence<TElement>;
+  partition(equater?: MaybeAsyncEqualityComparison<TElement>): AsyncSequence<AsyncSequence<TElement>>;
+  partitionBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparison<TBy>): AsyncSequence<AsyncSequence<TElement>>;
 
-  union(sequence: MaybeAsyncSequence<TElement>, equater?: MaybeAsyncEquater<TElement>): AsyncSequence<TElement>;
-  unionBy<TBy>(sequence: MaybeAsyncSequence<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncSequence<TElement>;
+  distinct(equater?: MaybeAsyncEqualityComparison<TElement>): AsyncSequence<TElement>;
+  distinctBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparison<TBy>): AsyncSequence<TElement>;
 
-  except(sequence: MaybeAsyncSequence<TElement>, equater?: MaybeAsyncEquater<TElement>): AsyncSequence<TElement>;
-  exceptBy<TBy>(sequence: MaybeAsyncSequence<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<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>;
 
-  intersect(sequence: MaybeAsyncSequence<TElement>, equater?: MaybeAsyncEquater<TElement>): AsyncSequence<TElement>;
-  intersectBy<TBy>(sequence: MaybeAsyncSequence<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<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>;
+
+  intersect(sequence: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEqualityComparison<TElement>): AsyncSequence<TElement>;
+  intersectBy<TBy>(sequence: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparison<TBy>): AsyncSequence<TElement>;
 
   all(predicate: MaybeAsyncAnyPredicate<TElement>): Promise<boolean>;
   any(predicate: MaybeAsyncAnyPredicate<TElement>): Promise<boolean>;
@@ -101,7 +107,7 @@ export interface AsyncSequence<TElement> extends AsyncIterable<TElement> {
 
   forEach(action: MaybeAsyncAction<TElement>): Promise<void>;
 
-  zip<TOther>(sequence: MaybeAsyncSequence<TOther>): AsyncSequence<[TElement, TOther]>;
+  zip<TOther>(sequence: MaybeAsyncIterable<TOther>): AsyncSequence<[TElement, TOther]>;
 
   indexed(): AsyncSequence<[number, TElement]>;
 
@@ -131,13 +137,13 @@ export interface GroupedAsyncSequence<TKey, TElement> extends AsyncSequence<TEle
 }
 
 export interface OrderedAsyncSequence<TElement> extends AsyncSequence<TElement> {
-  get comparer(): MaybeAsyncComparer<TElement>;
+  get comparer(): AsyncComparer<TElement>;
 
-  thenSelf(comparer?: MaybeAsyncComparer<TElement>): OrderedAsyncSequence<TElement>;
+  thenSelf(comparer?: MaybeAsyncComparisonOrComparer<TElement>): OrderedAsyncSequence<TElement>;
 
-  thenBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparer<TBy>): OrderedAsyncSequence<TElement>;
+  thenBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparisonOrComparer<TBy>): OrderedAsyncSequence<TElement>;
 
-  thenSelfDescending(comparer?: MaybeAsyncComparer<TElement>): OrderedAsyncSequence<TElement>;
+  thenSelfDescending(comparer?: MaybeAsyncComparisonOrComparer<TElement>): OrderedAsyncSequence<TElement>;
 
-  thenByDescending<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparer<TBy>): OrderedAsyncSequence<TElement>;
+  thenByDescending<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparisonOrComparer<TBy>): OrderedAsyncSequence<TElement>;
 }