From e5e6bffe1e55b3245dace830ff81efc1b040873f Mon Sep 17 00:00:00 2001
From: Herve BECHER <herve.becher@ext.ec.europa.eu>
Date: Mon, 14 Oct 2024 07:38:23 +0200
Subject: [PATCH] sync

---
 src/async/impl.ts   |  71 +++++---
 src/async/index.ts  |   2 +-
 src/async/types.ts  |  10 +-
 src/equality-set.ts |   2 +-
 src/sync/impl.ts    | 398 ++++++++++++++------------------------------
 src/sync/index.ts   |   8 +-
 src/sync/types.ts   |   7 +-
 src/types.ts        |   2 +-
 src/utils.ts        |   2 +-
 9 files changed, 193 insertions(+), 309 deletions(-)

diff --git a/src/async/impl.ts b/src/async/impl.ts
index f6665cb..b24ad2d 100644
--- a/src/async/impl.ts
+++ b/src/async/impl.ts
@@ -6,10 +6,10 @@ import { getRandomElementAsync } from "../random/index.js";
 import { AsyncRandomOptions } from "../random/types.js";
 import { selectionSorter } from "../sorting.js";
 import { Sequence } from "../sync/types.js";
-import { MaybeAsyncAnyPredicate, MaybeAsyncConverter, MaybeAsyncEquater, MaybeAsyncBiConverter, MaybeAsyncAccumulator, MaybeAsyncComparer, MaybeAsyncAction, MaybePromiseLike, MaybeAsyncGenerator, MaybeAsyncSequence } from "../types.js";
+import { MaybeAsyncAnyPredicate, MaybeAsyncConverter, MaybeAsyncEquater, MaybeAsyncBiConverter, MaybeAsyncAccumulator, MaybeAsyncComparer, MaybeAsyncAction, MaybePromiseLike, MaybeAsyncGenerator, MaybeAsyncSequence, MaybePromise } from "../types.js";
 import { strictEquals, identity, operatorCompare, defaultArrayComparer, combineAsyncComparers, asAsyncIterable } from "../utils.js";
 import { array, empty, wrap } from "./index.js";
-import { AsyncSequence, GroupedAsyncSequence, OrderedAsyncSequence } from "./types.js";
+import { AsyncSequence, AsyncSequencePipeline, GroupedAsyncSequence, OrderedAsyncSequence } from "./types.js";
 
 export class AsyncSequenceMarker { }
 
@@ -20,7 +20,7 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
 
   abstract iterator(): AsyncIterator<TElement>;
 
