From 595d9fd5fcbd4f7ac01bbf819a824612f0cbd380 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Herv=C3=A9=20BECHER?= <hbdu68@gmail.com>
Date: Fri, 17 May 2024 22:12:16 +0200
Subject: [PATCH] sequence type fixes and refactor

---
 src/async/impl.ts  | 272 +++++++++++++++++++++++----------------------
 src/async/index.ts |  26 +++--
 src/async/types.ts |  44 ++++----
 src/sync/impl.ts   | 153 +++++++++++++------------
 src/sync/index.ts  |   4 +-
 src/sync/types.ts  |  30 ++---
 src/types.ts       |   7 +-
 7 files changed, 287 insertions(+), 249 deletions(-)

diff --git a/src/async/impl.ts b/src/async/impl.ts
index d8b0d9f..f9f0f44 100644
--- a/src/async/impl.ts
+++ b/src/async/impl.ts
@@ -6,7 +6,7 @@ import { getRandomElementAsync } from "../random/index.js";
 import { AsyncRandomOptions } from "../random/types.js";
 import { selectionSorter } from "../sorting.js";
 import { Sequence } from "../sync/types.js";
-import { MaybeAsyncConverter, MaybeAsyncIterable, MaybeAsyncPredicate, MaybeAsyncEquater, MaybeAsyncBiConverter, MaybeAsyncAccumulator, MaybeAsyncComparer, MaybeAsyncAction, MaybePromise, Predicate } from "../types.js";
+import { MaybeAsyncConverter, MaybeAsyncPredicate, MaybeAsyncEquater, MaybeAsyncBiConverter, MaybeAsyncAccumulator, MaybeAsyncComparer, MaybeAsyncAction, MaybePromiseLike, MaybeAsyncGenerator, MaybeAsyncSequence } from "../types.js";
 import { strictEquals, identity, operatorCompare, asAsyncGenerator, defaultArrayComparer, combineAsyncComparers } from "../utils.js";
 import { array, empty, wrap } from "./index.js";
 import { AsyncSequence, GroupedAsyncSequence, OrderedAsyncSequence } from "./types.js";
@@ -18,7 +18,7 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
     return this.iterator();
   }
 
-  abstract iterator(): AsyncIterator<Awaited<TElement>>;
+  abstract iterator(): AsyncIterator<TElement>;
 
   apply<TResult>(pipeline: (sequence: AsyncSequence<TElement>) => TResult): TResult {
     return pipeline(this);
@@ -28,7 +28,7 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
     return new MapperAsyncSequence<TElement, TResult>(this, converter);
   }
 
-  selectMany<TResult>(converter: MaybeAsyncConverter<TElement, MaybeAsyncIterable<TResult>>): AsyncSequence<TResult> {
+  selectMany<TResult>(converter: MaybeAsyncConverter<TElement, MaybeAsyncSequence<TResult>>): AsyncSequence<TResult> {
     return new FlatMapperAsyncSequence<TElement, TResult>(this, converter);
   }
 
@@ -36,16 +36,22 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
     return new FilterAsyncSequence<TElement>(this, predicate);
   }
 
