diff --git a/src/async/impl.ts b/src/async/impl.ts
index c1c7699..f6665cb 100644
--- a/src/async/impl.ts
+++ b/src/async/impl.ts
@@ -6,7 +6,7 @@ import { getRandomElementAsync } from "../random/index.js";
 import { AsyncRandomOptions } from "../random/types.js";
 import { selectionSorter } from "../sorting.js";
 import { Sequence } from "../sync/types.js";
-import { MaybeAsyncConverter, MaybeAsyncPredicate, MaybeAsyncEquater, MaybeAsyncBiConverter, MaybeAsyncAccumulator, MaybeAsyncComparer, MaybeAsyncAction, MaybePromiseLike, MaybeAsyncGenerator, MaybeAsyncSequence } from "../types.js";
+import { MaybeAsyncAnyPredicate, MaybeAsyncConverter, MaybeAsyncEquater, MaybeAsyncBiConverter, MaybeAsyncAccumulator, MaybeAsyncComparer, MaybeAsyncAction, MaybePromiseLike, MaybeAsyncGenerator, MaybeAsyncSequence } from "../types.js";
 import { strictEquals, identity, operatorCompare, defaultArrayComparer, combineAsyncComparers, asAsyncIterable } from "../utils.js";
 import { array, empty, wrap } from "./index.js";
 import { AsyncSequence, GroupedAsyncSequence, OrderedAsyncSequence } from "./types.js";
@@ -25,15 +25,15 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
   }
 
   select<TResult>(converter: MaybeAsyncConverter<TElement, TResult>): AsyncSequence<TResult> {
-    return new MapperAsyncSequence<TElement, TResult>(this, converter);
+    return new SelectAsyncSequence<TElement, TResult>(this, converter);
   }
 
   selectMany<TResult>(converter: MaybeAsyncConverter<TElement, MaybeAsyncSequence<TResult>>): AsyncSequence<TResult> {
-    return new FlatMapperAsyncSequence<TElement, TResult>(this, converter);
+    return new SelectManyAsyncSequence<TElement, TResult>(this, converter);
   }
 
-  where(predicate: MaybeAsyncPredicate<TElement>): AsyncSequence<TElement> {
-    return new FilterAsyncSequence<TElement>(this, predicate);
+  where(predicate: MaybeAsyncAnyPredicate<TElement>): AsyncSequence<TElement> {
+    return new WhereAsyncSequence<TElement>(this, predicate);
   }
 
   groupBy<TKey>(keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector?: undefined, keyComparer?: MaybeAsyncEquater<TKey> | undefined): AsyncSequence<GroupedAsyncSequence<TKey, TElement>>;
@@ -133,7 +133,7 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
     return new ConcatAsyncSequence(arr);
   }
 