-  apply<TResult>(pipeline: (sequence: AsyncSequence<TElement>) => TResult): TResult {
+  apply<TResult>(pipeline: AsyncSequencePipeline<TElement, TResult>): MaybePromise<TResult> {
     return pipeline(this);
   }
 
@@ -397,7 +397,7 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
     let next = await iterator.next();
 
     if (next.done) {
-      throw new Error("Sequence contains no element.")
+      throw new Error("Sequence contains no element.");
     }
 
     if (!selector) {
@@ -620,15 +620,15 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
     return new ReversedAsyncSequence<TElement>(this);
   }
 
-  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[]> {
+  chunked(size: number): AsyncSequence<AsyncSequence<TElement>>;
+  chunked<TResult>(size: number, transformer: AsyncSequencePipeline<TElement, TResult>): AsyncSequence<TResult>;
+  chunked<TResult>(size: number, transformer?: AsyncSequencePipeline<TElement, TResult>): AsyncSequence<AsyncSequence<TElement>> | AsyncSequence<TResult> {
     if (size <= 0) {
       throw new Error("Chunk size must be positive.");
     }
 
-    const sequence = new ChunkedAsyncSequence<TElement>(this, size);
-    return asArray ? sequence : sequence.select(array);
+    const result = new ChunkedAsyncSequence<TElement>(this, size);
+    return transformer ? result.select(transformer) : result;
   }
 
   async random(options?: AsyncRandomOptions<TElement> | undefined): Promise<TElement | undefined> {
@@ -721,10 +721,6 @@ export class DelegatedAsyncSequence<TElement> extends AsyncSequenceMarker implem
     return this.#sequence;
   }
 
-  protected set sequence(value: AsyncSequence<TElement>) {
-    this.#sequence = value;
-  }
-
   [Symbol.asyncIterator]() {
     return this.iterator();
   }
@@ -733,7 +729,7 @@ export class DelegatedAsyncSequence<TElement> extends AsyncSequenceMarker implem
     return this.#sequence.iterator();
   }
 
-  apply<TResult>(pipeline: (sequence: AsyncSequence<TElement>) => TResult) {
+  apply<TResult>(pipeline: AsyncSequencePipeline<TElement, TResult>) {
     return this.#sequence.apply(pipeline);
   }
 
@@ -978,10 +974,10 @@ export class DelegatedAsyncSequence<TElement> extends AsyncSequenceMarker implem
     return this.#sequence.reversed();
   }
 
-  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);
+  chunked(size: number): AsyncSequence<AsyncSequence<TElement>>;
+  chunked<TResult>(size: number, transformer: AsyncSequencePipeline<TElement, TResult>): AsyncSequence<TResult>;
+  chunked(size: number, transformer?: any): any {
+    return this.#sequence.chunked(size, transformer);
   }
 
   random(options?: AsyncRandomOptions<TElement> | undefined): Promise<TElement | undefined> {
@@ -1186,9 +1182,9 @@ export class WrappedObjectAsync<T> extends BaseAsyncSequence<T> {
 }
 
 export class WrappedArrayAsync<T> extends BaseAsyncSequence<T> {
-  readonly #array: MaybePromiseLike<T>[];
+  readonly #array: ReadonlyArray<MaybePromiseLike<T>>;
 
-  constructor(array: MaybePromiseLike<T>[]) {
+  constructor(array: ReadonlyArray<MaybePromiseLike<T>>) {
     super();
 
     this.#array = array;
@@ -1694,6 +1690,10 @@ class AppendAsyncSequence<T> extends BaseAsyncSequence<T> {
     return n < 0 ? -1 : n + 1;
   }
 
+  override async maxCount() {
+    return await this.#sequence.maxCount() + 1;
+  }
+
   override async *iterator() {
     yield* this.#sequence;
     yield this.#obj;
@@ -1716,23 +1716,29 @@ class PrependAsyncSequence<T> extends BaseAsyncSequence<T> {
     return n < 0 ? -1 : n + 1;
   }
 
+  override async maxCount() {
+    return await this.#sequence.maxCount() + 1;
+  }
+
   override async *iterator() {
     yield this.#obj;
     yield* this.#sequence;
   }
 }
 
-class PeekAsyncSequence<T> extends DelegatedAsyncSequence<T> {
+class PeekAsyncSequence<T> extends BaseAsyncSequence<T> {
+  readonly #sequence: AsyncSequence<T>;
   readonly #action: MaybeAsyncAction<T>;
 
   constructor(sequence: AsyncSequence<T>, action: MaybeAsyncAction<T>) {
-    super(sequence);
+    super();
 
+    this.#sequence = sequence;
     this.#action = action;
   }
 
   override async *iterator() {
-    for await (const obj of this.sequence) {
+    for await (const obj of this.#sequence) {
       await this.#action(obj);
       yield obj;
     }
@@ -2023,7 +2029,7 @@ class GroupByAsyncSequence<TElement, TKey, TResult> extends BaseAsyncSequence<Gr
   }
 }
 
-class ChunkedAsyncSequence<T> extends BaseAsyncSequence<T[]> {
+class ChunkedAsyncSequence<T> extends BaseAsyncSequence<AsyncSequence<T>> {
   readonly #sequence: AsyncSequence<T>;
   readonly #size: number;
 
@@ -2046,13 +2052,13 @@ class ChunkedAsyncSequence<T> extends BaseAsyncSequence<T[]> {
       chunk.push(obj);
 
       if (chunk.length === this.#size) {
-        yield chunk;
+        yield array(chunk);
         chunk = [];
       }
     }
 
     if (chunk.length > 0) {
-      yield chunk;
+      yield array(chunk);
     }
   }
 }
@@ -2179,7 +2185,18 @@ class CacheAsyncSequence<T> extends BaseAsyncSequence<T> {
   }
 
   override async *iterator() {
-    yield* this.#cache ??= await this.#sequence.toArray();
+    if (this.#cache) {
+      yield* this.#cache;
+    } else {
+      const cache = [];
+
+      for await (const e of this.#sequence) {
+        cache.push(e);
+        yield e;
+      }
+
+      this.#cache = cache;
+    }
   }
 }
 
diff --git a/src/async/index.ts b/src/async/index.ts
index 75a46ec..a02aaae 100644
--- a/src/async/index.ts
+++ b/src/async/index.ts
@@ -33,7 +33,7 @@ export function single<T>(obj: MaybePromiseLike<T>): AsyncSequence<T> {
   return new WrappedObjectAsync(obj);
 }
 
-export function array<T>(array: MaybePromiseLike<T>[]): AsyncSequence<T> {
+export function array<T>(array: ReadonlyArray<MaybePromiseLike<T>>): AsyncSequence<T> {
   return new WrappedArrayAsync(array);
 }
 
diff --git a/src/async/types.ts b/src/async/types.ts
index 9a15884..89c2857 100644
--- a/src/async/types.ts
+++ b/src/async/types.ts
@@ -1,11 +1,13 @@
 import { Collector } from "../collector/types.js";
 import { AsyncRandomOptions } from "../random/types.js";
-import { MaybeAsyncAnyPredicate, MaybeAsyncConverter, MaybeAsyncEquater, MaybeAsyncBiConverter, MaybeAsyncAccumulator, MaybeAsyncComparer, MaybeAsyncAction, MaybeAsyncSequence } from "../types.js";
+import { MaybeAsyncAnyPredicate, MaybeAsyncConverter, MaybeAsyncEquater, MaybeAsyncBiConverter, MaybeAsyncAccumulator, MaybeAsyncComparer, MaybeAsyncAction, MaybeAsyncSequence, MaybeAsyncFunction, MaybePromise } from "../types.js";
+
+export type AsyncSequencePipeline<TElement, TResult> = MaybeAsyncFunction<(sequence: AsyncSequence<TElement>) => TResult>;
 
 export interface AsyncSequence<TElement> extends AsyncIterable<TElement> {
   iterator(): AsyncIterator<TElement>;
 
-  apply<TResult>(pipeline: (sequence: AsyncSequence<TElement>) => TResult): TResult;
+  apply<TResult>(pipeline: AsyncSequencePipeline<TElement, TResult>): MaybePromise<TResult>;
 
   count(predicate?: MaybeAsyncAnyPredicate<TElement>): Promise<number>;
   nonEnumeratedCount(): Promise<number>;
@@ -105,8 +107,8 @@ export interface AsyncSequence<TElement> extends AsyncIterable<TElement> {
 
   reversed(): AsyncSequence<TElement>;
 
-  chunked(size: number, asArray?: false): AsyncSequence<AsyncSequence<TElement>>;
-  chunked(size: number, asArray: true): AsyncSequence<TElement[]>;
+  chunked(size: number): AsyncSequence<AsyncSequence<TElement>>;
+  chunked<TResult>(size: number, transformer: AsyncSequencePipeline<TElement, TResult>): AsyncSequence<TResult>;
 
   random(options?: AsyncRandomOptions<TElement>): Promise<TElement | undefined>;
 
diff --git a/src/equality-set.ts b/src/equality-set.ts
index dc58753..3660898 100644
--- a/src/equality-set.ts
+++ b/src/equality-set.ts
@@ -93,7 +93,7 @@ class CustomEqualitySet<T> implements EqualitySet<T> {
   }
 
   values() {
-    return this[Symbol.iterator]();
+    return this.#list.values();
   }
 
   [Symbol.iterator]() {
diff --git a/src/sync/impl.ts b/src/sync/impl.ts
index 5190a66..91ada2e 100644
--- a/src/sync/impl.ts
+++ b/src/sync/impl.ts
@@ -1,5 +1,3 @@
-import util from "util";
-
 import { BaseAsyncSequence } from "../async/impl.js";
 import { AsyncSequence } from "../async/types.js";
 import { Collector } from "../collector/types.js";
@@ -11,7 +9,7 @@ import { RandomOptions } from "../random/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";
+import { Sequence, GroupedSequence, OrderedSequence, SequencePipeline } from "./types.js";
 
 export class SequenceMarker { }
 
@@ -20,10 +18,6 @@ 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();
   }
@@ -141,19 +135,11 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
     return new ConcatSequence(arr);
   }
 
-  count(predicate?: AnyPredicate<TElement>) {
+  _countWithPredicate(predicate: AnyPredicate<TElement>) {
     let count = 0;
 
-    if (predicate) {
-      for (const element of this) {
-        if (predicate(element)) {
-          count++;
-        }
-      }
-    } else {
-      const iterator = this.iterator();
-
-      while (!iterator.next().done) {
+    for (const element of this) {
+      if (predicate(element)) {
         count++;
       }
     }
@@ -161,6 +147,21 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
     return count;
   }
 
+  _countWithoutPredicate() {
+    let count = 0;
+    const iterator = this.iterator();
+
+    while (!iterator.next().done) {
+      count++;
+    }
+
+    return count;
+  }
+
+  count(predicate?: AnyPredicate<TElement>) {
+    return predicate ? this._countWithPredicate(predicate) : this._countWithoutPredicate();
+  }
+
   nonEnumeratedCount() {
     return -1;
   }
@@ -175,7 +176,7 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
     return n >= 0 ? n : Infinity;
   }
 
-  #tryGetFirst(predicate?: AnyPredicate<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)) {
@@ -217,7 +218,7 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
     return result.found ? result.element : def;
   }
 
-  #tryGetLast(predicate?: AnyPredicate<TElement>): { found: boolean, element?: TElement } {
+  #tryGetLast(predicate?: AnyPredicate<TElement>): { found: boolean, element?: TElement; } {
     let found = false;
     let result: TElement | undefined = undefined;
 
@@ -257,7 +258,7 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
     return result.found ? result.element : def;
   }
 
-  #tryGetSingle(predicate?: AnyPredicate<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;
 
@@ -405,7 +406,7 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
     let next = iterator.next();
 
     if (next.done) {
-      throw new Error("Sequence contains no element.")
+      throw new Error("Sequence contains no element.");
     }
 
     if (!selector) {
@@ -454,6 +455,58 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
     return this.#find(x => x < 0, converter, comparer);
   }
 
+  #findBounds<TResult>(selector?: Converter<TElement, TResult>, comparer?: Comparer<TResult>) {
+    const iterator = this.iterator();
+
+    let next = iterator.next();
+
+    if (next.done) {
+      throw new Error("Sequence contains no element.");
+    }
+
+    if (!selector) {
+      selector = identity as Converter<TElement, TResult>;
+    }
+
+    if (!comparer) {
+      comparer = operatorCompare;
+    }
+
+    let minBound = next.value, maxBound = minBound;
+    let convertedMinBound = selector(minBound), convertedMaxBound = convertedMinBound;
+
+    while (true) {
+      next = iterator.next();
+
+      if (next.done) {
+        break;
+      }
+
+      const value = next.value;
+      const convertedValue = selector(value);
+
+      if (comparer(convertedMinBound, convertedValue) > 0) {
+        minBound = value;
+        convertedMinBound = convertedValue;
+      }
+
+      if (comparer(convertedMaxBound, convertedValue) < 0) {
+        maxBound = value;
+        convertedMaxBound = convertedValue;
+      }
+    }
+
+    return { min: minBound, max: maxBound };
+  }
+
+  bounds(comparer?: Comparer<TElement>) {
+    return this.#findBounds(undefined, comparer);
+  }
+
+  boundsBy<TBy>(converter: Converter<TElement, TBy>, comparer?: Comparer<TBy>) {
+    return this.#findBounds(converter, comparer);
+  }
+
   order(comparer?: Comparer<TElement>): OrderedSequence<TElement> {
     return new OrderSequence<TElement>(this, false, comparer);
   }
@@ -628,15 +681,15 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
     return new ReversedSequence<TElement>(this);
   }
 
-  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[]> {
+  chunked(size: number): Sequence<Sequence<TElement>>;
+  chunked<TResult>(size: number, transformer: SequencePipeline<TElement, TResult>): Sequence<TResult>;
+  chunked<TResult>(size: number, transformer?: SequencePipeline<TElement, TResult>): Sequence<Sequence<TElement>> | Sequence<TResult> {
     if (size <= 0) {
       throw new Error("Chunk size must be positive.");
     }
 
-    const sequence = new ChunkedSequence<TElement>(this, size);
-    return asArray ? sequence : sequence.select(array);
+    const result = new ChunkedSequence<TElement>(this, size);
+    return transformer ? result.select(transformer) : result;
   }
 
   random(options?: RandomOptions<TElement>) {
@@ -729,10 +782,6 @@ 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();
   }
@@ -869,6 +918,14 @@ export class DelegatedSequence<TElement> extends SequenceMarker implements Seque
     return this.#sequence.maxBy(selector, comparer);
   }
 
+  bounds(comparer?: Comparer<TElement>) {
+    return this.#sequence.bounds(comparer);
+  }
+
+  boundsBy<TBy>(selector: Converter<TElement, TBy>, comparer?: Comparer<TBy>) {
+    return this.#sequence.boundsBy(selector, comparer);
+  }
+
   order(comparer?: Comparer<TElement>) {
     return this.#sequence.order(comparer);
   }
@@ -985,10 +1042,10 @@ export class DelegatedSequence<TElement> extends SequenceMarker implements Seque
     return this.#sequence.reversed();
   }
 
-  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);
+  chunked(size: number): Sequence<Sequence<TElement>>;
+  chunked<TResult>(size: number, transformer: SequencePipeline<TElement, TResult>): Sequence<TResult>;
+  chunked(size: number, transformer?: any): any {
+    return this.#sequence.chunked(size, transformer);
   }
 
   random(options?: RandomOptions<TElement>) {
@@ -1045,10 +1102,6 @@ export class GroupedSequenceImpl<TKey, TElement> extends DelegatedSequence<TElem
     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() };
   }
@@ -1131,10 +1184,6 @@ 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>();
@@ -1169,10 +1218,6 @@ 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> {
@@ -1205,10 +1250,6 @@ 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> {
@@ -1237,10 +1278,6 @@ 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> {
@@ -1265,10 +1302,6 @@ 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> {
@@ -1291,10 +1324,6 @@ 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> {
@@ -1309,13 +1338,9 @@ 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 WrappedReadonlyArray<T> extends BaseSequence<T> {
+export class WrappedArray<T> extends BaseSequence<T> {
   readonly #array: ReadonlyArray<T>;
 
   constructor(array: ReadonlyArray<T>) {
@@ -1377,24 +1402,6 @@ export class WrappedReadonlyArray<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> {
@@ -1431,10 +1438,6 @@ 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> {
@@ -1465,10 +1468,6 @@ 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]> {
@@ -1503,10 +1502,6 @@ 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> {
@@ -1521,10 +1516,6 @@ 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> {
@@ -1549,10 +1540,6 @@ 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> {
@@ -1605,10 +1592,6 @@ 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> {
@@ -1635,10 +1618,6 @@ 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> {
@@ -1667,10 +1646,6 @@ class DistinctBySequence<T, U> extends BaseSequence<T> {
       }
     }
   }
-
-  [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> {
@@ -1695,10 +1670,6 @@ 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> {
@@ -1717,10 +1688,6 @@ 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]> {
@@ -1747,10 +1714,6 @@ 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> {
@@ -1777,10 +1740,6 @@ 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> {
@@ -1810,10 +1769,6 @@ 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> {
@@ -1859,10 +1814,6 @@ 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> {
@@ -1899,10 +1850,6 @@ 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> {
@@ -1929,10 +1876,6 @@ 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> {
@@ -1964,10 +1907,6 @@ 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> {
@@ -2005,20 +1944,12 @@ 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> {
@@ -2030,10 +1961,6 @@ class OrderBySequence<T, U> extends BaseOrderedSequence<T> {
     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>) {
     const _sorter = sorter ?? defaultArrayComparer;
     return (a: T, b: T) => _sorter(selector(a), selector(b));
@@ -2044,10 +1971,6 @@ 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> {
@@ -2059,10 +1982,6 @@ class ThenOrderBySequence<T, U> extends BaseOrderedSequence<T> {
     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>) {
     const _baseSorter = baseSorter ?? defaultArrayComparer;
     const _sorter = sorter ?? defaultArrayComparer;
@@ -2094,10 +2013,6 @@ 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> {
@@ -2124,34 +2039,36 @@ 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> {
+class PeekSequence<T> extends BaseSequence<T> {
+  readonly #sequence: Sequence<T>;
   readonly #action: Action<T>;
 
   constructor(sequence: Sequence<T>, action: Action<T>) {
-    super(sequence);
+    super();
 
+    this.#sequence = sequence;
     this.#action = action;
   }
 
+  override nonEnumeratedCount() {
+    return this.#sequence.nonEnumeratedCount();
+  }
+
+  override maxCount() {
+    return this.#sequence.maxCount();
+  }
+
   override *iterator() {
-    for (const obj of this.sequence) {
+    for (const obj of this.#sequence) {
       this.#action(obj);
       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]> {
+export class ZippedSequence<T, U> extends BaseSequence<[T, U]> {
   readonly #first: Sequence<T>;
   readonly #second: Sequence<U>;
 
@@ -2188,10 +2105,6 @@ 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> {
@@ -2225,10 +2138,6 @@ 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> {
@@ -2264,10 +2173,6 @@ 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> {
@@ -2300,10 +2205,6 @@ 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> {
@@ -2338,10 +2239,6 @@ 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> {
@@ -2374,10 +2271,6 @@ 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> {
@@ -2412,10 +2305,6 @@ 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> {
@@ -2446,10 +2335,6 @@ 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>> {
@@ -2491,13 +2376,9 @@ 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<T[]> {
+class ChunkedSequence<T> extends BaseSequence<Sequence<T>> {
   readonly #sequence: Sequence<T>;
   readonly #size: number;
 
@@ -2524,19 +2405,15 @@ class ChunkedSequence<T> extends BaseSequence<T[]> {
       chunk.push(obj);
 
       if (chunk.length === this.#size) {
-        yield chunk;
+        yield array(chunk);
         chunk = [];
       }
     }
 
     if (chunk.length > 0) {
-      yield chunk;
+      yield array(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> {
@@ -2579,10 +2456,6 @@ class JoinSequence<TOuter, TInner, TKey, TResult> extends BaseSequence<TResult>
       }
     }
   }
-
-  [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> {
@@ -2632,10 +2505,6 @@ 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> {
@@ -2675,30 +2544,31 @@ 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> {
-  #cached = false;
+class CacheSequence<T> extends BaseSequence<T> {
+  readonly #sequence: Sequence<T>;
+  #cache: T[] | undefined;
 
   constructor(sequence: Sequence<T>) {
-    super(sequence);
+    super();
+
+    this.#sequence = sequence;
   }
 
-  override iterator() {
-    if (!this.#cached) {
-      this.sequence = array(this.sequence.toArray());
-      this.#cached = true;
+  override *iterator() {
+    if (this.#cache) {
+      yield* this.#cache;
+    } else {
+      const cache = [];
+
+      for (const e of this.#sequence) {
+        cache.push(e);
+        yield e;
+      }
+
+      this.#cache = cache;
     }
-
-    return super.iterator();
-  }
-
-  [util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string {
-    return `Cached { sequence: ${inspect(this.sequence)} }`;
   }
 }
 
@@ -2730,10 +2600,6 @@ class PartitionSequence<T> extends BaseSequence<Sequence<T>> {
       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<Sequence<TElement>> {
@@ -2767,10 +2633,6 @@ class PartitionBySequence<TElement, TBy> extends BaseSequence<Sequence<TElement>
       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)} }`;
-  }
 }
 
 class AwaitedSequence<T> extends BaseAsyncSequence<Awaited<T>> {
@@ -2785,8 +2647,4 @@ 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 b96af7c..1d4894f 100644
--- a/src/sync/index.ts
+++ b/src/sync/index.ts
@@ -1,6 +1,6 @@
 import { mathRandom } from "../random/index.js";
 import { RandomGenerator } from "../random/types.js";
-import { BigIntRangeSequence, ConcatSequence, SequenceMarker, FunctionSequence, GeneratorSequence, RangeSequence, RepeatSequence, RepeatForeverSequence, WrappedArrayLike, WrappedIterable, WrappedMap, WrappedObject, WrappedSet, WrappedReadonlyArray, EMPTY } from "./impl.js";
+import { BigIntRangeSequence, ConcatSequence, SequenceMarker, FunctionSequence, GeneratorSequence, RangeSequence, RepeatSequence, RepeatForeverSequence, WrappedArrayLike, WrappedIterable, WrappedMap, WrappedObject, WrappedSet, WrappedArray, EMPTY, ZippedSequence } from "./impl.js";
 import { Sequence } from "./types.js";
 
 export function wrap<T = any>(iterable: Iterable<T>): Sequence<T> {
@@ -36,7 +36,7 @@ export function single<T>(obj: T): Sequence<T> {
 }
 
 export function array<T = any>(array: ReadonlyArray<T>): Sequence<T> {
-  return new WrappedReadonlyArray(array);
+  return new WrappedArray(array);
 }
 
 export function arrayLike<T = any>(arrayLike: ArrayLike<T>): Sequence<T> {
@@ -142,6 +142,10 @@ export function concat<T>(...sequences: Sequence<T>[]): Sequence<T> {
   return new ConcatSequence(sequences);
 }
 
+export function zip<T>(first: Sequence<T>, second: Sequence<T>): Sequence<[T, T]> {
+  return new ZippedSequence(first, second);
+}
+
 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 5cde0bb..b3927ce 100644
--- a/src/sync/types.ts
+++ b/src/sync/types.ts
@@ -66,6 +66,9 @@ export interface Sequence<TElement> extends Iterable<TElement> {
   max(comparer?: Comparer<TElement>): TElement;
   maxBy<TBy>(selector: Converter<TElement, TBy>, comparer?: Comparer<TBy>): TElement;
 
+  bounds(comparer?: Comparer<TElement>): { min: TElement, max: TElement; };
+  boundsBy<TBy>(selector: Converter<TElement, TBy>, comparer?: Comparer<TBy>): { min: TElement, max: TElement; };
+
   order(comparer?: Comparer<TElement>): OrderedSequence<TElement>;
   orderBy<TBy>(selector: Converter<TElement, TBy>, comparer?: Comparer<TBy>): OrderedSequence<TElement>;
 
@@ -111,8 +114,8 @@ export interface Sequence<TElement> extends Iterable<TElement> {
 
   reversed(): Sequence<TElement>;
 
-  chunked(size: number, asArray?: false): Sequence<Sequence<TElement>>;
-  chunked(size: number, asArray: true): Sequence<TElement[]>;
+  chunked(size: number): Sequence<Sequence<TElement>>;
+  chunked<TResult>(size: number, transformer: SequencePipeline<TElement, TResult>): Sequence<TResult>;
 
   random(options?: RandomOptions<TElement>): TElement | undefined;
 
diff --git a/src/types.ts b/src/types.ts
index 3dfbd07..79c3b20 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -6,7 +6,7 @@ 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;
-export type Action<T> = (obj: T) => void;
+export type Action<T> = (obj: T) => unknown;
 export type Accumulator<TElement, TAccumulator> = (acc: TAccumulator, obj: TElement) => TAccumulator;
 export type Comparer<T> = (first: T, second: T) => number;
 export type Equater<T> = (first: T, second: T) => boolean;
diff --git a/src/utils.ts b/src/utils.ts
index 016e0c0..e5b239d 100644
--- a/src/utils.ts
+++ b/src/utils.ts
@@ -1,4 +1,4 @@
-import { Comparer, MaybeAsyncComparer, AsyncComparer, MaybeAsyncIterator } from "./types.js";
+import { Comparer, MaybeAsyncComparer, AsyncComparer } from "./types.js";
 
 export function isDefined<T = any>(obj: T): obj is NonNullable<T> {
   return obj !== undefined && obj !== null;