-  groupBy<TKey, TResult>(keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector?: MaybeAsyncConverter<TElement, TResult>, keyComparer?: MaybeAsyncEquater<TKey>): AsyncSequence<GroupedAsyncSequence<TKey, TResult>> {
-    return new GroupByAsyncSequence<TElement, TKey, TResult>(this, keySelector, elementSelector, keyComparer);
+  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(keySelector: any, elementSelector?: any, keyComparer?: any) {
+    return new GroupByAsyncSequence<any, any, any>(this, keySelector, elementSelector, keyComparer);
   }
 
-  join<TOther, TKey, TResult>(iterable: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector?: MaybeAsyncBiConverter<TElement, TOther, TResult>, keyComparer?: MaybeAsyncEquater<TKey>): AsyncSequence<TResult> {
-    return new JoinAsyncSequence<TElement, TOther, TKey, TResult>(this, wrap(iterable), firstKeySelector, secondKeySelector, resultSelector, 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(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, TResult>(iterable: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector?: MaybeAsyncBiConverter<TElement, AsyncSequence<TOther>, TResult>, keyComparer?: MaybeAsyncEquater<TKey>): AsyncSequence<TResult> {
-    return new GroupJoinAsyncSequence<TElement, TOther, TKey, TResult>(this, wrap(iterable), 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(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>) {
@@ -62,12 +68,12 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
     return false;
   }
 
-  async sequenceEquals(iterable: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEquater<TElement>) {
-    if (this === iterable) {
+  async sequenceEquals(sequence: MaybeAsyncSequence<TElement>, equater?: MaybeAsyncEquater<TElement>) {
+    if (this === sequence) {
       return true;
     }
 
-    const that = wrap(iterable);
+    const that = wrap(sequence);
 
     const thisCount = await this.nonEnumeratedCount();
     const thatCount = await that.nonEnumeratedCount();
@@ -113,15 +119,15 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
     return new RemoveAsyncSequence<TElement>(this, obj, all, equater);
   }
 
-  concat(...iterables: MaybeAsyncIterable<TElement>[]): AsyncSequence<TElement> {
-    if (iterables.length === 0) {
+  concat(...sequences: MaybeAsyncSequence<TElement>[]): AsyncSequence<TElement> {
+    if (sequences.length === 0) {
       return this;
     }
 
     const arr: AsyncSequence<TElement>[] = [this];
 
-    for (const iterable of iterables) {
-      arr.push(wrap(iterable));
+    for (const sequence of sequences) {
+      arr.push(wrap(sequence));
     }
 
     return new ConcatAsyncSequence(arr);
@@ -456,11 +462,11 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
     return new OrderByAsyncSequence<TElement, TBy>(this, true, selector, comparer);
   }
 
-  partition(equater?: MaybeAsyncEquater<TElement>): AsyncSequence<Awaited<TElement>[]> {
+  partition(equater?: MaybeAsyncEquater<TElement>): AsyncSequence<TElement[]> {
     return new PartitionAsyncSequence<TElement>(this, equater);
   }
 
-  partitionBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncSequence<Awaited<TElement>[]> {
+  partitionBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncSequence<TElement[]> {
     return new PartitionByAsyncSequence<TElement, TBy>(this, selector, equater);
   }
 
@@ -472,28 +478,28 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
     return new DistinctByAsyncSequence<TElement, TBy>(this, selector, equater);
   }
 
-  union(iterable: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEquater<TElement>): AsyncSequence<TElement> {
-    return new UnionAsyncSequence<TElement>(this, wrap(iterable), equater);
+  union(sequence: MaybeAsyncSequence<TElement>, equater?: MaybeAsyncEquater<TElement>): AsyncSequence<TElement> {
+    return new UnionAsyncSequence<TElement>(this, wrap(sequence), equater);
   }
 
-  unionBy<TBy>(iterable: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncSequence<TElement> {
-    return new UnionByAsyncSequence<TElement, TBy>(this, wrap(iterable), selector, equater);
+  unionBy<TBy>(sequence: MaybeAsyncSequence<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncSequence<TElement> {
+    return new UnionByAsyncSequence<TElement, TBy>(this, wrap(sequence), selector, equater);
   }
 
-  except(iterable: MaybeAsyncIterable<TElement>): AsyncSequence<TElement> {
-    return new ExceptAsyncSequence<TElement>(this, wrap(iterable));
+  except(sequence: MaybeAsyncSequence<TElement>): AsyncSequence<TElement> {
+    return new ExceptAsyncSequence<TElement>(this, wrap(sequence));
   }
 
-  exceptBy<TBy>(iterable: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>): AsyncSequence<TElement> {
-    return new ExceptByAsyncSequence<TElement, TBy>(this, wrap(iterable), selector);
+  exceptBy<TBy>(sequence: MaybeAsyncSequence<TElement>, selector: MaybeAsyncConverter<TElement, TBy>): AsyncSequence<TElement> {
+    return new ExceptByAsyncSequence<TElement, TBy>(this, wrap(sequence), selector);
   }
 
-  intersect(iterable: MaybeAsyncIterable<TElement>): AsyncSequence<TElement> {
-    return new IntersectAsyncSequence<TElement>(this, wrap(iterable));
+  intersect(sequence: MaybeAsyncSequence<TElement>): AsyncSequence<TElement> {
+    return new IntersectAsyncSequence<TElement>(this, wrap(sequence));
   }
 
-  intersectBy<TBy>(iterable: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>): AsyncSequence<TElement> {
-    return new IntersectByAsyncSequence<TElement, TBy>(this, wrap(iterable), selector);
+  intersectBy<TBy>(sequence: MaybeAsyncSequence<TElement>, selector: MaybeAsyncConverter<TElement, TBy>): AsyncSequence<TElement> {
+    return new IntersectByAsyncSequence<TElement, TBy>(this, wrap(sequence), selector);
   }
 
   async all(predicate: MaybeAsyncPredicate<TElement>) {
@@ -602,11 +608,11 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
     }
   }
 
-  zip<TOther>(iterable: MaybeAsyncIterable<TOther>): AsyncSequence<[Awaited<TElement>, Awaited<TOther>]> {
-    return new ZippedAsyncSequence<TElement, TOther>(this, wrap(iterable));
+  zip<TOther>(sequence: MaybeAsyncSequence<TOther>): AsyncSequence<[TElement, TOther]> {
+    return new ZippedAsyncSequence<TElement, TOther>(this, wrap(sequence));
   }
 
-  indexex(): AsyncSequence<[number, Awaited<TElement>]> {
+  indexex(): AsyncSequence<[number, TElement]> {
     return new IndexedAsyncSequence<TElement>(this);
   }
 
@@ -630,6 +636,10 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
     return new CacheAsyncSequence<TElement>(this);
   }
 
+  async asArray(): Promise<TElement[]> {
+    return await this.toArray();
+  }
+
   async toArray() {
     const array: TElement[] = [];
 
@@ -716,7 +726,7 @@ export class DelegatedAsyncSequence<TElement> extends AsyncSequenceMarker implem
     return this.#sequence.apply(pipeline);
   }
 
-  count(predicate?: ((obj: TElement) => MaybePromise<boolean>) | undefined): Promise<number> {
+  count(predicate?: MaybeAsyncPredicate<TElement> | undefined): Promise<number> {
     return this.#sequence.count(predicate);
   }
 
@@ -732,42 +742,42 @@ export class DelegatedAsyncSequence<TElement> extends AsyncSequenceMarker implem
     return this.#sequence.maxCount();
   }
 
-  select<TResult>(selector: (obj: TElement) => MaybePromise<TResult>): AsyncSequence<TResult> {
+  select<TResult>(selector: MaybeAsyncConverter<TElement, TResult>): AsyncSequence<TResult> {
     return this.#sequence.select(selector);
   }
 
-  selectMany<TResult>(selector: (obj: TElement) => MaybePromise<MaybeAsyncIterable<TResult>>): AsyncSequence<TResult> {
+  selectMany<TResult>(selector: MaybeAsyncConverter<TElement, MaybeAsyncSequence<TResult>>): AsyncSequence<TResult> {
     return this.#sequence.selectMany(selector);
   }
 
-  where(predicate: (obj: TElement) => MaybePromise<boolean>): AsyncSequence<TElement> {
+  where(predicate: MaybeAsyncPredicate<TElement>): AsyncSequence<TElement> {
     return this.#sequence.where(predicate);
   }
 
-  groupBy<TKey>(keySelector: (obj: TElement) => MaybePromise<TKey>, elementSelector?: undefined, keyComparer?: ((first: TKey, second: TKey) => MaybePromise<boolean>) | undefined): AsyncSequence<GroupedAsyncSequence<TKey, TElement>>;
-  groupBy<TKey, TResult>(keySelector: (obj: TElement) => MaybePromise<TKey>, elementSelector: (obj: TElement) => MaybePromise<TResult>, keyComparer?: ((first: TKey, second: TKey) => MaybePromise<boolean>) | undefined): AsyncSequence<GroupedAsyncSequence<TKey, TResult>>;
+  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(keySelector: any, elementSelector?: any, keyComparer?: any) {
     return this.#sequence.groupBy(keySelector, elementSelector, keyComparer);
   }
 
-  join<TOther, TKey>(iterable: MaybeAsyncIterable<TOther>, firstKeySelector: (obj: TElement) => MaybePromise<TKey>, secondKeySelector: (obj: TOther) => MaybePromise<TKey>, resultSelector?: undefined, keyComparer?: ((first: TKey, second: TKey) => MaybePromise<boolean>) | undefined): AsyncSequence<[Awaited<TElement>, Awaited<TOther>]>;
-  join<TOther, TKey, TResult>(iterable: MaybeAsyncIterable<TOther>, firstKeySelector: (obj: TElement) => MaybePromise<TKey>, secondKeySelector: (obj: TOther) => MaybePromise<TKey>, resultSelector: (first: TElement, second: TOther) => MaybePromise<TResult>, keyComparer?: ((first: TKey, second: TKey) => MaybePromise<boolean>) | undefined): AsyncSequence<TResult>;
-  join(iterable: any, firstKeySelector: any, secondKeySelector: any, resultSelector?: any, keyComparer?: any) {
-    return this.#sequence.join(iterable, firstKeySelector, secondKeySelector, resultSelector, 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(sequence: any, firstKeySelector: any, secondKeySelector: any, resultSelector?: any, keyComparer?: any) {
+    return this.#sequence.join(sequence, firstKeySelector, secondKeySelector, resultSelector, keyComparer);
   }
 
-  groupJoin<TOther, TKey>(iterable: MaybeAsyncIterable<TOther>, firstKeySelector: (obj: TElement) => MaybePromise<TKey>, secondKeySelector: (obj: TOther) => MaybePromise<TKey>, resultSelector?: undefined, keyComparer?: ((first: TKey, second: TKey) => MaybePromise<boolean>) | undefined): AsyncSequence<GroupedAsyncSequence<TElement, TOther>>;
-  groupJoin<TOther, TKey, TResult>(iterable: MaybeAsyncIterable<TOther>, firstKeySelector: (obj: TElement) => MaybePromise<TKey>, secondKeySelector: (obj: TOther) => MaybePromise<TKey>, resultSelector: (first: TElement, second: AsyncSequence<TOther>) => MaybePromise<TResult>, keyComparer?: ((first: TKey, second: TKey) => MaybePromise<boolean>) | undefined): AsyncSequence<TResult>;
-  groupJoin(iterable: any, firstKeySelector: any, secondKeySelector: any, resultSelector?: any, keyComparer?: any) {
-    return this.#sequence.groupJoin(iterable, 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(sequence: any, firstKeySelector: any, secondKeySelector: any, resultSelector?: any, keyComparer?: any) {
+    return this.#sequence.groupJoin(sequence, firstKeySelector, secondKeySelector, resultSelector, keyComparer);
   }
 
-  contains(obj: TElement, equater?: ((first: TElement, second: TElement) => MaybePromise<boolean>) | undefined): Promise<boolean> {
+  contains(obj: TElement, equater?: MaybeAsyncEquater<TElement> | undefined): Promise<boolean> {
     return this.#sequence.contains(obj, equater);
   }
 
-  sequenceEquals(iterable: MaybeAsyncIterable<TElement>, equater?: ((first: TElement, second: TElement) => MaybePromise<boolean>) | undefined): Promise<boolean> {
-    return this.#sequence.sequenceEquals(iterable, equater);
+  sequenceEquals(sequence: MaybeAsyncSequence<TElement>, equater?: MaybeAsyncEquater<TElement> | undefined): Promise<boolean> {
+    return this.#sequence.sequenceEquals(sequence, equater);
   }
 
   append(obj: TElement): AsyncSequence<TElement> {
@@ -778,35 +788,35 @@ export class DelegatedAsyncSequence<TElement> extends AsyncSequenceMarker implem
     return this.#sequence.prepend(obj);
   }
 
-  remove(obj: TElement, all?: boolean | undefined, equater?: ((first: TElement, second: TElement) => MaybePromise<boolean>) | undefined): AsyncSequence<TElement> {
+  remove(obj: TElement, all?: boolean | undefined, equater?: MaybeAsyncEquater<TElement> | undefined): AsyncSequence<TElement> {
     return this.#sequence.remove(obj, all, equater);
   }
 
-  concat(...iterables: MaybeAsyncIterable<TElement>[]): AsyncSequence<TElement> {
-    return this.#sequence.concat(...iterables);
+  concat(...sequences: MaybeAsyncSequence<TElement>[]): AsyncSequence<TElement> {
+    return this.#sequence.concat(...sequences);
   }
 
-  first(predicate?: ((obj: TElement) => MaybePromise<boolean>) | undefined): Promise<TElement> {
+  first(predicate?: MaybeAsyncPredicate<TElement> | undefined): Promise<TElement> {
     return this.#sequence.first(predicate);
   }
 
-  firstOrDefault(predicate?: ((obj: TElement) => MaybePromise<boolean>) | undefined, def?: TElement | undefined): Promise<TElement | undefined> {
+  firstOrDefault(predicate?: MaybeAsyncPredicate<TElement> | undefined, def?: TElement | undefined): Promise<TElement | undefined> {
     return this.#sequence.firstOrDefault(predicate, def);
   }
 
-  last(predicate?: ((obj: TElement) => MaybePromise<boolean>) | undefined): Promise<TElement> {
+  last(predicate?: MaybeAsyncPredicate<TElement> | undefined): Promise<TElement> {
     return this.#sequence.last(predicate);
   }
 
-  lastOrDefault(predicate?: ((obj: TElement) => MaybePromise<boolean>) | undefined, def?: TElement | undefined): Promise<TElement | undefined> {
+  lastOrDefault(predicate?: MaybeAsyncPredicate<TElement> | undefined, def?: TElement | undefined): Promise<TElement | undefined> {
     return this.#sequence.lastOrDefault(predicate, def);
   }
 
-  single(predicate?: ((obj: TElement) => MaybePromise<boolean>) | undefined): Promise<TElement> {
+  single(predicate?: MaybeAsyncPredicate<TElement> | undefined): Promise<TElement> {
     return this.#sequence.single(predicate);
   }
 
-  singleOrDefault(predicate?: ((obj: TElement) => MaybePromise<boolean>) | undefined, def?: TElement | undefined): Promise<TElement | undefined> {
+  singleOrDefault(predicate?: MaybeAsyncPredicate<TElement> | undefined, def?: TElement | undefined): Promise<TElement | undefined> {
     return this.#sequence.singleOrDefault(predicate, def);
   }
 
@@ -818,9 +828,9 @@ export class DelegatedAsyncSequence<TElement> extends AsyncSequenceMarker implem
     return this.#sequence.elementAtOrDefault(index, def);
   }
 
-  aggregate(accumulator: (acc: TElement, obj: TElement) => MaybePromise<TElement>): Promise<TElement>;
-  aggregate<TAccumulator>(accumulator: (acc: TAccumulator, obj: TElement) => MaybePromise<TAccumulator>, seed?: TAccumulator | undefined): Promise<TAccumulator>;
-  aggregate<TAccumulator, TResult>(accumulator: (acc: TAccumulator, obj: TElement) => MaybePromise<TAccumulator>, seed?: TAccumulator | undefined, resultSelector?: ((obj: TAccumulator) => MaybePromise<TResult>) | undefined): Promise<TResult>;
+  aggregate(accumulator: MaybeAsyncAccumulator<TElement, TElement>): Promise<TElement>;
+  aggregate<TAccumulator>(accumulator: MaybeAsyncAccumulator<TElement, TAccumulator>, seed?: TAccumulator | undefined): Promise<TAccumulator>;
+  aggregate<TAccumulator, TResult>(accumulator: MaybeAsyncAccumulator<TElement, TAccumulator>, seed?: TAccumulator | undefined, resultSelector?: MaybeAsyncConverter<TAccumulator, TResult> | undefined): Promise<TResult>;
   aggregate(accumulator: any, seed?: any, resultSelector?: any) {
     return this.#sequence.aggregate(accumulator, seed, resultSelector);
   }
@@ -829,7 +839,7 @@ export class DelegatedAsyncSequence<TElement> extends AsyncSequenceMarker implem
     return this.#sequence.min();
   }
 
-  minBy<TBy>(selector: (obj: TElement) => MaybePromise<TBy>): Promise<TElement> {
+  minBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>): Promise<TElement> {
     return this.#sequence.minBy(selector);
   }
 
@@ -837,77 +847,77 @@ export class DelegatedAsyncSequence<TElement> extends AsyncSequenceMarker implem
     return this.#sequence.max();
   }
 
-  maxBy<TBy>(selector: (obj: TElement) => MaybePromise<TBy>): Promise<TElement> {
+  maxBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>): Promise<TElement> {
     return this.#sequence.maxBy(selector);
   }
 
-  order(comparer?: ((first: TElement, second: TElement) => MaybePromise<number>) | undefined): AsyncSequence<TElement> {
+  order(comparer?: MaybeAsyncComparer<TElement> | undefined): AsyncSequence<TElement> {
     return this.#sequence.order(comparer);
   }
 
-  orderBy<TBy>(selector: (obj: TElement) => MaybePromise<TBy>, comparer?: ((first: TBy, second: TBy) => MaybePromise<number>) | undefined): AsyncSequence<TElement> {
+  orderBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparer<TBy> | undefined): AsyncSequence<TElement> {
     return this.#sequence.orderBy(selector, comparer);
   }
 
-  orderDescending(comparer?: ((first: TElement, second: TElement) => MaybePromise<number>) | undefined): AsyncSequence<TElement> {
+  orderDescending(comparer?: MaybeAsyncComparer<TElement> | undefined): AsyncSequence<TElement> {
     return this.#sequence.orderDescending(comparer);
   }
 
-  orderByDescending<TBy>(selector: (obj: TElement) => MaybePromise<TBy>, comparer?: ((first: TBy, second: TBy) => MaybePromise<number>) | undefined): AsyncSequence<TElement> {
+  orderByDescending<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparer<TBy> | undefined): AsyncSequence<TElement> {
     return this.#sequence.orderByDescending(selector, comparer);
   }
 
-  partition(equater?: MaybeAsyncEquater<TElement> | undefined): AsyncSequence<Awaited<TElement>[]> {
+  partition(equater?: MaybeAsyncEquater<TElement> | undefined): AsyncSequence<TElement[]> {
     return this.#sequence.partition(equater);
   }
 
-  partitionBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy> | undefined): AsyncSequence<Awaited<TElement>[]> {
+  partitionBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy> | undefined): AsyncSequence<TElement[]> {
     return this.#sequence.partitionBy(selector, equater);
   }
 
-  distinct(equater?: ((first: TElement, second: TElement) => MaybePromise<boolean>) | undefined): AsyncSequence<TElement> {
+  distinct(equater?: MaybeAsyncEquater<TElement> | undefined): AsyncSequence<TElement> {
     return this.#sequence.distinct(equater);
   }
 
-  distinctBy<TBy>(selector: (obj: TElement) => MaybePromise<TBy>, equater?: ((first: TBy, second: TBy) => MaybePromise<boolean>) | undefined): AsyncSequence<TElement> {
+  distinctBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy> | undefined): AsyncSequence<TElement> {
     return this.#sequence.distinctBy(selector, equater);
   }
 
-  union(iterable: MaybeAsyncIterable<TElement>, equater?: ((first: TElement, second: TElement) => MaybePromise<boolean>) | undefined): AsyncSequence<TElement> {
-    return this.#sequence.union(iterable, equater);
+  union(sequence: MaybeAsyncSequence<TElement>, equater?: MaybeAsyncEquater<TElement> | undefined): AsyncSequence<TElement> {
+    return this.#sequence.union(wrap(sequence), equater);
   }
 
-  unionBy<TBy>(iterable: MaybeAsyncIterable<TElement>, selector: (obj: TElement) => MaybePromise<TBy>, equater?: ((first: TBy, second: TBy) => MaybePromise<boolean>) | undefined): AsyncSequence<TElement> {
-    return this.#sequence.unionBy(iterable, selector, equater);
+  unionBy<TBy>(sequence: MaybeAsyncSequence<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy> | undefined): AsyncSequence<TElement> {
+    return this.#sequence.unionBy(wrap(sequence), selector, equater);
   }
 
-  except(iterable: MaybeAsyncIterable<TElement>, equater?: ((first: TElement, second: TElement) => MaybePromise<boolean>) | undefined): AsyncSequence<TElement> {
-    return this.#sequence.except(iterable, equater);
+  except(sequence: MaybeAsyncSequence<TElement>, equater?: MaybeAsyncEquater<TElement> | undefined): AsyncSequence<TElement> {
+    return this.#sequence.except(wrap(sequence), equater);
   }
 
-  exceptBy<TBy>(iterable: MaybeAsyncIterable<TElement>, selector: (obj: TElement) => MaybePromise<TBy>, equater?: ((first: TBy, second: TBy) => MaybePromise<boolean>) | undefined): AsyncSequence<TElement> {
-    return this.#sequence.exceptBy(iterable, selector, equater);
+  exceptBy<TBy>(sequence: MaybeAsyncSequence<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy> | undefined): AsyncSequence<TElement> {
+    return this.#sequence.exceptBy(wrap(sequence), selector, equater);
   }
 
-  intersect(iterable: MaybeAsyncIterable<TElement>, equater?: ((first: TElement, second: TElement) => MaybePromise<boolean>) | undefined): AsyncSequence<TElement> {
-    return this.#sequence.intersect(iterable, equater);
+  intersect(sequence: MaybeAsyncSequence<TElement>, equater?: MaybeAsyncEquater<TElement> | undefined): AsyncSequence<TElement> {
+    return this.#sequence.intersect(wrap(sequence), equater);
   }
 
-  intersectBy<TBy>(iterable: MaybeAsyncIterable<TElement>, selector: (obj: TElement) => MaybePromise<TBy>, equater?: ((first: TBy, second: TBy) => MaybePromise<boolean>) | undefined): AsyncSequence<TElement> {
-    return this.#sequence.intersectBy(iterable, selector, equater);
+  intersectBy<TBy>(sequence: MaybeAsyncSequence<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy> | undefined): AsyncSequence<TElement> {
+    return this.#sequence.intersectBy(wrap(sequence), selector, equater);
   }
 
-  all(predicate: (obj: TElement) => MaybePromise<boolean>): Promise<boolean> {
+  all(predicate: MaybeAsyncPredicate<TElement>): Promise<boolean> {
     return this.#sequence.all(predicate);
   }
 
-  any(predicate: (obj: TElement) => MaybePromise<boolean>): Promise<boolean>;
+  any(predicate: MaybeAsyncPredicate<TElement>): Promise<boolean>;
   any(): Promise<boolean>;
   any(predicate?: any) {
     return this.#sequence.any(predicate);
   }
 
-  none(predicate: Predicate<TElement>): Promise<boolean>;
+  none(predicate: MaybeAsyncPredicate<TElement>): Promise<boolean>;
   none(): Promise<boolean>;
   none(predicate?: any) {
     return this.#sequence.none(predicate);
@@ -921,7 +931,7 @@ export class DelegatedAsyncSequence<TElement> extends AsyncSequenceMarker implem
     return this.#sequence.skipLast(n);
   }
 
-  skipWhile(condition: (obj: TElement) => MaybePromise<boolean>): AsyncSequence<TElement> {
+  skipWhile(condition: MaybeAsyncPredicate<TElement>): AsyncSequence<TElement> {
     return this.#sequence.skipWhile(condition);
   }
 
@@ -933,23 +943,23 @@ export class DelegatedAsyncSequence<TElement> extends AsyncSequenceMarker implem
     return this.#sequence.takeLast(n);
   }
 
-  takeWhile(condition: (obj: TElement) => MaybePromise<boolean>): AsyncSequence<TElement> {
+  takeWhile(condition: MaybeAsyncPredicate<TElement>): AsyncSequence<TElement> {
     return this.#sequence.takeWhile(condition);
   }
 
-  peek(action: (obj: TElement) => MaybePromise<void>): AsyncSequence<TElement> {
+  peek(action: MaybeAsyncAction<TElement>): AsyncSequence<TElement> {
     return this.#sequence.peek(action);
   }
 
-  forEach(action: (obj: TElement) => MaybePromise<void>): Promise<void> {
+  forEach(action: MaybeAsyncAction<TElement>): Promise<void> {
     return this.#sequence.forEach(action);
   }
 
-  zip<TOther>(iterable: MaybeAsyncIterable<TOther>): AsyncSequence<[Awaited<TElement>, Awaited<TOther>]> {
-    return this.#sequence.zip(iterable);
+  zip<TOther>(sequence: MaybeAsyncSequence<TOther>): AsyncSequence<[TElement, TOther]> {
+    return this.#sequence.zip(wrap(sequence));
   }
 
-  indexex(): AsyncSequence<[number, Awaited<TElement>]> {
+  indexex(): AsyncSequence<[number, TElement]> {
     return this.#sequence.indexex();
   }
 
@@ -969,11 +979,15 @@ export class DelegatedAsyncSequence<TElement> extends AsyncSequenceMarker implem
     return this.#sequence.cached();
   }
 
+  asArray(): Promise<TElement[]> {
+    return this.#sequence.asArray();
+  }
+
   toArray(): Promise<TElement[]> {
     return this.#sequence.toArray();
   }
 
-  toMap<TKey, TValue>(keySelector: (obj: TElement) => MaybePromise<TKey>, valueSelector: (obj: TElement) => MaybePromise<TValue>): Promise<Map<TKey, TValue>> {
+  toMap<TKey, TValue>(keySelector: MaybeAsyncConverter<TElement, TKey>, valueSelector: MaybeAsyncConverter<TElement, TValue>): Promise<Map<TKey, TValue>> {
     return this.#sequence.toMap(keySelector, valueSelector);
   }
 
@@ -981,7 +995,7 @@ export class DelegatedAsyncSequence<TElement> extends AsyncSequenceMarker implem
     return this.#sequence.toSet();
   }
 
-  toObject<TValue>(keySelector: (obj: TElement) => MaybePromise<PropertyKey>, valueSelector: (obj: TElement) => MaybePromise<TValue>): Promise<Record<PropertyKey, TValue>> {
+  toObject<TKey extends PropertyKey, TValue>(keySelector: MaybeAsyncConverter<TElement, TKey>, valueSelector: MaybeAsyncConverter<TElement, TValue>): Promise<Record<TKey, TValue>> {
     return this.#sequence.toObject(keySelector, valueSelector);
   }
 
@@ -1059,15 +1073,11 @@ abstract class BaseOrderedAsyncSequence<TElement> extends BaseAsyncSequence<TEle
 }
 
 export class EmptyAsyncSequence<T> extends BaseAsyncSequence<T> {
-  static readonly INSTANCE = new EmptyAsyncSequence<any>();
-
   override async nonEnumeratedCount() {
     return 0;
   }
 
-  override async *iterator() {
-
-  }
+  override async *iterator() { }
 }
 
 export class RangeAsyncSequence extends BaseAsyncSequence<number> {
@@ -1095,10 +1105,10 @@ export class RangeAsyncSequence extends BaseAsyncSequence<number> {
 }
 
 export class RepeatAsyncSequence<T> extends BaseAsyncSequence<T> {
-  readonly #value: T;
+  readonly #value: MaybePromiseLike<T>;
   readonly #count: number;
 
-  constructor(value: T, count: number) {
+  constructor(value: MaybePromiseLike<T>, count: number) {
     super();
 
     this.#value = value;
@@ -1119,9 +1129,9 @@ export class RepeatAsyncSequence<T> extends BaseAsyncSequence<T> {
 }
 
 export class RepeatForeverAsyncSequence<T> extends BaseAsyncSequence<T> {
-  readonly #value: T;
+  readonly #value: MaybePromiseLike<T>;
 
-  constructor(value: T) {
+  constructor(value: MaybePromiseLike<T>) {
     super();
 
     this.#value = value;
@@ -1139,9 +1149,9 @@ export class RepeatForeverAsyncSequence<T> extends BaseAsyncSequence<T> {
 }
 
 export class WrappedObjectAsync<T> extends BaseAsyncSequence<T> {
-  readonly #obj: T | PromiseLike<T>;
+  readonly #obj: MaybePromiseLike<T>;
 
-  constructor(obj: T | PromiseLike<T>) {
+  constructor(obj: MaybePromiseLike<T>) {
     super();
 
     this.#obj = obj;
@@ -1157,9 +1167,9 @@ export class WrappedObjectAsync<T> extends BaseAsyncSequence<T> {
 }
 
 export class WrappedArrayAsync<T> extends BaseAsyncSequence<T> {
-  readonly #array: (T | PromiseLike<T>)[];
+  readonly #array: MaybePromiseLike<T>[];
 
-  constructor(array: (T | PromiseLike<T>)[]) {
+  constructor(array: MaybePromiseLike<T>[]) {
     super();
 
     this.#array = array;
@@ -1175,9 +1185,9 @@ export class WrappedArrayAsync<T> extends BaseAsyncSequence<T> {
 }
 
 export class WrappedArrayLikeAsync<T> extends BaseAsyncSequence<T> {
-  readonly #arrayLike: ArrayLike<T | PromiseLike<T>>;
+  readonly #arrayLike: ArrayLike<MaybePromiseLike<T>>;
 
-  constructor(arrayLike: ArrayLike<T | PromiseLike<T>>) {
+  constructor(arrayLike: ArrayLike<MaybePromiseLike<T>>) {
     super();
 
     this.#arrayLike = arrayLike;
@@ -1195,9 +1205,9 @@ export class WrappedArrayLikeAsync<T> extends BaseAsyncSequence<T> {
 }
 
 export class WrappedAsyncIterable<T> extends BaseAsyncSequence<T> {
-  readonly #iterable: AsyncIterable<T>;
+  readonly #iterable: AsyncIterable<MaybePromiseLike<T>>;
 
-  constructor(iterable: AsyncIterable<T>) {
+  constructor(iterable: AsyncIterable<MaybePromiseLike<T>>) {
     super();
 
     this.#iterable = iterable;
@@ -1209,9 +1219,9 @@ export class WrappedAsyncIterable<T> extends BaseAsyncSequence<T> {
 }
 
 export class GeneratorAsyncSequence<T> extends BaseAsyncSequence<T> {
-  readonly #generator: () => AsyncGenerator<T>;
+  readonly #generator: () => MaybeAsyncGenerator<MaybePromiseLike<T>>;
 
-  constructor(generator: () => AsyncGenerator<T>) {
+  constructor(generator: () => MaybeAsyncGenerator<MaybePromiseLike<T>>) {
     super();
 
     this.#generator = generator;
@@ -1223,9 +1233,9 @@ export class GeneratorAsyncSequence<T> extends BaseAsyncSequence<T> {
 }
 
 export class FunctionAsyncSequence<T> extends BaseAsyncSequence<T> {
-  readonly #f: () => MaybePromise<T>;
+  readonly #f: () => MaybePromiseLike<T>;
 
-  constructor(f: () => MaybePromise<T>) {
+  constructor(f: () => MaybePromiseLike<T>) {
     super();
 
     this.#f = f;
@@ -1243,9 +1253,9 @@ export class FunctionAsyncSequence<T> extends BaseAsyncSequence<T> {
 }
 
 export class WrappedSequence<T> extends BaseAsyncSequence<T> {
-  readonly #sequence: Sequence<T>;
+  readonly #sequence: Sequence<MaybePromiseLike<T>>;
 
-  constructor(sequence: Sequence<T>) {
+  constructor(sequence: Sequence<MaybePromiseLike<T>>) {
     super();
 
     this.#sequence = sequence;
@@ -1280,8 +1290,8 @@ export class ConcatAsyncSequence<T> extends BaseAsyncSequence<T> {
   override async nonEnumeratedCount() {
     let n = 0;
 
-    for (const iterable of this.#sequences) {
-      const m = await iterable.nonEnumeratedCount();
+    for (const sequence of this.#sequences) {
+      const m = await sequence.nonEnumeratedCount();
 
       if (m < 0) {
         return -1;
@@ -1370,9 +1380,9 @@ class FilterAsyncSequence<T> extends BaseAsyncSequence<T> {
 
 class FlatMapperAsyncSequence<T, U> extends BaseAsyncSequence<U> {
   readonly #sequence: AsyncSequence<T>;
-  readonly #converter: MaybeAsyncConverter<T, MaybeAsyncIterable<U>>;
+  readonly #converter: MaybeAsyncConverter<T, MaybeAsyncSequence<U>>;
 
-  constructor(sequence: AsyncSequence<T>, converter: MaybeAsyncConverter<T, MaybeAsyncIterable<U>>) {
+  constructor(sequence: AsyncSequence<T>, converter: MaybeAsyncConverter<T, MaybeAsyncSequence<U>>) {
     super();
 
     this.#sequence = sequence;
@@ -1386,7 +1396,7 @@ class FlatMapperAsyncSequence<T, U> extends BaseAsyncSequence<U> {
   }
 }
 
-class IndexedAsyncSequence<T> extends BaseAsyncSequence<[number, Awaited<T>]> {
+class IndexedAsyncSequence<T> extends BaseAsyncSequence<[number, T]> {
   readonly #sequence: AsyncSequence<T>;
 
   constructor(sequence: AsyncSequence<T>) {
@@ -1399,7 +1409,7 @@ class IndexedAsyncSequence<T> extends BaseAsyncSequence<[number, Awaited<T>]> {
     let i = 0;
 
     for await (const obj of this.#sequence) {
-      yield [i++, obj] as [number, Awaited<T>];
+      yield [i++, obj] as [number, T];
     }
   }
 }
@@ -1716,7 +1726,7 @@ class PeekAsyncSequence<T> extends BaseAsyncSequence<T> {
   }
 }
 
-class ZippedAsyncSequence<T, U> extends BaseAsyncSequence<[Awaited<T>, Awaited<U>]> {
+class ZippedAsyncSequence<T, U> extends BaseAsyncSequence<[T, U]> {
   readonly #first: AsyncSequence<T>;
   readonly #second: AsyncSequence<U>;
 
@@ -1746,7 +1756,7 @@ class ZippedAsyncSequence<T, U> extends BaseAsyncSequence<[Awaited<T>, Awaited<U
         return;
       }
 
-      yield [firstNext.value, secondNext.value] as [Awaited<T>, Awaited<U>];
+      yield [firstNext.value, secondNext.value] as [T, U];
     }
   }
 }
@@ -2158,7 +2168,7 @@ class CacheAsyncSequence<T> extends BaseAsyncSequence<T> {
   }
 }
 
-class PartitionAsyncSequence<T> extends BaseAsyncSequence<Awaited<T>[]> {
+class PartitionAsyncSequence<T> extends BaseAsyncSequence<T[]> {
   readonly #sequence: AsyncSequence<T>;
   readonly #equater: MaybeAsyncEquater<T>;
 
@@ -2170,7 +2180,7 @@ class PartitionAsyncSequence<T> extends BaseAsyncSequence<Awaited<T>[]> {
   }
 
   override async *iterator() {
-    const partitions = createAsyncEqualityMap<T, Awaited<T>[]>(this.#equater);
+    const partitions = createAsyncEqualityMap<T, T[]>(this.#equater);
 
     for await (const obj of this.#sequence) {
       const partition = await partitions.get(obj);
@@ -2186,7 +2196,7 @@ class PartitionAsyncSequence<T> extends BaseAsyncSequence<Awaited<T>[]> {
   }
 }
 
-class PartitionByAsyncSequence<TElement, TBy> extends BaseAsyncSequence<Awaited<TElement>[]> {
+class PartitionByAsyncSequence<TElement, TBy> extends BaseAsyncSequence<TElement[]> {
   readonly #sequence: AsyncSequence<TElement>;
   readonly #selector: MaybeAsyncConverter<TElement, TBy>;
   readonly #equater: MaybeAsyncEquater<TBy>;
@@ -2200,7 +2210,7 @@ class PartitionByAsyncSequence<TElement, TBy> extends BaseAsyncSequence<Awaited<
   }
 
   override async *iterator() {
-    const partitions = createAsyncEqualityMap<TBy, Awaited<TElement>[]>(this.#equater);
+    const partitions = createAsyncEqualityMap<TBy, TElement[]>(this.#equater);
 
     for await (const obj of this.#sequence) {
       const key = await this.#selector(obj);
diff --git a/src/async/index.ts b/src/async/index.ts
index 0e5135b..3306d26 100644
--- a/src/async/index.ts
+++ b/src/async/index.ts
@@ -1,15 +1,15 @@
 import { wrap as wrapSync } from "../sync/index.js";
 import { Sequence } from "../sync/types.js";
-import { MaybeAsyncIterable } from "../types.js";
+import { MaybeAsyncGenerator, MaybeAsyncIterable, MaybeAsyncSequence, MaybePromiseLike } from "../types.js";
 import { isAsyncIterable } from "../utils.js";
 import { WrappedSequence, WrappedAsyncIterable, EmptyAsyncSequence, WrappedObjectAsync, WrappedArrayAsync, WrappedArrayLikeAsync, FunctionAsyncSequence, GeneratorAsyncSequence, RangeAsyncSequence, RepeatForeverAsyncSequence, RepeatAsyncSequence, AsyncSequenceMarker } from "./impl.js";
 import { AsyncSequence } from "./types.js";
 
-export function asAsync<T>(sequence: Sequence<T>): AsyncSequence<T> {
+export function asAsync<T>(sequence: Sequence<MaybePromiseLike<T>>): AsyncSequence<T> {
   return new WrappedSequence(sequence);
 }
 
-export function wrap<T>(iterable: MaybeAsyncIterable<T>): AsyncSequence<T> {
+export function wrap<T>(iterable: MaybeAsyncIterable<MaybePromiseLike<T>>): AsyncSequence<T> {
   if (isAsyncSequence<T>(iterable)) {
     return iterable;
   }
@@ -21,27 +21,29 @@ export function wrap<T>(iterable: MaybeAsyncIterable<T>): AsyncSequence<T> {
   return asAsync(wrapSync(iterable));
 }
 
-export function sequence<T>(iterable: AsyncIterable<T>): AsyncSequence<T> {
+export function sequence<T>(iterable: AsyncIterable<MaybePromiseLike<T>>): AsyncSequence<T> {
   return new WrappedAsyncIterable(iterable);
 }
 
+export const EMPTY = new EmptyAsyncSequence<any>();
+
 export function empty<T>(): AsyncSequence<T> {
-  return EmptyAsyncSequence.INSTANCE;
+  return EMPTY;
 }
 
-export function single<T>(obj: T | PromiseLike<T>): AsyncSequence<T> {
+export function single<T>(obj: MaybePromiseLike<T>): AsyncSequence<T> {
   return new WrappedObjectAsync(obj);
 }
 
-export function array<T>(array: (T | PromiseLike<T>)[]): AsyncSequence<T> {
+export function array<T>(array: MaybePromiseLike<T>[]): AsyncSequence<T> {
   return new WrappedArrayAsync(array);
 }
 
-export function arrayLike<T>(arrayLike: ArrayLike<(T | PromiseLike<T>)>): AsyncSequence<T> {
+export function arrayLike<T>(arrayLike: ArrayLike<MaybePromiseLike<T>>): AsyncSequence<T> {
   return new WrappedArrayLikeAsync(arrayLike);
 }
 
-export function of<T>(...elements: (T | PromiseLike<T>)[]): AsyncSequence<T> {
+export function of<T>(...elements: MaybePromiseLike<T>[]): AsyncSequence<T> {
   switch (elements.length) {
     case 0:
       return empty();
@@ -52,11 +54,11 @@ export function of<T>(...elements: (T | PromiseLike<T>)[]): AsyncSequence<T> {
   }
 }
 
-export function func<T>(f: () => Promise<T>): AsyncSequence<T> {
+export function func<T>(f: () => MaybePromiseLike<T>): AsyncSequence<T> {
   return new FunctionAsyncSequence(f);
 }
 
-export function generator<T>(generator: () => AsyncGenerator<T>): AsyncSequence<T> {
+export function generator<T>(generator: () => MaybeAsyncGenerator<MaybePromiseLike<T>>): AsyncSequence<T> {
   return new GeneratorAsyncSequence(generator);
 }
 
@@ -76,7 +78,7 @@ export function range(a: number, b?: number, c?: number): AsyncSequence<number>
   return new RangeAsyncSequence(a, b, c);
 }
 
-export function repeat<T>(value: T, count?: number): AsyncSequence<T> {
+export function repeat<T>(value: MaybePromiseLike<T>, count?: number): AsyncSequence<T> {
   if (count == undefined) {
     return new RepeatForeverAsyncSequence(value);
   }
diff --git a/src/async/types.ts b/src/async/types.ts
index 4a729b3..bfd949d 100644
--- a/src/async/types.ts
+++ b/src/async/types.ts
@@ -1,9 +1,9 @@
 import { Collector } from "../collector/types.js";
 import { AsyncRandomOptions } from "../random/types.js";
-import { MaybeAsyncPredicate, MaybeAsyncConverter, MaybeAsyncIterable, MaybeAsyncEquater, MaybeAsyncBiConverter, MaybeAsyncAccumulator, MaybeAsyncComparer, Predicate, MaybeAsyncAction } from "../types.js";
+import { MaybeAsyncPredicate, MaybeAsyncConverter, MaybeAsyncEquater, MaybeAsyncBiConverter, MaybeAsyncAccumulator, MaybeAsyncComparer, MaybeAsyncAction, MaybeAsyncSequence } from "../types.js";
 
-export interface AsyncSequence<TElement> extends AsyncIterable<Awaited<TElement>> {
-  iterator(): AsyncIterator<Awaited<TElement>>;
+export interface AsyncSequence<TElement> extends AsyncIterable<TElement> {
+  iterator(): AsyncIterator<TElement>;
 
   apply<TResult>(pipeline: (sequence: AsyncSequence<TElement>) => TResult): TResult;
 
@@ -13,22 +13,22 @@ export interface AsyncSequence<TElement> extends AsyncIterable<Awaited<TElement>
   maxCount(): Promise<number>;
 
   select<TResult>(selector: MaybeAsyncConverter<TElement, TResult>): AsyncSequence<TResult>;
-  selectMany<TResult>(selector: MaybeAsyncConverter<TElement, MaybeAsyncIterable<TResult>>): AsyncSequence<TResult>;
+  selectMany<TResult>(selector: MaybeAsyncConverter<TElement, MaybeAsyncSequence<TResult>>): AsyncSequence<TResult>;
 
   where(predicate: MaybeAsyncPredicate<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>>;
 
-  join<TOther, TKey>(iterable: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector?: undefined, keyComparer?: MaybeAsyncEquater<TKey>): AsyncSequence<[Awaited<TElement>, Awaited<TOther>]>;
-  join<TOther, TKey, TResult>(iterable: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector: MaybeAsyncBiConverter<TElement, TOther, TResult>, keyComparer?: MaybeAsyncEquater<TKey>): AsyncSequence<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>;
 
-  groupJoin<TOther, TKey>(iterable: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector?: undefined, keyComparer?: MaybeAsyncEquater<TKey>): AsyncSequence<GroupedAsyncSequence<TElement, TOther>>;
-  groupJoin<TOther, TKey, TResult>(iterable: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector: MaybeAsyncBiConverter<TElement, AsyncSequence<TOther>, TResult>, keyComparer?: MaybeAsyncEquater<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>;
 
   contains(obj: TElement, equater?: MaybeAsyncEquater<TElement>): Promise<boolean>;
 
-  sequenceEquals(iterable: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEquater<TElement>): Promise<boolean>;
+  sequenceEquals(sequence: MaybeAsyncSequence<TElement>, equater?: MaybeAsyncEquater<TElement>): Promise<boolean>;
 
   append(obj: TElement): AsyncSequence<TElement>;
 
@@ -36,7 +36,7 @@ export interface AsyncSequence<TElement> extends AsyncIterable<Awaited<TElement>
 
   remove(obj: TElement, all?: boolean, equater?: MaybeAsyncEquater<TElement>): AsyncSequence<TElement>;
 
-  concat(...iterables: MaybeAsyncIterable<TElement>[]): AsyncSequence<TElement>;
+  concat(...sequences: MaybeAsyncSequence<TElement>[]): AsyncSequence<TElement>;
 
   first(predicate?: MaybeAsyncPredicate<TElement>): Promise<TElement>;
   firstOrDefault(predicate?: MaybeAsyncPredicate<TElement>, def?: TElement): Promise<TElement | undefined>;
@@ -66,25 +66,25 @@ export interface AsyncSequence<TElement> extends AsyncIterable<Awaited<TElement>
   orderDescending(comparer?: MaybeAsyncComparer<TElement>): AsyncSequence<TElement>;
   orderByDescending<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparer<TBy>): AsyncSequence<TElement>;
 
-  partition(equater?: MaybeAsyncEquater<TElement>): AsyncSequence<Awaited<TElement>[]>;
-  partitionBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncSequence<Awaited<TElement>[]>;
+  partition(equater?: MaybeAsyncEquater<TElement>): AsyncSequence<TElement[]>;
+  partitionBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncSequence<TElement[]>;
 
   distinct(equater?: MaybeAsyncEquater<TElement>): AsyncSequence<TElement>;
   distinctBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncSequence<TElement>;
 
-  union(iterable: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEquater<TElement>): AsyncSequence<TElement>;
-  unionBy<TBy>(iterable: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): 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>;
 
-  except(iterable: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEquater<TElement>): AsyncSequence<TElement>;
-  exceptBy<TBy>(iterable: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<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>;
 
-  intersect(iterable: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEquater<TElement>): AsyncSequence<TElement>;
-  intersectBy<TBy>(iterable: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<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>;
 
   all(predicate: MaybeAsyncPredicate<TElement>): Promise<boolean>;
   any(predicate: MaybeAsyncPredicate<TElement>): Promise<boolean>;
   any(): Promise<boolean>;
-  none(predicate: Predicate<TElement>): Promise<boolean>;
+  none(predicate: MaybeAsyncPredicate<TElement>): Promise<boolean>;
   none(): Promise<boolean>;
 
   skip(n: number): AsyncSequence<TElement>;
@@ -99,9 +99,9 @@ export interface AsyncSequence<TElement> extends AsyncIterable<Awaited<TElement>
 
   forEach(action: MaybeAsyncAction<TElement>): Promise<void>;
 
-  zip<TOther>(iterable: MaybeAsyncIterable<TOther>): AsyncSequence<[Awaited<TElement>, Awaited<TOther>]>;
+  zip<TOther>(sequence: MaybeAsyncSequence<TOther>): AsyncSequence<[TElement, TOther]>;
 
-  indexex(): AsyncSequence<[number, Awaited<TElement>]>;
+  indexex(): AsyncSequence<[number, TElement]>;
 
   reversed(): AsyncSequence<TElement>;
 
@@ -111,6 +111,8 @@ export interface AsyncSequence<TElement> extends AsyncIterable<Awaited<TElement>
 
   cached(): AsyncSequence<TElement>;
 
+  asArray(): Promise<TElement[]>;
+
   toArray(): Promise<TElement[]>;
   toMap<TKey, TValue>(keySelector: MaybeAsyncConverter<TElement, TKey>, valueSelector: MaybeAsyncConverter<TElement, TValue>): Promise<Map<TKey, TValue>>;
   toSet(): Promise<Set<TElement>>;
diff --git a/src/sync/impl.ts b/src/sync/impl.ts
index 01155cd..74f351d 100644
--- a/src/sync/impl.ts
+++ b/src/sync/impl.ts
@@ -6,7 +6,7 @@ import { getRandomElement } from "../random/index.js";
 import { RandomOptions } from "../random/types.js";
 import { Converter, FilterPredicate, Equater, BiConverter, Predicate, Accumulator, Comparer, Action } from "../types.js";
 import { strictEquals, identity, operatorCompare, reverseComparer, wrapAsIterable, defaultArrayComparer, combineComparers } from "../utils.js";
-import { array, empty, wrap } from "./index.js";
+import { array, empty } from "./index.js";
 import { Sequence, GroupedSequence, OrderedSequence } from "./types.js";
 
 export class SequenceMarker { }
@@ -26,7 +26,7 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
     return new SelectSequence<TElement, TResult>(this, converter);
   }
 
-  selectMany<TResult>(converter: Converter<TElement, Iterable<TResult>>): Sequence<TResult> {
+  selectMany<TResult>(converter: Converter<TElement, Sequence<TResult>>): Sequence<TResult> {
     return new SelectManySequence<TElement, TResult>(this, converter);
   }
 
@@ -38,12 +38,12 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
     return new GroupBySequence<TElement, TKey, TResult>(this, keySelector, elementSelector, keyComparer);
   }
 
-  join<TOther, TKey, TResult>(iterable: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: BiConverter<TElement, TOther, TResult>, keyComparer?: Equater<TKey>): Sequence<TResult> {
-    return new JoinSequence<TElement, TOther, TKey, TResult>(this, wrap(iterable), firstKeySelector, secondKeySelector, resultSelector, keyComparer);
+  join<TOther, TKey, TResult>(sequence: Sequence<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: BiConverter<TElement, TOther, TResult>, keyComparer?: Equater<TKey>): Sequence<TResult> {
+    return new JoinSequence<TElement, TOther, TKey, TResult>(this, sequence, firstKeySelector, secondKeySelector, resultSelector, keyComparer);
   }
 
-  groupJoin<TOther, TKey, TResult>(iterable: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: BiConverter<TElement, Sequence<TOther>, TResult>, keyComparer?: Equater<TKey>): Sequence<TResult> {
-    return new GroupJoinSequence<TElement, TOther, TKey, TResult>(this, wrap(iterable), firstKeySelector, secondKeySelector, resultSelector, keyComparer);
+  groupJoin<TOther, TKey, TResult>(sequence: Sequence<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: BiConverter<TElement, Sequence<TOther>, TResult>, keyComparer?: Equater<TKey>): Sequence<TResult> {
+    return new GroupJoinSequence<TElement, TOther, TKey, TResult>(this, sequence, firstKeySelector, secondKeySelector, resultSelector, keyComparer);
   }
 
   contains(obj: TElement, equater?: Equater<TElement>) {
@@ -60,15 +60,13 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
     return false;
   }
 
-  sequenceEquals(iterable: Iterable<TElement>, equater?: Equater<TElement>) {
-    if (this === iterable) {
+  sequenceEquals(sequence: Sequence<TElement>, equater?: Equater<TElement>) {
+    if (this === sequence) {
       return true;
     }
 
-    const that = wrap(iterable);
-
     const thisCount = this.nonEnumeratedCount();
-    const thatCount = that.nonEnumeratedCount();
+    const thatCount = sequence.nonEnumeratedCount();
 
     if (thisCount >= 0 && thatCount >= 0 && thisCount !== thatCount) {
       return false;
@@ -79,7 +77,7 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
     }
 
     const thisIterator = this.iterator();
-    const thatIterator = that.iterator();
+    const thatIterator = sequence.iterator();
 
     while (true) {
       const thisNext = thisIterator.next();
@@ -111,15 +109,15 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
     return new RemoveSequence<TElement>(this, obj, all, equater);
   }
 
-  concat(...iterables: Iterable<TElement>[]) {
-    if (iterables.length === 0) {
+  concat(...sequences: Sequence<TElement>[]) {
+    if (sequences.length === 0) {
       return this;
     }
 
     const arr: Sequence<TElement>[] = [this];
 
-    for (const iterable of iterables) {
-      arr.push(wrap(iterable));
+    for (const sequence of sequences) {
+      arr.push(sequence);
     }
 
     return new ConcatSequence(arr);
@@ -470,28 +468,28 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
     return new DistinctBySequence<TElement, TBy>(this, selector, equater);
   }
 
-  union(iterable: Iterable<TElement>, equater?: Equater<TElement>): Sequence<TElement> {
-    return new UnionSequence<TElement>(this, wrap(iterable), equater);
+  union(sequence: Sequence<TElement>, equater?: Equater<TElement>): Sequence<TElement> {
+    return new UnionSequence<TElement>(this, sequence, equater);
   }
 
-  unionBy<TBy>(iterable: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: Equater<TBy>): Sequence<TElement> {
-    return new UnionBySequence<TElement, TBy>(this, wrap(iterable), selector, equater);
+  unionBy<TBy>(sequence: Sequence<TElement>, selector: Converter<TElement, TBy>, equater?: Equater<TBy>): Sequence<TElement> {
+    return new UnionBySequence<TElement, TBy>(this, sequence, selector, equater);
   }
 
-  except(iterable: Iterable<TElement>): Sequence<TElement> {
-    return new ExceptSequence<TElement>(this, wrap(iterable));
+  except(sequence: Sequence<TElement>): Sequence<TElement> {
+    return new ExceptSequence<TElement>(this, sequence);
   }
 
-  exceptBy<TBy>(iterable: Iterable<TElement>, selector: Converter<TElement, TBy>): Sequence<TElement> {
-    return new ExceptBySequence<TElement, TBy>(this, wrap(iterable), selector);
+  exceptBy<TBy>(sequence: Sequence<TElement>, selector: Converter<TElement, TBy>): Sequence<TElement> {
+    return new ExceptBySequence<TElement, TBy>(this, sequence, selector);
   }
 
-  intersect(iterable: Iterable<TElement>): Sequence<TElement> {
-    return new IntersectSequence<TElement>(this, wrap(iterable));
+  intersect(sequence: Sequence<TElement>): Sequence<TElement> {
+    return new IntersectSequence<TElement>(this, sequence);
   }
 
-  intersectBy<TBy>(iterable: Iterable<TElement>, selector: Converter<TElement, TBy>): Sequence<TElement> {
-    return new IntersectBySequence<TElement, TBy>(this, wrap(iterable), selector);
+  intersectBy<TBy>(sequence: Sequence<TElement>, selector: Converter<TElement, TBy>): Sequence<TElement> {
+    return new IntersectBySequence<TElement, TBy>(this, sequence, selector);
   }
 
   all(predicate: Predicate<TElement>) {
@@ -600,8 +598,8 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
     }
   }
 
-  zip<TOther>(iterable: Iterable<TOther>): Sequence<[TElement, TOther]> {
-    return new ZippedSequence<TElement, TOther>(this, wrap(iterable));
+  zip<TOther>(sequence: Sequence<TOther>): Sequence<[TElement, TOther]> {
+    return new ZippedSequence<TElement, TOther>(this, sequence);
   }
 
   indexed(): Sequence<[number, TElement]> {
@@ -726,7 +724,7 @@ export class DelegatedSequence<TElement> extends SequenceMarker implements Seque
     return this.#sequence.select(selector);
   }
 
-  selectMany<TResult>(selector: Converter<TElement, Iterable<TResult>>) {
+  selectMany<TResult>(selector: Converter<TElement, Sequence<TResult>>) {
     return this.#sequence.selectMany(selector);
   }
 
@@ -734,27 +732,30 @@ export class DelegatedSequence<TElement> extends SequenceMarker implements Seque
     return this.#sequence.where(predicate);
   }
 
-  groupBy<TKey, TResult>(keySelector: Converter<TElement, TKey>, elementSelector?: Converter<TElement, TResult>, keyComparer?: Equater<TKey>) {
-    //@ts-ignore
+  groupBy<TKey>(keySelector: Converter<TElement, TKey>, elementSelector?: undefined, keyComparer?: Equater<TKey> | undefined): Sequence<GroupedSequence<TKey, TElement>>;
+  groupBy<TKey, TResult>(keySelector: Converter<TElement, TKey>, elementSelector: Converter<TElement, TResult>, keyComparer?: Equater<TKey> | undefined): Sequence<GroupedSequence<TKey, TResult>>;
+  groupBy(keySelector: any, elementSelector?: any, keyComparer?: any) {
     return this.#sequence.groupBy(keySelector, elementSelector, keyComparer);
   }
 
-  join<TOther, TKey, TResult>(iterable: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: BiConverter<TElement, TOther, TResult>, keyComparer?: Equater<TKey>) {
-    //@ts-ignore
-    return this.#sequence.join(iterable, firstKeySelector, secondKeySelector, resultSelector, keyComparer);
+  join<TOther, TKey>(sequence: Sequence<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: undefined, keyComparer?: Equater<TKey> | undefined): Sequence<[TElement, TOther]>;
+  join<TOther, TKey, TResult>(sequence: Sequence<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector: BiConverter<TElement, TOther, TResult>, keyComparer?: Equater<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, TResult>(iterable: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: BiConverter<TElement, Sequence<TOther>, TResult>, keyComparer?: Equater<TKey>) {
-    //@ts-ignore
-    return this.#sequence.groupJoin(iterable, firstKeySelector, secondKeySelector, resultSelector, keyComparer);
+  groupJoin<TOther, TKey>(sequence: Sequence<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: undefined, keyComparer?: Equater<TKey> | undefined): Sequence<GroupedSequence<TElement, TOther>>;
+  groupJoin<TOther, TKey, TResult>(sequence: Sequence<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector: BiConverter<TElement, Sequence<TOther>, TResult>, keyComparer?: Equater<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?: Equater<TElement>) {
     return this.#sequence.contains(obj, equater);
   }
 
-  sequenceEquals(iterable: Iterable<TElement>, equater?: Equater<TElement>) {
-    return this.#sequence.sequenceEquals(iterable, equater);
+  sequenceEquals(sequence: Sequence<TElement>, equater?: Equater<TElement>) {
+    return this.#sequence.sequenceEquals(sequence, equater);
   }
 
   append(obj: TElement) {
@@ -769,8 +770,8 @@ export class DelegatedSequence<TElement> extends SequenceMarker implements Seque
     return this.#sequence.remove(obj, all, equater);
   }
 
-  concat(...iterables: Iterable<TElement>[]) {
-    return this.#sequence.concat(...iterables);
+  concat(...sequences: Sequence<TElement>[]) {
+    return this.#sequence.concat(...sequences);
   }
 
   first(predicate?: Predicate<TElement>) {
@@ -857,41 +858,43 @@ export class DelegatedSequence<TElement> extends SequenceMarker implements Seque
     return this.#sequence.distinctBy(selector, equater);
   }
 
-  union(iterable: Iterable<TElement>, equater?: Equater<TElement>) {
-    return this.#sequence.union(iterable, equater);
+  union(sequence: Sequence<TElement>, equater?: Equater<TElement>) {
+    return this.#sequence.union(sequence, equater);
   }
 
-  unionBy<TBy>(iterable: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: Equater<TBy>) {
-    return this.#sequence.unionBy(iterable, selector, equater);
+  unionBy<TBy>(sequence: Sequence<TElement>, selector: Converter<TElement, TBy>, equater?: Equater<TBy>) {
+    return this.#sequence.unionBy(sequence, selector, equater);
   }
 
-  except(iterable: Iterable<TElement>, equater?: Equater<TElement>) {
-    return this.#sequence.except(iterable, equater);
+  except(sequence: Sequence<TElement>, equater?: Equater<TElement>) {
+    return this.#sequence.except(sequence, equater);
   }
 
-  exceptBy<TBy>(iterable: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: Equater<TBy>) {
-    return this.#sequence.exceptBy(iterable, selector, equater);
+  exceptBy<TBy>(sequence: Sequence<TElement>, selector: Converter<TElement, TBy>, equater?: Equater<TBy>) {
+    return this.#sequence.exceptBy(sequence, selector, equater);
   }
 
-  intersect(iterable: Iterable<TElement>, equater?: Equater<TElement>) {
-    return this.#sequence.intersect(iterable, equater);
+  intersect(sequence: Sequence<TElement>, equater?: Equater<TElement>) {
+    return this.#sequence.intersect(sequence, equater);
   }
 
-  intersectBy<TBy>(iterable: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: Equater<TBy>) {
-    return this.#sequence.intersectBy(iterable, selector, equater);
+  intersectBy<TBy>(sequence: Sequence<TElement>, selector: Converter<TElement, TBy>, equater?: Equater<TBy>) {
+    return this.#sequence.intersectBy(sequence, selector, equater);
   }
 
   all(predicate: Predicate<TElement>) {
     return this.#sequence.all(predicate);
   }
 
-  any(predicate?: Predicate<TElement>) {
-    //@ts-ignore
+  any(predicate: Predicate<TElement>): boolean;
+  any(): boolean;
+  any(predicate?: any) {
     return this.#sequence.any(predicate);
   }
 
-  none(predicate?: Predicate<TElement>) {
-    //@ts-ignore
+  none(predicate: Predicate<TElement>): boolean;
+  none(): boolean;
+  none(predicate?: any) {
     return this.#sequence.none(predicate);
   }
 
@@ -927,8 +930,8 @@ export class DelegatedSequence<TElement> extends SequenceMarker implements Seque
     this.#sequence.forEach(action);
   }
 
-  zip<TOther>(iterable: Iterable<TOther>) {
-    return this.#sequence.zip(iterable);
+  zip<TOther>(sequence: Sequence<TOther>) {
+    return this.#sequence.zip(sequence);
   }
 
   indexed() {
@@ -951,6 +954,10 @@ export class DelegatedSequence<TElement> extends SequenceMarker implements Seque
     return this.#sequence.cached();
   }
 
+  // awaited(): AsyncSequence<Awaited<TElement>> {
+  //   return this.#sequence.awaited();
+  // }
+
   asArray() {
     return this.#sequence.asArray();
   }
@@ -1053,16 +1060,10 @@ export abstract class BaseOrderedSequence<TElement> extends BaseSequence<TElemen
 }
 
 export class EmptySequence<T> extends BaseSequence<T> {
-  static readonly INSTANCE = new EmptySequence<any>();
-
   override nonEnumeratedCount() {
     return 0;
   }
 
-  override maxCount() {
-    return 0;
-  }
-
   override *iterator() { }
 }
 
@@ -1552,9 +1553,9 @@ class WhereSequence<TElement, TFiltered extends TElement> extends BaseSequence<T
 
 class SelectManySequence<T, U> extends BaseSequence<U> {
   readonly #sequence: Sequence<T>;
-  readonly #converter: Converter<T, Iterable<U>>;
+  readonly #converter: Converter<T, Sequence<U>>;
 
-  constructor(sequence: Sequence<T>, converter: Converter<T, Iterable<U>>) {
+  constructor(sequence: Sequence<T>, converter: Converter<T, Sequence<U>>) {
     super();
 
     this.#sequence = sequence;
@@ -2479,3 +2480,17 @@ class PartitionBySequence<TElement, TBy> extends BaseSequence<TElement[]> {
     yield* partitions.values();
   }
 }
+
+// class AwaitedSequence<T> extends BaseAsyncSequence<Awaited<T>> {
+//   readonly #sequence: Sequence<T>;
+
+//   constructor(sequence: Sequence<T>) {
+//     super();
+
+//     this.#sequence = sequence;
+//   }
+
+//   override async *iterator() {
+//     yield* this.#sequence;
+//   }
+// }
diff --git a/src/sync/index.ts b/src/sync/index.ts
index 8bb3658..a5844fa 100644
--- a/src/sync/index.ts
+++ b/src/sync/index.ts
@@ -27,8 +27,10 @@ export function sequence<T>(iterable: Iterable<T>): Sequence<T> {
   return new WrappedIterable(iterable);
 }
 
+export const EMPTY = new EmptySequence<any>();
+
 export function empty<T>(): Sequence<T> {
-  return EmptySequence.INSTANCE;
+  return EMPTY;
 }
 
 export function single<T>(obj: T): Sequence<T> {
diff --git a/src/sync/types.ts b/src/sync/types.ts
index 98f58bf..c5de42e 100644
--- a/src/sync/types.ts
+++ b/src/sync/types.ts
@@ -13,7 +13,7 @@ export interface Sequence<TElement> extends Iterable<TElement> {
   maxCount(): number;
 
   select<TResult>(selector: Converter<TElement, TResult>): Sequence<TResult>;
-  selectMany<TResult>(selector: Converter<TElement, Iterable<TResult>>): Sequence<TResult>;
+  selectMany<TResult>(selector: Converter<TElement, Sequence<TResult>>): Sequence<TResult>;
 
   where<TFiltered extends TElement>(predicate: FilterPredicate<TElement, TFiltered>): Sequence<TFiltered>;
   where(predicate: Predicate<TElement>): Sequence<TElement>;
@@ -21,15 +21,15 @@ export interface Sequence<TElement> extends Iterable<TElement> {
   groupBy<TKey>(keySelector: Converter<TElement, TKey>, elementSelector?: undefined, keyComparer?: Equater<TKey>): Sequence<GroupedSequence<TKey, TElement>>;
   groupBy<TKey, TResult>(keySelector: Converter<TElement, TKey>, elementSelector: Converter<TElement, TResult>, keyComparer?: Equater<TKey>): Sequence<GroupedSequence<TKey, TResult>>;
 
-  join<TOther, TKey>(iterable: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: undefined, keyComparer?: Equater<TKey>): Sequence<[TElement, TOther]>;
-  join<TOther, TKey, TResult>(iterable: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector: BiConverter<TElement, TOther, TResult>, keyComparer?: Equater<TKey>): Sequence<TResult>;
+  join<TOther, TKey>(sequence: Sequence<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: undefined, keyComparer?: Equater<TKey>): Sequence<[TElement, TOther]>;
+  join<TOther, TKey, TResult>(sequence: Sequence<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector: BiConverter<TElement, TOther, TResult>, keyComparer?: Equater<TKey>): Sequence<TResult>;
 
-  groupJoin<TOther, TKey>(iterable: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: undefined, keyComparer?: Equater<TKey>): Sequence<GroupedSequence<TElement, TOther>>;
-  groupJoin<TOther, TKey, TResult>(iterable: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector: BiConverter<TElement, Sequence<TOther>, TResult>, keyComparer?: Equater<TKey>): Sequence<TResult>;
+  groupJoin<TOther, TKey>(sequence: Sequence<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: undefined, keyComparer?: Equater<TKey>): Sequence<GroupedSequence<TElement, TOther>>;
+  groupJoin<TOther, TKey, TResult>(sequence: Sequence<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector: BiConverter<TElement, Sequence<TOther>, TResult>, keyComparer?: Equater<TKey>): Sequence<TResult>;
 
   contains(obj: TElement, equater?: Equater<TElement>): boolean;
 
-  sequenceEquals(iterable: Iterable<TElement>, equater?: Equater<TElement>): boolean;
+  sequenceEquals(sequence: Sequence<TElement>, equater?: Equater<TElement>): boolean;
 
   append(obj: TElement): Sequence<TElement>;
 
@@ -37,7 +37,7 @@ export interface Sequence<TElement> extends Iterable<TElement> {
 
   remove(obj: TElement, all?: boolean, equater?: Equater<TElement>): Sequence<TElement>;
 
-  concat(...iterables: Iterable<TElement>[]): Sequence<TElement>;
+  concat(...sequences: Sequence<TElement>[]): Sequence<TElement>;
 
   first(predicate?: Predicate<TElement>): TElement;
   firstOrDefault(predicate?: Predicate<TElement>, def?: TElement): TElement | undefined;
@@ -73,14 +73,14 @@ export interface Sequence<TElement> extends Iterable<TElement> {
   distinct(equater?: Equater<TElement>): Sequence<TElement>;
   distinctBy<TBy>(selector: Converter<TElement, TBy>, equater?: Equater<TBy>): Sequence<TElement>;
 
-  union(iterable: Iterable<TElement>, equater?: Equater<TElement>): Sequence<TElement>;
-  unionBy<TBy>(iterable: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: Equater<TBy>): Sequence<TElement>;
+  union(sequence: Sequence<TElement>, equater?: Equater<TElement>): Sequence<TElement>;
+  unionBy<TBy>(sequence: Sequence<TElement>, selector: Converter<TElement, TBy>, equater?: Equater<TBy>): Sequence<TElement>;
 
-  except(iterable: Iterable<TElement>, equater?: Equater<TElement>): Sequence<TElement>;
-  exceptBy<TBy>(iterable: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: Equater<TBy>): Sequence<TElement>;
+  except(sequence: Sequence<TElement>, equater?: Equater<TElement>): Sequence<TElement>;
+  exceptBy<TBy>(sequence: Sequence<TElement>, selector: Converter<TElement, TBy>, equater?: Equater<TBy>): Sequence<TElement>;
 
-  intersect(iterable: Iterable<TElement>, equater?: Equater<TElement>): Sequence<TElement>;
-  intersectBy<TBy>(iterable: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: Equater<TBy>): Sequence<TElement>;
+  intersect(sequence: Sequence<TElement>, equater?: Equater<TElement>): Sequence<TElement>;
+  intersectBy<TBy>(sequence: Sequence<TElement>, selector: Converter<TElement, TBy>, equater?: Equater<TBy>): Sequence<TElement>;
 
   all(predicate: Predicate<TElement>): boolean;
   any(predicate: Predicate<TElement>): boolean;
@@ -100,7 +100,7 @@ export interface Sequence<TElement> extends Iterable<TElement> {
 
   forEach(action: Action<TElement>): void;
 
-  zip<TOther>(iterable: Iterable<TOther>): Sequence<[TElement, TOther]>;
+  zip<TOther>(sequence: Sequence<TOther>): Sequence<[TElement, TOther]>;
 
   indexed(): Sequence<[number, TElement]>;
 
@@ -112,6 +112,8 @@ export interface Sequence<TElement> extends Iterable<TElement> {
 
   cached(): Sequence<TElement>;
 
+  // awaited(): AsyncSequence<Awaited<TElement>>;
+
   asArray(): TElement[];
   toArray(): TElement[];
   toMap<TKey, TValue>(keySelector: Converter<TElement, TKey>, valueSelector: Converter<TElement, TValue>): Map<TKey, TValue>;
diff --git a/src/types.ts b/src/types.ts
index 9a0677a..11952ae 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -1,3 +1,6 @@
+import { AsyncSequence } from "./async/types.js";
+import { Sequence } from "./sync/types.js";
+
 export type Predicate<T> = (obj: T) => boolean;
 export type FilterPredicate<TElement, TFiltered extends TElement> = (obj: TElement) => obj is TFiltered;
 export type Converter<TFrom, TTo> = (obj: TFrom) => TTo;
@@ -9,10 +12,12 @@ export type Equater<T> = (first: T, second: T) => boolean;
 
 export type MaybeAsyncIterable<T> = Iterable<T> | AsyncIterable<T>;
 export type MaybeAsyncIterator<T> = Iterator<T> | AsyncIterator<T>;
-
+export type MaybeAsyncGenerator<T> = Generator<T> | AsyncGenerator<T>;
 export type AsyncFunction<TFunc extends (...args: any) => any> = TFunc extends (...args: infer P) => infer R ? (...args: P) => Promise<Awaited<R>> : never;
 export type MaybePromise<T> = T | Promise<T>;
+export type MaybePromiseLike<T> = T | PromiseLike<T>;
 export type MaybeAsyncFunction<TFunc extends (...args: any) => any> = TFunc extends (...args: infer P) => infer R ? (...args: P) => MaybePromise<R> : never;
+export type MaybeAsyncSequence<T> = Sequence<T> | AsyncSequence<T>;
 
 export type AsyncPredicate<T> = AsyncFunction<Predicate<T>>;
 export type MaybeAsyncPredicate<T> = MaybeAsyncFunction<Predicate<T>>;