diff --git a/package-lock.json b/package-lock.json
index 77e1bef..6d4b8e3 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,11 +1,11 @@
 {
-  "name": "enumerable",
+  "name": "sequence-js",
   "version": "1.0.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
-      "name": "enumerable",
+      "name": "sequence-js",
       "version": "1.0.0",
       "license": "ISC",
       "devDependencies": {
@@ -76,9 +76,9 @@
       "dev": true
     },
     "node_modules/@types/node": {
-      "version": "20.12.8",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-20.12.8.tgz",
-      "integrity": "sha512-NU0rJLJnshZWdE/097cdCBbyW1h4hEg0xpovcoAQYHl8dnEyp/NAOiE45pvc+Bd1Dt+2r94v2eGFpQJ4R7g+2w==",
+      "version": "20.12.11",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-20.12.11.tgz",
+      "integrity": "sha512-vDg9PZ/zi+Nqp6boSOT7plNuthRugEKixDv5sFTIpkE89MmNtEArAShI4mxuX2+UrLEe9pxC1vm2cjm9YlWbJw==",
       "dev": true,
       "dependencies": {
         "undici-types": "~5.26.4"
diff --git a/package.json b/package.json
index 67fd29e..7ab328e 100644
--- a/package.json
+++ b/package.json
@@ -1,7 +1,7 @@
 {
-  "name": "enumerable",
+  "name": "sequence-js",
   "version": "1.0.0",
-  "description": "Implementation of Enumerable API from .NET",
+  "description": "Synchronous and asynchronous sequence manipulation library inspired by .NET Enumerables and Java Streams",
   "main": "src/index.ts",
   "type": "module",
   "scripts": {
diff --git a/src/async/impl.ts b/src/async/impl.ts
index 9fce8f4..be29db4 100644
--- a/src/async/impl.ts
+++ b/src/async/impl.ts
@@ -5,47 +5,47 @@ import { createQueue } from "../queue.js";
 import { getRandomElementAsync } from "../random/index.js";
 import { AsyncRandomOptions } from "../random/types.js";
 import { selectionSorter } from "../sorting.js";
-import { Enumerable } from "../sync/types.js";
+import { Sequence } from "../sync/types.js";
 import { MaybeAsyncConverter, MaybeAsyncIterable, MaybeAsyncPredicate, MaybeAsyncEquater, MaybeAsyncBiConverter, MaybeAsyncAccumulator, MaybeAsyncComparer, MaybeAsyncAction, MaybePromise, Predicate } from "../types.js";
 import { strictEquals, identity, operatorCompare, asAsyncGenerator, defaultArrayComparer, combineAsyncComparers } from "../utils.js";
 import { array, empty, wrap } from "./index.js";
-import { AsyncEnumerable, GroupedAsyncEnumerable, OrderedAsyncEnumerable } from "./types.js";
+import { AsyncSequence, GroupedAsyncSequence, OrderedAsyncSequence } from "./types.js";
 
-export class AsyncEnumerableMarker { }
+export class AsyncSequenceMarker { }
 
-export abstract class BaseAsyncEnumerable<TElement> extends AsyncEnumerableMarker implements AsyncEnumerable<TElement> {
+export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker implements AsyncSequence<TElement> {
   [Symbol.asyncIterator]() {
     return this.iterator();
   }
 
   abstract iterator(): AsyncIterator<Awaited<TElement>>;
 
-  apply<TResult>(pipeline: (enumerable: AsyncEnumerable<TElement>) => TResult): TResult {
+  apply<TResult>(pipeline: (sequence: AsyncSequence<TElement>) => TResult): TResult {
     return pipeline(this);
   }
 
-  select<TResult>(converter: MaybeAsyncConverter<TElement, TResult>): AsyncEnumerable<TResult> {
-    return new MapperAsyncEnumerable<TElement, TResult>(this, converter);
+  select<TResult>(converter: MaybeAsyncConverter<TElement, TResult>): AsyncSequence<TResult> {
+    return new MapperAsyncSequence<TElement, TResult>(this, converter);
   }
 
-  selectMany<TResult>(converter: MaybeAsyncConverter<TElement, MaybeAsyncIterable<TResult>>): AsyncEnumerable<TResult> {
-    return new FlatMapperAsyncEnumerable<TElement, TResult>(this, converter);
+  selectMany<TResult>(converter: MaybeAsyncConverter<TElement, MaybeAsyncIterable<TResult>>): AsyncSequence<TResult> {
+    return new FlatMapperAsyncSequence<TElement, TResult>(this, converter);
   }
 
-  where(predicate: MaybeAsyncPredicate<TElement>): AsyncEnumerable<TElement> {
-    return new FilterAsyncEnumerable<TElement>(this, predicate);
+  where(predicate: MaybeAsyncPredicate<TElement>): AsyncSequence<TElement> {
+    return new FilterAsyncSequence<TElement>(this, predicate);
   }
 
-  groupBy<TKey, TResult>(keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector?: MaybeAsyncConverter<TElement, TResult>, keyComparer?: MaybeAsyncEquater<TKey>): AsyncEnumerable<GroupedAsyncEnumerable<TKey, TResult>> {
-    return new GroupByAsyncEnumerable<TElement, TKey, TResult>(this, keySelector, elementSelector, keyComparer);
+  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);
   }
 
-  join<TOther, TKey, TResult>(iterable: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector?: MaybeAsyncBiConverter<TElement, TOther, TResult>, keyComparer?: MaybeAsyncEquater<TKey>): AsyncEnumerable<TResult> {
-    return new JoinAsyncEnumerable<TElement, TOther, TKey, TResult>(this, wrap(iterable), firstKeySelector, secondKeySelector, resultSelector, 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);
   }
 
-  groupJoin<TOther, TKey, TResult>(iterable: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector?: MaybeAsyncBiConverter<TElement, AsyncEnumerable<TOther>, TResult>, keyComparer?: MaybeAsyncEquater<TKey>): AsyncEnumerable<TResult> {
-    return new GroupJoinAsyncEnumerable<TElement, TOther, TKey, TResult>(this, wrap(iterable), 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);
   }
 
   async contains(obj: TElement, equater?: MaybeAsyncEquater<TElement>) {
@@ -101,30 +101,30 @@ export abstract class BaseAsyncEnumerable<TElement> extends AsyncEnumerableMarke
     }
   }
 
-  append(obj: TElement): AsyncEnumerable<TElement> {
-    return new AppendAsyncEnumerable<TElement>(this, obj);
+  append(obj: TElement): AsyncSequence<TElement> {
+    return new AppendAsyncSequence<TElement>(this, obj);
   }
 
-  prepend(obj: TElement): AsyncEnumerable<TElement> {
-    return new PrependAsyncEnumerable<TElement>(this, obj);
+  prepend(obj: TElement): AsyncSequence<TElement> {
+    return new PrependAsyncSequence<TElement>(this, obj);
   }
 
-  remove(obj: TElement, all?: boolean, equater?: MaybeAsyncEquater<TElement>): AsyncEnumerable<TElement> {
-    return new RemoveAsyncEnumerable<TElement>(this, obj, all, equater);
+  remove(obj: TElement, all?: boolean, equater?: MaybeAsyncEquater<TElement>): AsyncSequence<TElement> {
+    return new RemoveAsyncSequence<TElement>(this, obj, all, equater);
   }
 
-  concat(...iterables: MaybeAsyncIterable<TElement>[]): AsyncEnumerable<TElement> {
+  concat(...iterables: MaybeAsyncIterable<TElement>[]): AsyncSequence<TElement> {
     if (iterables.length === 0) {
       return this;
     }
 
-    const arr: AsyncEnumerable<TElement>[] = [this];
+    const arr: AsyncSequence<TElement>[] = [this];
 
     for (const iterable of iterables) {
       arr.push(wrap(iterable));
     }
 
-    return new ConcatAsyncEnumerable(arr);
+    return new ConcatAsyncSequence(arr);
   }
 
   async count(predicate?: MaybeAsyncPredicate<TElement>) {
@@ -440,52 +440,52 @@ export abstract class BaseAsyncEnumerable<TElement> extends AsyncEnumerableMarke
     return this.#find(x => x < 0, converter, comparer);
   }
 
-  order(comparer?: MaybeAsyncComparer<TElement>): OrderedAsyncEnumerable<TElement> {
-    return new OrderAsyncEnumerable<TElement>(this, false, comparer);
+  order(comparer?: MaybeAsyncComparer<TElement>): OrderedAsyncSequence<TElement> {
+    return new OrderAsyncSequence<TElement>(this, false, comparer);
   }
 
-  orderBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparer<TBy>): OrderedAsyncEnumerable<TElement> {
-    return new OrderByAsyncEnumerable<TElement, TBy>(this, false, selector, comparer);
+  orderBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparer<TBy>): OrderedAsyncSequence<TElement> {
+    return new OrderByAsyncSequence<TElement, TBy>(this, false, selector, comparer);
   }
 
-  orderDescending(comparer?: MaybeAsyncComparer<TElement>): OrderedAsyncEnumerable<TElement> {
-    return new OrderAsyncEnumerable<TElement>(this, true, comparer);
+  orderDescending(comparer?: MaybeAsyncComparer<TElement>): OrderedAsyncSequence<TElement> {
+    return new OrderAsyncSequence<TElement>(this, true, comparer);
   }
 
-  orderByDescending<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparer<TBy>): OrderedAsyncEnumerable<TElement> {
-    return new OrderByAsyncEnumerable<TElement, TBy>(this, true, selector, comparer);
+  orderByDescending<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparer<TBy>): OrderedAsyncSequence<TElement> {
+    return new OrderByAsyncSequence<TElement, TBy>(this, true, selector, comparer);
   }
 
-  distinct(equater?: MaybeAsyncEquater<TElement>): AsyncEnumerable<TElement> {
-    return new DistinctAsyncEnumerable<TElement>(this, equater);
+  distinct(equater?: MaybeAsyncEquater<TElement>): AsyncSequence<TElement> {
+    return new DistinctAsyncSequence<TElement>(this, equater);
   }
 
-  distinctBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncEnumerable<TElement> {
-    return new DistinctByAsyncEnumerable<TElement, TBy>(this, selector, equater);
+  distinctBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncSequence<TElement> {
+    return new DistinctByAsyncSequence<TElement, TBy>(this, selector, equater);
   }
 
-  union(iterable: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEquater<TElement>): AsyncEnumerable<TElement> {
-    return new UnionAsyncEnumerable<TElement>(this, wrap(iterable), equater);
+  union(iterable: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEquater<TElement>): AsyncSequence<TElement> {
+    return new UnionAsyncSequence<TElement>(this, wrap(iterable), equater);
   }
 
-  unionBy<TBy>(iterable: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncEnumerable<TElement> {
-    return new UnionByAsyncEnumerable<TElement, TBy>(this, wrap(iterable), selector, 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);
   }
 
-  except(iterable: MaybeAsyncIterable<TElement>): AsyncEnumerable<TElement> {
-    return new ExceptAsyncEnumerable<TElement>(this, wrap(iterable));
+  except(iterable: MaybeAsyncIterable<TElement>): AsyncSequence<TElement> {
+    return new ExceptAsyncSequence<TElement>(this, wrap(iterable));
   }
 
-  exceptBy<TBy>(iterable: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>): AsyncEnumerable<TElement> {
-    return new ExceptByAsyncEnumerable<TElement, TBy>(this, wrap(iterable), selector);
+  exceptBy<TBy>(iterable: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>): AsyncSequence<TElement> {
+    return new ExceptByAsyncSequence<TElement, TBy>(this, wrap(iterable), selector);
   }
 
-  intersect(iterable: MaybeAsyncIterable<TElement>): AsyncEnumerable<TElement> {
-    return new IntersectAsyncEnumerable<TElement>(this, wrap(iterable));
+  intersect(iterable: MaybeAsyncIterable<TElement>): AsyncSequence<TElement> {
+    return new IntersectAsyncSequence<TElement>(this, wrap(iterable));
   }
 
-  intersectBy<TBy>(iterable: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>): AsyncEnumerable<TElement> {
-    return new IntersectByAsyncEnumerable<TElement, TBy>(this, wrap(iterable), selector);
+  intersectBy<TBy>(iterable: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>): AsyncSequence<TElement> {
+    return new IntersectByAsyncSequence<TElement, TBy>(this, wrap(iterable), selector);
   }
 
   async all(predicate: MaybeAsyncPredicate<TElement>) {
@@ -544,48 +544,48 @@ export abstract class BaseAsyncEnumerable<TElement> extends AsyncEnumerableMarke
     return n < 0 && (await this.iterator().next()).done === true;
   }
 
-  skip(n: number): AsyncEnumerable<TElement> {
+  skip(n: number): AsyncSequence<TElement> {
     if (n < 0) {
       throw new Error("Cannot skip a negative number of elements.");
     }
 
-    return n === 0 ? this : new SkipAsyncEnumerable<TElement>(this, n);
+    return n === 0 ? this : new SkipAsyncSequence<TElement>(this, n);
   }
 
-  skipLast(n: number): AsyncEnumerable<TElement> {
+  skipLast(n: number): AsyncSequence<TElement> {
     if (n < 0) {
       throw new Error("Cannot skip a negative number of elements.");
     }
 
-    return n === 0 ? this : new SkipLastAsyncEnumerable<TElement>(this, n);
+    return n === 0 ? this : new SkipLastAsyncSequence<TElement>(this, n);
   }
 
-  skipWhile(predicate: MaybeAsyncPredicate<TElement>): AsyncEnumerable<TElement> {
-    return new SkipWhileAsyncEnumerable<TElement>(this, predicate);
+  skipWhile(predicate: MaybeAsyncPredicate<TElement>): AsyncSequence<TElement> {
+    return new SkipWhileAsyncSequence<TElement>(this, predicate);
   }
 
-  take(n: number): AsyncEnumerable<TElement> {
+  take(n: number): AsyncSequence<TElement> {
     if (n < 0) {
       throw new Error("Cannot take a negative number of elements.");
     }
 
-    return n === 0 ? empty<TElement>() : new TakeAsyncEnumerable<TElement>(this, n);
+    return n === 0 ? empty<TElement>() : new TakeAsyncSequence<TElement>(this, n);
   }
 
-  takeLast(n: number): AsyncEnumerable<TElement> {
+  takeLast(n: number): AsyncSequence<TElement> {
     if (n < 0) {
       throw new Error("Cannot take a negative number of elements.");
     }
 
-    return n === 0 ? empty<TElement>() : new TakeLastAsyncEnumerable<TElement>(this, n);
+    return n === 0 ? empty<TElement>() : new TakeLastAsyncSequence<TElement>(this, n);
   }
 
-  takeWhile(predicate: MaybeAsyncPredicate<TElement>): AsyncEnumerable<TElement> {
-    return new TakeWhileAsyncEnumerable<TElement>(this, predicate);
+  takeWhile(predicate: MaybeAsyncPredicate<TElement>): AsyncSequence<TElement> {
+    return new TakeWhileAsyncSequence<TElement>(this, predicate);
   }
 
-  peek(action: MaybeAsyncAction<TElement>): AsyncEnumerable<TElement> {
-    return new PeekAsyncEnumerable(this, action);
+  peek(action: MaybeAsyncAction<TElement>): AsyncSequence<TElement> {
+    return new PeekAsyncSequence(this, action);
   }
 
   async forEach(action: MaybeAsyncAction<TElement>) {
@@ -594,32 +594,32 @@ export abstract class BaseAsyncEnumerable<TElement> extends AsyncEnumerableMarke
     }
   }
 
-  zip<TOther>(iterable: MaybeAsyncIterable<TOther>): AsyncEnumerable<[Awaited<TElement>, Awaited<TOther>]> {
-    return new ZippedAsyncEnumerable<TElement, TOther>(this, wrap(iterable));
+  zip<TOther>(iterable: MaybeAsyncIterable<TOther>): AsyncSequence<[Awaited<TElement>, Awaited<TOther>]> {
+    return new ZippedAsyncSequence<TElement, TOther>(this, wrap(iterable));
   }
 
-  indexex(): AsyncEnumerable<[number, Awaited<TElement>]> {
-    return new IndexedAsyncEnumerable<TElement>(this);
+  indexex(): AsyncSequence<[number, Awaited<TElement>]> {
+    return new IndexedAsyncSequence<TElement>(this);
   }
 
-  reversed(): AsyncEnumerable<TElement> {
-    return new ReversedAsyncEnumerable<TElement>(this);
+  reversed(): AsyncSequence<TElement> {
+    return new ReversedAsyncSequence<TElement>(this);
   }
 
-  chunked(size: number): AsyncEnumerable<TElement[]> {
+  chunked(size: number): AsyncSequence<TElement[]> {
     if (size <= 0) {
       throw new Error("Chunk size must be positive.");
     }
 
-    return new ChunkedAsyncEnumerable<TElement>(this, size);
+    return new ChunkedAsyncSequence<TElement>(this, size);
   }
 
   async random(options?: AsyncRandomOptions<TElement> | undefined): Promise<TElement | undefined> {
     return (await getRandomElementAsync(this, options)).element;
   }
 
-  cached(): AsyncEnumerable<TElement> {
-    return new CacheAsyncEnumerable<TElement>(this);
+  cached(): AsyncSequence<TElement> {
+    return new CacheAsyncSequence<TElement>(this);
   }
 
   async toArray() {
@@ -679,21 +679,21 @@ export abstract class BaseAsyncEnumerable<TElement> extends AsyncEnumerableMarke
   }
 }
 
-export class DelegatedAsyncEnumerable<TElement> extends AsyncEnumerableMarker implements AsyncEnumerable<TElement> {
-  #enumerable: AsyncEnumerable<TElement>;
+export class DelegatedAsyncSequence<TElement> extends AsyncSequenceMarker implements AsyncSequence<TElement> {
+  #sequence: AsyncSequence<TElement>;
 
-  constructor(enumerable: AsyncEnumerable<TElement>) {
+  constructor(sequence: AsyncSequence<TElement>) {
     super();
 
-    this.#enumerable = enumerable;
+    this.#sequence = sequence;
   }
 
-  get enumerable() {
-    return this.#enumerable;
+  get sequence() {
+    return this.#sequence;
   }
 
-  protected set enumerable(value: AsyncEnumerable<TElement>) {
-    this.#enumerable = value;
+  protected set sequence(value: AsyncSequence<TElement>) {
+    this.#sequence = value;
   }
 
   [Symbol.asyncIterator]() {
@@ -701,283 +701,283 @@ export class DelegatedAsyncEnumerable<TElement> extends AsyncEnumerableMarker im
   }
 
   iterator() {
-    return this.#enumerable.iterator();
+    return this.#sequence.iterator();
   }
 
-  apply<TResult>(pipeline: (enumerable: AsyncEnumerable<TElement>) => TResult) {
-    return this.#enumerable.apply(pipeline);
+  apply<TResult>(pipeline: (sequence: AsyncSequence<TElement>) => TResult) {
+    return this.#sequence.apply(pipeline);
   }
 
   count(predicate?: ((obj: TElement) => MaybePromise<boolean>) | undefined): Promise<number> {
-    return this.#enumerable.count(predicate);
+    return this.#sequence.count(predicate);
   }
 
   nonEnumeratedCount(): Promise<number> {
-    return this.#enumerable.nonEnumeratedCount();
+    return this.#sequence.nonEnumeratedCount();
   }
 
   fastCount(): Promise<number> {
-    return this.#enumerable.fastCount();
+    return this.#sequence.fastCount();
   }
 
   maxCount(): Promise<number> {
-    return this.#enumerable.maxCount();
+    return this.#sequence.maxCount();
   }
 
-  select<TResult>(selector: (obj: TElement) => MaybePromise<TResult>): AsyncEnumerable<TResult> {
-    return this.#enumerable.select(selector);
+  select<TResult>(selector: (obj: TElement) => MaybePromise<TResult>): AsyncSequence<TResult> {
+    return this.#sequence.select(selector);
   }
 
-  selectMany<TResult>(selector: (obj: TElement) => MaybePromise<MaybeAsyncIterable<TResult>>): AsyncEnumerable<TResult> {
-    return this.#enumerable.selectMany(selector);
+  selectMany<TResult>(selector: (obj: TElement) => MaybePromise<MaybeAsyncIterable<TResult>>): AsyncSequence<TResult> {
+    return this.#sequence.selectMany(selector);
   }
 
-  where(predicate: (obj: TElement) => MaybePromise<boolean>): AsyncEnumerable<TElement> {
-    return this.#enumerable.where(predicate);
+  where(predicate: (obj: TElement) => MaybePromise<boolean>): AsyncSequence<TElement> {
+    return this.#sequence.where(predicate);
   }
 
-  groupBy<TKey>(keySelector: (obj: TElement) => MaybePromise<TKey>, elementSelector?: undefined, keyComparer?: ((first: TKey, second: TKey) => MaybePromise<boolean>) | undefined): AsyncEnumerable<GroupedAsyncEnumerable<TKey, TElement>>;
-  groupBy<TKey, TResult>(keySelector: (obj: TElement) => MaybePromise<TKey>, elementSelector: (obj: TElement) => MaybePromise<TResult>, keyComparer?: ((first: TKey, second: TKey) => MaybePromise<boolean>) | undefined): AsyncEnumerable<GroupedAsyncEnumerable<TKey, TResult>>;
+  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(keySelector: any, elementSelector?: any, keyComparer?: any) {
-    return this.#enumerable.groupBy(keySelector, elementSelector, keyComparer);
+    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): AsyncEnumerable<[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): AsyncEnumerable<TResult>;
+  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.#enumerable.join(iterable, firstKeySelector, secondKeySelector, resultSelector, keyComparer);
+    return this.#sequence.join(iterable, 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): AsyncEnumerable<GroupedAsyncEnumerable<TElement, TOther>>;
-  groupJoin<TOther, TKey, TResult>(iterable: MaybeAsyncIterable<TOther>, firstKeySelector: (obj: TElement) => MaybePromise<TKey>, secondKeySelector: (obj: TOther) => MaybePromise<TKey>, resultSelector: (first: TElement, second: AsyncEnumerable<TOther>) => MaybePromise<TResult>, keyComparer?: ((first: TKey, second: TKey) => MaybePromise<boolean>) | undefined): AsyncEnumerable<TResult>;
+  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.#enumerable.groupJoin(iterable, firstKeySelector, secondKeySelector, resultSelector, keyComparer);
+    return this.#sequence.groupJoin(iterable, firstKeySelector, secondKeySelector, resultSelector, keyComparer);
   }
 
   contains(obj: TElement, equater?: ((first: TElement, second: TElement) => MaybePromise<boolean>) | undefined): Promise<boolean> {
-    return this.#enumerable.contains(obj, equater);
+    return this.#sequence.contains(obj, equater);
   }
 
   sequenceEquals(iterable: MaybeAsyncIterable<TElement>, equater?: ((first: TElement, second: TElement) => MaybePromise<boolean>) | undefined): Promise<boolean> {
-    return this.#enumerable.sequenceEquals(iterable, equater);
+    return this.#sequence.sequenceEquals(iterable, equater);
   }
 
-  append(obj: TElement): AsyncEnumerable<TElement> {
-    return this.#enumerable.append(obj);
+  append(obj: TElement): AsyncSequence<TElement> {
+    return this.#sequence.append(obj);
   }
 
-  prepend(obj: TElement): AsyncEnumerable<TElement> {
-    return this.#enumerable.prepend(obj);
+  prepend(obj: TElement): AsyncSequence<TElement> {
+    return this.#sequence.prepend(obj);
   }
 
-  remove(obj: TElement, all?: boolean | undefined, equater?: ((first: TElement, second: TElement) => MaybePromise<boolean>) | undefined): AsyncEnumerable<TElement> {
-    return this.#enumerable.remove(obj, all, equater);
+  remove(obj: TElement, all?: boolean | undefined, equater?: ((first: TElement, second: TElement) => MaybePromise<boolean>) | undefined): AsyncSequence<TElement> {
+    return this.#sequence.remove(obj, all, equater);
   }
 
-  concat(...iterables: MaybeAsyncIterable<TElement>[]): AsyncEnumerable<TElement> {
-    return this.#enumerable.concat(...iterables);
+  concat(...iterables: MaybeAsyncIterable<TElement>[]): AsyncSequence<TElement> {
+    return this.#sequence.concat(...iterables);
   }
 
   first(predicate?: ((obj: TElement) => MaybePromise<boolean>) | undefined): Promise<TElement> {
-    return this.#enumerable.first(predicate);
+    return this.#sequence.first(predicate);
   }
 
   firstOrDefault(predicate?: ((obj: TElement) => MaybePromise<boolean>) | undefined, def?: TElement | undefined): Promise<TElement | undefined> {
-    return this.#enumerable.firstOrDefault(predicate, def);
+    return this.#sequence.firstOrDefault(predicate, def);
   }
 
   last(predicate?: ((obj: TElement) => MaybePromise<boolean>) | undefined): Promise<TElement> {
-    return this.#enumerable.last(predicate);
+    return this.#sequence.last(predicate);
   }
 
   lastOrDefault(predicate?: ((obj: TElement) => MaybePromise<boolean>) | undefined, def?: TElement | undefined): Promise<TElement | undefined> {
-    return this.#enumerable.lastOrDefault(predicate, def);
+    return this.#sequence.lastOrDefault(predicate, def);
   }
 
   single(predicate?: ((obj: TElement) => MaybePromise<boolean>) | undefined): Promise<TElement> {
-    return this.#enumerable.single(predicate);
+    return this.#sequence.single(predicate);
   }
 
   singleOrDefault(predicate?: ((obj: TElement) => MaybePromise<boolean>) | undefined, def?: TElement | undefined): Promise<TElement | undefined> {
-    return this.#enumerable.singleOrDefault(predicate, def);
+    return this.#sequence.singleOrDefault(predicate, def);
   }
 
   elementAt(index: number): Promise<TElement> {
-    return this.#enumerable.elementAt(index);
+    return this.#sequence.elementAt(index);
   }
 
   elementAtOrDefault(index: number, def?: TElement | undefined): Promise<TElement | undefined> {
-    return this.#enumerable.elementAtOrDefault(index, def);
+    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: any, seed?: any, resultSelector?: any) {
-    return this.#enumerable.aggregate(accumulator, seed, resultSelector);
+    return this.#sequence.aggregate(accumulator, seed, resultSelector);
   }
 
   min(): Promise<TElement> {
-    return this.#enumerable.min();
+    return this.#sequence.min();
   }
 
   minBy<TBy>(selector: (obj: TElement) => MaybePromise<TBy>): Promise<TElement> {
-    return this.#enumerable.minBy(selector);
+    return this.#sequence.minBy(selector);
   }
 
   max(): Promise<TElement> {
-    return this.#enumerable.max();
+    return this.#sequence.max();
   }
 
   maxBy<TBy>(selector: (obj: TElement) => MaybePromise<TBy>): Promise<TElement> {
-    return this.#enumerable.maxBy(selector);
+    return this.#sequence.maxBy(selector);
   }
 
-  order(comparer?: ((first: TElement, second: TElement) => MaybePromise<number>) | undefined): AsyncEnumerable<TElement> {
-    return this.#enumerable.order(comparer);
+  order(comparer?: ((first: TElement, second: TElement) => MaybePromise<number>) | undefined): AsyncSequence<TElement> {
+    return this.#sequence.order(comparer);
   }
 
-  orderBy<TBy>(selector: (obj: TElement) => MaybePromise<TBy>, comparer?: ((first: TBy, second: TBy) => MaybePromise<number>) | undefined): AsyncEnumerable<TElement> {
-    return this.#enumerable.orderBy(selector, comparer);
+  orderBy<TBy>(selector: (obj: TElement) => MaybePromise<TBy>, comparer?: ((first: TBy, second: TBy) => MaybePromise<number>) | undefined): AsyncSequence<TElement> {
+    return this.#sequence.orderBy(selector, comparer);
   }
 
-  orderDescending(comparer?: ((first: TElement, second: TElement) => MaybePromise<number>) | undefined): AsyncEnumerable<TElement> {
-    return this.#enumerable.orderDescending(comparer);
+  orderDescending(comparer?: ((first: TElement, second: TElement) => MaybePromise<number>) | undefined): AsyncSequence<TElement> {
+    return this.#sequence.orderDescending(comparer);
   }
 
-  orderByDescending<TBy>(selector: (obj: TElement) => MaybePromise<TBy>, comparer?: ((first: TBy, second: TBy) => MaybePromise<number>) | undefined): AsyncEnumerable<TElement> {
-    return this.#enumerable.orderByDescending(selector, comparer);
+  orderByDescending<TBy>(selector: (obj: TElement) => MaybePromise<TBy>, comparer?: ((first: TBy, second: TBy) => MaybePromise<number>) | undefined): AsyncSequence<TElement> {
+    return this.#sequence.orderByDescending(selector, comparer);
   }
 
-  distinct(equater?: ((first: TElement, second: TElement) => MaybePromise<boolean>) | undefined): AsyncEnumerable<TElement> {
-    return this.#enumerable.distinct(equater);
+  distinct(equater?: ((first: TElement, second: TElement) => MaybePromise<boolean>) | undefined): AsyncSequence<TElement> {
+    return this.#sequence.distinct(equater);
   }
 
-  distinctBy<TBy>(selector: (obj: TElement) => MaybePromise<TBy>, equater?: ((first: TBy, second: TBy) => MaybePromise<boolean>) | undefined): AsyncEnumerable<TElement> {
-    return this.#enumerable.distinctBy(selector, equater);
+  distinctBy<TBy>(selector: (obj: TElement) => MaybePromise<TBy>, equater?: ((first: TBy, second: TBy) => MaybePromise<boolean>) | undefined): AsyncSequence<TElement> {
+    return this.#sequence.distinctBy(selector, equater);
   }
 
-  union(iterable: MaybeAsyncIterable<TElement>, equater?: ((first: TElement, second: TElement) => MaybePromise<boolean>) | undefined): AsyncEnumerable<TElement> {
-    return this.#enumerable.union(iterable, equater);
+  union(iterable: MaybeAsyncIterable<TElement>, equater?: ((first: TElement, second: TElement) => MaybePromise<boolean>) | undefined): AsyncSequence<TElement> {
+    return this.#sequence.union(iterable, equater);
   }
 
-  unionBy<TBy>(iterable: MaybeAsyncIterable<TElement>, selector: (obj: TElement) => MaybePromise<TBy>, equater?: ((first: TBy, second: TBy) => MaybePromise<boolean>) | undefined): AsyncEnumerable<TElement> {
-    return this.#enumerable.unionBy(iterable, selector, 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);
   }
 
-  except(iterable: MaybeAsyncIterable<TElement>, equater?: ((first: TElement, second: TElement) => MaybePromise<boolean>) | undefined): AsyncEnumerable<TElement> {
-    return this.#enumerable.except(iterable, equater);
+  except(iterable: MaybeAsyncIterable<TElement>, equater?: ((first: TElement, second: TElement) => MaybePromise<boolean>) | undefined): AsyncSequence<TElement> {
+    return this.#sequence.except(iterable, equater);
   }
 
-  exceptBy<TBy>(iterable: MaybeAsyncIterable<TElement>, selector: (obj: TElement) => MaybePromise<TBy>, equater?: ((first: TBy, second: TBy) => MaybePromise<boolean>) | undefined): AsyncEnumerable<TElement> {
-    return this.#enumerable.exceptBy(iterable, selector, 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);
   }
 
-  intersect(iterable: MaybeAsyncIterable<TElement>, equater?: ((first: TElement, second: TElement) => MaybePromise<boolean>) | undefined): AsyncEnumerable<TElement> {
-    return this.#enumerable.intersect(iterable, equater);
+  intersect(iterable: MaybeAsyncIterable<TElement>, equater?: ((first: TElement, second: TElement) => MaybePromise<boolean>) | undefined): AsyncSequence<TElement> {
+    return this.#sequence.intersect(iterable, equater);
   }
 
-  intersectBy<TBy>(iterable: MaybeAsyncIterable<TElement>, selector: (obj: TElement) => MaybePromise<TBy>, equater?: ((first: TBy, second: TBy) => MaybePromise<boolean>) | undefined): AsyncEnumerable<TElement> {
-    return this.#enumerable.intersectBy(iterable, selector, 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);
   }
 
   all(predicate: (obj: TElement) => MaybePromise<boolean>): Promise<boolean> {
-    return this.#enumerable.all(predicate);
+    return this.#sequence.all(predicate);
   }
 
   any(predicate: (obj: TElement) => MaybePromise<boolean>): Promise<boolean>;
   any(): Promise<boolean>;
   any(predicate?: any) {
-    return this.#enumerable.any(predicate);
+    return this.#sequence.any(predicate);
   }
 
   none(predicate: Predicate<TElement>): Promise<boolean>;
   none(): Promise<boolean>;
   none(predicate?: any) {
-    return this.#enumerable.none(predicate);
+    return this.#sequence.none(predicate);
   }
 
-  skip(n: number): AsyncEnumerable<TElement> {
-    return this.#enumerable.skip(n);
+  skip(n: number): AsyncSequence<TElement> {
+    return this.#sequence.skip(n);
   }
 
-  skipLast(n: number): AsyncEnumerable<TElement> {
-    return this.#enumerable.skipLast(n);
+  skipLast(n: number): AsyncSequence<TElement> {
+    return this.#sequence.skipLast(n);
   }
 
-  skipWhile(condition: (obj: TElement) => MaybePromise<boolean>): AsyncEnumerable<TElement> {
-    return this.#enumerable.skipWhile(condition);
+  skipWhile(condition: (obj: TElement) => MaybePromise<boolean>): AsyncSequence<TElement> {
+    return this.#sequence.skipWhile(condition);
   }
 
-  take(n: number): AsyncEnumerable<TElement> {
-    return this.#enumerable.take(n);
+  take(n: number): AsyncSequence<TElement> {
+    return this.#sequence.take(n);
   }
 
-  takeLast(n: number): AsyncEnumerable<TElement> {
-    return this.#enumerable.takeLast(n);
+  takeLast(n: number): AsyncSequence<TElement> {
+    return this.#sequence.takeLast(n);
   }
 
-  takeWhile(condition: (obj: TElement) => MaybePromise<boolean>): AsyncEnumerable<TElement> {
-    return this.#enumerable.takeWhile(condition);
+  takeWhile(condition: (obj: TElement) => MaybePromise<boolean>): AsyncSequence<TElement> {
+    return this.#sequence.takeWhile(condition);
   }
 
-  peek(action: (obj: TElement) => MaybePromise<void>): AsyncEnumerable<TElement> {
-    return this.#enumerable.peek(action);
+  peek(action: (obj: TElement) => MaybePromise<void>): AsyncSequence<TElement> {
+    return this.#sequence.peek(action);
   }
 
   forEach(action: (obj: TElement) => MaybePromise<void>): Promise<void> {
-    return this.#enumerable.forEach(action);
+    return this.#sequence.forEach(action);
   }
 
-  zip<TOther>(iterable: MaybeAsyncIterable<TOther>): AsyncEnumerable<[Awaited<TElement>, Awaited<TOther>]> {
-    return this.#enumerable.zip(iterable);
+  zip<TOther>(iterable: MaybeAsyncIterable<TOther>): AsyncSequence<[Awaited<TElement>, Awaited<TOther>]> {
+    return this.#sequence.zip(iterable);
   }
 
-  indexex(): AsyncEnumerable<[number, Awaited<TElement>]> {
-    return this.#enumerable.indexex();
+  indexex(): AsyncSequence<[number, Awaited<TElement>]> {
+    return this.#sequence.indexex();
   }
 
-  reversed(): AsyncEnumerable<TElement> {
-    return this.#enumerable.reversed();
+  reversed(): AsyncSequence<TElement> {
+    return this.#sequence.reversed();
   }
 
-  chunked(size: number): AsyncEnumerable<TElement[]> {
-    return this.#enumerable.chunked(size);
+  chunked(size: number): AsyncSequence<TElement[]> {
+    return this.#sequence.chunked(size);
   }
 
   random(options?: AsyncRandomOptions<TElement> | undefined): Promise<TElement | undefined> {
-    return this.#enumerable.random(options);
+    return this.#sequence.random(options);
   }
 
-  cached(): AsyncEnumerable<TElement> {
-    return this.#enumerable.cached();
+  cached(): AsyncSequence<TElement> {
+    return this.#sequence.cached();
   }
 
   toArray(): Promise<TElement[]> {
-    return this.#enumerable.toArray();
+    return this.#sequence.toArray();
   }
 
   toMap<TKey, TValue>(keySelector: (obj: TElement) => MaybePromise<TKey>, valueSelector: (obj: TElement) => MaybePromise<TValue>): Promise<Map<TKey, TValue>> {
-    return this.#enumerable.toMap(keySelector, valueSelector);
+    return this.#sequence.toMap(keySelector, valueSelector);
   }
 
   toSet(): Promise<Set<TElement>> {
-    return this.#enumerable.toSet();
+    return this.#sequence.toSet();
   }
 
   toObject<TValue>(keySelector: (obj: TElement) => MaybePromise<PropertyKey>, valueSelector: (obj: TElement) => MaybePromise<TValue>): Promise<Record<PropertyKey, TValue>> {
-    return this.#enumerable.toObject(keySelector, valueSelector);
+    return this.#sequence.toObject(keySelector, valueSelector);
   }
 
   collect<TResult>(collector: Collector<TElement, any, TResult>): Promise<TResult> {
-    return this.#enumerable.collect(collector);
+    return this.#sequence.collect(collector);
   }
 }
 
-export class GroupedAsyncEnumerableImpl<TElement, TKey> extends DelegatedAsyncEnumerable<TElement> implements GroupedAsyncEnumerable<TKey, TElement> {
+export class GroupedAsyncSequenceImpl<TElement, TKey> extends DelegatedAsyncSequence<TElement> implements GroupedAsyncSequence<TKey, TElement> {
   readonly #key: TKey;
 
-  constructor(key: TKey, grouping: AsyncEnumerable<TElement>) {
+  constructor(key: TKey, grouping: AsyncSequence<TElement>) {
     super(grouping);
 
     this.#key = key;
@@ -988,51 +988,51 @@ export class GroupedAsyncEnumerableImpl<TElement, TKey> extends DelegatedAsyncEn
   }
 }
 
-abstract class BaseOrderedAsyncEnumerable<TElement> extends BaseAsyncEnumerable<TElement> implements OrderedAsyncEnumerable<TElement> {
-  readonly #enumerable: AsyncEnumerable<TElement>;
+abstract class BaseOrderedAsyncSequence<TElement> extends BaseAsyncSequence<TElement> implements OrderedAsyncSequence<TElement> {
+  readonly #sequence: AsyncSequence<TElement>;
   readonly #sorter: MaybeAsyncComparer<TElement>;
   readonly #descending: boolean;
 
-  constructor(enumerable: AsyncEnumerable<TElement>, sorter: MaybeAsyncComparer<TElement>, descending: boolean) {
+  constructor(sequence: AsyncSequence<TElement>, sorter: MaybeAsyncComparer<TElement>, descending: boolean) {
     super();
 
-    this.#enumerable = enumerable;
+    this.#sequence = sequence;
     this.#sorter = sorter;
     this.#descending = descending;
   }
 
   override async nonEnumeratedCount() {
-    return await this.#enumerable.nonEnumeratedCount();
+    return await this.#sequence.nonEnumeratedCount();
   }
 
   override async maxCount() {
-    return await this.#enumerable.maxCount();
+    return await this.#sequence.maxCount();
   }
 
   get comparer() {
     return this.#sorter;
   }
 
-  thenSelf(comparer?: MaybeAsyncComparer<TElement>): OrderedAsyncEnumerable<TElement> {
-    return new ThenOrderAsyncEnumerable(this, false, comparer);
+  thenSelf(comparer?: MaybeAsyncComparer<TElement>): OrderedAsyncSequence<TElement> {
+    return new ThenOrderAsyncSequence(this, false, comparer);
   }
 
-  thenBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparer<TBy>): OrderedAsyncEnumerable<TElement> {
-    return new ThenOrderByAsyncEnumerable<TElement, TBy>(this, false, selector, comparer);
+  thenBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparer<TBy>): OrderedAsyncSequence<TElement> {
+    return new ThenOrderByAsyncSequence<TElement, TBy>(this, false, selector, comparer);
   }
 
-  thenSelfDescending(comparer?: MaybeAsyncComparer<TElement>): OrderedAsyncEnumerable<TElement> {
-    return new ThenOrderAsyncEnumerable(this, true, comparer);
+  thenSelfDescending(comparer?: MaybeAsyncComparer<TElement>): OrderedAsyncSequence<TElement> {
+    return new ThenOrderAsyncSequence(this, true, comparer);
   }
 
-  thenByDescending<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparer<TBy>): OrderedAsyncEnumerable<TElement> {
-    return new ThenOrderByAsyncEnumerable<TElement, TBy>(this, true, selector, comparer);
+  thenByDescending<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparer<TBy>): OrderedAsyncSequence<TElement> {
+    return new ThenOrderByAsyncSequence<TElement, TBy>(this, true, selector, comparer);
   }
 
   override async *iterator() {
     const arr: TElement[] = [];
 
-    for await (const obj of this.#enumerable) {
+    for await (const obj of this.#sequence) {
       arr.push(obj);
     }
 
@@ -1042,8 +1042,8 @@ abstract class BaseOrderedAsyncEnumerable<TElement> extends BaseAsyncEnumerable<
   }
 }
 
-export class EmptyAsyncEnumerable<T> extends BaseAsyncEnumerable<T> {
-  static readonly INSTANCE = new EmptyAsyncEnumerable<any>();
+export class EmptyAsyncSequence<T> extends BaseAsyncSequence<T> {
+  static readonly INSTANCE = new EmptyAsyncSequence<any>();
 
   override async nonEnumeratedCount() {
     return 0;
@@ -1054,7 +1054,7 @@ export class EmptyAsyncEnumerable<T> extends BaseAsyncEnumerable<T> {
   }
 }
 
-export class RangeAsyncEnumerable extends BaseAsyncEnumerable<number> {
+export class RangeAsyncSequence extends BaseAsyncSequence<number> {
   readonly #min: number;
   readonly #max: number;
   readonly #step: number;
@@ -1078,7 +1078,7 @@ export class RangeAsyncEnumerable extends BaseAsyncEnumerable<number> {
   }
 }
 
-export class RepeatAsyncEnumerable<T> extends BaseAsyncEnumerable<T> {
+export class RepeatAsyncSequence<T> extends BaseAsyncSequence<T> {
   readonly #value: T;
   readonly #count: number;
 
@@ -1102,7 +1102,7 @@ export class RepeatAsyncEnumerable<T> extends BaseAsyncEnumerable<T> {
   }
 }
 
-export class RepeatForeverAsyncEnumerable<T> extends BaseAsyncEnumerable<T> {
+export class RepeatForeverAsyncSequence<T> extends BaseAsyncSequence<T> {
   readonly #value: T;
 
   constructor(value: T) {
@@ -1122,7 +1122,7 @@ export class RepeatForeverAsyncEnumerable<T> extends BaseAsyncEnumerable<T> {
   }
 }
 
-export class WrappedObjectAsync<T> extends BaseAsyncEnumerable<T> {
+export class WrappedObjectAsync<T> extends BaseAsyncSequence<T> {
   readonly #obj: T | PromiseLike<T>;
 
   constructor(obj: T | PromiseLike<T>) {
@@ -1140,7 +1140,7 @@ export class WrappedObjectAsync<T> extends BaseAsyncEnumerable<T> {
   }
 }
 
-export class WrappedArrayAsync<T> extends BaseAsyncEnumerable<T> {
+export class WrappedArrayAsync<T> extends BaseAsyncSequence<T> {
   readonly #array: (T | PromiseLike<T>)[];
 
   constructor(array: (T | PromiseLike<T>)[]) {
@@ -1158,7 +1158,7 @@ export class WrappedArrayAsync<T> extends BaseAsyncEnumerable<T> {
   }
 }
 
-export class WrappedArrayLikeAsync<T> extends BaseAsyncEnumerable<T> {
+export class WrappedArrayLikeAsync<T> extends BaseAsyncSequence<T> {
   readonly #arrayLike: ArrayLike<T | PromiseLike<T>>;
 
   constructor(arrayLike: ArrayLike<T | PromiseLike<T>>) {
@@ -1178,7 +1178,7 @@ export class WrappedArrayLikeAsync<T> extends BaseAsyncEnumerable<T> {
   }
 }
 
-export class WrappedAsyncIterable<T> extends BaseAsyncEnumerable<T> {
+export class WrappedAsyncIterable<T> extends BaseAsyncSequence<T> {
   readonly #iterable: AsyncIterable<T>;
 
   constructor(iterable: AsyncIterable<T>) {
@@ -1192,7 +1192,7 @@ export class WrappedAsyncIterable<T> extends BaseAsyncEnumerable<T> {
   }
 }
 
-export class GeneratorAsyncEnumerable<T> extends BaseAsyncEnumerable<T> {
+export class GeneratorAsyncSequence<T> extends BaseAsyncSequence<T> {
   readonly #generator: () => AsyncGenerator<T>;
 
   constructor(generator: () => AsyncGenerator<T>) {
@@ -1206,7 +1206,7 @@ export class GeneratorAsyncEnumerable<T> extends BaseAsyncEnumerable<T> {
   }
 }
 
-export class FunctionAsyncEnumerable<T> extends BaseAsyncEnumerable<T> {
+export class FunctionAsyncSequence<T> extends BaseAsyncSequence<T> {
   readonly #f: () => MaybePromise<T>;
 
   constructor(f: () => MaybePromise<T>) {
@@ -1226,45 +1226,45 @@ export class FunctionAsyncEnumerable<T> extends BaseAsyncEnumerable<T> {
   }
 }
 
-export class WrappedEnumerable<T> extends BaseAsyncEnumerable<T> {
-  readonly #enumerable: Enumerable<T>;
+export class WrappedSequence<T> extends BaseAsyncSequence<T> {
+  readonly #sequence: Sequence<T>;
 
-  constructor(enumerable: Enumerable<T>) {
+  constructor(sequence: Sequence<T>) {
     super();
 
-    this.#enumerable = enumerable;
+    this.#sequence = sequence;
   }
 
   override async nonEnumeratedCount() {
-    return this.#enumerable.nonEnumeratedCount();
+    return this.#sequence.nonEnumeratedCount();
   }
 
   override async fastCount() {
-    return this.#enumerable.fastCount();
+    return this.#sequence.fastCount();
   }
 
   override async maxCount() {
-    return this.#enumerable.maxCount();
+    return this.#sequence.maxCount();
   }
 
   override async *iterator() {
-    yield* this.#enumerable;
+    yield* this.#sequence;
   }
 }
 
-export class ConcatAsyncEnumerable<T> extends BaseAsyncEnumerable<T> {
-  readonly #enumerables: Iterable<AsyncEnumerable<T>>;
+export class ConcatAsyncSequence<T> extends BaseAsyncSequence<T> {
+  readonly #sequences: Iterable<AsyncSequence<T>>;
 
-  constructor(enumerables: Iterable<AsyncEnumerable<T>>) {
+  constructor(sequences: Iterable<AsyncSequence<T>>) {
     super();
 
-    this.#enumerables = enumerables;
+    this.#sequences = sequences;
   }
 
   override async nonEnumeratedCount() {
     let n = 0;
 
-    for (const iterable of this.#enumerables) {
+    for (const iterable of this.#sequences) {
       const m = await iterable.nonEnumeratedCount();
 
       if (m < 0) {
@@ -1278,27 +1278,27 @@ export class ConcatAsyncEnumerable<T> extends BaseAsyncEnumerable<T> {
   }
 
   override async *iterator() {
-    for (const enumerable of this.#enumerables) {
-      yield* enumerable;
+    for (const sequence of this.#sequences) {
+      yield* sequence;
     }
   }
 }
 
-export class DistinctAsyncEnumerable<T> extends BaseAsyncEnumerable<T> {
-  readonly #enumerable: AsyncEnumerable<T>;
+export class DistinctAsyncSequence<T> extends BaseAsyncSequence<T> {
+  readonly #sequence: AsyncSequence<T>;
   readonly #equater: MaybeAsyncEquater<T> | undefined;
 
-  constructor(enumerable: AsyncEnumerable<T>, equater?: MaybeAsyncEquater<T>) {
+  constructor(sequence: AsyncSequence<T>, equater?: MaybeAsyncEquater<T>) {
     super();
 
-    this.#enumerable = enumerable;
+    this.#sequence = sequence;
     this.#equater = equater;
   }
 
   override async *iterator() {
     const set = createAsyncEqualitySet(this.#equater);
 
-    for await (const obj of this.#enumerable) {
+    for await (const obj of this.#sequence) {
       if (await set.add(obj)) {
         yield obj;
       }
@@ -1306,15 +1306,15 @@ export class DistinctAsyncEnumerable<T> extends BaseAsyncEnumerable<T> {
   }
 }
 
-export class DistinctByAsyncEnumerable<T, U> extends BaseAsyncEnumerable<T> {
-  readonly #enumerable: AsyncEnumerable<T>;
+export class DistinctByAsyncSequence<T, U> extends BaseAsyncSequence<T> {
+  readonly #sequence: AsyncSequence<T>;
   readonly #selector: MaybeAsyncConverter<T, U>;
   readonly #equater: MaybeAsyncEquater<U> | undefined;
 
-  constructor(enumerable: AsyncEnumerable<T>, selector: MaybeAsyncConverter<T, U>, equater?: MaybeAsyncEquater<U>) {
+  constructor(sequence: AsyncSequence<T>, selector: MaybeAsyncConverter<T, U>, equater?: MaybeAsyncEquater<U>) {
     super();
 
-    this.#enumerable = enumerable;
+    this.#sequence = sequence;
     this.#selector = selector;
     this.#equater = equater;
   }
@@ -1322,7 +1322,7 @@ export class DistinctByAsyncEnumerable<T, U> extends BaseAsyncEnumerable<T> {
   override async *iterator() {
     const set = createAsyncEqualitySet(this.#equater);
 
-    for await (const obj of this.#enumerable) {
+    for await (const obj of this.#sequence) {
       if (await set.add(await this.#selector(obj))) {
         yield obj;
       }
@@ -1332,19 +1332,19 @@ export class DistinctByAsyncEnumerable<T, U> extends BaseAsyncEnumerable<T> {
   }
 }
 
-export class FilterAsyncEnumerable<T> extends BaseAsyncEnumerable<T> {
-  readonly #enumerable: AsyncEnumerable<T>;
+export class FilterAsyncSequence<T> extends BaseAsyncSequence<T> {
+  readonly #sequence: AsyncSequence<T>;
   readonly #predicate: MaybeAsyncPredicate<T>;
 
-  constructor(enumerable: AsyncEnumerable<T>, predicate: MaybeAsyncPredicate<T>) {
+  constructor(sequence: AsyncSequence<T>, predicate: MaybeAsyncPredicate<T>) {
     super();
 
-    this.#enumerable = enumerable;
+    this.#sequence = sequence;
     this.#predicate = predicate;
   }
 
   override async *iterator() {
-    for await (const obj of this.#enumerable) {
+    for await (const obj of this.#sequence) {
       if (await this.#predicate(obj)) {
         yield obj;
       }
@@ -1352,77 +1352,77 @@ export class FilterAsyncEnumerable<T> extends BaseAsyncEnumerable<T> {
   }
 }
 
-export class FlatMapperAsyncEnumerable<T, U> extends BaseAsyncEnumerable<U> {
-  readonly #enumerable: AsyncEnumerable<T>;
+export class FlatMapperAsyncSequence<T, U> extends BaseAsyncSequence<U> {
+  readonly #sequence: AsyncSequence<T>;
   readonly #converter: MaybeAsyncConverter<T, MaybeAsyncIterable<U>>;
 
-  constructor(enumerable: AsyncEnumerable<T>, converter: MaybeAsyncConverter<T, MaybeAsyncIterable<U>>) {
+  constructor(sequence: AsyncSequence<T>, converter: MaybeAsyncConverter<T, MaybeAsyncIterable<U>>) {
     super();
 
-    this.#enumerable = enumerable;
+    this.#sequence = sequence;
     this.#converter = converter;
   }
 
   override async *iterator() {
-    for await (const obj of this.#enumerable) {
+    for await (const obj of this.#sequence) {
       yield* await this.#converter(obj);
     }
   }
 }
 
-export class IndexedAsyncEnumerable<T> extends BaseAsyncEnumerable<[number, Awaited<T>]> {
-  readonly #enumerable: AsyncEnumerable<T>;
+export class IndexedAsyncSequence<T> extends BaseAsyncSequence<[number, Awaited<T>]> {
+  readonly #sequence: AsyncSequence<T>;
 
-  constructor(enumerable: AsyncEnumerable<T>) {
+  constructor(sequence: AsyncSequence<T>) {
     super();
 
-    this.#enumerable = enumerable;
+    this.#sequence = sequence;
   }
 
   override async *iterator() {
     let i = 0;
 
-    for await (const obj of this.#enumerable) {
+    for await (const obj of this.#sequence) {
       yield [i++, obj] as [number, Awaited<T>];
     }
   }
 }
 
-export class MapperAsyncEnumerable<T, U> extends BaseAsyncEnumerable<U> {
-  readonly #enumerable: AsyncEnumerable<T>;
+export class MapperAsyncSequence<T, U> extends BaseAsyncSequence<U> {
+  readonly #sequence: AsyncSequence<T>;
   readonly #converter: MaybeAsyncConverter<T, U>;
 
-  constructor(enumerable: AsyncEnumerable<T>, converter: MaybeAsyncConverter<T, U>) {
+  constructor(sequence: AsyncSequence<T>, converter: MaybeAsyncConverter<T, U>) {
     super();
 
-    this.#enumerable = enumerable;
+    this.#sequence = sequence;
     this.#converter = converter;
   }
 
   override async nonEnumeratedCount() {
-    return await this.#enumerable.nonEnumeratedCount();
+    return await this.#sequence.nonEnumeratedCount();
   }
 
   override async *iterator() {
-    for await (const obj of this.#enumerable) {
+    for await (const obj of this.#sequence) {
       yield await this.#converter(obj);
     }
   }
 }
 
-export class SkipWhileAsyncEnumerable<T> extends BaseAsyncEnumerable<T> {
-  readonly #enumerable: AsyncEnumerable<T>;
+export class SkipWhileAsyncSequence<T> extends BaseAsyncSequence<T> {
+  readonly #sequence: AsyncSequence<T>;
   readonly #predicate: MaybeAsyncPredicate<T>;
 
-  constructor(enumerable: AsyncEnumerable<T>, predicate: MaybeAsyncPredicate<T>) {
+  constructor(sequence: AsyncSequence<T>, predicate: MaybeAsyncPredicate<T>) {
     super();
 
-    this.#enumerable = enumerable;
+    this.#sequence = sequence;
     this.#predicate = predicate;
   }
 
   override async *iterator() {
-    const iterator = this.#enumerable.iterator();
+    const iterator = this.#sequence.iterator();
 
     while (true) {
       const next = await iterator.next();
@@ -1443,24 +1443,24 @@ export class SkipWhileAsyncEnumerable<T> extends BaseAsyncEnumerable<T> {
   }
 }
 
-export class SkipLastAsyncEnumerable<T> extends BaseAsyncEnumerable<T> {
-  readonly #enumerable: AsyncEnumerable<T>;
+export class SkipLastAsyncSequence<T> extends BaseAsyncSequence<T> {
+  readonly #sequence: AsyncSequence<T>;
   readonly #n: number;
 
-  constructor(enumerable: AsyncEnumerable<T>, n: number) {
+  constructor(sequence: AsyncSequence<T>, n: number) {
     super();
 
-    this.#enumerable = enumerable;
+    this.#sequence = sequence;
     this.#n = n;
   }
 
   override async nonEnumeratedCount() {
-    const n = await this.#enumerable.nonEnumeratedCount();
+    const n = await this.#sequence.nonEnumeratedCount();
     return n < 0 ? -1 : Math.max(0, n - this.#n);
   }
 
   override async *iterator() {
-    const iterator = this.#enumerable.iterator();
+    const iterator = this.#sequence.iterator();
     const buffer = new Array<T>(this.#n); // n > 0
     let i = 0;
 
@@ -1484,24 +1484,24 @@ export class SkipLastAsyncEnumerable<T> extends BaseAsyncEnumerable<T> {
   }
 }
 
-export class SkipAsyncEnumerable<T> extends BaseAsyncEnumerable<T> {
-  readonly #enumerable: AsyncEnumerable<T>;
+export class SkipAsyncSequence<T> extends BaseAsyncSequence<T> {
+  readonly #sequence: AsyncSequence<T>;
   readonly #n: number;
 
-  constructor(enumerable: AsyncEnumerable<T>, n: number) {
+  constructor(sequence: AsyncSequence<T>, n: number) {
     super();
 
-    this.#enumerable = enumerable;
+    this.#sequence = sequence;
     this.#n = n;
   }
 
   override async nonEnumeratedCount() {
-    const n = await this.#enumerable.nonEnumeratedCount();
+    const n = await this.#sequence.nonEnumeratedCount();
     return n < 0 ? -1 : Math.max(0, n - this.#n);
   }
 
   override async *iterator() {
-    const iterator = this.#enumerable.iterator();
+    const iterator = this.#sequence.iterator();
     let i = 0;
 
     do {
@@ -1516,19 +1516,19 @@ export class SkipAsyncEnumerable<T> extends BaseAsyncEnumerable<T> {
   }
 }
 
-export class TakeWhileAsyncEnumerable<T> extends BaseAsyncEnumerable<T> {
-  readonly #enumerable: AsyncEnumerable<T>;
+export class TakeWhileAsyncSequence<T> extends BaseAsyncSequence<T> {
+  readonly #sequence: AsyncSequence<T>;
   readonly #predicate: MaybeAsyncPredicate<T>;
 
-  constructor(enumerable: AsyncEnumerable<T>, predicate: MaybeAsyncPredicate<T>) {
+  constructor(sequence: AsyncSequence<T>, predicate: MaybeAsyncPredicate<T>) {
     super();
 
-    this.#enumerable = enumerable;
+    this.#sequence = sequence;
     this.#predicate = predicate;
   }
 
   override async *iterator() {
-    for await (const obj of this.#enumerable) {
+    for await (const obj of this.#sequence) {
       if (!await this.#predicate(obj)) {
         return;
       }
@@ -1538,26 +1538,26 @@ export class TakeWhileAsyncEnumerable<T> extends BaseAsyncEnumerable<T> {
   }
 }
 
-export class TakeLastAsyncEnumerable<T> extends BaseAsyncEnumerable<T> {
-  readonly #enumerable: AsyncEnumerable<T>;
+export class TakeLastAsyncSequence<T> extends BaseAsyncSequence<T> {
+  readonly #sequence: AsyncSequence<T>;
   readonly #n: number;
 
-  constructor(enumerable: AsyncEnumerable<T>, n: number) {
+  constructor(sequence: AsyncSequence<T>, n: number) {
     super();
 
-    this.#enumerable = enumerable;
+    this.#sequence = sequence;
     this.#n = n;
   }
 
   override async nonEnumeratedCount() {
-    const n = await this.#enumerable.nonEnumeratedCount();
+    const n = await this.#sequence.nonEnumeratedCount();
     return n < 0 ? -1 : Math.min(this.#n, n);
   }
 
   override async *iterator() {
     const queue = createQueue<T>(this.#n);
 
-    for await (const obj of this.#enumerable) {
+    for await (const obj of this.#sequence) {
       queue.enqueue(obj);
     }
 
@@ -1565,24 +1565,24 @@ export class TakeLastAsyncEnumerable<T> extends BaseAsyncEnumerable<T> {
   }
 }
 
-export class TakeAsyncEnumerable<T> extends BaseAsyncEnumerable<T> {
-  readonly #enumerable: AsyncEnumerable<T>;
+export class TakeAsyncSequence<T> extends BaseAsyncSequence<T> {
+  readonly #sequence: AsyncSequence<T>;
   readonly #n: number;
 
-  constructor(enumerable: AsyncEnumerable<T>, n: number) {
+  constructor(sequence: AsyncSequence<T>, n: number) {
     super();
 
-    this.#enumerable = enumerable;
+    this.#sequence = sequence;
     this.#n = n;
   }
 
   override async nonEnumeratedCount() {
-    const n = await this.#enumerable.nonEnumeratedCount();
+    const n = await this.#sequence.nonEnumeratedCount();
     return n < 0 ? -1 : Math.min(this.#n, n);
   }
 
   override async *iterator() {
-    const iterator = this.#enumerable.iterator();
+    const iterator = this.#sequence.iterator();
     let i = this.#n;
 
     while (i > 0) {
@@ -1598,15 +1598,15 @@ export class TakeAsyncEnumerable<T> extends BaseAsyncEnumerable<T> {
   }
 }
 
-export class OrderAsyncEnumerable<T> extends BaseOrderedAsyncEnumerable<T> {
-  constructor(enumerable: AsyncEnumerable<T>, descending: boolean, sorter?: MaybeAsyncComparer<T>) {
-    super(enumerable, sorter ?? defaultArrayComparer, descending);
+export class OrderAsyncSequence<T> extends BaseOrderedAsyncSequence<T> {
+  constructor(sequence: AsyncSequence<T>, descending: boolean, sorter?: MaybeAsyncComparer<T>) {
+    super(sequence, sorter ?? defaultArrayComparer, descending);
   }
 }
 
-export class OrderByAsyncEnumerable<T, U> extends BaseOrderedAsyncEnumerable<T> {
-  constructor(enumerable: AsyncEnumerable<T>, descending: boolean, selector: MaybeAsyncConverter<T, U>, sorter?: MaybeAsyncComparer<U>) {
-    super(enumerable, OrderByAsyncEnumerable.#createSorter(selector, sorter), descending);
+export 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>) {
@@ -1615,15 +1615,15 @@ export class OrderByAsyncEnumerable<T, U> extends BaseOrderedAsyncEnumerable<T>
   }
 }
 
-export class ThenOrderAsyncEnumerable<T> extends BaseOrderedAsyncEnumerable<T> {
-  constructor(enumerable: OrderedAsyncEnumerable<T>, descending: boolean, sorter?: MaybeAsyncComparer<T>) {
-    super(enumerable, combineAsyncComparers(enumerable.comparer ?? defaultArrayComparer, sorter ?? defaultArrayComparer), descending);
+export class ThenOrderAsyncSequence<T> extends BaseOrderedAsyncSequence<T> {
+  constructor(sequence: OrderedAsyncSequence<T>, descending: boolean, sorter?: MaybeAsyncComparer<T>) {
+    super(sequence, combineAsyncComparers(sequence.comparer ?? defaultArrayComparer, sorter ?? defaultArrayComparer), descending);
   }
 }
 
-export class ThenOrderByAsyncEnumerable<T, U> extends BaseOrderedAsyncEnumerable<T> {
-  constructor(enumerable: OrderedAsyncEnumerable<T>, descending: boolean, selector: MaybeAsyncConverter<T, U>, sorter?: MaybeAsyncComparer<U>) {
-    super(enumerable, ThenOrderByAsyncEnumerable.#createCombinedSorter(enumerable.comparer, selector, sorter), descending);
+export 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>) {
@@ -1633,78 +1633,78 @@ export class ThenOrderByAsyncEnumerable<T, U> extends BaseOrderedAsyncEnumerable
   }
 }
 
-export class AppendAsyncEnumerable<T> extends BaseAsyncEnumerable<T> {
-  readonly #enumerable: AsyncEnumerable<T>;
+export class AppendAsyncSequence<T> extends BaseAsyncSequence<T> {
+  readonly #sequence: AsyncSequence<T>;
   readonly #obj: T;
 
-  constructor(enumerable: AsyncEnumerable<T>, obj: T) {
+  constructor(sequence: AsyncSequence<T>, obj: T) {
     super();
 
-    this.#enumerable = enumerable;
+    this.#sequence = sequence;
     this.#obj = obj;
   }
 
   override async nonEnumeratedCount() {
-    const n = await this.#enumerable.nonEnumeratedCount();
+    const n = await this.#sequence.nonEnumeratedCount();
     return n < 0 ? -1 : n + 1;
   }
 
   override async *iterator() {
-    yield* this.#enumerable;
+    yield* this.#sequence;
     yield this.#obj;
   }
 }
 
-export class PrependAsyncEnumerable<T> extends BaseAsyncEnumerable<T> {
-  readonly #enumerable: AsyncEnumerable<T>;
+export class PrependAsyncSequence<T> extends BaseAsyncSequence<T> {
+  readonly #sequence: AsyncSequence<T>;
   readonly #obj: T;
 
-  constructor(enumerable: AsyncEnumerable<T>, obj: T) {
+  constructor(sequence: AsyncSequence<T>, obj: T) {
     super();
 
-    this.#enumerable = enumerable;
+    this.#sequence = sequence;
     this.#obj = obj;
   }
 
   override async nonEnumeratedCount() {
-    const n = await this.#enumerable.nonEnumeratedCount();
+    const n = await this.#sequence.nonEnumeratedCount();
     return n < 0 ? -1 : n + 1;
   }
 
   override async *iterator() {
     yield this.#obj;
-    yield* this.#enumerable;
+    yield* this.#sequence;
   }
 }
 
-export class PeekAsyncEnumerable<T> extends BaseAsyncEnumerable<T> {
-  readonly #enumerable: AsyncEnumerable<T>;
+export class PeekAsyncSequence<T> extends BaseAsyncSequence<T> {
+  readonly #sequence: AsyncSequence<T>;
   readonly #action: MaybeAsyncAction<T>;
 
-  constructor(enumerable: AsyncEnumerable<T>, action: MaybeAsyncAction<T>) {
+  constructor(sequence: AsyncSequence<T>, action: MaybeAsyncAction<T>) {
     super();
 
-    this.#enumerable = enumerable;
+    this.#sequence = sequence;
     this.#action = action;
   }
 
   override async nonEnumeratedCount() {
-    return await this.#enumerable.nonEnumeratedCount();
+    return await this.#sequence.nonEnumeratedCount();
   }
 
   override async *iterator() {
-    for await (const obj of this.#enumerable) {
+    for await (const obj of this.#sequence) {
       await this.#action(obj);
       yield obj;
     }
   }
 }
 
-export class ZippedAsyncEnumerable<T, U> extends BaseAsyncEnumerable<[Awaited<T>, Awaited<U>]> {
-  readonly #first: AsyncEnumerable<T>;
-  readonly #second: AsyncEnumerable<U>;
+export class ZippedAsyncSequence<T, U> extends BaseAsyncSequence<[Awaited<T>, Awaited<U>]> {
+  readonly #first: AsyncSequence<T>;
+  readonly #second: AsyncSequence<U>;
 
-  constructor(first: AsyncEnumerable<T>, second: AsyncEnumerable<U>) {
+  constructor(first: AsyncSequence<T>, second: AsyncSequence<U>) {
     super();
 
     this.#first = first;
@@ -1735,12 +1735,12 @@ export class ZippedAsyncEnumerable<T, U> extends BaseAsyncEnumerable<[Awaited<T>
   }
 }
 
-export class UnionAsyncEnumerable<T> extends BaseAsyncEnumerable<T> {
-  readonly #first: AsyncEnumerable<T>;
-  readonly #second: AsyncEnumerable<T>;
+export class UnionAsyncSequence<T> extends BaseAsyncSequence<T> {
+  readonly #first: AsyncSequence<T>;
+  readonly #second: AsyncSequence<T>;
   readonly #equater: MaybeAsyncEquater<T> | undefined;
 
-  constructor(first: AsyncEnumerable<T>, second: AsyncEnumerable<T>, equater?: MaybeAsyncEquater<T>) {
+  constructor(first: AsyncSequence<T>, second: AsyncSequence<T>, equater?: MaybeAsyncEquater<T>) {
     super();
 
     this.#first = first;
@@ -1767,13 +1767,13 @@ export class UnionAsyncEnumerable<T> extends BaseAsyncEnumerable<T> {
   }
 }
 
-export class UnionByAsyncEnumerable<T, U> extends BaseAsyncEnumerable<T> {
-  readonly #first: AsyncEnumerable<T>;
-  readonly #second: AsyncEnumerable<T>;
+export 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;
 
-  constructor(first: AsyncEnumerable<T>, second: AsyncEnumerable<T>, selector: MaybeAsyncConverter<T, U>, equater?: MaybeAsyncEquater<U>) {
+  constructor(first: AsyncSequence<T>, second: AsyncSequence<T>, selector: MaybeAsyncConverter<T, U>, equater?: MaybeAsyncEquater<U>) {
     super();
 
     this.#first = first;
@@ -1801,12 +1801,12 @@ export class UnionByAsyncEnumerable<T, U> extends BaseAsyncEnumerable<T> {
   }
 }
 
-export class ExceptAsyncEnumerable<T> extends BaseAsyncEnumerable<T> {
-  readonly #first: AsyncEnumerable<T>;
-  readonly #second: AsyncEnumerable<T>;
+export class ExceptAsyncSequence<T> extends BaseAsyncSequence<T> {
+  readonly #first: AsyncSequence<T>;
+  readonly #second: AsyncSequence<T>;
   readonly #equater: MaybeAsyncEquater<T> | undefined;
 
-  constructor(first: AsyncEnumerable<T>, second: AsyncEnumerable<T>, equater?: MaybeAsyncEquater<T>) {
+  constructor(first: AsyncSequence<T>, second: AsyncSequence<T>, equater?: MaybeAsyncEquater<T>) {
     super();
 
     this.#first = first;
@@ -1831,13 +1831,13 @@ export class ExceptAsyncEnumerable<T> extends BaseAsyncEnumerable<T> {
   }
 }
 
-export class ExceptByAsyncEnumerable<T, U> extends BaseAsyncEnumerable<T> {
-  readonly #first: AsyncEnumerable<T>;
-  readonly #second: AsyncEnumerable<T>;
+export 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;
 
-  constructor(first: AsyncEnumerable<T>, second: AsyncEnumerable<T>, selector: MaybeAsyncConverter<T, U>, equater?: MaybeAsyncEquater<U>) {
+  constructor(first: AsyncSequence<T>, second: AsyncSequence<T>, selector: MaybeAsyncConverter<T, U>, equater?: MaybeAsyncEquater<U>) {
     super();
 
     this.#first = first;
@@ -1863,12 +1863,12 @@ export class ExceptByAsyncEnumerable<T, U> extends BaseAsyncEnumerable<T> {
   }
 }
 
-export class IntersectAsyncEnumerable<T> extends BaseAsyncEnumerable<T> {
-  readonly #first: AsyncEnumerable<T>;
-  readonly #second: AsyncEnumerable<T>;
+export class IntersectAsyncSequence<T> extends BaseAsyncSequence<T> {
+  readonly #first: AsyncSequence<T>;
+  readonly #second: AsyncSequence<T>;
   readonly #equater: MaybeAsyncEquater<T> | undefined;
 
-  constructor(first: AsyncEnumerable<T>, second: AsyncEnumerable<T>, equater?: MaybeAsyncEquater<T>) {
+  constructor(first: AsyncSequence<T>, second: AsyncSequence<T>, equater?: MaybeAsyncEquater<T>) {
     super();
 
     this.#first = first;
@@ -1893,13 +1893,13 @@ export class IntersectAsyncEnumerable<T> extends BaseAsyncEnumerable<T> {
   }
 }
 
-export class IntersectByAsyncEnumerable<T, U> extends BaseAsyncEnumerable<T> {
-  readonly #first: AsyncEnumerable<T>;
-  readonly #second: AsyncEnumerable<T>;
+export 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;
 
-  constructor(first: AsyncEnumerable<T>, second: AsyncEnumerable<T>, selector: MaybeAsyncConverter<T, U>, equater?: MaybeAsyncEquater<U>) {
+  constructor(first: AsyncSequence<T>, second: AsyncSequence<T>, selector: MaybeAsyncConverter<T, U>, equater?: MaybeAsyncEquater<U>) {
     super();
 
     this.#first = first;
@@ -1925,19 +1925,19 @@ export class IntersectByAsyncEnumerable<T, U> extends BaseAsyncEnumerable<T> {
   }
 }
 
-export class ReversedAsyncEnumerable<T> extends BaseAsyncEnumerable<T> {
-  readonly #enumerable: AsyncEnumerable<T>;
+export class ReversedAsyncSequence<T> extends BaseAsyncSequence<T> {
+  readonly #sequence: AsyncSequence<T>;
 
-  constructor(enumerable: AsyncEnumerable<T>) {
+  constructor(sequence: AsyncSequence<T>) {
     super();
 
-    this.#enumerable = enumerable;
+    this.#sequence = sequence;
   }
 
   override async *iterator() {
     const buffer: T[] = [];
 
-    for await (const obj of this.#enumerable) {
+    for await (const obj of this.#sequence) {
       buffer.push(obj);
     }
 
@@ -1947,16 +1947,16 @@ export class ReversedAsyncEnumerable<T> extends BaseAsyncEnumerable<T> {
   }
 }
 
-export class GroupByAsyncEnumerable<TElement, TKey, TResult> extends BaseAsyncEnumerable<GroupedAsyncEnumerable<TKey, TResult>> {
-  readonly #enumerable: AsyncEnumerable<TElement>;
+export class GroupByAsyncSequence<TElement, TKey, TResult> extends BaseAsyncSequence<GroupedAsyncSequence<TKey, TResult>> {
+  readonly #sequence: AsyncSequence<TElement>;
   readonly #keySelector: MaybeAsyncConverter<TElement, TKey>;
   readonly #elementSelector: MaybeAsyncConverter<TElement, TResult>;
   readonly #keyComparer: MaybeAsyncEquater<TKey> | undefined;
 
-  constructor(enumerable: AsyncEnumerable<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?: MaybeAsyncEquater<TKey>) {
     super();
 
-    this.#enumerable = enumerable;
+    this.#sequence = sequence;
     this.#keySelector = keySelector;
     this.#elementSelector = elementSelector ?? identity as MaybeAsyncConverter<TElement, TResult>;
     this.#keyComparer = keyComparer;
@@ -1965,7 +1965,7 @@ export class GroupByAsyncEnumerable<TElement, TKey, TResult> extends BaseAsyncEn
   override async *iterator() {
     const groupings = createAsyncEqualityMap<TKey, TResult[]>(this.#keyComparer);
 
-    for await (const obj of this.#enumerable) {
+    for await (const obj of this.#sequence) {
       const key = await this.#keySelector(obj);
       let grouping = await groupings.get(key);
 
@@ -1977,31 +1977,31 @@ export class GroupByAsyncEnumerable<TElement, TKey, TResult> extends BaseAsyncEn
     }
 
     for await (const entry of groupings) {
-      yield new GroupedAsyncEnumerableImpl(entry[0], array(entry[1]));
+      yield new GroupedAsyncSequenceImpl(entry[0], array(entry[1]));
     }
   }
 }
 
-export class ChunkedAsyncEnumerable<T> extends BaseAsyncEnumerable<T[]> {
-  readonly #enumerable: AsyncEnumerable<T>;
+export class ChunkedAsyncSequence<T> extends BaseAsyncSequence<T[]> {
+  readonly #sequence: AsyncSequence<T>;
   readonly #size: number;
 
-  constructor(enumerable: AsyncEnumerable<T>, size: number) {
+  constructor(sequence: AsyncSequence<T>, size: number) {
     super();
 
-    this.#enumerable = enumerable;
+    this.#sequence = sequence;
     this.#size = size;
   }
 
   override async nonEnumeratedCount() {
-    const n = await this.#enumerable.nonEnumeratedCount();
+    const n = await this.#sequence.nonEnumeratedCount();
     return n < 0 ? -1 : Math.ceil(n / this.#size);
   }
 
   override async *iterator() {
     let chunk: T[] = [];
 
-    for await (const obj of this.#enumerable) {
+    for await (const obj of this.#sequence) {
       chunk.push(obj);
 
       if (chunk.length === this.#size) {
@@ -2016,15 +2016,15 @@ export class ChunkedAsyncEnumerable<T> extends BaseAsyncEnumerable<T[]> {
   }
 }
 
-export class JoinAsyncEnumerable<TOuter, TInner, TKey, TResult> extends BaseAsyncEnumerable<TResult> {
-  readonly #first: AsyncEnumerable<TOuter>;
-  readonly #second: AsyncEnumerable<TInner>;
+export class JoinAsyncSequence<TOuter, TInner, TKey, TResult> extends BaseAsyncSequence<TResult> {
+  readonly #first: AsyncSequence<TOuter>;
+  readonly #second: AsyncSequence<TInner>;
   readonly #firstKeySelector: MaybeAsyncConverter<TOuter, TKey>;
   readonly #secondKeySelector: MaybeAsyncConverter<TInner, TKey>;
   readonly #resultSelector: MaybeAsyncBiConverter<TOuter, TInner, TResult>;
   readonly #keyComparer: MaybeAsyncEquater<TKey>;
 
-  constructor(first: AsyncEnumerable<TOuter>, second: AsyncEnumerable<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?: MaybeAsyncEquater<TKey>) {
     super();
 
     this.#first = first;
@@ -2050,27 +2050,27 @@ export class JoinAsyncEnumerable<TOuter, TInner, TKey, TResult> extends BaseAsyn
   }
 }
 
-export class GroupJoinAsyncEnumerable<TOuter, TInner, TKey, TResult> extends BaseAsyncEnumerable<TResult> {
-  readonly #first: AsyncEnumerable<TOuter>;
-  readonly #second: AsyncEnumerable<TInner>;
+export class GroupJoinAsyncSequence<TOuter, TInner, TKey, TResult> extends BaseAsyncSequence<TResult> {
+  readonly #first: AsyncSequence<TOuter>;
+  readonly #second: AsyncSequence<TInner>;
   readonly #firstKeySelector: MaybeAsyncConverter<TOuter, TKey>;
   readonly #secondKeySelector: MaybeAsyncConverter<TInner, TKey>;
-  readonly #resultSelector: MaybeAsyncBiConverter<TOuter, AsyncEnumerable<TInner>, TResult>;
+  readonly #resultSelector: MaybeAsyncBiConverter<TOuter, AsyncSequence<TInner>, TResult>;
   readonly #keyComparer: MaybeAsyncEquater<TKey>;
 
-  constructor(first: AsyncEnumerable<TOuter>, second: AsyncEnumerable<TInner>, firstKeySelector: MaybeAsyncConverter<TOuter, TKey>, secondKeySelector: MaybeAsyncConverter<TInner, TKey>, resultSelector?: MaybeAsyncBiConverter<TOuter, AsyncEnumerable<TInner>, TResult>, keyComparer?: MaybeAsyncEquater<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>) {
     super();
 
     this.#first = first;
     this.#second = second;
     this.#firstKeySelector = firstKeySelector;
     this.#secondKeySelector = secondKeySelector;
-    this.#resultSelector = resultSelector ?? GroupJoinAsyncEnumerable.#defaultResultSelector as MaybeAsyncBiConverter<TOuter, AsyncEnumerable<TInner>, TResult>;
+    this.#resultSelector = resultSelector ?? GroupJoinAsyncSequence.#defaultResultSelector as MaybeAsyncBiConverter<TOuter, AsyncSequence<TInner>, TResult>;
     this.#keyComparer = keyComparer ?? strictEquals;
   }
 
-  static #defaultResultSelector<TOuter, TInner>(first: TOuter, second: AsyncEnumerable<TInner>) {
-    return new GroupedAsyncEnumerableImpl(first, second);
+  static #defaultResultSelector<TOuter, TInner>(first: TOuter, second: AsyncSequence<TInner>) {
+    return new GroupedAsyncSequenceImpl(first, second);
   }
 
   override async *iterator() {
@@ -2092,16 +2092,16 @@ export class GroupJoinAsyncEnumerable<TOuter, TInner, TKey, TResult> extends Bas
   }
 }
 
-export class RemoveAsyncEnumerable<T> extends BaseAsyncEnumerable<T> {
-  readonly #enumerable: AsyncEnumerable<T>;
+export class RemoveAsyncSequence<T> extends BaseAsyncSequence<T> {
+  readonly #sequence: AsyncSequence<T>;
   readonly #obj: T;
   readonly #all: boolean;
   readonly #equater: MaybeAsyncEquater<T>;
 
-  constructor(enumerable: AsyncEnumerable<T>, obj: T, all?: boolean, equater?: MaybeAsyncEquater<T>) {
+  constructor(sequence: AsyncSequence<T>, obj: T, all?: boolean, equater?: MaybeAsyncEquater<T>) {
     super();
 
-    this.#enumerable = enumerable;
+    this.#sequence = sequence;
     this.#obj = obj;
     this.#all = all ?? false;
     this.#equater = equater ?? strictEquals;
@@ -2110,7 +2110,7 @@ export class RemoveAsyncEnumerable<T> extends BaseAsyncEnumerable<T> {
   override async *iterator() {
     let gotOne = false;
 
-    for await (const obj of this.#enumerable) {
+    for await (const obj of this.#sequence) {
       if (await this.#equater(this.#obj, obj)) {
         if (this.#all) {
           continue;
@@ -2127,17 +2127,17 @@ export class RemoveAsyncEnumerable<T> extends BaseAsyncEnumerable<T> {
   }
 }
 
-export class CacheAsyncEnumerable<T> extends BaseAsyncEnumerable<T> {
-  readonly #enumerable: AsyncEnumerable<T>;
+export class CacheAsyncSequence<T> extends BaseAsyncSequence<T> {
+  readonly #sequence: AsyncSequence<T>;
   #cache: T[] | undefined;
 
-  constructor(enumerable: AsyncEnumerable<T>) {
+  constructor(sequence: AsyncSequence<T>) {
     super();
 
-    this.#enumerable = enumerable;
+    this.#sequence = sequence;
   }
 
   override async *iterator() {
-    yield* this.#cache ??= await this.#enumerable.toArray();
+    yield* this.#cache ??= await this.#sequence.toArray();
   }
 }
diff --git a/src/async/index.ts b/src/async/index.ts
index 924b489..0e5135b 100644
--- a/src/async/index.ts
+++ b/src/async/index.ts
@@ -1,16 +1,16 @@
 import { wrap as wrapSync } from "../sync/index.js";
-import { Enumerable } from "../sync/types.js";
+import { Sequence } from "../sync/types.js";
 import { MaybeAsyncIterable } from "../types.js";
 import { isAsyncIterable } from "../utils.js";
-import { WrappedEnumerable, WrappedAsyncIterable, EmptyAsyncEnumerable, WrappedObjectAsync, WrappedArrayAsync, WrappedArrayLikeAsync, FunctionAsyncEnumerable, GeneratorAsyncEnumerable, RangeAsyncEnumerable, RepeatForeverAsyncEnumerable, RepeatAsyncEnumerable, AsyncEnumerableMarker } from "./impl.js";
-import { AsyncEnumerable } from "./types.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>(enumerable: Enumerable<T>): AsyncEnumerable<T> {
-  return new WrappedEnumerable(enumerable);
+export function asAsync<T>(sequence: Sequence<T>): AsyncSequence<T> {
+  return new WrappedSequence(sequence);
 }
 
-export function wrap<T>(iterable: MaybeAsyncIterable<T>): AsyncEnumerable<T> {
-  if (isAsyncEnumerable<T>(iterable)) {
+export function wrap<T>(iterable: MaybeAsyncIterable<T>): AsyncSequence<T> {
+  if (isAsyncSequence<T>(iterable)) {
     return iterable;
   }
 
@@ -21,27 +21,27 @@ export function wrap<T>(iterable: MaybeAsyncIterable<T>): AsyncEnumerable<T> {
   return asAsync(wrapSync(iterable));
 }
 
-export function sequence<T>(iterable: AsyncIterable<T>): AsyncEnumerable<T> {
+export function sequence<T>(iterable: AsyncIterable<T>): AsyncSequence<T> {
   return new WrappedAsyncIterable(iterable);
 }
 
-export function empty<T>(): AsyncEnumerable<T> {
-  return EmptyAsyncEnumerable.INSTANCE;
+export function empty<T>(): AsyncSequence<T> {
+  return EmptyAsyncSequence.INSTANCE;
 }
 
-export function single<T>(obj: T | PromiseLike<T>): AsyncEnumerable<T> {
+export function single<T>(obj: T | PromiseLike<T>): AsyncSequence<T> {
   return new WrappedObjectAsync(obj);
 }
 
-export function array<T>(array: (T | PromiseLike<T>)[]): AsyncEnumerable<T> {
+export function array<T>(array: (T | PromiseLike<T>)[]): AsyncSequence<T> {
   return new WrappedArrayAsync(array);
 }
 
-export function arrayLike<T>(arrayLike: ArrayLike<(T | PromiseLike<T>)>): AsyncEnumerable<T> {
+export function arrayLike<T>(arrayLike: ArrayLike<(T | PromiseLike<T>)>): AsyncSequence<T> {
   return new WrappedArrayLikeAsync(arrayLike);
 }
 
-export function of<T>(...elements: (T | PromiseLike<T>)[]): AsyncEnumerable<T> {
+export function of<T>(...elements: (T | PromiseLike<T>)[]): AsyncSequence<T> {
   switch (elements.length) {
     case 0:
       return empty();
@@ -52,18 +52,18 @@ export function of<T>(...elements: (T | PromiseLike<T>)[]): AsyncEnumerable<T> {
   }
 }
 
-export function func<T>(f: () => Promise<T>): AsyncEnumerable<T> {
-  return new FunctionAsyncEnumerable(f);
+export function func<T>(f: () => Promise<T>): AsyncSequence<T> {
+  return new FunctionAsyncSequence(f);
 }
 
-export function generator<T>(generator: () => AsyncGenerator<T>): AsyncEnumerable<T> {
-  return new GeneratorAsyncEnumerable(generator);
+export function generator<T>(generator: () => AsyncGenerator<T>): AsyncSequence<T> {
+  return new GeneratorAsyncSequence(generator);
 }
 
-export function range(max: number): AsyncEnumerable<number>
-export function range(min: number, max: number): AsyncEnumerable<number>
-export function range(min: number, max: number, step: number): AsyncEnumerable<number>
-export function range(a: number, b?: number, c?: number): AsyncEnumerable<number> {
+export function range(max: number): AsyncSequence<number>
+export function range(min: number, max: number): AsyncSequence<number>
+export function range(min: number, max: number, step: number): AsyncSequence<number>
+export function range(a: number, b?: number, c?: number): AsyncSequence<number> {
   if (b === undefined) {
     b = a;
     a = 0;
@@ -73,12 +73,12 @@ export function range(a: number, b?: number, c?: number): AsyncEnumerable<number
     c = 1;
   }
 
-  return new RangeAsyncEnumerable(a, b, c);
+  return new RangeAsyncSequence(a, b, c);
 }
 
-export function repeat<T>(value: T, count?: number): AsyncEnumerable<T> {
+export function repeat<T>(value: T, count?: number): AsyncSequence<T> {
   if (count == undefined) {
-    return new RepeatForeverAsyncEnumerable(value);
+    return new RepeatForeverAsyncSequence(value);
   }
 
   if (count < 0) {
@@ -93,9 +93,9 @@ export function repeat<T>(value: T, count?: number): AsyncEnumerable<T> {
     return new WrappedObjectAsync(value);
   }
 
-  return new RepeatAsyncEnumerable(value, count);
+  return new RepeatAsyncSequence(value, count);
 }
 
-export function isAsyncEnumerable<T = any>(obj: any): obj is AsyncEnumerable<T> {
-  return obj instanceof AsyncEnumerableMarker;
+export function isAsyncSequence<T = any>(obj: any): obj is AsyncSequence<T> {
+  return obj instanceof AsyncSequenceMarker;
 }
diff --git a/src/async/types.ts b/src/async/types.ts
index 7c1ed2d..2a0723d 100644
--- a/src/async/types.ts
+++ b/src/async/types.ts
@@ -2,41 +2,41 @@ 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";
 
-export interface AsyncEnumerable<TElement> extends AsyncIterable<Awaited<TElement>> {
+export interface AsyncSequence<TElement> extends AsyncIterable<Awaited<TElement>> {
   iterator(): AsyncIterator<Awaited<TElement>>;
 
-  apply<TResult>(pipeline: (enumerable: AsyncEnumerable<TElement>) => TResult): TResult;
+  apply<TResult>(pipeline: (sequence: AsyncSequence<TElement>) => TResult): TResult;
 
   count(predicate?: MaybeAsyncPredicate<TElement>): Promise<number>;
   nonEnumeratedCount(): Promise<number>;
   fastCount(): Promise<number>;
   maxCount(): Promise<number>;
 
-  select<TResult>(selector: MaybeAsyncConverter<TElement, TResult>): AsyncEnumerable<TResult>;
-  selectMany<TResult>(selector: MaybeAsyncConverter<TElement, MaybeAsyncIterable<TResult>>): AsyncEnumerable<TResult>;
+  select<TResult>(selector: MaybeAsyncConverter<TElement, TResult>): AsyncSequence<TResult>;
+  selectMany<TResult>(selector: MaybeAsyncConverter<TElement, MaybeAsyncIterable<TResult>>): AsyncSequence<TResult>;
 
-  where(predicate: MaybeAsyncPredicate<TElement>): AsyncEnumerable<TElement>;
+  where(predicate: MaybeAsyncPredicate<TElement>): AsyncSequence<TElement>;
 
-  groupBy<TKey>(keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector?: undefined, keyComparer?: MaybeAsyncEquater<TKey>): AsyncEnumerable<GroupedAsyncEnumerable<TKey, TElement>>;
-  groupBy<TKey, TResult>(keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector: MaybeAsyncConverter<TElement, TResult>, keyComparer?: MaybeAsyncEquater<TKey>): AsyncEnumerable<GroupedAsyncEnumerable<TKey, TResult>>;
+  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>): AsyncEnumerable<[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>): AsyncEnumerable<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>;
 
-  groupJoin<TOther, TKey>(iterable: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector?: undefined, keyComparer?: MaybeAsyncEquater<TKey>): AsyncEnumerable<GroupedAsyncEnumerable<TElement, TOther>>;
-  groupJoin<TOther, TKey, TResult>(iterable: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector: MaybeAsyncBiConverter<TElement, AsyncEnumerable<TOther>, TResult>, keyComparer?: MaybeAsyncEquater<TKey>): AsyncEnumerable<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>;
 
   contains(obj: TElement, equater?: MaybeAsyncEquater<TElement>): Promise<boolean>;
 
   sequenceEquals(iterable: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEquater<TElement>): Promise<boolean>;
 
-  append(obj: TElement): AsyncEnumerable<TElement>;
+  append(obj: TElement): AsyncSequence<TElement>;
 
-  prepend(obj: TElement): AsyncEnumerable<TElement>;
+  prepend(obj: TElement): AsyncSequence<TElement>;
 
-  remove(obj: TElement, all?: boolean, equater?: MaybeAsyncEquater<TElement>): AsyncEnumerable<TElement>;
+  remove(obj: TElement, all?: boolean, equater?: MaybeAsyncEquater<TElement>): AsyncSequence<TElement>;
 
-  concat(...iterables: MaybeAsyncIterable<TElement>[]): AsyncEnumerable<TElement>;
+  concat(...iterables: MaybeAsyncIterable<TElement>[]): AsyncSequence<TElement>;
 
   first(predicate?: MaybeAsyncPredicate<TElement>): Promise<TElement>;
   firstOrDefault(predicate?: MaybeAsyncPredicate<TElement>, def?: TElement): Promise<TElement | undefined>;
@@ -60,23 +60,23 @@ export interface AsyncEnumerable<TElement> extends AsyncIterable<Awaited<TElemen
   max(): Promise<TElement>;
   maxBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>): Promise<TElement>;
 
-  order(comparer?: MaybeAsyncComparer<TElement>): AsyncEnumerable<TElement>;
-  orderBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparer<TBy>): AsyncEnumerable<TElement>;
+  order(comparer?: MaybeAsyncComparer<TElement>): AsyncSequence<TElement>;
+  orderBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparer<TBy>): AsyncSequence<TElement>;
 
-  orderDescending(comparer?: MaybeAsyncComparer<TElement>): AsyncEnumerable<TElement>;
-  orderByDescending<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparer<TBy>): AsyncEnumerable<TElement>;
+  orderDescending(comparer?: MaybeAsyncComparer<TElement>): AsyncSequence<TElement>;
+  orderByDescending<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparer<TBy>): AsyncSequence<TElement>;
 
-  distinct(equater?: MaybeAsyncEquater<TElement>): AsyncEnumerable<TElement>;
-  distinctBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncEnumerable<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>): AsyncEnumerable<TElement>;
-  unionBy<TBy>(iterable: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncEnumerable<TElement>;
+  union(iterable: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEquater<TElement>): AsyncSequence<TElement>;
+  unionBy<TBy>(iterable: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncSequence<TElement>;
 
-  except(iterable: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEquater<TElement>): AsyncEnumerable<TElement>;
-  exceptBy<TBy>(iterable: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncEnumerable<TElement>;
+  except(iterable: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEquater<TElement>): AsyncSequence<TElement>;
+  exceptBy<TBy>(iterable: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncSequence<TElement>;
 
-  intersect(iterable: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEquater<TElement>): AsyncEnumerable<TElement>;
-  intersectBy<TBy>(iterable: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncEnumerable<TElement>;
+  intersect(iterable: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEquater<TElement>): AsyncSequence<TElement>;
+  intersectBy<TBy>(iterable: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncSequence<TElement>;
 
   all(predicate: MaybeAsyncPredicate<TElement>): Promise<boolean>;
   any(predicate: MaybeAsyncPredicate<TElement>): Promise<boolean>;
@@ -84,29 +84,29 @@ export interface AsyncEnumerable<TElement> extends AsyncIterable<Awaited<TElemen
   none(predicate: Predicate<TElement>): Promise<boolean>;
   none(): Promise<boolean>;
 
-  skip(n: number): AsyncEnumerable<TElement>;
-  skipLast(n: number): AsyncEnumerable<TElement>;
-  skipWhile(condition: MaybeAsyncPredicate<TElement>): AsyncEnumerable<TElement>;
+  skip(n: number): AsyncSequence<TElement>;
+  skipLast(n: number): AsyncSequence<TElement>;
+  skipWhile(condition: MaybeAsyncPredicate<TElement>): AsyncSequence<TElement>;
 
-  take(n: number): AsyncEnumerable<TElement>;
-  takeLast(n: number): AsyncEnumerable<TElement>;
-  takeWhile(condition: MaybeAsyncPredicate<TElement>): AsyncEnumerable<TElement>;
+  take(n: number): AsyncSequence<TElement>;
+  takeLast(n: number): AsyncSequence<TElement>;
+  takeWhile(condition: MaybeAsyncPredicate<TElement>): AsyncSequence<TElement>;
 
-  peek(action: MaybeAsyncAction<TElement>): AsyncEnumerable<TElement>;
+  peek(action: MaybeAsyncAction<TElement>): AsyncSequence<TElement>;
 
   forEach(action: MaybeAsyncAction<TElement>): Promise<void>;
 
-  zip<TOther>(iterable: MaybeAsyncIterable<TOther>): AsyncEnumerable<[Awaited<TElement>, Awaited<TOther>]>;
+  zip<TOther>(iterable: MaybeAsyncIterable<TOther>): AsyncSequence<[Awaited<TElement>, Awaited<TOther>]>;
 
-  indexex(): AsyncEnumerable<[number, Awaited<TElement>]>;
+  indexex(): AsyncSequence<[number, Awaited<TElement>]>;
 
-  reversed(): AsyncEnumerable<TElement>;
+  reversed(): AsyncSequence<TElement>;
 
-  chunked(size: number): AsyncEnumerable<TElement[]>;
+  chunked(size: number): AsyncSequence<TElement[]>;
 
   random(options?: AsyncRandomOptions<TElement>): Promise<TElement | undefined>;
 
-  cached(): AsyncEnumerable<TElement>;
+  cached(): AsyncSequence<TElement>;
 
   toArray(): Promise<TElement[]>;
   toMap<TKey, TValue>(keySelector: MaybeAsyncConverter<TElement, TKey>, valueSelector: MaybeAsyncConverter<TElement, TValue>): Promise<Map<TKey, TValue>>;
@@ -116,18 +116,18 @@ export interface AsyncEnumerable<TElement> extends AsyncIterable<Awaited<TElemen
   collect<TResult>(collector: Collector<TElement, any, TResult>): Promise<TResult>;
 }
 
-export interface GroupedAsyncEnumerable<TKey, TElement> extends AsyncEnumerable<TElement> {
+export interface GroupedAsyncSequence<TKey, TElement> extends AsyncSequence<TElement> {
   get key(): TKey;
 }
 
-export interface OrderedAsyncEnumerable<TElement> extends AsyncEnumerable<TElement> {
+export interface OrderedAsyncSequence<TElement> extends AsyncSequence<TElement> {
   get comparer(): MaybeAsyncComparer<TElement>;
 
-  thenSelf(comparer?: MaybeAsyncComparer<TElement>): OrderedAsyncEnumerable<TElement>;
+  thenSelf(comparer?: MaybeAsyncComparer<TElement>): OrderedAsyncSequence<TElement>;
 
-  thenBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparer<TBy>): OrderedAsyncEnumerable<TElement>;
+  thenBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparer<TBy>): OrderedAsyncSequence<TElement>;
 
-  thenSelfDescending(comparer?: MaybeAsyncComparer<TElement>): OrderedAsyncEnumerable<TElement>;
+  thenSelfDescending(comparer?: MaybeAsyncComparer<TElement>): OrderedAsyncSequence<TElement>;
 
-  thenByDescending<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparer<TBy>): OrderedAsyncEnumerable<TElement>;
+  thenByDescending<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparer<TBy>): OrderedAsyncSequence<TElement>;
 }
diff --git a/src/index.ts b/src/index.ts
index 3713778..38dd087 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -1,8 +1,8 @@
-export { BaseEnumerable, DelegatedEnumerable } from "./sync/impl.js";
-export * as Enumerables from "./sync/index.js";
+export { BaseSequence, DelegatedSequence } from "./sync/impl.js";
+export * as Sequences from "./sync/index.js";
 export * from "./sync/types.js";
-export { BaseAsyncEnumerable, DelegatedAsyncEnumerable } from "./async/impl.js";
-export * as AsyncEnumerables from "./async/index.js";
+export { BaseAsyncSequence, DelegatedAsyncSequence } from "./async/impl.js";
+export * as AsyncSequences from "./async/index.js";
 export * from "./async/types.js";
 export * as Collectors from "./collector/index.js";
 export * from "./collector/types.js";
diff --git a/src/sync/impl.ts b/src/sync/impl.ts
index 1486965..cacd1ab 100644
--- a/src/sync/impl.ts
+++ b/src/sync/impl.ts
@@ -7,43 +7,43 @@ 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 { Enumerable, GroupedEnumerable, OrderedEnumerable } from "./types.js";
+import { Sequence, GroupedSequence, OrderedSequence } from "./types.js";
 
-export class EnumerableMarker { }
+export class SequenceMarker { }
 
-export abstract class BaseEnumerable<TElement> extends EnumerableMarker implements Enumerable<TElement> {
+export abstract class BaseSequence<TElement> extends SequenceMarker implements Sequence<TElement> {
   [Symbol.iterator]() {
     return this.iterator();
   }
 
   abstract iterator(): Iterator<TElement>;
 
-  apply<TResult>(pipeline: (enumerable: this) => TResult) {
+  apply<TResult>(pipeline: (sequence: this) => TResult) {
     return pipeline(this);
   }
 
-  select<TResult>(converter: Converter<TElement, TResult>): Enumerable<TResult> {
-    return new SelectEnumerable<TElement, TResult>(this, converter);
+  select<TResult>(converter: Converter<TElement, TResult>): Sequence<TResult> {
+    return new SelectSequence<TElement, TResult>(this, converter);
   }
 
-  selectMany<TResult>(converter: Converter<TElement, Iterable<TResult>>): Enumerable<TResult> {
-    return new SelectManyEnumerable<TElement, TResult>(this, converter);
+  selectMany<TResult>(converter: Converter<TElement, Iterable<TResult>>): Sequence<TResult> {
+    return new SelectManySequence<TElement, TResult>(this, converter);
   }
 
-  where<TFiltered extends TElement>(predicate: FilterPredicate<TElement, TFiltered>): Enumerable<TFiltered> {
-    return new WhereEnumerable<TElement, TFiltered>(this, predicate);
+  where<TFiltered extends TElement>(predicate: FilterPredicate<TElement, TFiltered>): Sequence<TFiltered> {
+    return new WhereSequence<TElement, TFiltered>(this, predicate);
   }
 
-  groupBy<TKey, TResult>(keySelector: Converter<TElement, TKey>, elementSelector?: Converter<TElement, TResult>, keyComparer?: Equater<TKey>): Enumerable<GroupedEnumerable<TKey, TResult>> {
-    return new GroupByEnumerable<TElement, TKey, TResult>(this, keySelector, elementSelector, keyComparer);
+  groupBy<TKey, TResult>(keySelector: Converter<TElement, TKey>, elementSelector?: Converter<TElement, TResult>, keyComparer?: Equater<TKey>): Sequence<GroupedSequence<TKey, TResult>> {
+    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>): Enumerable<TResult> {
-    return new JoinEnumerable<TElement, TOther, TKey, TResult>(this, wrap(iterable), firstKeySelector, secondKeySelector, resultSelector, 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);
   }
 
-  groupJoin<TOther, TKey, TResult>(iterable: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: BiConverter<TElement, Enumerable<TOther>, TResult>, keyComparer?: Equater<TKey>): Enumerable<TResult> {
-    return new GroupJoinEnumerable<TElement, TOther, TKey, TResult>(this, wrap(iterable), 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);
   }
 
   contains(obj: TElement, equater?: Equater<TElement>) {
@@ -99,16 +99,16 @@ export abstract class BaseEnumerable<TElement> extends EnumerableMarker implemen
     }
   }
 
-  append(obj: TElement): Enumerable<TElement> {
-    return new AppendEnumerable<TElement>(this, obj);
+  append(obj: TElement): Sequence<TElement> {
+    return new AppendSequence<TElement>(this, obj);
   }
 
-  prepend(obj: TElement): Enumerable<TElement> {
-    return new PrependEnumerable<TElement>(this, obj);
+  prepend(obj: TElement): Sequence<TElement> {
+    return new PrependSequence<TElement>(this, obj);
   }
 
-  remove(obj: TElement, all?: boolean, equater?: Equater<TElement>): Enumerable<TElement> {
-    return new RemoveEnumerable<TElement>(this, obj, all, equater);
+  remove(obj: TElement, all?: boolean, equater?: Equater<TElement>): Sequence<TElement> {
+    return new RemoveSequence<TElement>(this, obj, all, equater);
   }
 
   concat(...iterables: Iterable<TElement>[]) {
@@ -116,13 +116,13 @@ export abstract class BaseEnumerable<TElement> extends EnumerableMarker implemen
       return this;
     }
 
-    const arr: Enumerable<TElement>[] = [this];
+    const arr: Sequence<TElement>[] = [this];
 
     for (const iterable of iterables) {
       arr.push(wrap(iterable));
     }
 
-    return new ConcatEnumerable(arr);
+    return new ConcatSequence(arr);
   }
 
   count(predicate?: Predicate<TElement>) {
@@ -438,52 +438,52 @@ export abstract class BaseEnumerable<TElement> extends EnumerableMarker implemen
     return this.#find(x => x < 0, converter, comparer);
   }
 
-  order(comparer?: Comparer<TElement>): OrderedEnumerable<TElement> {
-    return new OrderEnumerable<TElement>(this, false, comparer);
+  order(comparer?: Comparer<TElement>): OrderedSequence<TElement> {
+    return new OrderSequence<TElement>(this, false, comparer);
   }
 
-  orderBy<TBy>(selector: Converter<TElement, TBy>, comparer?: Comparer<TBy>): OrderedEnumerable<TElement> {
-    return new OrderByEnumerable<TElement, TBy>(this, false, selector, comparer);
+  orderBy<TBy>(selector: Converter<TElement, TBy>, comparer?: Comparer<TBy>): OrderedSequence<TElement> {
+    return new OrderBySequence<TElement, TBy>(this, false, selector, comparer);
   }
 
-  orderDescending(comparer?: Comparer<TElement>): OrderedEnumerable<TElement> {
-    return new OrderEnumerable<TElement>(this, true, comparer);
+  orderDescending(comparer?: Comparer<TElement>): OrderedSequence<TElement> {
+    return new OrderSequence<TElement>(this, true, comparer);
   }
 
-  orderByDescending<TBy>(selector: Converter<TElement, TBy>, comparer?: Comparer<TBy>): OrderedEnumerable<TElement> {
-    return new OrderByEnumerable<TElement, TBy>(this, true, selector, comparer);
+  orderByDescending<TBy>(selector: Converter<TElement, TBy>, comparer?: Comparer<TBy>): OrderedSequence<TElement> {
+    return new OrderBySequence<TElement, TBy>(this, true, selector, comparer);
   }
 
-  distinct(equater?: Equater<TElement>): Enumerable<TElement> {
-    return new DistinctEnumerable<TElement>(this, equater);
+  distinct(equater?: Equater<TElement>): Sequence<TElement> {
+    return new DistinctSequence<TElement>(this, equater);
   }
 
-  distinctBy<TBy>(selector: Converter<TElement, TBy>, equater?: Equater<TBy>): Enumerable<TElement> {
-    return new DistinctByEnumerable<TElement, TBy>(this, selector, equater);
+  distinctBy<TBy>(selector: Converter<TElement, TBy>, equater?: Equater<TBy>): Sequence<TElement> {
+    return new DistinctBySequence<TElement, TBy>(this, selector, equater);
   }
 
-  union(iterable: Iterable<TElement>, equater?: Equater<TElement>): Enumerable<TElement> {
-    return new UnionEnumerable<TElement>(this, wrap(iterable), equater);
+  union(iterable: Iterable<TElement>, equater?: Equater<TElement>): Sequence<TElement> {
+    return new UnionSequence<TElement>(this, wrap(iterable), equater);
   }
 
-  unionBy<TBy>(iterable: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: Equater<TBy>): Enumerable<TElement> {
-    return new UnionByEnumerable<TElement, TBy>(this, wrap(iterable), selector, 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);
   }
 
-  except(iterable: Iterable<TElement>): Enumerable<TElement> {
-    return new ExceptEnumerable<TElement>(this, wrap(iterable));
+  except(iterable: Iterable<TElement>): Sequence<TElement> {
+    return new ExceptSequence<TElement>(this, wrap(iterable));
   }
 
-  exceptBy<TBy>(iterable: Iterable<TElement>, selector: Converter<TElement, TBy>): Enumerable<TElement> {
-    return new ExceptByEnumerable<TElement, TBy>(this, wrap(iterable), selector);
+  exceptBy<TBy>(iterable: Iterable<TElement>, selector: Converter<TElement, TBy>): Sequence<TElement> {
+    return new ExceptBySequence<TElement, TBy>(this, wrap(iterable), selector);
   }
 
-  intersect(iterable: Iterable<TElement>): Enumerable<TElement> {
-    return new IntersectEnumerable<TElement>(this, wrap(iterable));
+  intersect(iterable: Iterable<TElement>): Sequence<TElement> {
+    return new IntersectSequence<TElement>(this, wrap(iterable));
   }
 
-  intersectBy<TBy>(iterable: Iterable<TElement>, selector: Converter<TElement, TBy>): Enumerable<TElement> {
-    return new IntersectByEnumerable<TElement, TBy>(this, wrap(iterable), selector);
+  intersectBy<TBy>(iterable: Iterable<TElement>, selector: Converter<TElement, TBy>): Sequence<TElement> {
+    return new IntersectBySequence<TElement, TBy>(this, wrap(iterable), selector);
   }
 
   all(predicate: Predicate<TElement>) {
@@ -542,48 +542,48 @@ export abstract class BaseEnumerable<TElement> extends EnumerableMarker implemen
     return n < 0 && this.iterator().next().done === true;
   }
 
-  skip(n: number): Enumerable<TElement> {
+  skip(n: number): Sequence<TElement> {
     if (n < 0) {
       throw new Error("Cannot skip a negative number of elements.");
     }
 
-    return n === 0 ? this : new SkipEnumerable<TElement>(this, n);
+    return n === 0 ? this : new SkipSequence<TElement>(this, n);
   }
 
-  skipLast(n: number): Enumerable<TElement> {
+  skipLast(n: number): Sequence<TElement> {
     if (n < 0) {
       throw new Error("Cannot skip a negative number of elements.");
     }
 
-    return n === 0 ? this : new SkipLastEnumerable<TElement>(this, n);
+    return n === 0 ? this : new SkipLastSequence<TElement>(this, n);
   }
 
-  skipWhile(predicate: Predicate<TElement>): Enumerable<TElement> {
-    return new SkipWhileEnumerable<TElement>(this, predicate);
+  skipWhile(predicate: Predicate<TElement>): Sequence<TElement> {
+    return new SkipWhileSequence<TElement>(this, predicate);
   }
 
-  take(n: number): Enumerable<TElement> {
+  take(n: number): Sequence<TElement> {
     if (n < 0) {
       throw new Error("Cannot take a negative number of elements.");
     }
 
-    return n === 0 ? empty<TElement>() : new TakeEnumerable<TElement>(this, n);
+    return n === 0 ? empty<TElement>() : new TakeSequence<TElement>(this, n);
   }
 
-  takeLast(n: number): Enumerable<TElement> {
+  takeLast(n: number): Sequence<TElement> {
     if (n < 0) {
       throw new Error("Cannot take a negative number of elements.");
     }
 
-    return n === 0 ? empty<TElement>() : new TakeLastEnumerable<TElement>(this, n);
+    return n === 0 ? empty<TElement>() : new TakeLastSequence<TElement>(this, n);
   }
 
-  takeWhile(predicate: Predicate<TElement>): Enumerable<TElement> {
-    return new TakeWhileEnumerable<TElement>(this, predicate);
+  takeWhile(predicate: Predicate<TElement>): Sequence<TElement> {
+    return new TakeWhileSequence<TElement>(this, predicate);
   }
 
-  peek(action: Action<TElement>): Enumerable<TElement> {
-    return new PeekEnumerable(this, action);
+  peek(action: Action<TElement>): Sequence<TElement> {
+    return new PeekSequence(this, action);
   }
 
   forEach(action: Action<TElement>) {
@@ -592,32 +592,32 @@ export abstract class BaseEnumerable<TElement> extends EnumerableMarker implemen
     }
   }
 
-  zip<TOther>(iterable: Iterable<TOther>): Enumerable<[TElement, TOther]> {
-    return new ZippedEnumerable<TElement, TOther>(this, wrap(iterable));
+  zip<TOther>(iterable: Iterable<TOther>): Sequence<[TElement, TOther]> {
+    return new ZippedSequence<TElement, TOther>(this, wrap(iterable));
   }
 
-  indexed(): Enumerable<[number, TElement]> {
-    return new IndexedEnumerable<TElement>(this);
+  indexed(): Sequence<[number, TElement]> {
+    return new IndexedSequence<TElement>(this);
   }
 
-  reversed(): Enumerable<TElement> {
-    return new ReversedEnumerable<TElement>(this);
+  reversed(): Sequence<TElement> {
+    return new ReversedSequence<TElement>(this);
   }
 
-  chunked(size: number): Enumerable<TElement[]> {
+  chunked(size: number): Sequence<TElement[]> {
     if (size <= 0) {
       throw new Error("Chunk size must be positive.");
     }
 
-    return new ChunkedEnumerable<TElement>(this, size);
+    return new ChunkedSequence<TElement>(this, size);
   }
 
   random(options?: RandomOptions<TElement>) {
     return getRandomElement(this, options).element;
   }
 
-  cached(): Enumerable<TElement> {
-    return new CacheEnumerable<TElement>(this);
+  cached(): Sequence<TElement> {
+    return new CacheSequence<TElement>(this);
   }
 
   asArray() {
@@ -669,21 +669,21 @@ export abstract class BaseEnumerable<TElement> extends EnumerableMarker implemen
   }
 }
 
-export class DelegatedEnumerable<TElement> extends EnumerableMarker implements Enumerable<TElement> {
-  #enumerable: Enumerable<TElement>;
+export class DelegatedSequence<TElement> extends SequenceMarker implements Sequence<TElement> {
+  #sequence: Sequence<TElement>;
 
-  constructor(enumerable: Enumerable<TElement>) {
+  constructor(sequence: Sequence<TElement>) {
     super();
 
-    this.#enumerable = enumerable;
+    this.#sequence = sequence;
   }
 
-  get enumerable() {
-    return this.#enumerable;
+  get sequence() {
+    return this.#sequence;
   }
 
-  protected set enumerable(value: Enumerable<TElement>) {
-    this.#enumerable = value;
+  protected set sequence(value: Sequence<TElement>) {
+    this.#sequence = value;
   }
 
   [Symbol.iterator]() {
@@ -691,279 +691,279 @@ export class DelegatedEnumerable<TElement> extends EnumerableMarker implements E
   }
 
   iterator() {
-    return this.#enumerable.iterator();
+    return this.#sequence.iterator();
   }
 
-  apply<TResult>(pipeline: (enumerable: Enumerable<TElement>) => TResult) {
-    return this.#enumerable.apply(pipeline);
+  apply<TResult>(pipeline: (sequence: Sequence<TElement>) => TResult) {
+    return this.#sequence.apply(pipeline);
   }
 
   count(predicate?: Predicate<TElement>) {
-    return this.#enumerable.count(predicate);
+    return this.#sequence.count(predicate);
   }
 
   nonEnumeratedCount() {
-    return this.#enumerable.nonEnumeratedCount();
+    return this.#sequence.nonEnumeratedCount();
   }
 
   fastCount() {
-    return this.#enumerable.fastCount();
+    return this.#sequence.fastCount();
   }
 
   maxCount() {
-    return this.#enumerable.maxCount();
+    return this.#sequence.maxCount();
   }
 
   select<TResult>(selector: Converter<TElement, TResult>) {
-    return this.#enumerable.select(selector);
+    return this.#sequence.select(selector);
   }
 
   selectMany<TResult>(selector: Converter<TElement, Iterable<TResult>>) {
-    return this.#enumerable.selectMany(selector);
+    return this.#sequence.selectMany(selector);
   }
 
   where<TFiltered extends TElement>(predicate: FilterPredicate<TElement, TFiltered>) {
-    return this.#enumerable.where(predicate);
+    return this.#sequence.where(predicate);
   }
 
   groupBy<TKey, TResult>(keySelector: Converter<TElement, TKey>, elementSelector?: Converter<TElement, TResult>, keyComparer?: Equater<TKey>) {
     //@ts-ignore
-    return this.#enumerable.groupBy(keySelector, elementSelector, keyComparer);
+    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.#enumerable.join(iterable, firstKeySelector, secondKeySelector, resultSelector, keyComparer);
+    return this.#sequence.join(iterable, firstKeySelector, secondKeySelector, resultSelector, keyComparer);
   }
 
-  groupJoin<TOther, TKey, TResult>(iterable: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: BiConverter<TElement, Enumerable<TOther>, TResult>, keyComparer?: Equater<TKey>) {
+  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.#enumerable.groupJoin(iterable, firstKeySelector, secondKeySelector, resultSelector, keyComparer);
+    return this.#sequence.groupJoin(iterable, firstKeySelector, secondKeySelector, resultSelector, keyComparer);
   }
 
   contains(obj: TElement, equater?: Equater<TElement>) {
-    return this.#enumerable.contains(obj, equater);
+    return this.#sequence.contains(obj, equater);
   }
 
   sequenceEquals(iterable: Iterable<TElement>, equater?: Equater<TElement>) {
-    return this.#enumerable.sequenceEquals(iterable, equater);
+    return this.#sequence.sequenceEquals(iterable, equater);
   }
 
   append(obj: TElement) {
-    return this.#enumerable.append(obj);
+    return this.#sequence.append(obj);
   }
 
   prepend(obj: TElement) {
-    return this.#enumerable.prepend(obj);
+    return this.#sequence.prepend(obj);
   }
 
   remove(obj: TElement, all?: boolean, equater?: Equater<TElement>) {
-    return this.#enumerable.remove(obj, all, equater);
+    return this.#sequence.remove(obj, all, equater);
   }
 
   concat(...iterables: Iterable<TElement>[]) {
-    return this.#enumerable.concat(...iterables);
+    return this.#sequence.concat(...iterables);
   }
 
   first(predicate?: Predicate<TElement>) {
-    return this.#enumerable.first(predicate);
+    return this.#sequence.first(predicate);
   }
 
   firstOrDefault(predicate?: Predicate<TElement>, def?: TElement) {
-    return this.#enumerable.firstOrDefault(predicate, def);
+    return this.#sequence.firstOrDefault(predicate, def);
   }
 
   last(predicate?: Predicate<TElement>) {
-    return this.#enumerable.last(predicate);
+    return this.#sequence.last(predicate);
   }
 
   lastOrDefault(predicate?: Predicate<TElement>, def?: TElement) {
-    return this.#enumerable.lastOrDefault(predicate, def);
+    return this.#sequence.lastOrDefault(predicate, def);
   }
 
   single(predicate?: Predicate<TElement>) {
-    return this.#enumerable.single(predicate);
+    return this.#sequence.single(predicate);
   }
 
   singleOrDefault(predicate?: Predicate<TElement>, def?: TElement) {
-    return this.#enumerable.singleOrDefault(predicate, def);
+    return this.#sequence.singleOrDefault(predicate, def);
   }
 
   elementAt(index: number) {
-    return this.#enumerable.elementAt(index);
+    return this.#sequence.elementAt(index);
   }
 
   elementAtOrDefault(index: number, def?: TElement) {
-    return this.#enumerable.elementAtOrDefault(index, def);
+    return this.#sequence.elementAtOrDefault(index, def);
   }
 
   aggregate<TAccumulator, TResult>(accumulator: Accumulator<TElement, TAccumulator>, seed?: TAccumulator, resultSelector?: Converter<TAccumulator, TResult>) {
-    return this.#enumerable.aggregate(accumulator, seed, resultSelector);
+    return this.#sequence.aggregate(accumulator, seed, resultSelector);
   }
 
   min(comparer?: Comparer<TElement>) {
-    return this.#enumerable.min(comparer);
+    return this.#sequence.min(comparer);
   }
 
   minBy<TBy>(selector: Converter<TElement, TBy>, comparer?: Comparer<TBy>) {
-    return this.#enumerable.minBy(selector, comparer);
+    return this.#sequence.minBy(selector, comparer);
   }
 
   max(comparer?: Comparer<TElement>) {
-    return this.#enumerable.max(comparer);
+    return this.#sequence.max(comparer);
   }
 
   maxBy<TBy>(selector: Converter<TElement, TBy>, comparer?: Comparer<TBy>) {
-    return this.#enumerable.maxBy(selector, comparer);
+    return this.#sequence.maxBy(selector, comparer);
   }
 
   order(comparer?: Comparer<TElement>) {
-    return this.#enumerable.order(comparer);
+    return this.#sequence.order(comparer);
   }
 
   orderBy<TBy>(selector: Converter<TElement, TBy>, comparer?: Comparer<TBy>) {
-    return this.#enumerable.orderBy(selector, comparer);
+    return this.#sequence.orderBy(selector, comparer);
   }
 
   orderDescending(comparer?: Comparer<TElement>) {
-    return this.#enumerable.orderDescending(comparer);
+    return this.#sequence.orderDescending(comparer);
   }
 
   orderByDescending<TBy>(selector: Converter<TElement, TBy>, comparer?: Comparer<TBy>) {
-    return this.#enumerable.orderByDescending(selector, comparer);
+    return this.#sequence.orderByDescending(selector, comparer);
   }
 
   distinct(equater?: Equater<TElement>) {
-    return this.#enumerable.distinct(equater);
+    return this.#sequence.distinct(equater);
   }
 
   distinctBy<TBy>(selector: Converter<TElement, TBy>, equater?: Equater<TBy>) {
-    return this.#enumerable.distinctBy(selector, equater);
+    return this.#sequence.distinctBy(selector, equater);
   }
 
   union(iterable: Iterable<TElement>, equater?: Equater<TElement>) {
-    return this.#enumerable.union(iterable, equater);
+    return this.#sequence.union(iterable, equater);
   }
 
   unionBy<TBy>(iterable: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: Equater<TBy>) {
-    return this.#enumerable.unionBy(iterable, selector, equater);
+    return this.#sequence.unionBy(iterable, selector, equater);
   }
 
   except(iterable: Iterable<TElement>, equater?: Equater<TElement>) {
-    return this.#enumerable.except(iterable, equater);
+    return this.#sequence.except(iterable, equater);
   }
 
   exceptBy<TBy>(iterable: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: Equater<TBy>) {
-    return this.#enumerable.exceptBy(iterable, selector, equater);
+    return this.#sequence.exceptBy(iterable, selector, equater);
   }
 
   intersect(iterable: Iterable<TElement>, equater?: Equater<TElement>) {
-    return this.#enumerable.intersect(iterable, equater);
+    return this.#sequence.intersect(iterable, equater);
   }
 
   intersectBy<TBy>(iterable: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: Equater<TBy>) {
-    return this.#enumerable.intersectBy(iterable, selector, equater);
+    return this.#sequence.intersectBy(iterable, selector, equater);
   }
 
   all(predicate: Predicate<TElement>) {
-    return this.#enumerable.all(predicate);
+    return this.#sequence.all(predicate);
   }
 
   any(predicate?: Predicate<TElement>) {
     //@ts-ignore
-    return this.#enumerable.any(predicate);
+    return this.#sequence.any(predicate);
   }
 
   none(predicate?: Predicate<TElement>) {
     //@ts-ignore
-    return this.#enumerable.none(predicate);
+    return this.#sequence.none(predicate);
   }
 
   skip(n: number) {
-    return this.#enumerable.skip(n);
+    return this.#sequence.skip(n);
   }
 
   skipLast(n: number) {
-    return this.#enumerable.skipLast(n);
+    return this.#sequence.skipLast(n);
   }
 
   skipWhile(condition: Predicate<TElement>) {
-    return this.#enumerable.skipWhile(condition);
+    return this.#sequence.skipWhile(condition);
   }
 
   take(n: number) {
-    return this.#enumerable.take(n);
+    return this.#sequence.take(n);
   }
 
   takeLast(n: number) {
-    return this.#enumerable.takeLast(n);
+    return this.#sequence.takeLast(n);
   }
 
   takeWhile(condition: Predicate<TElement>) {
-    return this.#enumerable.takeWhile(condition);
+    return this.#sequence.takeWhile(condition);
   }
 
   peek(action: Action<TElement>) {
-    return this.#enumerable.peek(action);
+    return this.#sequence.peek(action);
   }
 
   forEach(action: Action<TElement>) {
-    this.#enumerable.forEach(action);
+    this.#sequence.forEach(action);
   }
 
   zip<TOther>(iterable: Iterable<TOther>) {
-    return this.#enumerable.zip(iterable);
+    return this.#sequence.zip(iterable);
   }
 
   indexed() {
-    return this.#enumerable.indexed();
+    return this.#sequence.indexed();
   }
 
   reversed() {
-    return this.#enumerable.reversed();
+    return this.#sequence.reversed();
   }
 
   chunked(size: number) {
-    return this.#enumerable.chunked(size);
+    return this.#sequence.chunked(size);
   }
 
   random(options?: RandomOptions<TElement>) {
-    return this.#enumerable.random(options);
+    return this.#sequence.random(options);
   }
 
   cached() {
-    return this.#enumerable.cached();
+    return this.#sequence.cached();
   }
 
   asArray() {
-    return this.#enumerable.asArray();
+    return this.#sequence.asArray();
   }
 
   toArray() {
-    return this.#enumerable.toArray();
+    return this.#sequence.toArray();
   }
 
   toMap<TKey, TValue>(keySelector: Converter<TElement, TKey>, valueSelector: Converter<TElement, TValue>) {
-    return this.#enumerable.toMap(keySelector, valueSelector);
+    return this.#sequence.toMap(keySelector, valueSelector);
   }
 
   toSet() {
-    return this.#enumerable.toSet();
+    return this.#sequence.toSet();
   }
 
   toObject<TKey extends PropertyKey, TValue>(keySelector: Converter<TElement, TKey>, valueSelector: Converter<TElement, TValue>) {
-    return this.#enumerable.toObject(keySelector, valueSelector);
+    return this.#sequence.toObject(keySelector, valueSelector);
   }
 
   collect<TResult>(collector: Collector<TElement, any, TResult>) {
-    return this.#enumerable.collect(collector);
+    return this.#sequence.collect(collector);
   }
 }
 
-export class GroupedEnumerableImpl<TKey, TElement> extends DelegatedEnumerable<TElement> implements GroupedEnumerable<TKey, TElement> {
+export class GroupedSequenceImpl<TKey, TElement> extends DelegatedSequence<TElement> implements GroupedSequence<TKey, TElement> {
   readonly #key: TKey;
 
-  constructor(key: TKey, grouping: Enumerable<TElement>) {
+  constructor(key: TKey, grouping: Sequence<TElement>) {
     super(grouping);
 
     this.#key = key;
@@ -974,51 +974,51 @@ export class GroupedEnumerableImpl<TKey, TElement> extends DelegatedEnumerable<T
   }
 }
 
-export abstract class BaseOrderedEnumerable<TElement> extends BaseEnumerable<TElement> implements OrderedEnumerable<TElement> {
-  readonly #enumerable: Enumerable<TElement>;
+export abstract class BaseOrderedSequence<TElement> extends BaseSequence<TElement> implements OrderedSequence<TElement> {
+  readonly #sequence: Sequence<TElement>;
   readonly #sorter: Comparer<TElement> | undefined;
   readonly #descending: boolean;
 
-  constructor(enumerable: Enumerable<TElement>, sorter: Comparer<TElement> | undefined, descending: boolean) {
+  constructor(sequence: Sequence<TElement>, sorter: Comparer<TElement> | undefined, descending: boolean) {
     super();
 
-    this.#enumerable = enumerable;
+    this.#sequence = sequence;
     this.#sorter = sorter;
     this.#descending = descending;
   }
 
   override nonEnumeratedCount() {
-    return this.#enumerable.nonEnumeratedCount();
+    return this.#sequence.nonEnumeratedCount();
   }
 
   override maxCount() {
-    return this.#enumerable.maxCount();
+    return this.#sequence.maxCount();
   }
 
   get comparer() {
     return this.#sorter;
   }
 
-  thenSelf(comparer?: Comparer<TElement>): OrderedEnumerable<TElement> {
-    return new ThenOrderEnumerable(this, false, comparer);
+  thenSelf(comparer?: Comparer<TElement>): OrderedSequence<TElement> {
+    return new ThenOrderSequence(this, false, comparer);
   }
 
-  thenBy<TBy>(selector: Converter<TElement, TBy>, comparer?: Comparer<TBy>): OrderedEnumerable<TElement> {
-    return new ThenOrderByEnumerable<TElement, TBy>(this, false, selector, comparer);
+  thenBy<TBy>(selector: Converter<TElement, TBy>, comparer?: Comparer<TBy>): OrderedSequence<TElement> {
+    return new ThenOrderBySequence<TElement, TBy>(this, false, selector, comparer);
   }
 
-  thenSelfDescending(comparer?: Comparer<TElement>): OrderedEnumerable<TElement> {
-    return new ThenOrderEnumerable(this, true, comparer);
+  thenSelfDescending(comparer?: Comparer<TElement>): OrderedSequence<TElement> {
+    return new ThenOrderSequence(this, true, comparer);
   }
 
-  thenByDescending<TBy>(selector: Converter<TElement, TBy>, comparer?: Comparer<TBy>): OrderedEnumerable<TElement> {
-    return new ThenOrderByEnumerable<TElement, TBy>(this, true, selector, comparer);
+  thenByDescending<TBy>(selector: Converter<TElement, TBy>, comparer?: Comparer<TBy>): OrderedSequence<TElement> {
+    return new ThenOrderBySequence<TElement, TBy>(this, true, selector, comparer);
   }
 
   override *iterator() {
     const arr: TElement[] = [];
 
-    for (const obj of this.#enumerable) {
+    for (const obj of this.#sequence) {
       arr.push(obj);
     }
 
@@ -1036,8 +1036,8 @@ export abstract class BaseOrderedEnumerable<TElement> extends BaseEnumerable<TEl
   }
 }
 
-export class EmptyEnumerable<T> extends BaseEnumerable<T> {
-  static readonly INSTANCE = new EmptyEnumerable<any>();
+export class EmptySequence<T> extends BaseSequence<T> {
+  static readonly INSTANCE = new EmptySequence<any>();
 
   override nonEnumeratedCount() {
     return 0;
@@ -1050,7 +1050,7 @@ export class EmptyEnumerable<T> extends BaseEnumerable<T> {
   override *iterator() { }
 }
 
-export class RangeEnumerable extends BaseEnumerable<number> {
+export class RangeSequence extends BaseSequence<number> {
   readonly #min: number;
   readonly #max: number;
   readonly #step: number;
@@ -1082,7 +1082,7 @@ export class RangeEnumerable extends BaseEnumerable<number> {
   }
 }
 
-export class BigIntRangeEnumerable extends BaseEnumerable<bigint> {
+export class BigIntRangeSequence extends BaseSequence<bigint> {
   readonly #min: bigint;
   readonly #max: bigint;
   readonly #step: bigint;
@@ -1114,7 +1114,7 @@ export class BigIntRangeEnumerable extends BaseEnumerable<bigint> {
   }
 }
 
-export class RepeatEnumerable<T> extends BaseEnumerable<T> {
+export class RepeatSequence<T> extends BaseSequence<T> {
   readonly #value: T;
   readonly #count: number;
 
@@ -1142,7 +1142,7 @@ export class RepeatEnumerable<T> extends BaseEnumerable<T> {
   }
 }
 
-export class RepeatForeverEnumerable<T> extends BaseEnumerable<T> {
+export class RepeatForeverSequence<T> extends BaseSequence<T> {
   readonly #value: T;
 
   constructor(value: T) {
@@ -1166,7 +1166,7 @@ export class RepeatForeverEnumerable<T> extends BaseEnumerable<T> {
   }
 }
 
-export class WrappedObject<T> extends BaseEnumerable<T> {
+export class WrappedObject<T> extends BaseSequence<T> {
   readonly #obj: T;
 
   constructor(obj: T) {
@@ -1188,7 +1188,7 @@ export class WrappedObject<T> extends BaseEnumerable<T> {
   }
 }
 
-export class WrappedIterable<T> extends BaseEnumerable<T> {
+export class WrappedIterable<T> extends BaseSequence<T> {
   readonly #iterable: Iterable<T>;
 
   constructor(iterable: Iterable<T>) {
@@ -1202,7 +1202,7 @@ export class WrappedIterable<T> extends BaseEnumerable<T> {
   }
 }
 
-export class WrappedArray<T> extends BaseEnumerable<T> {
+export class WrappedArray<T> extends BaseSequence<T> {
   readonly #array: T[];
 
   constructor(array: T[]) {
@@ -1266,7 +1266,7 @@ export class WrappedArray<T> extends BaseEnumerable<T> {
   }
 }
 
-export class WrappedArrayLike<T> extends BaseEnumerable<T> {
+export class WrappedArrayLike<T> extends BaseSequence<T> {
   readonly #arrayLike: ArrayLike<T>;
 
   constructor(arrayLike: ArrayLike<T>) {
@@ -1302,7 +1302,7 @@ export class WrappedArrayLike<T> extends BaseEnumerable<T> {
   }
 }
 
-export class WrappedSet<T> extends BaseEnumerable<T> {
+export class WrappedSet<T> extends BaseSequence<T> {
   readonly #set: Set<T>;
 
   constructor(set: Set<T>) {
@@ -1332,7 +1332,7 @@ export class WrappedSet<T> extends BaseEnumerable<T> {
   }
 }
 
-export class WrappedMap<K, V> extends BaseEnumerable<[K, V]> {
+export class WrappedMap<K, V> extends BaseSequence<[K, V]> {
   readonly #map: Map<K, V>;
 
   constructor(map: Map<K, V>) {
@@ -1366,7 +1366,7 @@ export class WrappedMap<K, V> extends BaseEnumerable<[K, V]> {
   }
 }
 
-export class GeneratorEnumerable<T> extends BaseEnumerable<T> {
+export class GeneratorSequence<T> extends BaseSequence<T> {
   readonly #generator: () => Iterable<T>;
 
   constructor(generator: () => Iterable<T>) {
@@ -1380,7 +1380,7 @@ export class GeneratorEnumerable<T> extends BaseEnumerable<T> {
   }
 }
 
-export class FunctionEnumerable<T> extends BaseEnumerable<T> {
+export class FunctionSequence<T> extends BaseSequence<T> {
   readonly #f: () => T;
 
   constructor(f: () => T) {
@@ -1404,20 +1404,20 @@ export class FunctionEnumerable<T> extends BaseEnumerable<T> {
   }
 }
 
-export class ConcatEnumerable<T> extends BaseEnumerable<T> {
-  readonly #enumerables: Iterable<Enumerable<T>>;
+export class ConcatSequence<T> extends BaseSequence<T> {
+  readonly #sequences: Iterable<Sequence<T>>;
 
-  constructor(enumerables: Iterable<Enumerable<T>>) {
+  constructor(sequences: Iterable<Sequence<T>>) {
     super();
 
-    this.#enumerables = enumerables;
+    this.#sequences = sequences;
   }
 
   override nonEnumeratedCount() {
     let n = 0;
 
-    for (const enumerable of this.#enumerables) {
-      const m = enumerable.nonEnumeratedCount();
+    for (const sequence of this.#sequences) {
+      const m = sequence.nonEnumeratedCount();
 
       if (m < 0) {
         return super.nonEnumeratedCount();
@@ -1432,8 +1432,8 @@ export class ConcatEnumerable<T> extends BaseEnumerable<T> {
   override count() {
     let n = 0;
 
-    for (const enumerable of this.#enumerables) {
-      n += enumerable.count();
+    for (const sequence of this.#sequences) {
+      n += sequence.count();
     }
 
     return n;
@@ -1442,39 +1442,39 @@ export class ConcatEnumerable<T> extends BaseEnumerable<T> {
   override maxCount() {
     let n = 0;
 
-    for (const enumerable of this.#enumerables) {
-      n += enumerable.maxCount();
+    for (const sequence of this.#sequences) {
+      n += sequence.maxCount();
     }
 
     return n;
   }
 
   override *iterator() {
-    for (const enumerable of this.#enumerables) {
-      yield* enumerable;
+    for (const sequence of this.#sequences) {
+      yield* sequence;
     }
   }
 }
 
-export class DistinctEnumerable<T> extends BaseEnumerable<T> {
-  readonly #enumerable: Enumerable<T>;
+export class DistinctSequence<T> extends BaseSequence<T> {
+  readonly #sequence: Sequence<T>;
   readonly #equater: Equater<T> | undefined;
 
-  constructor(enumerable: Enumerable<T>, equater?: Equater<T>) {
+  constructor(sequence: Sequence<T>, equater?: Equater<T>) {
     super();
 
-    this.#enumerable = enumerable;
+    this.#sequence = sequence;
     this.#equater = equater;
   }
 
   override maxCount() {
-    return this.#enumerable.maxCount();
+    return this.#sequence.maxCount();
   }
 
   override *iterator() {
     const set = createEqualitySet(this.#equater);
 
-    for (const obj of this.#enumerable) {
+    for (const obj of this.#sequence) {
       if (set.add(obj)) {
         yield obj;
       }
@@ -1482,27 +1482,27 @@ export class DistinctEnumerable<T> extends BaseEnumerable<T> {
   }
 }
 
-export class DistinctByEnumerable<T, U> extends BaseEnumerable<T> {
-  readonly #enumerable: Enumerable<T>;
+export class DistinctBySequence<T, U> extends BaseSequence<T> {
+  readonly #sequence: Sequence<T>;
   readonly #selector: Converter<T, U>;
   readonly #equater: Equater<U> | undefined;
 
-  constructor(enumerable: Enumerable<T>, selector: Converter<T, U>, equater?: Equater<U>) {
+  constructor(sequence: Sequence<T>, selector: Converter<T, U>, equater?: Equater<U>) {
     super();
 
-    this.#enumerable = enumerable;
+    this.#sequence = sequence;
     this.#selector = selector;
     this.#equater = equater;
   }
 
   override maxCount() {
-    return this.#enumerable.maxCount();
+    return this.#sequence.maxCount();
   }
 
   override *iterator() {
     const set = createEqualitySet(this.#equater);
 
-    for (const obj of this.#enumerable) {
+    for (const obj of this.#sequence) {
       if (set.add(this.#selector(obj))) {
         yield obj;
       }
@@ -1510,23 +1510,23 @@ export class DistinctByEnumerable<T, U> extends BaseEnumerable<T> {
   }
 }
 
-export class WhereEnumerable<TElement, TFiltered extends TElement> extends BaseEnumerable<TFiltered> {
-  readonly #enumerable: Enumerable<TElement>;
+export class WhereSequence<TElement, TFiltered extends TElement> extends BaseSequence<TFiltered> {
+  readonly #sequence: Sequence<TElement>;
   readonly #predicate: FilterPredicate<TElement, TFiltered>;
 
-  constructor(enumerable: Enumerable<TElement>, predicate: FilterPredicate<TElement, TFiltered>) {
+  constructor(sequence: Sequence<TElement>, predicate: FilterPredicate<TElement, TFiltered>) {
     super();
 
-    this.#enumerable = enumerable;
+    this.#sequence = sequence;
     this.#predicate = predicate;
   }
 
   override maxCount() {
-    return this.#enumerable.maxCount();
+    return this.#sequence.maxCount();
   }
 
   override *iterator() {
-    for (const obj of this.#enumerable) {
+    for (const obj of this.#sequence) {
       if (this.#predicate(obj)) {
         yield obj;
       }
@@ -1534,93 +1534,93 @@ export class WhereEnumerable<TElement, TFiltered extends TElement> extends BaseE
   }
 }
 
-export class SelectManyEnumerable<T, U> extends BaseEnumerable<U> {
-  readonly #enumerable: Enumerable<T>;
+export class SelectManySequence<T, U> extends BaseSequence<U> {
+  readonly #sequence: Sequence<T>;
   readonly #converter: Converter<T, Iterable<U>>;
 
-  constructor(enumerable: Enumerable<T>, converter: Converter<T, Iterable<U>>) {
+  constructor(sequence: Sequence<T>, converter: Converter<T, Iterable<U>>) {
     super();
 
-    this.#enumerable = enumerable;
+    this.#sequence = sequence;
     this.#converter = converter;
   }
 
   override *iterator() {
-    for (const obj of this.#enumerable) {
+    for (const obj of this.#sequence) {
       yield* this.#converter(obj);
     }
   }
 }
 
-export class IndexedEnumerable<T> extends BaseEnumerable<[number, T]> {
-  readonly #enumerable: Enumerable<T>;
+export class IndexedSequence<T> extends BaseSequence<[number, T]> {
+  readonly #sequence: Sequence<T>;
 
-  constructor(enumerable: Enumerable<T>) {
+  constructor(sequence: Sequence<T>) {
     super();
 
-    this.#enumerable = enumerable;
+    this.#sequence = sequence;
   }
 
   override nonEnumeratedCount() {
-    return this.#enumerable.nonEnumeratedCount();
+    return this.#sequence.nonEnumeratedCount();
   }
 
   override maxCount() {
-    return this.#enumerable.maxCount();
+    return this.#sequence.maxCount();
   }
 
   override *iterator() {
     let i = 0;
 
-    for (const obj of this.#enumerable) {
+    for (const obj of this.#sequence) {
       yield [i++, obj] as [number, T];
     }
   }
 }
 
-export class SelectEnumerable<T, U> extends BaseEnumerable<U> {
-  readonly #enumerable: Enumerable<T>;
+export class SelectSequence<T, U> extends BaseSequence<U> {
+  readonly #sequence: Sequence<T>;
   readonly #converter: Converter<T, U>;
 
-  constructor(enumerable: Enumerable<T>, converter: Converter<T, U>) {
+  constructor(sequence: Sequence<T>, converter: Converter<T, U>) {
     super();
 
-    this.#enumerable = enumerable;
+    this.#sequence = sequence;
     this.#converter = converter;
   }
 
   override nonEnumeratedCount() {
-    return this.#enumerable.nonEnumeratedCount();
+    return this.#sequence.nonEnumeratedCount();
   }
 
   override maxCount() {
-    return this.#enumerable.maxCount();
+    return this.#sequence.maxCount();
   }
 
   override *iterator() {
-    for (const obj of this.#enumerable) {
+    for (const obj of this.#sequence) {
       yield this.#converter(obj);
     }
   }
 }
 
-export class SkipWhileEnumerable<T> extends BaseEnumerable<T> {
-  readonly #enumerable: Enumerable<T>;
+export class SkipWhileSequence<T> extends BaseSequence<T> {
+  readonly #sequence: Sequence<T>;
   readonly #predicate: Predicate<T>;
 
-  constructor(enumerable: Enumerable<T>, predicate: Predicate<T>) {
+  constructor(sequence: Sequence<T>, predicate: Predicate<T>) {
     super();
 
-    this.#enumerable = enumerable;
+    this.#sequence = sequence;
     this.#predicate = predicate;
   }
 
   override maxCount() {
-    return this.#enumerable.maxCount();
+    return this.#sequence.maxCount();
   }
 
   override *iterator() {
-    const e = wrapAsIterable(this.#enumerable.iterator());
+    const e = wrapAsIterable(this.#sequence.iterator());
 
     for (const obj of e) {
       if (!this.#predicate(obj)) {
@@ -1633,28 +1633,28 @@ export class SkipWhileEnumerable<T> extends BaseEnumerable<T> {
   }
 }
 
-export class SkipLastEnumerable<T> extends BaseEnumerable<T> {
-  readonly #enumerable: Enumerable<T>;
+export class SkipLastSequence<T> extends BaseSequence<T> {
+  readonly #sequence: Sequence<T>;
   readonly #n: number;
 
-  constructor(enumerable: Enumerable<T>, n: number) {
+  constructor(sequence: Sequence<T>, n: number) {
     super();
 
-    this.#enumerable = enumerable;
+    this.#sequence = sequence;
     this.#n = n;
   }
 
   override nonEnumeratedCount() {
-    const n = this.#enumerable.nonEnumeratedCount();
+    const n = this.#sequence.nonEnumeratedCount();
     return n < 0 ? super.nonEnumeratedCount() : Math.max(0, n - this.#n);
   }
 
   override maxCount() {
-    return Math.max(0, this.#enumerable.maxCount() - this.#n);
+    return Math.max(0, this.#sequence.maxCount() - this.#n);
   }
 
   override *iterator() {
-    const iterator = this.#enumerable.iterator();
+    const iterator = this.#sequence.iterator();
     const buffer = new Array<T>(this.#n); // n > 0
     let i = 0;
 
@@ -1678,28 +1678,28 @@ export class SkipLastEnumerable<T> extends BaseEnumerable<T> {
   }
 }
 
-export class SkipEnumerable<T> extends BaseEnumerable<T> {
-  readonly #enumerable: Enumerable<T>;
+export class SkipSequence<T> extends BaseSequence<T> {
+  readonly #sequence: Sequence<T>;
   readonly #n: number;
 
-  constructor(enumerable: Enumerable<T>, n: number) {
+  constructor(sequence: Sequence<T>, n: number) {
     super();
 
-    this.#enumerable = enumerable;
+    this.#sequence = sequence;
     this.#n = n;
   }
 
   override nonEnumeratedCount() {
-    const n = this.#enumerable.nonEnumeratedCount();
+    const n = this.#sequence.nonEnumeratedCount();
     return n < 0 ? super.nonEnumeratedCount() : Math.max(0, n - this.#n);
   }
 
   override maxCount() {
-    return Math.max(0, this.#enumerable.maxCount() - this.#n);
+    return Math.max(0, this.#sequence.maxCount() - this.#n);
   }
 
   override *iterator() {
-    const iterator = this.#enumerable.iterator();
+    const iterator = this.#sequence.iterator();
     let i = 0;
 
     do {
@@ -1714,23 +1714,23 @@ export class SkipEnumerable<T> extends BaseEnumerable<T> {
   }
 }
 
-export class TakeWhileEnumerable<T> extends BaseEnumerable<T> {
-  readonly #enumerable: Enumerable<T>;
+export class TakeWhileSequence<T> extends BaseSequence<T> {
+  readonly #sequence: Sequence<T>;
   readonly #predicate: Predicate<T>;
 
-  constructor(enumerable: Enumerable<T>, predicate: Predicate<T>) {
+  constructor(sequence: Sequence<T>, predicate: Predicate<T>) {
     super();
 
-    this.#enumerable = enumerable;
+    this.#sequence = sequence;
     this.#predicate = predicate;
   }
 
   override maxCount() {
-    return this.#enumerable.maxCount();
+    return this.#sequence.maxCount();
   }
 
   override *iterator() {
-    for (const obj of this.#enumerable) {
+    for (const obj of this.#sequence) {
       if (!this.#predicate(obj)) {
         return;
       }
@@ -1740,30 +1740,30 @@ export class TakeWhileEnumerable<T> extends BaseEnumerable<T> {
   }
 }
 
-export class TakeLastEnumerable<T> extends BaseEnumerable<T> {
-  readonly #enumerable: Enumerable<T>;
+export class TakeLastSequence<T> extends BaseSequence<T> {
+  readonly #sequence: Sequence<T>;
   readonly #n: number;
 
-  constructor(enumerable: Enumerable<T>, n: number) {
+  constructor(sequence: Sequence<T>, n: number) {
     super();
 
-    this.#enumerable = enumerable;
+    this.#sequence = sequence;
     this.#n = n;
   }
 
   override nonEnumeratedCount() {
-    const n = this.#enumerable.nonEnumeratedCount();
+    const n = this.#sequence.nonEnumeratedCount();
     return n < 0 ? super.nonEnumeratedCount() : Math.min(this.#n, n);
   }
 
   override maxCount() {
-    return Math.min(this.#n, this.#enumerable.maxCount());
+    return Math.min(this.#n, this.#sequence.maxCount());
   }
 
   override *iterator() {
     const queue = createQueue<T>(this.#n);
 
-    for (const obj of this.#enumerable) {
+    for (const obj of this.#sequence) {
       queue.enqueue(obj);
     }
 
@@ -1771,28 +1771,28 @@ export class TakeLastEnumerable<T> extends BaseEnumerable<T> {
   }
 }
 
-export class TakeEnumerable<T> extends BaseEnumerable<T> {
-  readonly #enumerable: Enumerable<T>;
+export class TakeSequence<T> extends BaseSequence<T> {
+  readonly #sequence: Sequence<T>;
   readonly #n: number;
 
-  constructor(enumerable: Enumerable<T>, n: number) {
+  constructor(sequence: Sequence<T>, n: number) {
     super();
 
-    this.#enumerable = enumerable;
+    this.#sequence = sequence;
     this.#n = n;
   }
 
   override nonEnumeratedCount() {
-    const n = this.#enumerable.nonEnumeratedCount();
+    const n = this.#sequence.nonEnumeratedCount();
     return n < 0 ? super.nonEnumeratedCount() : Math.min(this.#n, n);
   }
 
   override maxCount() {
-    return Math.min(this.#n, this.#enumerable.maxCount());
+    return Math.min(this.#n, this.#sequence.maxCount());
   }
 
   override *iterator() {
-    const iterator = this.#enumerable.iterator();
+    const iterator = this.#sequence.iterator();
     let i = this.#n;
 
     while (i > 0) {
@@ -1808,15 +1808,15 @@ export class TakeEnumerable<T> extends BaseEnumerable<T> {
   }
 }
 
-export class OrderEnumerable<T> extends BaseOrderedEnumerable<T> {
-  constructor(enumerable: Enumerable<T>, descending: boolean, sorter?: Comparer<T>) {
-    super(enumerable, sorter, descending);
+export class OrderSequence<T> extends BaseOrderedSequence<T> {
+  constructor(sequence: Sequence<T>, descending: boolean, sorter?: Comparer<T>) {
+    super(sequence, sorter, descending);
   }
 }
 
-export class OrderByEnumerable<T, U> extends BaseOrderedEnumerable<T> {
-  constructor(enumerable: Enumerable<T>, descending: boolean, selector: Converter<T, U>, sorter?: Comparer<U>) {
-    super(enumerable, OrderByEnumerable.#createSorter(selector, sorter), descending);
+export class OrderBySequence<T, U> extends BaseOrderedSequence<T> {
+  constructor(sequence: Sequence<T>, descending: boolean, selector: Converter<T, U>, sorter?: Comparer<U>) {
+    super(sequence, OrderBySequence.#createSorter(selector, sorter), descending);
   }
 
   static #createSorter<T, U>(selector: Converter<T, U>, sorter?: Comparer<U>) {
@@ -1825,15 +1825,15 @@ export class OrderByEnumerable<T, U> extends BaseOrderedEnumerable<T> {
   }
 }
 
-export class ThenOrderEnumerable<T> extends BaseOrderedEnumerable<T> {
-  constructor(enumerable: OrderedEnumerable<T>, descending: boolean, sorter?: Comparer<T>) {
-    super(enumerable, combineComparers(enumerable.comparer ?? defaultArrayComparer, sorter ?? defaultArrayComparer), descending);
+export class ThenOrderSequence<T> extends BaseOrderedSequence<T> {
+  constructor(sequence: OrderedSequence<T>, descending: boolean, sorter?: Comparer<T>) {
+    super(sequence, combineComparers(sequence.comparer ?? defaultArrayComparer, sorter ?? defaultArrayComparer), descending);
   }
 }
 
-export class ThenOrderByEnumerable<T, U> extends BaseOrderedEnumerable<T> {
-  constructor(enumerable: OrderedEnumerable<T>, descending: boolean, selector: Converter<T, U>, sorter?: Comparer<U>) {
-    super(enumerable, ThenOrderByEnumerable.#createCombinedSorter(enumerable.comparer, selector, sorter), descending);
+export class ThenOrderBySequence<T, U> extends BaseOrderedSequence<T> {
+  constructor(sequence: OrderedSequence<T>, descending: boolean, selector: Converter<T, U>, sorter?: Comparer<U>) {
+    super(sequence, ThenOrderBySequence.#createCombinedSorter(sequence.comparer, selector, sorter), descending);
   }
 
   static #createCombinedSorter<T, U>(baseSorter: Comparer<T> | undefined, selector: Converter<T, U>, sorter?: Comparer<U>) {
@@ -1843,63 +1843,63 @@ export class ThenOrderByEnumerable<T, U> extends BaseOrderedEnumerable<T> {
   }
 }
 
-export class AppendEnumerable<T> extends BaseEnumerable<T> {
-  readonly #enumerable: Enumerable<T>;
+export class AppendSequence<T> extends BaseSequence<T> {
+  readonly #sequence: Sequence<T>;
   readonly #obj: T;
 
-  constructor(enumerable: Enumerable<T>, obj: T) {
+  constructor(sequence: Sequence<T>, obj: T) {
     super();
 
-    this.#enumerable = enumerable;
+    this.#sequence = sequence;
     this.#obj = obj;
   }
 
   override nonEnumeratedCount() {
-    const n = this.#enumerable.nonEnumeratedCount();
+    const n = this.#sequence.nonEnumeratedCount();
     return n < 0 ? super.nonEnumeratedCount() : n + 1;
   }
 
   override maxCount() {
-    return this.#enumerable.maxCount() + 1;
+    return this.#sequence.maxCount() + 1;
   }
 
   override *iterator() {
-    yield* this.#enumerable;
+    yield* this.#sequence;
     yield this.#obj;
   }
 }
 
-export class PrependEnumerable<T> extends BaseEnumerable<T> {
-  readonly #enumerable: Enumerable<T>;
+export class PrependSequence<T> extends BaseSequence<T> {
+  readonly #sequence: Sequence<T>;
   readonly #obj: T;
 
-  constructor(enumerable: Enumerable<T>, obj: T) {
+  constructor(sequence: Sequence<T>, obj: T) {
     super();
 
-    this.#enumerable = enumerable;
+    this.#sequence = sequence;
     this.#obj = obj;
   }
 
   override nonEnumeratedCount() {
-    const n = this.#enumerable.nonEnumeratedCount();
+    const n = this.#sequence.nonEnumeratedCount();
     return n < 0 ? super.nonEnumeratedCount() : n + 1;
   }
 
   override maxCount() {
-    return this.#enumerable.maxCount() + 1;
+    return this.#sequence.maxCount() + 1;
   }
 
   override *iterator() {
     yield this.#obj;
-    yield* this.#enumerable;
+    yield* this.#sequence;
   }
 }
 
-export class PeekEnumerable<T> extends DelegatedEnumerable<T> {
+export class PeekSequence<T> extends DelegatedSequence<T> {
   readonly #action: Action<T>;
 
-  constructor(enumerable: Enumerable<T>, action: Action<T>) {
-    super(enumerable);
+  constructor(sequence: Sequence<T>, action: Action<T>) {
+    super(sequence);
 
     this.#action = action;
   }
@@ -1912,11 +1912,11 @@ export class PeekEnumerable<T> extends DelegatedEnumerable<T> {
   }
 }
 
-export class ZippedEnumerable<T, U> extends BaseEnumerable<[T, U]> {
-  readonly #first: Enumerable<T>;
-  readonly #second: Enumerable<U>;
+export class ZippedSequence<T, U> extends BaseSequence<[T, U]> {
+  readonly #first: Sequence<T>;
+  readonly #second: Sequence<U>;
 
-  constructor(first: Enumerable<T>, second: Enumerable<U>) {
+  constructor(first: Sequence<T>, second: Sequence<U>) {
     super();
 
     this.#first = first;
@@ -1951,12 +1951,12 @@ export class ZippedEnumerable<T, U> extends BaseEnumerable<[T, U]> {
   }
 }
 
-export class UnionEnumerable<T> extends BaseEnumerable<T> {
-  readonly #first: Enumerable<T>;
-  readonly #second: Enumerable<T>;
+export class UnionSequence<T> extends BaseSequence<T> {
+  readonly #first: Sequence<T>;
+  readonly #second: Sequence<T>;
   readonly #equater: Equater<T> | undefined;
 
-  constructor(first: Enumerable<T>, second: Enumerable<T>, equater?: Equater<T>) {
+  constructor(first: Sequence<T>, second: Sequence<T>, equater?: Equater<T>) {
     super();
 
     this.#first = first;
@@ -1984,13 +1984,13 @@ export class UnionEnumerable<T> extends BaseEnumerable<T> {
   }
 }
 
-export class UnionByEnumerable<T, U> extends BaseEnumerable<T> {
-  readonly #first: Enumerable<T>;
-  readonly #second: Enumerable<T>;
+export class UnionBySequence<T, U> extends BaseSequence<T> {
+  readonly #first: Sequence<T>;
+  readonly #second: Sequence<T>;
   readonly #selector: Converter<T, U>;
   readonly #equater: Equater<U> | undefined;
 
-  constructor(first: Enumerable<T>, second: Enumerable<T>, selector: Converter<T, U>, equater?: Equater<U>) {
+  constructor(first: Sequence<T>, second: Sequence<T>, selector: Converter<T, U>, equater?: Equater<U>) {
     super();
 
     this.#first = first;
@@ -2019,12 +2019,12 @@ export class UnionByEnumerable<T, U> extends BaseEnumerable<T> {
   }
 }
 
-export class ExceptEnumerable<T> extends BaseEnumerable<T> {
-  readonly #first: Enumerable<T>;
-  readonly #second: Enumerable<T>;
+export class ExceptSequence<T> extends BaseSequence<T> {
+  readonly #first: Sequence<T>;
+  readonly #second: Sequence<T>;
   readonly #equater: Equater<T> | undefined;
 
-  constructor(first: Enumerable<T>, second: Enumerable<T>, equater?: Equater<T>) {
+  constructor(first: Sequence<T>, second: Sequence<T>, equater?: Equater<T>) {
     super();
 
     this.#first = first;
@@ -2051,13 +2051,13 @@ export class ExceptEnumerable<T> extends BaseEnumerable<T> {
   }
 }
 
-export class ExceptByEnumerable<T, U> extends BaseEnumerable<T> {
-  readonly #first: Enumerable<T>;
-  readonly #second: Enumerable<T>;
+export class ExceptBySequence<T, U> extends BaseSequence<T> {
+  readonly #first: Sequence<T>;
+  readonly #second: Sequence<T>;
   readonly #selector: Converter<T, U>;
   readonly #equater: Equater<U> | undefined;
 
-  constructor(first: Enumerable<T>, second: Enumerable<T>, selector: Converter<T, U>, equater?: Equater<U>) {
+  constructor(first: Sequence<T>, second: Sequence<T>, selector: Converter<T, U>, equater?: Equater<U>) {
     super();
 
     this.#first = first;
@@ -2085,12 +2085,12 @@ export class ExceptByEnumerable<T, U> extends BaseEnumerable<T> {
   }
 }
 
-export class IntersectEnumerable<T> extends BaseEnumerable<T> {
-  readonly #first: Enumerable<T>;
-  readonly #second: Enumerable<T>;
+export class IntersectSequence<T> extends BaseSequence<T> {
+  readonly #first: Sequence<T>;
+  readonly #second: Sequence<T>;
   readonly #equater: Equater<T> | undefined;
 
-  constructor(first: Enumerable<T>, second: Enumerable<T>, equater?: Equater<T>) {
+  constructor(first: Sequence<T>, second: Sequence<T>, equater?: Equater<T>) {
     super();
 
     this.#first = first;
@@ -2117,13 +2117,13 @@ export class IntersectEnumerable<T> extends BaseEnumerable<T> {
   }
 }
 
-export class IntersectByEnumerable<T, U> extends BaseEnumerable<T> {
-  readonly #first: Enumerable<T>;
-  readonly #second: Enumerable<T>;
+export class IntersectBySequence<T, U> extends BaseSequence<T> {
+  readonly #first: Sequence<T>;
+  readonly #second: Sequence<T>;
   readonly #selector: Converter<T, U>;
   readonly #equater: Equater<U> | undefined;
 
-  constructor(first: Enumerable<T>, second: Enumerable<T>, selector: Converter<T, U>, equater?: Equater<U>) {
+  constructor(first: Sequence<T>, second: Sequence<T>, selector: Converter<T, U>, equater?: Equater<U>) {
     super();
 
     this.#first = first;
@@ -2151,27 +2151,27 @@ export class IntersectByEnumerable<T, U> extends BaseEnumerable<T> {
   }
 }
 
-export class ReversedEnumerable<T> extends BaseEnumerable<T> {
-  readonly #enumerable: Enumerable<T>;
+export class ReversedSequence<T> extends BaseSequence<T> {
+  readonly #sequence: Sequence<T>;
 
-  constructor(enumerable: Enumerable<T>) {
+  constructor(sequence: Sequence<T>) {
     super();
 
-    this.#enumerable = enumerable;
+    this.#sequence = sequence;
   }
 
   override nonEnumeratedCount() {
-    return this.#enumerable.nonEnumeratedCount();
+    return this.#sequence.nonEnumeratedCount();
   }
 
   override maxCount() {
-    return this.#enumerable.maxCount();
+    return this.#sequence.maxCount();
   }
 
   override *iterator() {
     const buffer: T[] = [];
 
-    for (const obj of this.#enumerable) {
+    for (const obj of this.#sequence) {
       buffer.push(obj);
     }
 
@@ -2181,29 +2181,29 @@ export class ReversedEnumerable<T> extends BaseEnumerable<T> {
   }
 }
 
-export class GroupByEnumerable<TElement, TKey, TResult> extends BaseEnumerable<GroupedEnumerable<TKey, TResult>> {
-  readonly #enumerable: Enumerable<TElement>;
+export class GroupBySequence<TElement, TKey, TResult> extends BaseSequence<GroupedSequence<TKey, TResult>> {
+  readonly #sequence: Sequence<TElement>;
   readonly #keySelector: Converter<TElement, TKey>;
   readonly #elementSelector: Converter<TElement, TResult>;
   readonly #keyComparer: Equater<TKey> | undefined;
 
-  constructor(enumerable: Enumerable<TElement>, keySelector: Converter<TElement, TKey>, elementSelector?: Converter<TElement, TResult>, keyComparer?: Equater<TKey>) {
+  constructor(sequence: Sequence<TElement>, keySelector: Converter<TElement, TKey>, elementSelector?: Converter<TElement, TResult>, keyComparer?: Equater<TKey>) {
     super();
 
-    this.#enumerable = enumerable;
+    this.#sequence = sequence;
     this.#keySelector = keySelector;
     this.#elementSelector = elementSelector ?? identity as Converter<TElement, TResult>;
     this.#keyComparer = keyComparer;
   }
 
   override maxCount() {
-    return this.#enumerable.maxCount();
+    return this.#sequence.maxCount();
   }
 
   override *iterator() {
     const groupings = createEqualityMap<TKey, TResult[]>(this.#keyComparer);
 
-    for (const obj of this.#enumerable) {
+    for (const obj of this.#sequence) {
       const key = this.#keySelector(obj);
       let grouping = groupings.get(key);
 
@@ -2215,35 +2215,35 @@ export class GroupByEnumerable<TElement, TKey, TResult> extends BaseEnumerable<G
     }
 
     for (const entry of groupings) {
-      yield new GroupedEnumerableImpl(entry[0], array(entry[1]));
+      yield new GroupedSequenceImpl(entry[0], array(entry[1]));
     }
   }
 }
 
-export class ChunkedEnumerable<T> extends BaseEnumerable<T[]> {
-  readonly #enumerable: Enumerable<T>;
+export class ChunkedSequence<T> extends BaseSequence<T[]> {
+  readonly #sequence: Sequence<T>;
   readonly #size: number;
 
-  constructor(enumerable: Enumerable<T>, size: number) {
+  constructor(sequence: Sequence<T>, size: number) {
     super();
 
-    this.#enumerable = enumerable;
+    this.#sequence = sequence;
     this.#size = size;
   }
 
   override nonEnumeratedCount() {
-    const n = this.#enumerable.nonEnumeratedCount();
+    const n = this.#sequence.nonEnumeratedCount();
     return n < 0 ? super.nonEnumeratedCount() : Math.ceil(n / this.#size);
   }
 
   override maxCount() {
-    return Math.ceil(this.#enumerable.maxCount() / this.#size);
+    return Math.ceil(this.#sequence.maxCount() / this.#size);
   }
 
   override *iterator() {
     let chunk: T[] = [];
 
-    for (const obj of this.#enumerable) {
+    for (const obj of this.#sequence) {
       chunk.push(obj);
 
       if (chunk.length === this.#size) {
@@ -2258,22 +2258,22 @@ export class ChunkedEnumerable<T> extends BaseEnumerable<T[]> {
   }
 }
 
-export class JoinEnumerable<TOuter, TInner, TKey, TResult> extends BaseEnumerable<TResult> {
-  readonly #first: Enumerable<TOuter>;
-  readonly #second: Enumerable<TInner>;
+export class JoinSequence<TOuter, TInner, TKey, TResult> extends BaseSequence<TResult> {
+  readonly #first: Sequence<TOuter>;
+  readonly #second: Sequence<TInner>;
   readonly #firstKeySelector: Converter<TOuter, TKey>;
   readonly #secondKeySelector: Converter<TInner, TKey>;
   readonly #resultSelector: BiConverter<TOuter, TInner, TResult>;
   readonly #keyComparer: Equater<TKey>;
 
-  constructor(first: Enumerable<TOuter>, second: Enumerable<TInner>, firstKeySelector: Converter<TOuter, TKey>, secondKeySelector: Converter<TInner, TKey>, resultSelector?: BiConverter<TOuter, TInner, TResult>, keyComparer?: Equater<TKey>) {
+  constructor(first: Sequence<TOuter>, second: Sequence<TInner>, firstKeySelector: Converter<TOuter, TKey>, secondKeySelector: Converter<TInner, TKey>, resultSelector?: BiConverter<TOuter, TInner, TResult>, keyComparer?: Equater<TKey>) {
     super();
 
     this.#first = first;
     this.#second = second;
     this.#firstKeySelector = firstKeySelector;
     this.#secondKeySelector = secondKeySelector;
-    this.#resultSelector = resultSelector ?? JoinEnumerable.#defaultResultSelector as BiConverter<TOuter, TInner, TResult>;
+    this.#resultSelector = resultSelector ?? JoinSequence.#defaultResultSelector as BiConverter<TOuter, TInner, TResult>;
     this.#keyComparer = keyComparer ?? strictEquals;
   }
 
@@ -2300,27 +2300,27 @@ export class JoinEnumerable<TOuter, TInner, TKey, TResult> extends BaseEnumerabl
   }
 }
 
-export class GroupJoinEnumerable<TOuter, TInner, TKey, TResult> extends BaseEnumerable<TResult> {
-  readonly #first: Enumerable<TOuter>;
-  readonly #second: Enumerable<TInner>;
+export class GroupJoinSequence<TOuter, TInner, TKey, TResult> extends BaseSequence<TResult> {
+  readonly #first: Sequence<TOuter>;
+  readonly #second: Sequence<TInner>;
   readonly #firstKeySelector: Converter<TOuter, TKey>;
   readonly #secondKeySelector: Converter<TInner, TKey>;
-  readonly #resultSelector: BiConverter<TOuter, Enumerable<TInner>, TResult>;
+  readonly #resultSelector: BiConverter<TOuter, Sequence<TInner>, TResult>;
   readonly #keyComparer: Equater<TKey>;
 
-  constructor(first: Enumerable<TOuter>, second: Enumerable<TInner>, firstKeySelector: Converter<TOuter, TKey>, secondKeySelector: Converter<TInner, TKey>, resultSelector?: BiConverter<TOuter, Enumerable<TInner>, TResult>, keyComparer?: Equater<TKey>) {
+  constructor(first: Sequence<TOuter>, second: Sequence<TInner>, firstKeySelector: Converter<TOuter, TKey>, secondKeySelector: Converter<TInner, TKey>, resultSelector?: BiConverter<TOuter, Sequence<TInner>, TResult>, keyComparer?: Equater<TKey>) {
     super();
 
     this.#first = first;
     this.#second = second;
     this.#firstKeySelector = firstKeySelector;
     this.#secondKeySelector = secondKeySelector;
-    this.#resultSelector = resultSelector ?? GroupJoinEnumerable.#defaultResultSelector as BiConverter<TOuter, Enumerable<TInner>, TResult>;
+    this.#resultSelector = resultSelector ?? GroupJoinSequence.#defaultResultSelector as BiConverter<TOuter, Sequence<TInner>, TResult>;
     this.#keyComparer = keyComparer ?? strictEquals;
   }
 
-  static #defaultResultSelector<TOuter, TInner>(first: TOuter, second: Enumerable<TInner>) {
-    return new GroupedEnumerableImpl(first, second);
+  static #defaultResultSelector<TOuter, TInner>(first: TOuter, second: Sequence<TInner>) {
+    return new GroupedSequenceImpl(first, second);
   }
 
   override nonEnumeratedCount() {
@@ -2349,29 +2349,29 @@ export class GroupJoinEnumerable<TOuter, TInner, TKey, TResult> extends BaseEnum
   }
 }
 
-export class RemoveEnumerable<T> extends BaseEnumerable<T> {
-  readonly #enumerable: Enumerable<T>;
+export class RemoveSequence<T> extends BaseSequence<T> {
+  readonly #sequence: Sequence<T>;
   readonly #obj: T;
   readonly #all: boolean;
   readonly #equater: Equater<T>;
 
-  constructor(enumerable: Enumerable<T>, obj: T, all?: boolean, equater?: Equater<T>) {
+  constructor(sequence: Sequence<T>, obj: T, all?: boolean, equater?: Equater<T>) {
     super();
 
-    this.#enumerable = enumerable;
+    this.#sequence = sequence;
     this.#obj = obj;
     this.#all = all ?? false;
     this.#equater = equater ?? strictEquals;
   }
 
   override maxCount() {
-    return this.#enumerable.maxCount();
+    return this.#sequence.maxCount();
   }
 
   override *iterator() {
     let gotOne = false;
 
-    for (const obj of this.#enumerable) {
+    for (const obj of this.#sequence) {
       if (this.#equater(this.#obj, obj)) {
         if (this.#all) {
           continue;
@@ -2388,16 +2388,16 @@ export class RemoveEnumerable<T> extends BaseEnumerable<T> {
   }
 }
 
-export class CacheEnumerable<T> extends DelegatedEnumerable<T> {
+export class CacheSequence<T> extends DelegatedSequence<T> {
   #cached = false;
 
-  constructor(enumerable: Enumerable<T>) {
-    super(enumerable);
+  constructor(sequence: Sequence<T>) {
+    super(sequence);
   }
 
   override iterator() {
     if (!this.#cached) {
-      this.enumerable = array(this.enumerable.toArray());
+      this.sequence = array(this.sequence.toArray());
       this.#cached = true;
     }
 
diff --git a/src/sync/index.ts b/src/sync/index.ts
index 7dcb325..8bb3658 100644
--- a/src/sync/index.ts
+++ b/src/sync/index.ts
@@ -1,10 +1,10 @@
 import { mathRandom } from "../random/index.js";
 import { RandomGenerator } from "../random/types.js";
-import { BigIntRangeEnumerable, ConcatEnumerable, EmptyEnumerable, EnumerableMarker, FunctionEnumerable, GeneratorEnumerable, RangeEnumerable, RepeatEnumerable, RepeatForeverEnumerable, WrappedArray, WrappedArrayLike, WrappedIterable, WrappedMap, WrappedObject, WrappedSet } from "./impl.js";
-import { Enumerable } from "./types.js";
+import { BigIntRangeSequence, ConcatSequence, EmptySequence, SequenceMarker, FunctionSequence, GeneratorSequence, RangeSequence, RepeatSequence, RepeatForeverSequence, WrappedArray, WrappedArrayLike, WrappedIterable, WrappedMap, WrappedObject, WrappedSet } from "./impl.js";
+import { Sequence } from "./types.js";
 
-export function wrap<T>(iterable: Iterable<T>): Enumerable<T> {
-  if (isEnumerable<T>(iterable)) {
+export function wrap<T>(iterable: Iterable<T>): Sequence<T> {
+  if (isSequence<T>(iterable)) {
     return iterable;
   }
 
@@ -17,41 +17,41 @@ export function wrap<T>(iterable: Iterable<T>): Enumerable<T> {
   }
 
   if (iterable instanceof Map) {
-    return map(iterable) as unknown as Enumerable<T>;
+    return map(iterable) as unknown as Sequence<T>;
   }
 
   return sequence(iterable);
 }
 
-export function sequence<T>(iterable: Iterable<T>): Enumerable<T> {
+export function sequence<T>(iterable: Iterable<T>): Sequence<T> {
   return new WrappedIterable(iterable);
 }
 
-export function empty<T>(): Enumerable<T> {
-  return EmptyEnumerable.INSTANCE;
+export function empty<T>(): Sequence<T> {
+  return EmptySequence.INSTANCE;
 }
 
-export function single<T>(obj: T): Enumerable<T> {
+export function single<T>(obj: T): Sequence<T> {
   return new WrappedObject(obj);
 }
 
-export function array<T>(array: T[]): Enumerable<T> {
+export function array<T>(array: T[]): Sequence<T> {
   return new WrappedArray(array);
 }
 
-export function arrayLike<T>(arrayLike: ArrayLike<T>): Enumerable<T> {
+export function arrayLike<T>(arrayLike: ArrayLike<T>): Sequence<T> {
   return new WrappedArrayLike(arrayLike);
 }
 
-export function set<T>(set: Set<T>): Enumerable<T> {
+export function set<T>(set: Set<T>): Sequence<T> {
   return new WrappedSet(set);
 }
 
-export function map<K, V>(map: Map<K, V>): Enumerable<[K, V]> {
+export function map<K, V>(map: Map<K, V>): Sequence<[K, V]> {
   return new WrappedMap(map);
 }
 
-export function of<T>(...elements: T[]): Enumerable<T> {
+export function of<T>(...elements: T[]): Sequence<T> {
   switch (elements.length) {
     case 0:
       return empty();
@@ -62,30 +62,30 @@ export function of<T>(...elements: T[]): Enumerable<T> {
   }
 }
 
-export function ofPropertyKeys<T extends PropertyKey>(...elements: T[]): Enumerable<T> {
+export function ofPropertyKeys<T extends PropertyKey>(...elements: T[]): Sequence<T> {
   return of(...elements);
 }
 
-export function entries<T>(o: Record<string, T> | ArrayLike<T>): Enumerable<[string, T]> {
+export function entries<T>(o: Record<string, T> | ArrayLike<T>): Sequence<[string, T]> {
   return array(Object.entries(o));
 }
 
-export function keys(o: object): Enumerable<string> {
+export function keys(o: object): Sequence<string> {
   return array(Object.keys(o));
 }
 
-export function func<T>(f: () => T): Enumerable<T> {
-  return new FunctionEnumerable(f);
+export function func<T>(f: () => T): Sequence<T> {
+  return new FunctionSequence(f);
 }
 
-export function generator<T>(generator: () => Iterable<T>): Enumerable<T> {
-  return new GeneratorEnumerable(generator);
+export function generator<T>(generator: () => Iterable<T>): Sequence<T> {
+  return new GeneratorSequence(generator);
 }
 
-export function range(max: number): Enumerable<number>
-export function range(min: number, max: number): Enumerable<number>
-export function range(min: number, max: number, step: number): Enumerable<number>
-export function range(a: number, b?: number, c?: number): Enumerable<number> {
+export function range(max: number): Sequence<number>
+export function range(min: number, max: number): Sequence<number>
+export function range(min: number, max: number, step: number): Sequence<number>
+export function range(a: number, b?: number, c?: number): Sequence<number> {
   if (b === undefined) {
     b = a;
     a = 0;
@@ -95,13 +95,13 @@ export function range(a: number, b?: number, c?: number): Enumerable<number> {
     c = 1;
   }
 
-  return new RangeEnumerable(a, b, c);
+  return new RangeSequence(a, b, c);
 }
 
-export function bigintRange(max: bigint): Enumerable<bigint>
-export function bigintRange(min: bigint, max: bigint): Enumerable<bigint>
-export function bigintRange(min: bigint, max: bigint, step: bigint): Enumerable<bigint>
-export function bigintRange(a: bigint, b?: bigint, c?: bigint): Enumerable<bigint> {
+export function bigintRange(max: bigint): Sequence<bigint>
+export function bigintRange(min: bigint, max: bigint): Sequence<bigint>
+export function bigintRange(min: bigint, max: bigint, step: bigint): Sequence<bigint>
+export function bigintRange(a: bigint, b?: bigint, c?: bigint): Sequence<bigint> {
   if (b === undefined) {
     b = a;
     a = 0n;
@@ -111,12 +111,12 @@ export function bigintRange(a: bigint, b?: bigint, c?: bigint): Enumerable<bigin
     c = 1n;
   }
 
-  return new BigIntRangeEnumerable(a, b, c);
+  return new BigIntRangeSequence(a, b, c);
 }
 
-export function repeat<T>(value: T, count?: number): Enumerable<T> {
+export function repeat<T>(value: T, count?: number): Sequence<T> {
   if (count == undefined) {
-    return new RepeatForeverEnumerable(value);
+    return new RepeatForeverSequence(value);
   }
 
   if (count < 0) {
@@ -131,17 +131,17 @@ export function repeat<T>(value: T, count?: number): Enumerable<T> {
     return new WrappedObject(value);
   }
 
-  return new RepeatEnumerable(value, count);
+  return new RepeatSequence(value, count);
 }
 
-export function randomSequence(random?: RandomGenerator): Enumerable<number> {
-  return new FunctionEnumerable(random ?? mathRandom);
+export function randomSequence(random?: RandomGenerator): Sequence<number> {
+  return new FunctionSequence(random ?? mathRandom);
 }
 
-export function concat<T>(...enumerables: Enumerable<T>[]): Enumerable<T> {
-  return new ConcatEnumerable(enumerables);
+export function concat<T>(...sequences: Sequence<T>[]): Sequence<T> {
+  return new ConcatSequence(sequences);
 }
 
-export function isEnumerable<T = any>(obj: any): obj is Enumerable<T> {
-  return obj instanceof EnumerableMarker;
+export function isSequence<T = any>(obj: any): obj is Sequence<T> {
+  return obj instanceof SequenceMarker;
 }
diff --git a/src/sync/types.ts b/src/sync/types.ts
index 8c51162..d09dcac 100644
--- a/src/sync/types.ts
+++ b/src/sync/types.ts
@@ -2,42 +2,42 @@ import { Collector } from "../collector/types.js";
 import { RandomOptions } from "../random/types.js";
 import { Predicate, Converter, FilterPredicate, Equater, BiConverter, Accumulator, Comparer, Action } from "../types.js";
 
-export interface Enumerable<TElement> extends Iterable<TElement> {
+export interface Sequence<TElement> extends Iterable<TElement> {
   iterator(): Iterator<TElement>;
 
-  apply<TResult>(pipeline: (enumerable: Enumerable<TElement>) => TResult): TResult;
+  apply<TResult>(pipeline: (sequence: Sequence<TElement>) => TResult): TResult;
 
   count(predicate?: Predicate<TElement>): number;
   nonEnumeratedCount(): number;
   fastCount(): number;
   maxCount(): number;
 
-  select<TResult>(selector: Converter<TElement, TResult>): Enumerable<TResult>;
-  selectMany<TResult>(selector: Converter<TElement, Iterable<TResult>>): Enumerable<TResult>;
+  select<TResult>(selector: Converter<TElement, TResult>): Sequence<TResult>;
+  selectMany<TResult>(selector: Converter<TElement, Iterable<TResult>>): Sequence<TResult>;
 
-  where<TFiltered extends TElement>(predicate: FilterPredicate<TElement, TFiltered>): Enumerable<TFiltered>;
-  where(predicate: Predicate<TElement>): Enumerable<TElement>;
+  where<TFiltered extends TElement>(predicate: FilterPredicate<TElement, TFiltered>): Sequence<TFiltered>;
+  where(predicate: Predicate<TElement>): Sequence<TElement>;
 
-  groupBy<TKey>(keySelector: Converter<TElement, TKey>, elementSelector?: undefined, keyComparer?: Equater<TKey>): Enumerable<GroupedEnumerable<TKey, TElement>>;
-  groupBy<TKey, TResult>(keySelector: Converter<TElement, TKey>, elementSelector: Converter<TElement, TResult>, keyComparer?: Equater<TKey>): Enumerable<GroupedEnumerable<TKey, TResult>>;
+  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>): Enumerable<[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>): Enumerable<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>;
 
-  groupJoin<TOther, TKey>(iterable: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: undefined, keyComparer?: Equater<TKey>): Enumerable<GroupedEnumerable<TElement, TOther>>;
-  groupJoin<TOther, TKey, TResult>(iterable: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector: BiConverter<TElement, Enumerable<TOther>, TResult>, keyComparer?: Equater<TKey>): Enumerable<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>;
 
   contains(obj: TElement, equater?: Equater<TElement>): boolean;
 
   sequenceEquals(iterable: Iterable<TElement>, equater?: Equater<TElement>): boolean;
 
-  append(obj: TElement): Enumerable<TElement>;
+  append(obj: TElement): Sequence<TElement>;
 
-  prepend(obj: TElement): Enumerable<TElement>;
+  prepend(obj: TElement): Sequence<TElement>;
 
-  remove(obj: TElement, all?: boolean, equater?: Equater<TElement>): Enumerable<TElement>;
+  remove(obj: TElement, all?: boolean, equater?: Equater<TElement>): Sequence<TElement>;
 
-  concat(...iterables: Iterable<TElement>[]): Enumerable<TElement>;
+  concat(...iterables: Iterable<TElement>[]): Sequence<TElement>;
 
   first(predicate?: Predicate<TElement>): TElement;
   firstOrDefault(predicate?: Predicate<TElement>, def?: TElement): TElement | undefined;
@@ -61,23 +61,23 @@ export interface Enumerable<TElement> extends Iterable<TElement> {
   max(comparer?: Comparer<TElement>): TElement;
   maxBy<TBy>(selector: Converter<TElement, TBy>, comparer?: Comparer<TBy>): TElement;
 
-  order(comparer?: Comparer<TElement>): OrderedEnumerable<TElement>;
-  orderBy<TBy>(selector: Converter<TElement, TBy>, comparer?: Comparer<TBy>): OrderedEnumerable<TElement>;
+  order(comparer?: Comparer<TElement>): OrderedSequence<TElement>;
+  orderBy<TBy>(selector: Converter<TElement, TBy>, comparer?: Comparer<TBy>): OrderedSequence<TElement>;
 
-  orderDescending(comparer?: Comparer<TElement>): OrderedEnumerable<TElement>;
-  orderByDescending<TBy>(selector: Converter<TElement, TBy>, comparer?: Comparer<TBy>): OrderedEnumerable<TElement>;
+  orderDescending(comparer?: Comparer<TElement>): OrderedSequence<TElement>;
+  orderByDescending<TBy>(selector: Converter<TElement, TBy>, comparer?: Comparer<TBy>): OrderedSequence<TElement>;
 
-  distinct(equater?: Equater<TElement>): Enumerable<TElement>;
-  distinctBy<TBy>(selector: Converter<TElement, TBy>, equater?: Equater<TBy>): Enumerable<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>): Enumerable<TElement>;
-  unionBy<TBy>(iterable: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: Equater<TBy>): Enumerable<TElement>;
+  union(iterable: Iterable<TElement>, equater?: Equater<TElement>): Sequence<TElement>;
+  unionBy<TBy>(iterable: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: Equater<TBy>): Sequence<TElement>;
 
-  except(iterable: Iterable<TElement>, equater?: Equater<TElement>): Enumerable<TElement>;
-  exceptBy<TBy>(iterable: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: Equater<TBy>): Enumerable<TElement>;
+  except(iterable: Iterable<TElement>, equater?: Equater<TElement>): Sequence<TElement>;
+  exceptBy<TBy>(iterable: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: Equater<TBy>): Sequence<TElement>;
 
-  intersect(iterable: Iterable<TElement>, equater?: Equater<TElement>): Enumerable<TElement>;
-  intersectBy<TBy>(iterable: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: Equater<TBy>): Enumerable<TElement>;
+  intersect(iterable: Iterable<TElement>, equater?: Equater<TElement>): Sequence<TElement>;
+  intersectBy<TBy>(iterable: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: Equater<TBy>): Sequence<TElement>;
 
   all(predicate: Predicate<TElement>): boolean;
   any(predicate: Predicate<TElement>): boolean;
@@ -85,29 +85,29 @@ export interface Enumerable<TElement> extends Iterable<TElement> {
   none(predicate: Predicate<TElement>): boolean;
   none(): boolean;
 
-  skip(n: number): Enumerable<TElement>;
-  skipLast(n: number): Enumerable<TElement>;
-  skipWhile(condition: Predicate<TElement>): Enumerable<TElement>;
+  skip(n: number): Sequence<TElement>;
+  skipLast(n: number): Sequence<TElement>;
+  skipWhile(condition: Predicate<TElement>): Sequence<TElement>;
 
-  take(n: number): Enumerable<TElement>;
-  takeLast(n: number): Enumerable<TElement>;
-  takeWhile(condition: Predicate<TElement>): Enumerable<TElement>;
+  take(n: number): Sequence<TElement>;
+  takeLast(n: number): Sequence<TElement>;
+  takeWhile(condition: Predicate<TElement>): Sequence<TElement>;
 
-  peek(action: Action<TElement>): Enumerable<TElement>;
+  peek(action: Action<TElement>): Sequence<TElement>;
 
   forEach(action: Action<TElement>): void;
 
-  zip<TOther>(iterable: Iterable<TOther>): Enumerable<[TElement, TOther]>;
+  zip<TOther>(iterable: Iterable<TOther>): Sequence<[TElement, TOther]>;
 
-  indexed(): Enumerable<[number, TElement]>;
+  indexed(): Sequence<[number, TElement]>;
 
-  reversed(): Enumerable<TElement>;
+  reversed(): Sequence<TElement>;
 
-  chunked(size: number): Enumerable<TElement[]>;
+  chunked(size: number): Sequence<TElement[]>;
 
   random(options?: RandomOptions<TElement>): TElement | undefined;
 
-  cached(): Enumerable<TElement>;
+  cached(): Sequence<TElement>;
 
   asArray(): TElement[];
   toArray(): TElement[];
@@ -118,18 +118,18 @@ export interface Enumerable<TElement> extends Iterable<TElement> {
   collect<TResult>(collector: Collector<TElement, any, TResult>): TResult;
 }
 
-export interface GroupedEnumerable<TKey, TElement> extends Enumerable<TElement> {
+export interface GroupedSequence<TKey, TElement> extends Sequence<TElement> {
   get key(): TKey;
 }
 
-export interface OrderedEnumerable<TElement> extends Enumerable<TElement> {
+export interface OrderedSequence<TElement> extends Sequence<TElement> {
   get comparer(): Comparer<TElement> | undefined;
 
-  thenSelf(comparer?: Comparer<TElement>): OrderedEnumerable<TElement>;
+  thenSelf(comparer?: Comparer<TElement>): OrderedSequence<TElement>;
 
-  thenBy<TBy>(selector: Converter<TElement, TBy>, comparer?: Comparer<TBy>): OrderedEnumerable<TElement>;
+  thenBy<TBy>(selector: Converter<TElement, TBy>, comparer?: Comparer<TBy>): OrderedSequence<TElement>;
 
-  thenSelfDescending(comparer?: Comparer<TElement>): OrderedEnumerable<TElement>;
+  thenSelfDescending(comparer?: Comparer<TElement>): OrderedSequence<TElement>;
 
-  thenByDescending<TBy>(selector: Converter<TElement, TBy>, comparer?: Comparer<TBy>): OrderedEnumerable<TElement>;
+  thenByDescending<TBy>(selector: Converter<TElement, TBy>, comparer?: Comparer<TBy>): OrderedSequence<TElement>;
 }