-  async count(predicate?: MaybeAsyncPredicate<TElement>) {
+  async count(predicate?: MaybeAsyncAnyPredicate<TElement>) {
     let count = 0;
 
     if (predicate) {
@@ -167,7 +167,7 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
     return n >= 0 ? n : Infinity;
   }
 
-  async #tryGetFirst(predicate?: MaybeAsyncPredicate<TElement>) {
+  async #tryGetFirst(predicate?: MaybeAsyncAnyPredicate<TElement>) {
     if (predicate) {
       for await (const element of this) {
         if (await predicate(element)) {
@@ -193,7 +193,7 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
     } as const;
   }
 
-  async first(predicate?: MaybeAsyncPredicate<TElement>) {
+  async first(predicate?: MaybeAsyncAnyPredicate<TElement>) {
     const result = await this.#tryGetFirst(predicate);
 
     if (result.found) {
@@ -203,13 +203,13 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
     throw new Error("No element was found.");
   }
 
-  async firstOrDefault(predicate?: MaybeAsyncPredicate<TElement>, def?: TElement) {
+  async firstOrDefault(predicate?: MaybeAsyncAnyPredicate<TElement>, def?: TElement) {
     const result = await this.#tryGetFirst(predicate);
 
     return result.found ? result.element : def;
   }
 
-  async #tryGetLast(predicate?: MaybeAsyncPredicate<TElement>) {
+  async #tryGetLast(predicate?: MaybeAsyncAnyPredicate<TElement>) {
     let found = false;
     let result: TElement | undefined = undefined;
 
@@ -233,7 +233,7 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
     };
   }
 
-  async last(predicate?: MaybeAsyncPredicate<TElement>) {
+  async last(predicate?: MaybeAsyncAnyPredicate<TElement>) {
     const result = await this.#tryGetLast(predicate);
 
     if (result.found) {
@@ -243,13 +243,13 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
     throw new Error("No element was found.");
   }
 
-  async lastOrDefault(predicate?: MaybeAsyncPredicate<TElement>, def?: TElement) {
+  async lastOrDefault(predicate?: MaybeAsyncAnyPredicate<TElement>, def?: TElement) {
     const result = await this.#tryGetLast(predicate);
 
     return result.found ? result.element : def;
   }
 
-  async #tryGetSingle(predicate?: MaybeAsyncPredicate<TElement>) {
+  async #tryGetSingle(predicate?: MaybeAsyncAnyPredicate<TElement>) {
     if (predicate) {
       let result: { found: true; element: TElement; } | undefined = undefined;
 
@@ -297,7 +297,7 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
     } as const;
   }
 
-  async single(predicate?: MaybeAsyncPredicate<TElement>) {
+  async single(predicate?: MaybeAsyncAnyPredicate<TElement>) {
     const result = await this.#tryGetSingle(predicate);
 
     if (result.found == true) {
@@ -318,7 +318,7 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
     throw new Error(reason);
   }
 
-  async singleOrDefault(predicate?: MaybeAsyncPredicate<TElement>, def?: TElement) {
+  async singleOrDefault(predicate?: MaybeAsyncAnyPredicate<TElement>, def?: TElement) {
     const result = await this.#tryGetSingle(predicate);
 
     return result.found ? result.element : def;
@@ -391,7 +391,7 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
     return acc as unknown as TResult;
   }
 
-  async #find<TResult>(sorter: MaybeAsyncPredicate<number>, selector?: MaybeAsyncConverter<TElement, TResult>, comparer?: MaybeAsyncComparer<TResult>) {
+  async #find<TResult>(sorter: MaybeAsyncAnyPredicate<number>, selector?: MaybeAsyncConverter<TElement, TResult>, comparer?: MaybeAsyncComparer<TResult>) {
     const iterator = this.iterator();
 
     let next = await iterator.next();
@@ -462,11 +462,11 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
     return new OrderByAsyncSequence<TElement, TBy>(this, true, selector, comparer);
   }
 
-  partition(equater?: MaybeAsyncEquater<TElement>): AsyncSequence<TElement[]> {
+  partition(equater?: MaybeAsyncEquater<TElement>): AsyncSequence<AsyncSequence<TElement>> {
     return new PartitionAsyncSequence<TElement>(this, equater);
   }
 
-  partitionBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncSequence<TElement[]> {
+  partitionBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncSequence<AsyncSequence<TElement>> {
     return new PartitionByAsyncSequence<TElement, TBy>(this, selector, equater);
   }
 
@@ -502,7 +502,7 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
     return new IntersectByAsyncSequence<TElement, TBy>(this, wrap(sequence), selector);
   }
 
-  async all(predicate: MaybeAsyncPredicate<TElement>) {
+  async all(predicate: MaybeAsyncAnyPredicate<TElement>) {
     const n = await this.nonEnumeratedCount();
 
     if (n === 0) {
@@ -518,7 +518,7 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
     return true;
   }
 
-  async any(predicate?: MaybeAsyncPredicate<TElement>) {
+  async any(predicate?: MaybeAsyncAnyPredicate<TElement>) {
     const n = await this.nonEnumeratedCount();
 
     if (n === 0) {
@@ -538,7 +538,7 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
     return n < 0 ? !(await this.iterator().next()).done : n > 0;
   }
 
-  async none(predicate?: MaybeAsyncPredicate<TElement>) {
+  async none(predicate?: MaybeAsyncAnyPredicate<TElement>) {
     const n = await this.nonEnumeratedCount();
 
     if (n === 0) {
@@ -574,7 +574,7 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
     return n === 0 ? this : new SkipLastAsyncSequence<TElement>(this, n);
   }
 
-  skipWhile(predicate: MaybeAsyncPredicate<TElement>): AsyncSequence<TElement> {
+  skipWhile(predicate: MaybeAsyncAnyPredicate<TElement>): AsyncSequence<TElement> {
     return new SkipWhileAsyncSequence<TElement>(this, predicate);
   }
 
@@ -594,7 +594,7 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
     return n === 0 ? empty<TElement>() : new TakeLastAsyncSequence<TElement>(this, n);
   }
 
-  takeWhile(predicate: MaybeAsyncPredicate<TElement>): AsyncSequence<TElement> {
+  takeWhile(predicate: MaybeAsyncAnyPredicate<TElement>): AsyncSequence<TElement> {
     return new TakeWhileAsyncSequence<TElement>(this, predicate);
   }
 
@@ -612,7 +612,7 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
     return new ZippedAsyncSequence<TElement, TOther>(this, wrap(sequence));
   }
 
-  indexex(): AsyncSequence<[number, TElement]> {
+  indexed(): AsyncSequence<[number, TElement]> {
     return new IndexedAsyncSequence<TElement>(this);
   }
 
@@ -620,12 +620,15 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
     return new ReversedAsyncSequence<TElement>(this);
   }
 
-  chunked(size: number): AsyncSequence<AsyncSequence<TElement>> {
+  chunked(size: number, asArray?: false): AsyncSequence<AsyncSequence<TElement>>;
+  chunked(size: number, asArray: true): AsyncSequence<TElement[]>;
+  chunked(size: number, asArray?: boolean): AsyncSequence<AsyncSequence<TElement>> | AsyncSequence<TElement[]> {
     if (size <= 0) {
       throw new Error("Chunk size must be positive.");
     }
 
-    return new ChunkedAsyncSequence<TElement>(this, size);
+    const sequence = new ChunkedAsyncSequence<TElement>(this, size);
+    return asArray ? sequence : sequence.select(array);
   }
 
   async random(options?: AsyncRandomOptions<TElement> | undefined): Promise<TElement | undefined> {
@@ -636,6 +639,10 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
     return new CacheAsyncSequence<TElement>(this);
   }
 
+  async asArray(): Promise<TElement[]> {
+    return await this.toArray();
+  }
+
   async toArray() {
     const array: TElement[] = [];
 
@@ -646,8 +653,12 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
     return array;
   }
 
-  async toMap<TKey, TValue>(keySelector: MaybeAsyncConverter<TElement, TKey>, valueSelector: MaybeAsyncConverter<TElement, TValue>) {
-    const map = new Map<TKey, TValue>();
+  toMap<TKey>(keySelector: MaybeAsyncConverter<TElement, TKey>): Promise<Map<TKey, TElement>>;
+  toMap<TKey, TValue>(keySelector: MaybeAsyncConverter<TElement, TKey>, valueSelector: MaybeAsyncConverter<TElement, TValue>): Promise<Map<TKey, TValue>>;
+  async toMap<TKey>(keySelector: MaybeAsyncConverter<TElement, TKey>, valueSelector?: MaybeAsyncConverter<TElement, any>): Promise<Map<TKey, any>> {
+    valueSelector ??= identity;
+
+    const map = new Map<TKey, any>();
 
     for await (const element of this) {
       const key = await keySelector(element);
@@ -669,8 +680,12 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
     return set;
   }
 
-  async toObject<TValue>(keySelector: MaybeAsyncConverter<TElement, PropertyKey>, valueSelector: MaybeAsyncConverter<TElement, TValue>) {
-    const obj: Record<PropertyKey, TValue> = {};
+  toObject<TKey extends PropertyKey>(keySelector: MaybeAsyncConverter<TElement, TKey>): Promise<Record<TKey, TElement>>;
+  toObject<TKey extends PropertyKey, TValue>(keySelector: MaybeAsyncConverter<TElement, TKey>, valueSelector: MaybeAsyncConverter<TElement, TValue>): Promise<Record<TKey, TValue>>;
+  async toObject<TKey extends PropertyKey>(keySelector: MaybeAsyncConverter<TElement, TKey>, valueSelector?: MaybeAsyncConverter<TElement, any>): Promise<Record<TKey, any>> {
+    valueSelector ??= identity;
+
+    const obj: Record<PropertyKey, any> = {};
 
     for await (const element of this) {
       const key = await keySelector(element);
@@ -722,7 +737,7 @@ export class DelegatedAsyncSequence<TElement> extends AsyncSequenceMarker implem
     return this.#sequence.apply(pipeline);
   }
 
-  count(predicate?: MaybeAsyncPredicate<TElement> | undefined): Promise<number> {
+  count(predicate?: MaybeAsyncAnyPredicate<TElement> | undefined): Promise<number> {
     return this.#sequence.count(predicate);
   }
 
@@ -746,7 +761,7 @@ export class DelegatedAsyncSequence<TElement> extends AsyncSequenceMarker implem
     return this.#sequence.selectMany(selector);
   }
 
-  where(predicate: MaybeAsyncPredicate<TElement>): AsyncSequence<TElement> {
+  where(predicate: MaybeAsyncAnyPredicate<TElement>): AsyncSequence<TElement> {
     return this.#sequence.where(predicate);
   }
 
@@ -792,27 +807,27 @@ export class DelegatedAsyncSequence<TElement> extends AsyncSequenceMarker implem
     return this.#sequence.concat(...sequences);
   }
 
-  first(predicate?: MaybeAsyncPredicate<TElement> | undefined): Promise<TElement> {
+  first(predicate?: MaybeAsyncAnyPredicate<TElement> | undefined): Promise<TElement> {
     return this.#sequence.first(predicate);
   }
 
-  firstOrDefault(predicate?: MaybeAsyncPredicate<TElement> | undefined, def?: TElement | undefined): Promise<TElement | undefined> {
+  firstOrDefault(predicate?: MaybeAsyncAnyPredicate<TElement> | undefined, def?: TElement | undefined): Promise<TElement | undefined> {
     return this.#sequence.firstOrDefault(predicate, def);
   }
 
-  last(predicate?: MaybeAsyncPredicate<TElement> | undefined): Promise<TElement> {
+  last(predicate?: MaybeAsyncAnyPredicate<TElement> | undefined): Promise<TElement> {
     return this.#sequence.last(predicate);
   }
 
-  lastOrDefault(predicate?: MaybeAsyncPredicate<TElement> | undefined, def?: TElement | undefined): Promise<TElement | undefined> {
+  lastOrDefault(predicate?: MaybeAsyncAnyPredicate<TElement> | undefined, def?: TElement | undefined): Promise<TElement | undefined> {
     return this.#sequence.lastOrDefault(predicate, def);
   }
 
-  single(predicate?: MaybeAsyncPredicate<TElement> | undefined): Promise<TElement> {
+  single(predicate?: MaybeAsyncAnyPredicate<TElement> | undefined): Promise<TElement> {
     return this.#sequence.single(predicate);
   }
 
-  singleOrDefault(predicate?: MaybeAsyncPredicate<TElement> | undefined, def?: TElement | undefined): Promise<TElement | undefined> {
+  singleOrDefault(predicate?: MaybeAsyncAnyPredicate<TElement> | undefined, def?: TElement | undefined): Promise<TElement | undefined> {
     return this.#sequence.singleOrDefault(predicate, def);
   }
 
@@ -863,11 +878,11 @@ export class DelegatedAsyncSequence<TElement> extends AsyncSequenceMarker implem
     return this.#sequence.orderByDescending(selector, comparer);
   }
 
-  partition(equater?: MaybeAsyncEquater<TElement> | undefined): AsyncSequence<TElement[]> {
+  partition(equater?: MaybeAsyncEquater<TElement> | undefined): AsyncSequence<AsyncSequence<TElement>> {
     return this.#sequence.partition(equater);
   }
 
-  partitionBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy> | undefined): AsyncSequence<TElement[]> {
+  partitionBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy> | undefined): AsyncSequence<AsyncSequence<TElement>> {
     return this.#sequence.partitionBy(selector, equater);
   }
 
@@ -903,17 +918,17 @@ export class DelegatedAsyncSequence<TElement> extends AsyncSequenceMarker implem
     return this.#sequence.intersectBy(wrap(sequence), selector, equater);
   }
 
-  all(predicate: MaybeAsyncPredicate<TElement>): Promise<boolean> {
+  all(predicate: MaybeAsyncAnyPredicate<TElement>): Promise<boolean> {
     return this.#sequence.all(predicate);
   }
 
-  any(predicate: MaybeAsyncPredicate<TElement>): Promise<boolean>;
+  any(predicate: MaybeAsyncAnyPredicate<TElement>): Promise<boolean>;
   any(): Promise<boolean>;
   any(predicate?: any) {
     return this.#sequence.any(predicate);
   }
 
-  none(predicate: MaybeAsyncPredicate<TElement>): Promise<boolean>;
+  none(predicate: MaybeAsyncAnyPredicate<TElement>): Promise<boolean>;
   none(): Promise<boolean>;
   none(predicate?: any) {
     return this.#sequence.none(predicate);
@@ -927,7 +942,7 @@ export class DelegatedAsyncSequence<TElement> extends AsyncSequenceMarker implem
     return this.#sequence.skipLast(n);
   }
 
-  skipWhile(condition: MaybeAsyncPredicate<TElement>): AsyncSequence<TElement> {
+  skipWhile(condition: MaybeAsyncAnyPredicate<TElement>): AsyncSequence<TElement> {
     return this.#sequence.skipWhile(condition);
   }
 
@@ -939,7 +954,7 @@ export class DelegatedAsyncSequence<TElement> extends AsyncSequenceMarker implem
     return this.#sequence.takeLast(n);
   }
 
-  takeWhile(condition: MaybeAsyncPredicate<TElement>): AsyncSequence<TElement> {
+  takeWhile(condition: MaybeAsyncAnyPredicate<TElement>): AsyncSequence<TElement> {
     return this.#sequence.takeWhile(condition);
   }
 
@@ -955,16 +970,18 @@ export class DelegatedAsyncSequence<TElement> extends AsyncSequenceMarker implem
     return this.#sequence.zip(wrap(sequence));
   }
 
-  indexex(): AsyncSequence<[number, TElement]> {
-    return this.#sequence.indexex();
+  indexed(): AsyncSequence<[number, TElement]> {
+    return this.#sequence.indexed();
   }
 
   reversed(): AsyncSequence<TElement> {
     return this.#sequence.reversed();
   }
 
-  chunked(size: number): AsyncSequence<AsyncSequence<TElement>> {
-    return this.#sequence.chunked(size);
+  chunked(size: number, asArray?: false): AsyncSequence<AsyncSequence<TElement>>;
+  chunked(size: number, asArray: true): AsyncSequence<TElement[]>;
+  chunked(size: number, asArray?: any): AsyncSequence<AsyncSequence<TElement>> | AsyncSequence<TElement[]> {
+    return this.#sequence.chunked(size, asArray);
   }
 
   random(options?: AsyncRandomOptions<TElement> | undefined): Promise<TElement | undefined> {
@@ -975,11 +992,17 @@ export class DelegatedAsyncSequence<TElement> extends AsyncSequenceMarker implem
     return this.#sequence.cached();
   }
 
+  asArray(): Promise<TElement[]> {
+    return this.#sequence.asArray();
+  }
+
   toArray(): Promise<TElement[]> {
     return this.#sequence.toArray();
   }
 
-  toMap<TKey, TValue>(keySelector: MaybeAsyncConverter<TElement, TKey>, valueSelector: MaybeAsyncConverter<TElement, TValue>): Promise<Map<TKey, TValue>> {
+  toMap<TKey>(keySelector: MaybeAsyncConverter<TElement, TKey>): Promise<Map<TKey, TElement>>;
+  toMap<TKey, TValue>(keySelector: MaybeAsyncConverter<TElement, TKey>, valueSelector: MaybeAsyncConverter<TElement, TValue>): Promise<Map<TKey, TValue>>;
+  toMap(keySelector: any, valueSelector?: any) {
     return this.#sequence.toMap(keySelector, valueSelector);
   }
 
@@ -987,7 +1010,9 @@ export class DelegatedAsyncSequence<TElement> extends AsyncSequenceMarker implem
     return this.#sequence.toSet();
   }
 
-  toObject<TKey extends PropertyKey, TValue>(keySelector: MaybeAsyncConverter<TElement, TKey>, valueSelector: MaybeAsyncConverter<TElement, TValue>): Promise<Record<TKey, TValue>> {
+  toObject<TKey extends PropertyKey>(keySelector: MaybeAsyncConverter<TElement, TKey>): Promise<Record<TKey, TElement>>;
+  toObject<TKey extends PropertyKey, TValue>(keySelector: MaybeAsyncConverter<TElement, TKey>, valueSelector: MaybeAsyncConverter<TElement, TValue>): Promise<Record<TKey, TValue>>;
+  toObject(keySelector: any, valueSelector?: any) {
     return this.#sequence.toObject(keySelector, valueSelector);
   }
 
@@ -1352,11 +1377,11 @@ class DistinctByAsyncSequence<T, U> extends BaseAsyncSequence<T> {
   }
 }
 
-class FilterAsyncSequence<T> extends BaseAsyncSequence<T> {
+class WhereAsyncSequence<T> extends BaseAsyncSequence<T> {
   readonly #sequence: AsyncSequence<T>;
-  readonly #predicate: MaybeAsyncPredicate<T>;
+  readonly #predicate: MaybeAsyncAnyPredicate<T>;
 
-  constructor(sequence: AsyncSequence<T>, predicate: MaybeAsyncPredicate<T>) {
+  constructor(sequence: AsyncSequence<T>, predicate: MaybeAsyncAnyPredicate<T>) {
     super();
 
     this.#sequence = sequence;
@@ -1372,7 +1397,7 @@ class FilterAsyncSequence<T> extends BaseAsyncSequence<T> {
   }
 }
 
-class FlatMapperAsyncSequence<T, U> extends BaseAsyncSequence<U> {
+class SelectManyAsyncSequence<T, U> extends BaseAsyncSequence<U> {
   readonly #sequence: AsyncSequence<T>;
   readonly #converter: MaybeAsyncConverter<T, MaybeAsyncSequence<U>>;
 
@@ -1408,7 +1433,7 @@ class IndexedAsyncSequence<T> extends BaseAsyncSequence<[number, T]> {
   }
 }
 
-class MapperAsyncSequence<T, U> extends BaseAsyncSequence<U> {
+class SelectAsyncSequence<T, U> extends BaseAsyncSequence<U> {
   readonly #sequence: AsyncSequence<T>;
   readonly #converter: MaybeAsyncConverter<T, U>;
 
@@ -1432,9 +1457,9 @@ class MapperAsyncSequence<T, U> extends BaseAsyncSequence<U> {
 
 class SkipWhileAsyncSequence<T> extends BaseAsyncSequence<T> {
   readonly #sequence: AsyncSequence<T>;
-  readonly #predicate: MaybeAsyncPredicate<T>;
+  readonly #predicate: MaybeAsyncAnyPredicate<T>;
 
-  constructor(sequence: AsyncSequence<T>, predicate: MaybeAsyncPredicate<T>) {
+  constructor(sequence: AsyncSequence<T>, predicate: MaybeAsyncAnyPredicate<T>) {
     super();
 
     this.#sequence = sequence;
@@ -1538,9 +1563,9 @@ class SkipAsyncSequence<T> extends BaseAsyncSequence<T> {
 
 class TakeWhileAsyncSequence<T> extends BaseAsyncSequence<T> {
   readonly #sequence: AsyncSequence<T>;
-  readonly #predicate: MaybeAsyncPredicate<T>;
+  readonly #predicate: MaybeAsyncAnyPredicate<T>;
 
-  constructor(sequence: AsyncSequence<T>, predicate: MaybeAsyncPredicate<T>) {
+  constructor(sequence: AsyncSequence<T>, predicate: MaybeAsyncAnyPredicate<T>) {
     super();
 
     this.#sequence = sequence;
@@ -1998,7 +2023,7 @@ class GroupByAsyncSequence<TElement, TKey, TResult> extends BaseAsyncSequence<Gr
   }
 }
 
-class ChunkedAsyncSequence<T> extends BaseAsyncSequence<AsyncSequence<T>> {
+class ChunkedAsyncSequence<T> extends BaseAsyncSequence<T[]> {
   readonly #sequence: AsyncSequence<T>;
   readonly #size: number;
 
@@ -2021,13 +2046,13 @@ class ChunkedAsyncSequence<T> extends BaseAsyncSequence<AsyncSequence<T>> {
       chunk.push(obj);
 
       if (chunk.length === this.#size) {
-        yield array(chunk);
+        yield chunk;
         chunk = [];
       }
     }
 
     if (chunk.length > 0) {
-      yield array(chunk);
+      yield chunk;
     }
   }
 }
@@ -2158,7 +2183,7 @@ class CacheAsyncSequence<T> extends BaseAsyncSequence<T> {
   }
 }
 
-class PartitionAsyncSequence<T> extends BaseAsyncSequence<T[]> {
+class PartitionAsyncSequence<T> extends BaseAsyncSequence<AsyncSequence<T>> {
   readonly #sequence: AsyncSequence<T>;
   readonly #equater: MaybeAsyncEquater<T>;
 
@@ -2182,11 +2207,13 @@ class PartitionAsyncSequence<T> extends BaseAsyncSequence<T[]> {
       }
     }
 
-    yield* partitions.values();
+    for (const partition of partitions.values()) {
+      yield array(partition);
+    }
   }
 }
 
-class PartitionByAsyncSequence<TElement, TBy> extends BaseAsyncSequence<TElement[]> {
+class PartitionByAsyncSequence<TElement, TBy> extends BaseAsyncSequence<AsyncSequence<TElement>> {
   readonly #sequence: AsyncSequence<TElement>;
   readonly #selector: MaybeAsyncConverter<TElement, TBy>;
   readonly #equater: MaybeAsyncEquater<TBy>;
@@ -2213,6 +2240,8 @@ class PartitionByAsyncSequence<TElement, TBy> extends BaseAsyncSequence<TElement
       }
     }
 
-    yield* partitions.values();
+    for (const partition of partitions.values()) {
+      yield array(partition);
+    }
   }
 }
diff --git a/src/async/index.ts b/src/async/index.ts
index 1d71875..75a46ec 100644
--- a/src/async/index.ts
+++ b/src/async/index.ts
@@ -2,7 +2,7 @@ import { wrap as wrapSync } from "../sync/index.js";
 import { Sequence } from "../sync/types.js";
 import { MaybeAsyncGenerator, MaybeAsyncIterable, MaybePromiseLike } from "../types.js";
 import { isAsyncIterable } from "../utils.js";
-import { WrappedSequence, WrappedAsyncIterable, WrappedObjectAsync, WrappedArrayAsync, WrappedArrayLikeAsync, FunctionAsyncSequence, GeneratorAsyncSequence, RangeAsyncSequence, RepeatForeverAsyncSequence, RepeatAsyncSequence, AsyncSequenceMarker, EMPTY } from "./impl.js";
+import { WrappedSequence, WrappedAsyncIterable, WrappedObjectAsync, WrappedArrayAsync, WrappedArrayLikeAsync, FunctionAsyncSequence, GeneratorAsyncSequence, RangeAsyncSequence, RepeatForeverAsyncSequence, RepeatAsyncSequence, AsyncSequenceMarker, EMPTY, ConcatAsyncSequence } from "./impl.js";
 import { AsyncSequence } from "./types.js";
 
 export function asAsync<T>(sequence: Sequence<MaybePromiseLike<T>>): AsyncSequence<T> {
@@ -52,6 +52,10 @@ export function of<T>(...elements: MaybePromiseLike<T>[]): AsyncSequence<T> {
   }
 }
 
+export function concat<T>(...sequences: AsyncSequence<T>[]): AsyncSequence<T> {
+  return new ConcatAsyncSequence<T>(sequences);
+}
+
 export function func<T>(f: () => MaybePromiseLike<T>): AsyncSequence<T> {
   return new FunctionAsyncSequence(f);
 }
diff --git a/src/async/types.ts b/src/async/types.ts
index bfcb7c4..9a15884 100644
--- a/src/async/types.ts
+++ b/src/async/types.ts
@@ -1,13 +1,13 @@
 import { Collector } from "../collector/types.js";
 import { AsyncRandomOptions } from "../random/types.js";
-import { MaybeAsyncPredicate, MaybeAsyncConverter, MaybeAsyncEquater, MaybeAsyncBiConverter, MaybeAsyncAccumulator, MaybeAsyncComparer, MaybeAsyncAction, MaybeAsyncSequence } from "../types.js";
+import { MaybeAsyncAnyPredicate, MaybeAsyncConverter, MaybeAsyncEquater, MaybeAsyncBiConverter, MaybeAsyncAccumulator, MaybeAsyncComparer, MaybeAsyncAction, MaybeAsyncSequence } from "../types.js";
 
 export interface AsyncSequence<TElement> extends AsyncIterable<TElement> {
   iterator(): AsyncIterator<TElement>;
 
   apply<TResult>(pipeline: (sequence: AsyncSequence<TElement>) => TResult): TResult;
 
-  count(predicate?: MaybeAsyncPredicate<TElement>): Promise<number>;
+  count(predicate?: MaybeAsyncAnyPredicate<TElement>): Promise<number>;
   nonEnumeratedCount(): Promise<number>;
   fastCount(): Promise<number>;
   maxCount(): Promise<number>;
@@ -15,7 +15,7 @@ export interface AsyncSequence<TElement> extends AsyncIterable<TElement> {
   select<TResult>(selector: MaybeAsyncConverter<TElement, TResult>): AsyncSequence<TResult>;
   selectMany<TResult>(selector: MaybeAsyncConverter<TElement, MaybeAsyncSequence<TResult>>): AsyncSequence<TResult>;
 
-  where(predicate: MaybeAsyncPredicate<TElement>): AsyncSequence<TElement>;
+  where(predicate: MaybeAsyncAnyPredicate<TElement>): AsyncSequence<TElement>;
 
   groupBy<TKey>(keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector?: undefined, keyComparer?: MaybeAsyncEquater<TKey>): AsyncSequence<GroupedAsyncSequence<TKey, TElement>>;
   groupBy<TKey, TResult>(keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector: MaybeAsyncConverter<TElement, TResult>, keyComparer?: MaybeAsyncEquater<TKey>): AsyncSequence<GroupedAsyncSequence<TKey, TResult>>;
@@ -38,14 +38,14 @@ export interface AsyncSequence<TElement> extends AsyncIterable<TElement> {
 
   concat(...sequences: MaybeAsyncSequence<TElement>[]): AsyncSequence<TElement>;
 
-  first(predicate?: MaybeAsyncPredicate<TElement>): Promise<TElement>;
-  firstOrDefault(predicate?: MaybeAsyncPredicate<TElement>, def?: TElement): Promise<TElement | undefined>;
+  first(predicate?: MaybeAsyncAnyPredicate<TElement>): Promise<TElement>;
+  firstOrDefault(predicate?: MaybeAsyncAnyPredicate<TElement>, def?: TElement): Promise<TElement | undefined>;
 
-  last(predicate?: MaybeAsyncPredicate<TElement>): Promise<TElement>;
-  lastOrDefault(predicate?: MaybeAsyncPredicate<TElement>, def?: TElement): Promise<TElement | undefined>;
+  last(predicate?: MaybeAsyncAnyPredicate<TElement>): Promise<TElement>;
+  lastOrDefault(predicate?: MaybeAsyncAnyPredicate<TElement>, def?: TElement): Promise<TElement | undefined>;
 
-  single(predicate?: MaybeAsyncPredicate<TElement>): Promise<TElement>;
-  singleOrDefault(predicate?: MaybeAsyncPredicate<TElement>, def?: TElement): Promise<TElement | undefined>;
+  single(predicate?: MaybeAsyncAnyPredicate<TElement>): Promise<TElement>;
+  singleOrDefault(predicate?: MaybeAsyncAnyPredicate<TElement>, def?: TElement): Promise<TElement | undefined>;
 
   elementAt(index: number): Promise<TElement>;
   elementAtOrDefault(index: number, def?: TElement): Promise<TElement | undefined>;
@@ -66,8 +66,8 @@ export interface AsyncSequence<TElement> extends AsyncIterable<TElement> {
   orderDescending(comparer?: MaybeAsyncComparer<TElement>): AsyncSequence<TElement>;
   orderByDescending<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparer<TBy>): AsyncSequence<TElement>;
 
-  partition(equater?: MaybeAsyncEquater<TElement>): AsyncSequence<TElement[]>;
-  partitionBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncSequence<TElement[]>;
+  partition(equater?: MaybeAsyncEquater<TElement>): AsyncSequence<AsyncSequence<TElement>>;
+  partitionBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncSequence<AsyncSequence<TElement>>;
 
   distinct(equater?: MaybeAsyncEquater<TElement>): AsyncSequence<TElement>;
   distinctBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncSequence<TElement>;
@@ -81,19 +81,19 @@ export interface AsyncSequence<TElement> extends AsyncIterable<TElement> {
   intersect(sequence: MaybeAsyncSequence<TElement>, equater?: MaybeAsyncEquater<TElement>): AsyncSequence<TElement>;
   intersectBy<TBy>(sequence: MaybeAsyncSequence<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEquater<TBy>): AsyncSequence<TElement>;
 
-  all(predicate: MaybeAsyncPredicate<TElement>): Promise<boolean>;
-  any(predicate: MaybeAsyncPredicate<TElement>): Promise<boolean>;
+  all(predicate: MaybeAsyncAnyPredicate<TElement>): Promise<boolean>;
+  any(predicate: MaybeAsyncAnyPredicate<TElement>): Promise<boolean>;
   any(): Promise<boolean>;
-  none(predicate: MaybeAsyncPredicate<TElement>): Promise<boolean>;
+  none(predicate: MaybeAsyncAnyPredicate<TElement>): Promise<boolean>;
   none(): Promise<boolean>;
 
   skip(n: number): AsyncSequence<TElement>;
   skipLast(n: number): AsyncSequence<TElement>;
-  skipWhile(condition: MaybeAsyncPredicate<TElement>): AsyncSequence<TElement>;
+  skipWhile(condition: MaybeAsyncAnyPredicate<TElement>): AsyncSequence<TElement>;
 
   take(n: number): AsyncSequence<TElement>;
   takeLast(n: number): AsyncSequence<TElement>;
-  takeWhile(condition: MaybeAsyncPredicate<TElement>): AsyncSequence<TElement>;
+  takeWhile(condition: MaybeAsyncAnyPredicate<TElement>): AsyncSequence<TElement>;
 
   peek(action: MaybeAsyncAction<TElement>): AsyncSequence<TElement>;
 
@@ -101,19 +101,24 @@ export interface AsyncSequence<TElement> extends AsyncIterable<TElement> {
 
   zip<TOther>(sequence: MaybeAsyncSequence<TOther>): AsyncSequence<[TElement, TOther]>;
 
-  indexex(): AsyncSequence<[number, TElement]>;
+  indexed(): AsyncSequence<[number, TElement]>;
 
   reversed(): AsyncSequence<TElement>;
 
-  chunked(size: number): AsyncSequence<AsyncSequence<TElement>>;
+  chunked(size: number, asArray?: false): AsyncSequence<AsyncSequence<TElement>>;
+  chunked(size: number, asArray: true): AsyncSequence<TElement[]>;
 
   random(options?: AsyncRandomOptions<TElement>): Promise<TElement | undefined>;
 
   cached(): AsyncSequence<TElement>;
 
+  asArray(): Promise<TElement[]>;
+
   toArray(): Promise<TElement[]>;
+  toMap<TKey>(keySelector: MaybeAsyncConverter<TElement, TKey>): Promise<Map<TKey, TElement>>;
   toMap<TKey, TValue>(keySelector: MaybeAsyncConverter<TElement, TKey>, valueSelector: MaybeAsyncConverter<TElement, TValue>): Promise<Map<TKey, TValue>>;
   toSet(): Promise<Set<TElement>>;
+  toObject<TKey extends PropertyKey>(keySelector: MaybeAsyncConverter<TElement, TKey>): Promise<Record<TKey, TElement>>;
   toObject<TKey extends PropertyKey, TValue>(keySelector: MaybeAsyncConverter<TElement, TKey>, valueSelector: MaybeAsyncConverter<TElement, TValue>): Promise<Record<TKey, TValue>>;
 
   collect<TResult>(collector: Collector<TElement, any, TResult>): Promise<TResult>;
diff --git a/src/sync/impl.ts b/src/sync/impl.ts
index e814745..5190a66 100644
--- a/src/sync/impl.ts
+++ b/src/sync/impl.ts
@@ -1,3 +1,5 @@
+import util from "util";
+
 import { BaseAsyncSequence } from "../async/impl.js";
 import { AsyncSequence } from "../async/types.js";
 import { Collector } from "../collector/types.js";
@@ -6,7 +8,7 @@ import { createEqualitySet } from "../equality-set.js";
 import { createQueue } from "../queue.js";
 import { getRandomElement } from "../random/index.js";
 import { RandomOptions } from "../random/types.js";
-import { Converter, FilterPredicate, Equater, BiConverter, Predicate, Accumulator, Comparer, Action } from "../types.js";
+import { AnyPredicate, Converter, FilterPredicate, Equater, BiConverter, Accumulator, Comparer, Action } from "../types.js";
 import { strictEquals, identity, operatorCompare, reverseComparer, asIterable, defaultArrayComparer, combineComparers } from "../utils.js";
 import { array, empty } from "./index.js";
 import { Sequence, GroupedSequence, OrderedSequence } from "./types.js";
@@ -18,6 +20,18 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
     return this.iterator();
   }
 
+  [util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
+    return "Sequence {}";
+  }
+
+  override valueOf() {
+    return this.toJSON();
+  }
+
+  toJSON() {
+    return this.asArray();
+  }
+
   abstract iterator(): Iterator<TElement>;
 
   apply<TResult>(pipeline: (sequence: this) => TResult) {
@@ -32,8 +46,10 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
     return new SelectManySequence<TElement, TResult>(this, converter);
   }
 
-  where<TFiltered extends TElement>(predicate: FilterPredicate<TElement, TFiltered>): Sequence<TFiltered> {
-    return new WhereSequence<TElement, TFiltered>(this, predicate);
+  where<TFiltered extends TElement>(predicate: FilterPredicate<TElement, TFiltered>): Sequence<TFiltered>;
+  where(predicate: AnyPredicate<TElement>): Sequence<TElement>;
+  where(predicate: any) {
+    return new WhereSequence<TElement, any>(this, predicate);
   }
 
   groupBy<TKey, TResult>(keySelector: Converter<TElement, TKey>, elementSelector?: Converter<TElement, TResult>, keyComparer?: Equater<TKey>): Sequence<GroupedSequence<TKey, TResult>> {
@@ -125,7 +141,7 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
     return new ConcatSequence(arr);
   }
 
-  count(predicate?: Predicate<TElement>) {
+  count(predicate?: AnyPredicate<TElement>) {
     let count = 0;
 
     if (predicate) {
@@ -159,7 +175,7 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
     return n >= 0 ? n : Infinity;
   }
 
-  #tryGetFirst(predicate?: Predicate<TElement>): { found: boolean, element?: TElement | undefined } {
+  #tryGetFirst(predicate?: AnyPredicate<TElement>): { found: boolean, element?: TElement | undefined } {
     if (predicate) {
       for (const element of this) {
         if (predicate(element)) {
@@ -185,7 +201,7 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
     };
   }
 
-  first(predicate?: Predicate<TElement>) {
+  first(predicate?: AnyPredicate<TElement>) {
     const result = this.#tryGetFirst(predicate);
 
     if (result.found) {
@@ -195,13 +211,13 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
     throw new Error("No element was found.");
   }
 
-  firstOrDefault(predicate?: Predicate<TElement>, def?: TElement) {
+  firstOrDefault(predicate?: AnyPredicate<TElement>, def?: TElement) {
     const result = this.#tryGetFirst(predicate);
 
     return result.found ? result.element : def;
   }
 
-  #tryGetLast(predicate?: Predicate<TElement>): { found: boolean, element?: TElement } {
+  #tryGetLast(predicate?: AnyPredicate<TElement>): { found: boolean, element?: TElement } {
     let found = false;
     let result: TElement | undefined = undefined;
 
@@ -225,7 +241,7 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
     };
   }
 
-  last(predicate?: Predicate<TElement>) {
+  last(predicate?: AnyPredicate<TElement>) {
     const result = this.#tryGetLast(predicate);
 
     if (result.found) {
@@ -235,13 +251,13 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
     throw new Error("No element was found.");
   }
 
-  lastOrDefault(predicate?: Predicate<TElement>, def?: TElement) {
+  lastOrDefault(predicate?: AnyPredicate<TElement>, def?: TElement) {
     const result = this.#tryGetLast(predicate);
 
     return result.found ? result.element : def;
   }
 
-  #tryGetSingle(predicate?: Predicate<TElement>): { found: boolean, element?: TElement, reason?: number } {
+  #tryGetSingle(predicate?: AnyPredicate<TElement>): { found: boolean, element?: TElement, reason?: number } {
     if (predicate) {
       let result: { found: boolean; element: TElement; } | undefined = undefined;
 
@@ -289,7 +305,7 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
     };
   }
 
-  single(predicate?: Predicate<TElement>) {
+  single(predicate?: AnyPredicate<TElement>) {
     const result = this.#tryGetSingle(predicate);
 
     if (result.found) {
@@ -310,7 +326,7 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
     throw new Error(reason);
   }
 
-  singleOrDefault(predicate?: Predicate<TElement>, def?: TElement) {
+  singleOrDefault(predicate?: AnyPredicate<TElement>, def?: TElement) {
     const result = this.#tryGetSingle(predicate);
 
     return result.found ? result.element : def;
@@ -383,7 +399,7 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
     return acc as unknown as TResult;
   }
 
-  #find<TResult>(sorter: Predicate<number>, selector?: Converter<TElement, TResult>, comparer?: Comparer<TResult>) {
+  #find<TResult>(sorter: AnyPredicate<number>, selector?: Converter<TElement, TResult>, comparer?: Comparer<TResult>) {
     const iterator = this.iterator();
 
     let next = iterator.next();
@@ -454,11 +470,11 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
     return new OrderBySequence<TElement, TBy>(this, true, selector, comparer);
   }
 
-  partition(equater?: Equater<TElement>): Sequence<TElement[]> {
+  partition(equater?: Equater<TElement>): Sequence<Sequence<TElement>> {
     return new PartitionSequence<TElement>(this, equater);
   }
 
-  partitionBy<TBy>(selector: Converter<TElement, TBy>, equater?: Equater<TBy>): Sequence<TElement[]> {
+  partitionBy<TBy>(selector: Converter<TElement, TBy>, equater?: Equater<TBy>): Sequence<Sequence<TElement>> {
     return new PartitionBySequence<TElement, TBy>(this, selector, equater);
   }
 
@@ -494,7 +510,7 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
     return new IntersectBySequence<TElement, TBy>(this, sequence, selector);
   }
 
-  all(predicate: Predicate<TElement>) {
+  all(predicate: AnyPredicate<TElement>) {
     const n = this.nonEnumeratedCount();
 
     if (n === 0) {
@@ -510,7 +526,7 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
     return true;
   }
 
-  any(predicate?: Predicate<TElement>) {
+  any(predicate?: AnyPredicate<TElement>) {
     const n = this.nonEnumeratedCount();
 
     if (n === 0) {
@@ -530,7 +546,7 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
     return n < 0 ? !this.iterator().next().done : n > 0;
   }
 
-  none(predicate?: Predicate<TElement>) {
+  none(predicate?: AnyPredicate<TElement>) {
     const n = this.nonEnumeratedCount();
 
     if (n === 0) {
@@ -566,7 +582,7 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
     return n === 0 ? this : new SkipLastSequence<TElement>(this, n);
   }
 
-  skipWhile(predicate: Predicate<TElement>): Sequence<TElement> {
+  skipWhile(predicate: AnyPredicate<TElement>): Sequence<TElement> {
     return new SkipWhileSequence<TElement>(this, predicate);
   }
 
@@ -586,7 +602,7 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
     return n === 0 ? empty<TElement>() : new TakeLastSequence<TElement>(this, n);
   }
 
-  takeWhile(predicate: Predicate<TElement>): Sequence<TElement> {
+  takeWhile(predicate: AnyPredicate<TElement>): Sequence<TElement> {
     return new TakeWhileSequence<TElement>(this, predicate);
   }
 
@@ -612,12 +628,15 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
     return new ReversedSequence<TElement>(this);
   }
 
-  chunked(size: number): Sequence<Sequence<TElement>> {
+  chunked(size: number, asArray?: false): Sequence<Sequence<TElement>>;
+  chunked(size: number, asArray: true): Sequence<TElement[]>;
+  chunked(size: number, asArray?: boolean): Sequence<Sequence<TElement>> | Sequence<TElement[]> {
     if (size <= 0) {
       throw new Error("Chunk size must be positive.");
     }
 
-    return new ChunkedSequence<TElement>(this, size);
+    const sequence = new ChunkedSequence<TElement>(this, size);
+    return asArray ? sequence : sequence.select(array);
   }
 
   random(options?: RandomOptions<TElement>) {
@@ -632,12 +651,20 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
     return new AwaitedSequence<TElement>(this);
   }
 
+  asArray() {
+    return this.toArray();
+  }
+
   toArray() {
     return Array.from(this);
   }
 
-  toMap<TKey, TValue>(keySelector: Converter<TElement, TKey>, valueSelector: Converter<TElement, TValue>) {
-    const map = new Map<TKey, TValue>();
+  toMap<TKey>(keySelector: Converter<TElement, TKey>): Map<TKey, TElement>;
+  toMap<TKey, TValue>(keySelector: Converter<TElement, TKey>, valueSelector: Converter<TElement, TValue>): Map<TKey, TValue>;
+  toMap<TKey>(keySelector: Converter<TElement, TKey>, valueSelector?: Converter<TElement, any>): Map<TKey, any> {
+    valueSelector ??= identity;
+
+    const map = new Map();
 
     for (const element of this) {
       const key = keySelector(element);
@@ -653,8 +680,12 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
     return new Set(this);
   }
 
-  toObject<TKey extends PropertyKey, TValue>(keySelector: Converter<TElement, TKey>, valueSelector: Converter<TElement, TValue>) {
-    const obj: Record<PropertyKey, TValue> = {};
+  toObject<TKey extends PropertyKey>(keySelector: Converter<TElement, TKey>): Record<TKey, TElement>;
+  toObject<TKey extends PropertyKey, TValue>(keySelector: Converter<TElement, TKey>, valueSelector: Converter<TElement, TValue>): Record<TKey, TValue>;
+  toObject<TKey extends PropertyKey>(keySelector: Converter<TElement, TKey>, valueSelector?: Converter<TElement, any>): Record<TKey, any> {
+    valueSelector ??= identity;
+
+    const obj: Record<PropertyKey, any> = {};
 
     for (const element of this) {
       const key = keySelector(element);
@@ -698,6 +729,14 @@ export class DelegatedSequence<TElement> extends SequenceMarker implements Seque
     return this.iterator();
   }
 
+  [util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
+    return inspect(this.#sequence);
+  }
+
+  toJSON() {
+    return this.#sequence.toJSON();
+  }
+
   iterator() {
     return this.#sequence.iterator();
   }
@@ -706,7 +745,7 @@ export class DelegatedSequence<TElement> extends SequenceMarker implements Seque
     return this.#sequence.apply(pipeline);
   }
 
-  count(predicate?: Predicate<TElement>) {
+  count(predicate?: AnyPredicate<TElement>) {
     return this.#sequence.count(predicate);
   }
 
@@ -730,7 +769,9 @@ export class DelegatedSequence<TElement> extends SequenceMarker implements Seque
     return this.#sequence.selectMany(selector);
   }
 
-  where<TFiltered extends TElement>(predicate: FilterPredicate<TElement, TFiltered>) {
+  where<TFiltered extends TElement>(predicate: FilterPredicate<TElement, TFiltered>): Sequence<TFiltered>;
+  where(predicate: AnyPredicate<TElement>): Sequence<TElement>;
+  where(predicate: any): Sequence<any> {
     return this.#sequence.where(predicate);
   }
 
@@ -776,27 +817,27 @@ export class DelegatedSequence<TElement> extends SequenceMarker implements Seque
     return this.#sequence.concat(...sequences);
   }
 
-  first(predicate?: Predicate<TElement>) {
+  first(predicate?: AnyPredicate<TElement>) {
     return this.#sequence.first(predicate);
   }
 
-  firstOrDefault(predicate?: Predicate<TElement>, def?: TElement) {
+  firstOrDefault(predicate?: AnyPredicate<TElement>, def?: TElement) {
     return this.#sequence.firstOrDefault(predicate, def);
   }
 
-  last(predicate?: Predicate<TElement>) {
+  last(predicate?: AnyPredicate<TElement>) {
     return this.#sequence.last(predicate);
   }
 
-  lastOrDefault(predicate?: Predicate<TElement>, def?: TElement) {
+  lastOrDefault(predicate?: AnyPredicate<TElement>, def?: TElement) {
     return this.#sequence.lastOrDefault(predicate, def);
   }
 
-  single(predicate?: Predicate<TElement>) {
+  single(predicate?: AnyPredicate<TElement>) {
     return this.#sequence.single(predicate);
   }
 
-  singleOrDefault(predicate?: Predicate<TElement>, def?: TElement) {
+  singleOrDefault(predicate?: AnyPredicate<TElement>, def?: TElement) {
     return this.#sequence.singleOrDefault(predicate, def);
   }
 
@@ -844,11 +885,11 @@ export class DelegatedSequence<TElement> extends SequenceMarker implements Seque
     return this.#sequence.orderByDescending(selector, comparer);
   }
 
-  partition(equater?: Equater<TElement> | undefined): Sequence<TElement[]> {
+  partition(equater?: Equater<TElement> | undefined): Sequence<Sequence<TElement>> {
     return this.#sequence.partition(equater);
   }
 
-  partitionBy<TBy>(selector: Converter<TElement, TBy>, equater?: Equater<TBy> | undefined): Sequence<TElement[]> {
+  partitionBy<TBy>(selector: Converter<TElement, TBy>, equater?: Equater<TBy> | undefined): Sequence<Sequence<TElement>> {
     return this.#sequence.partitionBy(selector, equater);
   }
 
@@ -884,17 +925,17 @@ export class DelegatedSequence<TElement> extends SequenceMarker implements Seque
     return this.#sequence.intersectBy(sequence, selector, equater);
   }
 
-  all(predicate: Predicate<TElement>) {
+  all(predicate: AnyPredicate<TElement>) {
     return this.#sequence.all(predicate);
   }
 
-  any(predicate: Predicate<TElement>): boolean;
+  any(predicate: AnyPredicate<TElement>): boolean;
   any(): boolean;
   any(predicate?: any) {
     return this.#sequence.any(predicate);
   }
 
-  none(predicate: Predicate<TElement>): boolean;
+  none(predicate: AnyPredicate<TElement>): boolean;
   none(): boolean;
   none(predicate?: any) {
     return this.#sequence.none(predicate);
@@ -908,7 +949,7 @@ export class DelegatedSequence<TElement> extends SequenceMarker implements Seque
     return this.#sequence.skipLast(n);
   }
 
-  skipWhile(condition: Predicate<TElement>) {
+  skipWhile(condition: AnyPredicate<TElement>) {
     return this.#sequence.skipWhile(condition);
   }
 
@@ -920,7 +961,7 @@ export class DelegatedSequence<TElement> extends SequenceMarker implements Seque
     return this.#sequence.takeLast(n);
   }
 
-  takeWhile(condition: Predicate<TElement>) {
+  takeWhile(condition: AnyPredicate<TElement>) {
     return this.#sequence.takeWhile(condition);
   }
 
@@ -944,8 +985,10 @@ export class DelegatedSequence<TElement> extends SequenceMarker implements Seque
     return this.#sequence.reversed();
   }
 
-  chunked(size: number) {
-    return this.#sequence.chunked(size);
+  chunked(size: number, asArray?: false): Sequence<Sequence<TElement>>;
+  chunked(size: number, asArray: true): Sequence<TElement[]>;
+  chunked(size: number, asArray?: any): Sequence<Sequence<TElement>> | Sequence<TElement[]> {
+    return this.#sequence.chunked(size, asArray);
   }
 
   random(options?: RandomOptions<TElement>) {
@@ -960,11 +1003,17 @@ export class DelegatedSequence<TElement> extends SequenceMarker implements Seque
     return this.#sequence.awaited();
   }
 
+  asArray() {
+    return this.#sequence.asArray();
+  }
+
   toArray() {
     return this.#sequence.toArray();
   }
 
-  toMap<TKey, TValue>(keySelector: Converter<TElement, TKey>, valueSelector: Converter<TElement, TValue>) {
+  toMap<TKey>(keySelector: Converter<TElement, TKey>): Map<TKey, TElement>;
+  toMap<TKey, TValue>(keySelector: Converter<TElement, TKey>, valueSelector: Converter<TElement, TValue>): Map<TKey, TValue>;
+  toMap(keySelector: any, valueSelector?: any) {
     return this.#sequence.toMap(keySelector, valueSelector);
   }
 
@@ -972,7 +1021,9 @@ export class DelegatedSequence<TElement> extends SequenceMarker implements Seque
     return this.#sequence.toSet();
   }
 
-  toObject<TKey extends PropertyKey, TValue>(keySelector: Converter<TElement, TKey>, valueSelector: Converter<TElement, TValue>) {
+  toObject<TKey extends PropertyKey>(keySelector: Converter<TElement, TKey>): Record<TKey, TElement>;
+  toObject<TKey extends PropertyKey, TValue>(keySelector: Converter<TElement, TKey>, valueSelector: Converter<TElement, TValue>): Record<TKey, TValue>;
+  toObject(keySelector: any, valueSelector?: any) {
     return this.#sequence.toObject(keySelector, valueSelector);
   }
 
@@ -993,8 +1044,17 @@ export class GroupedSequenceImpl<TKey, TElement> extends DelegatedSequence<TElem
   public get key() {
     return this.#key;
   }
+
+  [util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
+    return `Group { key: ${inspect(this.#key)}, sequence: ${inspect(this.sequence)} }`;
+  }
+
+  override toJSON() {
+    return { key: this.#key, items: this.toArray() };
+  }
 }
 
+//# TODO
 export abstract class BaseOrderedSequence<TElement> extends BaseSequence<TElement> implements OrderedSequence<TElement> {
   readonly #sequence: Sequence<TElement>;
   readonly #sorter: Comparer<TElement> | undefined;
@@ -1008,6 +1068,10 @@ export abstract class BaseOrderedSequence<TElement> extends BaseSequence<TElemen
     this.#descending = descending;
   }
 
+  protected get sequence() {
+    return this.#sequence;
+  }
+
   override nonEnumeratedCount() {
     return this.#sequence.nonEnumeratedCount();
   }
@@ -1020,6 +1084,10 @@ export abstract class BaseOrderedSequence<TElement> extends BaseSequence<TElemen
     return this.#sorter;
   }
 
+  get descending() {
+    return this.#descending;
+  }
+
   thenSelf(comparer?: Comparer<TElement>): OrderedSequence<TElement> {
     return new ThenOrderSequence(this, false, comparer);
   }
@@ -1063,6 +1131,10 @@ class EmptySequence<T> extends BaseSequence<T> {
   }
 
   override *iterator() { }
+
+  [util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
+    return `Empty {}`;
+  }
 }
 
 export const EMPTY = new EmptySequence<any>();
@@ -1097,6 +1169,10 @@ export class RangeSequence extends BaseSequence<number> {
       yield i;
     }
   }
+
+  [util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
+    return `Range { start: ${inspect(this.#min)}, end: ${inspect(this.#max)}, step: ${inspect(this.#step)} }`;
+  }
 }
 
 export class BigIntRangeSequence extends BaseSequence<bigint> {
@@ -1129,6 +1205,10 @@ export class BigIntRangeSequence extends BaseSequence<bigint> {
       yield i;
     }
   }
+
+  [util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
+    return `BigIntRange { start: ${inspect(this.#min)}, end: ${inspect(this.#max)}, step: ${inspect(this.#step)} }`;
+  }
 }
 
 export class RepeatSequence<T> extends BaseSequence<T> {
@@ -1157,6 +1237,10 @@ export class RepeatSequence<T> extends BaseSequence<T> {
       yield this.#value;
     }
   }
+
+  [util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
+    return `Repeat { value: ${inspect(this.#value)}, amount: ${inspect(this.#count)} }`;
+  }
 }
 
 export class RepeatForeverSequence<T> extends BaseSequence<T> {
@@ -1181,6 +1265,10 @@ export class RepeatForeverSequence<T> extends BaseSequence<T> {
       yield this.#value;
     }
   }
+
+  [util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
+    return `RepeatForever { value: ${inspect(this.#value)} }`;
+  }
 }
 
 export class WrappedObject<T> extends BaseSequence<T> {
@@ -1203,6 +1291,10 @@ export class WrappedObject<T> extends BaseSequence<T> {
   override *iterator() {
     yield this.#obj;
   }
+
+  [util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
+    return `WrappedObject { value: ${inspect(this.#obj)} }`;
+  }
 }
 
 export class WrappedIterable<T> extends BaseSequence<T> {
@@ -1217,17 +1309,25 @@ export class WrappedIterable<T> extends BaseSequence<T> {
   override iterator() {
     return this.#iterable[Symbol.iterator]();
   }
+
+  [util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
+    return `WrappedIterable { value: ${inspect(this.#iterable)} }`;
+  }
 }
 
-export class WrappedArray<T> extends BaseSequence<T> {
-  readonly #array: T[];
+export class WrappedReadonlyArray<T> extends BaseSequence<T> {
+  readonly #array: ReadonlyArray<T>;
 
-  constructor(array: T[]) {
+  constructor(array: ReadonlyArray<T>) {
     super();
 
     this.#array = array;
   }
 
+  get array() {
+    return this.#array;
+  }
+
   override nonEnumeratedCount() {
     return this.#array.length;
   }
@@ -1244,11 +1344,11 @@ export class WrappedArray<T> extends BaseSequence<T> {
     return this.#array.includes(obj);
   }
 
-  override all(predicate: Predicate<T>) {
+  override all(predicate: AnyPredicate<T>) {
     return this.#array.every(predicate);
   }
 
-  override any(predicate?: Predicate<T>) {
+  override any(predicate?: AnyPredicate<T>) {
     if (predicate) {
       return this.#array.some(predicate);
     }
@@ -1256,7 +1356,7 @@ export class WrappedArray<T> extends BaseSequence<T> {
     return this.#array.length > 0;
   }
 
-  override none(predicate?: Predicate<T>) {
+  override none(predicate?: AnyPredicate<T>) {
     if (predicate) {
       return !this.#array.some(predicate);
     }
@@ -1277,6 +1377,24 @@ export class WrappedArray<T> extends BaseSequence<T> {
       }
     }
   }
+
+  [util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
+    return `WrappedArray { value: ${inspect(this.#array)} }`;
+  }
+}
+
+export class WrappedArray<T> extends WrappedReadonlyArray<T> {
+  constructor(array: T[]) {
+    super(array);
+  }
+
+  override asArray() {
+    return this.array as T[];
+  }
+
+  [util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
+    return `WrappedArray { value: ${inspect(this.array)} }`;
+  }
 }
 
 export class WrappedArrayLike<T> extends BaseSequence<T> {
@@ -1313,12 +1431,16 @@ export class WrappedArrayLike<T> extends BaseSequence<T> {
       }
     }
   }
+
+  [util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
+    return `WrappedArrayLike { value: ${inspect(this.#arrayLike)} }`;
+  }
 }
 
 export class WrappedSet<T> extends BaseSequence<T> {
-  readonly #set: Set<T>;
+  readonly #set: ReadonlySet<T>;
 
-  constructor(set: Set<T>) {
+  constructor(set: ReadonlySet<T>) {
     super();
 
     this.#set = set;
@@ -1343,12 +1465,16 @@ export class WrappedSet<T> extends BaseSequence<T> {
   override iterator() {
     return this.#set.values();
   }
+
+  [util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
+    return `WrappedSet { value: ${inspect(this.#set)} }`;
+  }
 }
 
 export class WrappedMap<K, V> extends BaseSequence<[K, V]> {
-  readonly #map: Map<K, V>;
+  readonly #map: ReadonlyMap<K, V>;
 
-  constructor(map: Map<K, V>) {
+  constructor(map: ReadonlyMap<K, V>) {
     super();
 
     this.#map = map;
@@ -1377,6 +1503,10 @@ export class WrappedMap<K, V> extends BaseSequence<[K, V]> {
   override iterator() {
     return this.#map.entries();
   }
+
+  [util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
+    return `WrappedMap { value: ${inspect(this.#map)} }`;
+  }
 }
 
 export class GeneratorSequence<T> extends BaseSequence<T> {
@@ -1391,6 +1521,10 @@ export class GeneratorSequence<T> extends BaseSequence<T> {
   override iterator() {
     return this.#generator()[Symbol.iterator]();
   }
+
+  [util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
+    return `WrappedGenerator { value: ${inspect(this.#generator)} }`;
+  }
 }
 
 export class FunctionSequence<T> extends BaseSequence<T> {
@@ -1415,6 +1549,10 @@ export class FunctionSequence<T> extends BaseSequence<T> {
       yield this.#f();
     }
   }
+
+  [util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
+    return `WrappedFunction { value: ${inspect(this.#f)} }`;
+  }
 }
 
 export class ConcatSequence<T> extends BaseSequence<T> {
@@ -1467,6 +1605,10 @@ export class ConcatSequence<T> extends BaseSequence<T> {
       yield* sequence;
     }
   }
+
+  [util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
+    return `Concat { sequences: ${inspect(this.#sequences)} }`;
+  }
 }
 
 class DistinctSequence<T> extends BaseSequence<T> {
@@ -1493,18 +1635,22 @@ class DistinctSequence<T> extends BaseSequence<T> {
       }
     }
   }
+
+  [util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
+    return `Distinct { equater: ${inspect(this.#equater)}, sequence: ${inspect(this.#sequence)} }`;
+  }
 }
 
 class DistinctBySequence<T, U> extends BaseSequence<T> {
   readonly #sequence: Sequence<T>;
-  readonly #selector: Converter<T, U>;
+  readonly #converter: Converter<T, U>;
   readonly #equater: Equater<U> | undefined;
 
-  constructor(sequence: Sequence<T>, selector: Converter<T, U>, equater?: Equater<U>) {
+  constructor(sequence: Sequence<T>, converter: Converter<T, U>, equater?: Equater<U>) {
     super();
 
     this.#sequence = sequence;
-    this.#selector = selector;
+    this.#converter = converter;
     this.#equater = equater;
   }
 
@@ -1516,11 +1662,15 @@ class DistinctBySequence<T, U> extends BaseSequence<T> {
     const set = createEqualitySet(this.#equater);
 
     for (const obj of this.#sequence) {
-      if (set.add(this.#selector(obj))) {
+      if (set.add(this.#converter(obj))) {
         yield obj;
       }
     }
   }
+
+  [util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
+    return `DistinctBy { converter: ${inspect(this.#converter)}, equater: ${inspect(this.#equater)}, sequence: ${inspect(this.#sequence)} }`;
+  }
 }
 
 class WhereSequence<TElement, TFiltered extends TElement> extends BaseSequence<TFiltered> {
@@ -1545,6 +1695,10 @@ class WhereSequence<TElement, TFiltered extends TElement> extends BaseSequence<T
       }
     }
   }
+
+  [util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
+    return `Where { predicate: ${inspect(this.#predicate)}, sequence: ${inspect(this.#sequence)} }`;
+  }
 }
 
 class SelectManySequence<T, U> extends BaseSequence<U> {
@@ -1563,6 +1717,10 @@ class SelectManySequence<T, U> extends BaseSequence<U> {
       yield* this.#converter(obj);
     }
   }
+
+  [util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
+    return `SelectMany { converter: ${inspect(this.#converter)}, sequence: ${inspect(this.#sequence)} }`;
+  }
 }
 
 class IndexedSequence<T> extends BaseSequence<[number, T]> {
@@ -1589,6 +1747,10 @@ class IndexedSequence<T> extends BaseSequence<[number, T]> {
       yield [i++, obj] as [number, T];
     }
   }
+
+  [util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
+    return `Indexed { sequence: ${inspect(this.#sequence)} }`;
+  }
 }
 
 class SelectSequence<T, U> extends BaseSequence<U> {
@@ -1615,13 +1777,17 @@ class SelectSequence<T, U> extends BaseSequence<U> {
       yield this.#converter(obj);
     }
   }
+
+  [util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
+    return `Select { converter: ${inspect(this.#converter)}, sequence: ${inspect(this.#sequence)} }`;
+  }
 }
 
 class SkipWhileSequence<T> extends BaseSequence<T> {
   readonly #sequence: Sequence<T>;
-  readonly #predicate: Predicate<T>;
+  readonly #predicate: AnyPredicate<T>;
 
-  constructor(sequence: Sequence<T>, predicate: Predicate<T>) {
+  constructor(sequence: Sequence<T>, predicate: AnyPredicate<T>) {
     super();
 
     this.#sequence = sequence;
@@ -1644,6 +1810,10 @@ class SkipWhileSequence<T> extends BaseSequence<T> {
 
     yield* e;
   }
+
+  [util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
+    return `SkipWhile { predicate: ${inspect(this.#predicate)}, sequence: ${inspect(this.#sequence)} }`;
+  }
 }
 
 class SkipLastSequence<T> extends BaseSequence<T> {
@@ -1689,6 +1859,10 @@ class SkipLastSequence<T> extends BaseSequence<T> {
       i = (i + 1) % this.#n;
     }
   }
+
+  [util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
+    return `SkipLast { amount: ${inspect(this.#n)}, sequence: ${inspect(this.#sequence)} }`;
+  }
 }
 
 class SkipSequence<T> extends BaseSequence<T> {
@@ -1725,13 +1899,17 @@ class SkipSequence<T> extends BaseSequence<T> {
 
     yield* asIterable(iterator);
   }
+
+  [util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
+    return `Skip { amount: ${inspect(this.#n)}, sequence: ${inspect(this.#sequence)} }`;
+  }
 }
 
 class TakeWhileSequence<T> extends BaseSequence<T> {
   readonly #sequence: Sequence<T>;
-  readonly #predicate: Predicate<T>;
+  readonly #predicate: AnyPredicate<T>;
 
-  constructor(sequence: Sequence<T>, predicate: Predicate<T>) {
+  constructor(sequence: Sequence<T>, predicate: AnyPredicate<T>) {
     super();
 
     this.#sequence = sequence;
@@ -1751,6 +1929,10 @@ class TakeWhileSequence<T> extends BaseSequence<T> {
       yield obj;
     }
   }
+
+  [util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
+    return `TakeWhile { predicate: ${inspect(this.#predicate)}, sequence: ${inspect(this.#sequence)} }`;
+  }
 }
 
 class TakeLastSequence<T> extends BaseSequence<T> {
@@ -1782,6 +1964,10 @@ class TakeLastSequence<T> extends BaseSequence<T> {
 
     yield* queue;
   }
+
+  [util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
+    return `TakeLast { amount: ${inspect(this.#n)}, sequence: ${inspect(this.#sequence)} }`;
+  }
 }
 
 class TakeSequence<T> extends BaseSequence<T> {
@@ -1819,17 +2005,33 @@ class TakeSequence<T> extends BaseSequence<T> {
       i--;
     }
   }
+
+  [util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
+    return `Take { amount: ${inspect(this.#n)}, sequence: ${inspect(this.#sequence)} }`;
+  }
 }
 
 class OrderSequence<T> extends BaseOrderedSequence<T> {
   constructor(sequence: Sequence<T>, descending: boolean, sorter?: Comparer<T>) {
     super(sequence, sorter, descending);
   }
+
+  [util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
+    return `Order${this.descending ? "Descending" : ""} { sequence: ${inspect(this.sequence)} }`;
+  }
 }
 
 class OrderBySequence<T, U> extends BaseOrderedSequence<T> {
+  readonly #selector: Converter<T, U>;
+
   constructor(sequence: Sequence<T>, descending: boolean, selector: Converter<T, U>, sorter?: Comparer<U>) {
     super(sequence, OrderBySequence.#createSorter(selector, sorter), descending);
+
+    this.#selector = selector;
+  }
+
+  [util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
+    return `OrderBy${this.descending ? "Descending" : ""} { converter: ${inspect(this.#selector)}, sequence: ${inspect(this.sequence)} }`;
   }
 
   static #createSorter<T, U>(selector: Converter<T, U>, sorter?: Comparer<U>) {
@@ -1842,11 +2044,23 @@ class ThenOrderSequence<T> extends BaseOrderedSequence<T> {
   constructor(sequence: OrderedSequence<T>, descending: boolean, sorter?: Comparer<T>) {
     super(sequence, combineComparers(sequence.comparer ?? defaultArrayComparer, sorter ?? defaultArrayComparer), descending);
   }
+
+  [util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
+    return `ThenOrder${this.descending ? "Descending" : ""} { sequence: ${inspect(this.sequence)} }`;
+  }
 }
 
 class ThenOrderBySequence<T, U> extends BaseOrderedSequence<T> {
+  readonly #selector: Converter<T, U>;
+
   constructor(sequence: OrderedSequence<T>, descending: boolean, selector: Converter<T, U>, sorter?: Comparer<U>) {
     super(sequence, ThenOrderBySequence.#createCombinedSorter(sequence.comparer, selector, sorter), descending);
+
+    this.#selector = selector;
+  }
+
+  [util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
+    return `ThenOrderBy${this.descending ? "Descending" : ""} { converter: ${inspect(this.#selector)}, sequence: ${inspect(this.sequence)} }`;
   }
 
   static #createCombinedSorter<T, U>(baseSorter: Comparer<T> | undefined, selector: Converter<T, U>, sorter?: Comparer<U>) {
@@ -1880,6 +2094,10 @@ class AppendSequence<T> extends BaseSequence<T> {
     yield* this.#sequence;
     yield this.#obj;
   }
+
+  [util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
+    return `Append { value: ${inspect(this.#obj)}, sequence: ${inspect(this.#sequence)} }`;
+  }
 }
 
 class PrependSequence<T> extends BaseSequence<T> {
@@ -1906,6 +2124,10 @@ class PrependSequence<T> extends BaseSequence<T> {
     yield this.#obj;
     yield* this.#sequence;
   }
+
+  [util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
+    return `Prepend { value: ${inspect(this.#obj)}, sequence: ${inspect(this.#sequence)} }`;
+  }
 }
 
 class PeekSequence<T> extends DelegatedSequence<T> {
@@ -1923,6 +2145,10 @@ class PeekSequence<T> extends DelegatedSequence<T> {
       yield obj;
     }
   }
+
+  [util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
+    return `Prepend { action: ${inspect(this.#action)}, sequence: ${inspect(this.sequence)} }`;
+  }
 }
 
 class ZippedSequence<T, U> extends BaseSequence<[T, U]> {
@@ -1962,6 +2188,10 @@ class ZippedSequence<T, U> extends BaseSequence<[T, U]> {
       yield [firstNext.value, secondNext.value] as [T, U];
     }
   }
+
+  [util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
+    return `Zip { first: ${inspect(this.#first)}, second: ${inspect(this.#second)} }`;
+  }
 }
 
 class UnionSequence<T> extends BaseSequence<T> {
@@ -1995,6 +2225,10 @@ class UnionSequence<T> extends BaseSequence<T> {
       }
     }
   }
+
+  [util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
+    return `Union { first: ${inspect(this.#first)}, second: ${inspect(this.#second)} }`;
+  }
 }
 
 class UnionBySequence<T, U> extends BaseSequence<T> {
@@ -2030,6 +2264,10 @@ class UnionBySequence<T, U> extends BaseSequence<T> {
       }
     }
   }
+
+  [util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
+    return `Zip { converter: ${inspect(this.#selector)}, equater: ${inspect(this.#equater)}, first: ${inspect(this.#first)}, second: ${inspect(this.#second)} }`;
+  }
 }
 
 class ExceptSequence<T> extends BaseSequence<T> {
@@ -2062,6 +2300,10 @@ class ExceptSequence<T> extends BaseSequence<T> {
       }
     }
   }
+
+  [util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
+    return `Except { equater: ${inspect(this.#equater)}, first: ${inspect(this.#first)}, second: ${inspect(this.#second)} }`;
+  }
 }
 
 class ExceptBySequence<T, U> extends BaseSequence<T> {
@@ -2096,6 +2338,10 @@ class ExceptBySequence<T, U> extends BaseSequence<T> {
       }
     }
   }
+
+  [util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
+    return `ExceptBy { converter: ${inspect(this.#selector)}, equater: ${inspect(this.#equater)}, first: ${inspect(this.#first)}, second: ${inspect(this.#second)} }`;
+  }
 }
 
 class IntersectSequence<T> extends BaseSequence<T> {
@@ -2128,6 +2374,10 @@ class IntersectSequence<T> extends BaseSequence<T> {
       }
     }
   }
+
+  [util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
+    return `Intersect { equater: ${inspect(this.#equater)}, first: ${inspect(this.#first)}, second: ${inspect(this.#second)} }`;
+  }
 }
 
 class IntersectBySequence<T, U> extends BaseSequence<T> {
@@ -2162,6 +2412,10 @@ class IntersectBySequence<T, U> extends BaseSequence<T> {
       }
     }
   }
+
+  [util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
+    return `IntersectBy { converter: ${inspect(this.#selector)}, equater: ${inspect(this.#equater)}, first: ${inspect(this.#first)}, second: ${inspect(this.#second)} }`;
+  }
 }
 
 class ReversedSequence<T> extends BaseSequence<T> {
@@ -2192,21 +2446,25 @@ class ReversedSequence<T> extends BaseSequence<T> {
       yield buffer.pop()!;
     }
   }
+
+  [util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
+    return `Reversed { sequence: ${inspect(this.#sequence)} }`;
+  }
 }
 
 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;
+  readonly #keyEquater: Equater<TKey> | undefined;
 
-  constructor(sequence: Sequence<TElement>, keySelector: Converter<TElement, TKey>, elementSelector?: Converter<TElement, TResult>, keyComparer?: Equater<TKey>) {
+  constructor(sequence: Sequence<TElement>, keySelector: Converter<TElement, TKey>, elementSelector?: Converter<TElement, TResult>, keyEquater?: Equater<TKey>) {
     super();
 
     this.#sequence = sequence;
     this.#keySelector = keySelector;
     this.#elementSelector = elementSelector ?? identity as Converter<TElement, TResult>;
-    this.#keyComparer = keyComparer;
+    this.#keyEquater = keyEquater;
   }
 
   override maxCount() {
@@ -2214,7 +2472,7 @@ class GroupBySequence<TElement, TKey, TResult> extends BaseSequence<GroupedSeque
   }
 
   override *iterator() {
-    const groupings = createEqualityMap<TKey, TResult[]>(this.#keyComparer);
+    const groupings = createEqualityMap<TKey, TResult[]>(this.#keyEquater);
 
     for (const obj of this.#sequence) {
       const key = this.#keySelector(obj);
@@ -2233,9 +2491,13 @@ class GroupBySequence<TElement, TKey, TResult> extends BaseSequence<GroupedSeque
       yield new GroupedSequenceImpl(entry[0], array(entry[1]));
     }
   }
+
+  [util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
+    return `GroupBy { keySelector: ${inspect(this.#keySelector)}, elementSelector: ${inspect(this.#elementSelector)}, keyEquater: ${inspect(this.#keyEquater)}, sequence: ${inspect(this.#sequence)} }`;
+  }
 }
 
-class ChunkedSequence<T> extends BaseSequence<Sequence<T>> {
+class ChunkedSequence<T> extends BaseSequence<T[]> {
   readonly #sequence: Sequence<T>;
   readonly #size: number;
 
@@ -2262,15 +2524,19 @@ class ChunkedSequence<T> extends BaseSequence<Sequence<T>> {
       chunk.push(obj);
 
       if (chunk.length === this.#size) {
-        yield array(chunk);
+        yield chunk;
         chunk = [];
       }
     }
 
     if (chunk.length > 0) {
-      yield array(chunk);
+      yield chunk;
     }
   }
+
+  [util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
+    return `ChunkedAsArray { size: ${inspect(this.#size, options)} sequence: ${inspect(this.#sequence, options)} }`;
+  }
 }
 
 class JoinSequence<TOuter, TInner, TKey, TResult> extends BaseSequence<TResult> {
@@ -2279,9 +2545,9 @@ class JoinSequence<TOuter, TInner, TKey, TResult> extends BaseSequence<TResult>
   readonly #firstKeySelector: Converter<TOuter, TKey>;
   readonly #secondKeySelector: Converter<TInner, TKey>;
   readonly #resultSelector: BiConverter<TOuter, TInner, TResult>;
-  readonly #keyComparer: Equater<TKey>;
+  readonly #keyEquater: 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>) {
+  constructor(first: Sequence<TOuter>, second: Sequence<TInner>, firstKeySelector: Converter<TOuter, TKey>, secondKeySelector: Converter<TInner, TKey>, resultSelector?: BiConverter<TOuter, TInner, TResult>, keyEquater?: Equater<TKey>) {
     super();
 
     this.#first = first;
@@ -2289,7 +2555,7 @@ class JoinSequence<TOuter, TInner, TKey, TResult> extends BaseSequence<TResult>
     this.#firstKeySelector = firstKeySelector;
     this.#secondKeySelector = secondKeySelector;
     this.#resultSelector = resultSelector ?? JoinSequence.#defaultResultSelector as BiConverter<TOuter, TInner, TResult>;
-    this.#keyComparer = keyComparer ?? strictEquals;
+    this.#keyEquater = keyEquater ?? strictEquals;
   }
 
   static #defaultResultSelector<TOuter, TInner>(first: TOuter, second: TInner): [TOuter, TInner] {
@@ -2307,12 +2573,16 @@ class JoinSequence<TOuter, TInner, TKey, TResult> extends BaseSequence<TResult>
       for (const secondObj of this.#second) {
         const secondKey = this.#secondKeySelector(secondObj);
 
-        if (this.#keyComparer(firstKey, secondKey)) {
+        if (this.#keyEquater(firstKey, secondKey)) {
           yield this.#resultSelector(firstObj, secondObj);
         }
       }
     }
   }
+
+  [util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
+    return `Join { firstKeySelector: ${inspect(this.#firstKeySelector)}, secondKeySelector: ${inspect(this.#secondKeySelector)}, resultSelector: ${inspect(this.#resultSelector)}, keyEquater: ${inspect(this.#keyEquater)}, first: ${inspect(this.#first)}, second: ${inspect(this.#second)} }`;
+  }
 }
 
 class GroupJoinSequence<TOuter, TInner, TKey, TResult> extends BaseSequence<TResult> {
@@ -2321,9 +2591,9 @@ class GroupJoinSequence<TOuter, TInner, TKey, TResult> extends BaseSequence<TRes
   readonly #firstKeySelector: Converter<TOuter, TKey>;
   readonly #secondKeySelector: Converter<TInner, TKey>;
   readonly #resultSelector: BiConverter<TOuter, Sequence<TInner>, TResult>;
-  readonly #keyComparer: Equater<TKey>;
+  readonly #keyEquater: 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>) {
+  constructor(first: Sequence<TOuter>, second: Sequence<TInner>, firstKeySelector: Converter<TOuter, TKey>, secondKeySelector: Converter<TInner, TKey>, resultSelector?: BiConverter<TOuter, Sequence<TInner>, TResult>, keyEquater?: Equater<TKey>) {
     super();
 
     this.#first = first;
@@ -2331,7 +2601,7 @@ class GroupJoinSequence<TOuter, TInner, TKey, TResult> extends BaseSequence<TRes
     this.#firstKeySelector = firstKeySelector;
     this.#secondKeySelector = secondKeySelector;
     this.#resultSelector = resultSelector ?? GroupJoinSequence.#defaultResultSelector as BiConverter<TOuter, Sequence<TInner>, TResult>;
-    this.#keyComparer = keyComparer ?? strictEquals;
+    this.#keyEquater = keyEquater ?? strictEquals;
   }
 
   static #defaultResultSelector<TOuter, TInner>(first: TOuter, second: Sequence<TInner>) {
@@ -2354,7 +2624,7 @@ class GroupJoinSequence<TOuter, TInner, TKey, TResult> extends BaseSequence<TRes
       for (const secondObj of this.#second) {
         const secondKey = this.#secondKeySelector(secondObj);
 
-        if (this.#keyComparer(firstKey, secondKey)) {
+        if (this.#keyEquater(firstKey, secondKey)) {
           secondObjs.push(secondObj);
         }
       }
@@ -2362,6 +2632,10 @@ class GroupJoinSequence<TOuter, TInner, TKey, TResult> extends BaseSequence<TRes
       yield this.#resultSelector(firstObj, array(secondObjs));
     }
   }
+
+  [util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
+    return `GroupJoin { firstKeySelector: ${inspect(this.#firstKeySelector)}, secondKeySelector: ${inspect(this.#secondKeySelector)}, resultSelector: ${inspect(this.#resultSelector)}, keyEquater: ${inspect(this.#keyEquater)}, first: ${inspect(this.#first)}, second: ${inspect(this.#second)} }`;
+  }
 }
 
 class RemoveSequence<T> extends BaseSequence<T> {
@@ -2401,6 +2675,10 @@ class RemoveSequence<T> extends BaseSequence<T> {
       yield obj;
     }
   }
+
+  [util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
+    return `Remove { value: ${inspect(this.#obj)}, all: ${inspect(this.#all)}, equater: ${inspect(this.#equater)} sequence: ${inspect(this.#sequence)} }`;
+  }
 }
 
 class CacheSequence<T> extends DelegatedSequence<T> {
@@ -2418,9 +2696,13 @@ class CacheSequence<T> extends DelegatedSequence<T> {
 
     return super.iterator();
   }
+
+  [util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
+    return `Cached { sequence: ${inspect(this.sequence)} }`;
+  }
 }
 
-class PartitionSequence<T> extends BaseSequence<T[]> {
+class PartitionSequence<T> extends BaseSequence<Sequence<T>> {
   readonly #sequence: Sequence<T>;
   readonly #equater: Equater<T>;
 
@@ -2444,11 +2726,17 @@ class PartitionSequence<T> extends BaseSequence<T[]> {
       }
     }
 
-    yield* partitions.values();
+    for (const partition of partitions.values()) {
+      yield array(partition);
+    }
+  }
+
+  [util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
+    return `Partition { equater: ${inspect(this.#equater)}, sequence: ${inspect(this.#sequence)} }`;
   }
 }
 
-class PartitionBySequence<TElement, TBy> extends BaseSequence<TElement[]> {
+class PartitionBySequence<TElement, TBy> extends BaseSequence<Sequence<TElement>> {
   readonly #sequence: Sequence<TElement>;
   readonly #selector: Converter<TElement, TBy>;
   readonly #equater: Equater<TBy>;
@@ -2475,7 +2763,13 @@ class PartitionBySequence<TElement, TBy> extends BaseSequence<TElement[]> {
       }
     }
 
-    yield* partitions.values();
+    for (const partition of partitions.values()) {
+      yield array(partition);
+    }
+  }
+
+  [util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
+    return `PartitionBy { converter: ${inspect(this.#selector)}, equater: ${inspect(this.#equater)}, sequence: ${inspect(this.#sequence)} }`;
   }
 }
 
@@ -2491,4 +2785,8 @@ class AwaitedSequence<T> extends BaseAsyncSequence<Awaited<T>> {
   override async *iterator() {
     yield* this.#sequence;
   }
+
+  [util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
+    return `Awaited { sequence: ${inspect(this.#sequence)} }`;
+  }
 }
diff --git a/src/sync/index.ts b/src/sync/index.ts
index 1102dd8..b96af7c 100644
--- a/src/sync/index.ts
+++ b/src/sync/index.ts
@@ -1,9 +1,9 @@
 import { mathRandom } from "../random/index.js";
 import { RandomGenerator } from "../random/types.js";
-import { BigIntRangeSequence, ConcatSequence, SequenceMarker, FunctionSequence, GeneratorSequence, RangeSequence, RepeatSequence, RepeatForeverSequence, WrappedArray, WrappedArrayLike, WrappedIterable, WrappedMap, WrappedObject, WrappedSet, EMPTY } from "./impl.js";
+import { BigIntRangeSequence, ConcatSequence, SequenceMarker, FunctionSequence, GeneratorSequence, RangeSequence, RepeatSequence, RepeatForeverSequence, WrappedArrayLike, WrappedIterable, WrappedMap, WrappedObject, WrappedSet, WrappedReadonlyArray, EMPTY } from "./impl.js";
 import { Sequence } from "./types.js";
 
-export function wrap<T>(iterable: Iterable<T>): Sequence<T> {
+export function wrap<T = any>(iterable: Iterable<T>): Sequence<T> {
   if (isSequence<T>(iterable)) {
     return iterable;
   }
@@ -23,11 +23,11 @@ export function wrap<T>(iterable: Iterable<T>): Sequence<T> {
   return sequence(iterable);
 }
 
-export function sequence<T>(iterable: Iterable<T>): Sequence<T> {
+export function sequence<T = any>(iterable: Iterable<T>): Sequence<T> {
   return new WrappedIterable(iterable);
 }
 
-export function empty<T>(): Sequence<T> {
+export function empty<T = any>(): Sequence<T> {
   return EMPTY;
 }
 
@@ -35,19 +35,19 @@ export function single<T>(obj: T): Sequence<T> {
   return new WrappedObject(obj);
 }
 
-export function array<T>(array: T[]): Sequence<T> {
-  return new WrappedArray(array);
+export function array<T = any>(array: ReadonlyArray<T>): Sequence<T> {
+  return new WrappedReadonlyArray(array);
 }
 
-export function arrayLike<T>(arrayLike: ArrayLike<T>): Sequence<T> {
+export function arrayLike<T = any>(arrayLike: ArrayLike<T>): Sequence<T> {
   return new WrappedArrayLike(arrayLike);
 }
 
-export function set<T>(set: Set<T>): Sequence<T> {
+export function set<T>(set: ReadonlySet<T>): Sequence<T> {
   return new WrappedSet(set);
 }
 
-export function map<K, V>(map: Map<K, V>): Sequence<[K, V]> {
+export function map<K, V>(map: ReadonlyMap<K, V>): Sequence<[K, V]> {
   return new WrappedMap(map);
 }
 
diff --git a/src/sync/types.ts b/src/sync/types.ts
index 45babc9..5cde0bb 100644
--- a/src/sync/types.ts
+++ b/src/sync/types.ts
@@ -1,14 +1,18 @@
 import { AsyncSequence } from "../async/types.js";
 import { Collector } from "../collector/types.js";
 import { RandomOptions } from "../random/types.js";
-import { Predicate, Converter, FilterPredicate, Equater, BiConverter, Accumulator, Comparer, Action } from "../types.js";
+import { AnyPredicate, Converter, FilterPredicate, Equater, BiConverter, Accumulator, Comparer, Action } from "../types.js";
+
+export type SequencePipeline<TElement, TResult> = (sequence: Sequence<TElement>) => TResult;
 
 export interface Sequence<TElement> extends Iterable<TElement> {
   iterator(): Iterator<TElement>;
 
-  apply<TResult>(pipeline: (sequence: Sequence<TElement>) => TResult): TResult;
+  toJSON(): any;
 
-  count(predicate?: Predicate<TElement>): number;
+  apply<TResult>(pipeline: SequencePipeline<TElement, TResult>): TResult;
+
+  count(predicate?: AnyPredicate<TElement>): number;
   nonEnumeratedCount(): number;
   fastCount(): number;
   maxCount(): number;
@@ -17,7 +21,7 @@ export interface Sequence<TElement> extends Iterable<TElement> {
   selectMany<TResult>(selector: Converter<TElement, Sequence<TResult>>): Sequence<TResult>;
 
   where<TFiltered extends TElement>(predicate: FilterPredicate<TElement, TFiltered>): Sequence<TFiltered>;
-  where(predicate: Predicate<TElement>): Sequence<TElement>;
+  where(predicate: AnyPredicate<TElement>): Sequence<TElement>;
 
   groupBy<TKey>(keySelector: Converter<TElement, TKey>, elementSelector?: undefined, keyComparer?: Equater<TKey>): Sequence<GroupedSequence<TKey, TElement>>;
   groupBy<TKey, TResult>(keySelector: Converter<TElement, TKey>, elementSelector: Converter<TElement, TResult>, keyComparer?: Equater<TKey>): Sequence<GroupedSequence<TKey, TResult>>;
@@ -40,14 +44,14 @@ export interface Sequence<TElement> extends Iterable<TElement> {
 
   concat(...sequences: Sequence<TElement>[]): Sequence<TElement>;
 
-  first(predicate?: Predicate<TElement>): TElement;
-  firstOrDefault(predicate?: Predicate<TElement>, def?: TElement): TElement | undefined;
+  first(predicate?: AnyPredicate<TElement>): TElement;
+  firstOrDefault(predicate?: AnyPredicate<TElement>, def?: TElement): TElement | undefined;
 
-  last(predicate?: Predicate<TElement>): TElement;
-  lastOrDefault(predicate?: Predicate<TElement>, def?: TElement): TElement | undefined;
+  last(predicate?: AnyPredicate<TElement>): TElement;
+  lastOrDefault(predicate?: AnyPredicate<TElement>, def?: TElement): TElement | undefined;
 
-  single(predicate?: Predicate<TElement>): TElement;
-  singleOrDefault(predicate?: Predicate<TElement>, def?: TElement): TElement | undefined;
+  single(predicate?: AnyPredicate<TElement>): TElement;
+  singleOrDefault(predicate?: AnyPredicate<TElement>, def?: TElement): TElement | undefined;
 
   elementAt(index: number): TElement;
   elementAtOrDefault(index: number, def?: TElement): TElement | undefined;
@@ -68,8 +72,8 @@ export interface Sequence<TElement> extends Iterable<TElement> {
   orderDescending(comparer?: Comparer<TElement>): OrderedSequence<TElement>;
   orderByDescending<TBy>(selector: Converter<TElement, TBy>, comparer?: Comparer<TBy>): OrderedSequence<TElement>;
 
-  partition(equater?: Equater<TElement>): Sequence<TElement[]>;
-  partitionBy<TBy>(selector: Converter<TElement, TBy>, equater?: Equater<TBy>): Sequence<TElement[]>;
+  partition(equater?: Equater<TElement>): Sequence<Sequence<TElement>>;
+  partitionBy<TBy>(selector: Converter<TElement, TBy>, equater?: Equater<TBy>): Sequence<Sequence<TElement>>;
 
   distinct(equater?: Equater<TElement>): Sequence<TElement>;
   distinctBy<TBy>(selector: Converter<TElement, TBy>, equater?: Equater<TBy>): Sequence<TElement>;
@@ -83,19 +87,19 @@ export interface Sequence<TElement> extends Iterable<TElement> {
   intersect(sequence: Sequence<TElement>, equater?: Equater<TElement>): Sequence<TElement>;
   intersectBy<TBy>(sequence: Sequence<TElement>, selector: Converter<TElement, TBy>, equater?: Equater<TBy>): Sequence<TElement>;
 
-  all(predicate: Predicate<TElement>): boolean;
-  any(predicate: Predicate<TElement>): boolean;
+  all(predicate: AnyPredicate<TElement>): boolean;
+  any(predicate: AnyPredicate<TElement>): boolean;
   any(): boolean;
-  none(predicate: Predicate<TElement>): boolean;
+  none(predicate: AnyPredicate<TElement>): boolean;
   none(): boolean;
 
   skip(n: number): Sequence<TElement>;
   skipLast(n: number): Sequence<TElement>;
-  skipWhile(condition: Predicate<TElement>): Sequence<TElement>;
+  skipWhile(condition: AnyPredicate<TElement>): Sequence<TElement>;
 
   take(n: number): Sequence<TElement>;
   takeLast(n: number): Sequence<TElement>;
-  takeWhile(condition: Predicate<TElement>): Sequence<TElement>;
+  takeWhile(condition: AnyPredicate<TElement>): Sequence<TElement>;
 
   peek(action: Action<TElement>): Sequence<TElement>;
 
@@ -107,7 +111,8 @@ export interface Sequence<TElement> extends Iterable<TElement> {
 
   reversed(): Sequence<TElement>;
 
-  chunked(size: number): Sequence<Sequence<TElement>>;
+  chunked(size: number, asArray?: false): Sequence<Sequence<TElement>>;
+  chunked(size: number, asArray: true): Sequence<TElement[]>;
 
   random(options?: RandomOptions<TElement>): TElement | undefined;
 
@@ -115,9 +120,12 @@ export interface Sequence<TElement> extends Iterable<TElement> {
 
   awaited(): AsyncSequence<Awaited<TElement>>;
 
+  asArray(): TElement[];
   toArray(): TElement[];
+  toMap<TKey>(keySelector: Converter<TElement, TKey>): Map<TKey, TElement>;
   toMap<TKey, TValue>(keySelector: Converter<TElement, TKey>, valueSelector: Converter<TElement, TValue>): Map<TKey, TValue>;
   toSet(): Set<TElement>;
+  toObject<TKey extends PropertyKey>(keySelector: Converter<TElement, TKey>): Record<TKey, TElement>;
   toObject<TKey extends PropertyKey, TValue>(keySelector: Converter<TElement, TKey>, valueSelector: Converter<TElement, TValue>): Record<TKey, TValue>;
 
   collect<TResult>(collector: Collector<TElement, any, TResult>): TResult;
diff --git a/src/types.ts b/src/types.ts
index 11952ae..3dfbd07 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -2,6 +2,7 @@ import { AsyncSequence } from "./async/types.js";
 import { Sequence } from "./sync/types.js";
 
 export type Predicate<T> = (obj: T) => boolean;
+export type AnyPredicate<T> = (obj: T) => unknown;
 export type FilterPredicate<TElement, TFiltered extends TElement> = (obj: TElement) => obj is TFiltered;
 export type Converter<TFrom, TTo> = (obj: TFrom) => TTo;
 export type BiConverter<TFromFirst, TFromSecond, TTo> = (first: TFromFirst, second: TFromSecond) => TTo;
@@ -20,7 +21,9 @@ export type MaybeAsyncFunction<TFunc extends (...args: any) => any> = TFunc exte
 export type MaybeAsyncSequence<T> = Sequence<T> | AsyncSequence<T>;
 
 export type AsyncPredicate<T> = AsyncFunction<Predicate<T>>;
+export type AsyncAnyPredicate<T> = AsyncFunction<AnyPredicate<T>>;
 export type MaybeAsyncPredicate<T> = MaybeAsyncFunction<Predicate<T>>;
+export type MaybeAsyncAnyPredicate<T> = MaybeAsyncFunction<AnyPredicate<T>>;
 export type AsyncConverter<TFrom, TTo> = AsyncFunction<Converter<TFrom, TTo>>;
 export type MaybeAsyncConverter<TFrom, TTo> = MaybeAsyncFunction<Converter<TFrom, TTo>>;
 export type AsyncBiConverter<TFromFirst, TFromSecond, TTo> = AsyncFunction<BiConverter<TFromFirst, TFromSecond, TTo>>;