effect 4.0.0-beta.4 → 4.0.0-beta.41

package/dist/Chunk.d.ts

@@ -72,10 +72,12 @@ import * as RA from "./Array.ts";
 import type { NonEmptyReadonlyArray } from "./Array.ts";
 import * as Equal from "./Equal.ts";
 import * as Equivalence from "./Equivalence.ts";
+import type * as Filter from "./Filter.ts";
 import type { TypeLambda } from "./HKT.ts";
 import { type Inspectable } from "./Inspectable.ts";
 import type { NonEmptyIterable } from "./NonEmptyIterable.ts";
 import type { Option } from "./Option.ts";
+import * as O from "./Option.ts";
 import * as Order from "./Order.ts";
 import type { Pipeable } from "./Pipeable.ts";
 import { type Predicate, type Refinement } from "./Predicate.ts";
@@ -1120,19 +1122,19 @@ export declare const appendAll: {
  * @example
  * ```ts
  * import { Chunk } from "effect"
- * import * as Option from "effect/Option"
+ * import * as Result from "effect/Result"
  *
  * const chunk = Chunk.make("1", "2", "hello", "3", "world")
  * const numbers = Chunk.filterMap(chunk, (str) => {
  *   const num = parseInt(str)
- *   return isNaN(num) ? Option.none() : Option.some(num)
+ *   return isNaN(num) ? Result.failVoid : Result.succeed(num)
  * })
  * console.log(Chunk.toArray(numbers)) // [1, 2, 3]
  *
  * // With index parameter
  * const evenIndexNumbers = Chunk.filterMap(chunk, (str, i) => {
  *   const num = parseInt(str)
- *   return isNaN(num) || i % 2 !== 0 ? Option.none() : Option.some(num)
+ *   return isNaN(num) || i % 2 !== 0 ? Result.failVoid : Result.succeed(num)
  * })
  * console.log(Chunk.toArray(evenIndexNumbers)) // [1]
  * ```
@@ -1147,19 +1149,19 @@ export declare const filterMap: {
      * @example
      * ```ts
      * import { Chunk } from "effect"
-     * import * as Option from "effect/Option"
+     * import * as Result from "effect/Result"
      *
      * const chunk = Chunk.make("1", "2", "hello", "3", "world")
      * const numbers = Chunk.filterMap(chunk, (str) => {
      *   const num = parseInt(str)
-     *   return isNaN(num) ? Option.none() : Option.some(num)
+     *   return isNaN(num) ? Result.failVoid : Result.succeed(num)
      * })
      * console.log(Chunk.toArray(numbers)) // [1, 2, 3]
      *
      * // With index parameter
      * const evenIndexNumbers = Chunk.filterMap(chunk, (str, i) => {
      *   const num = parseInt(str)
-     *   return isNaN(num) || i % 2 !== 0 ? Option.none() : Option.some(num)
+     *   return isNaN(num) || i % 2 !== 0 ? Result.failVoid : Result.succeed(num)
      * })
      * console.log(Chunk.toArray(evenIndexNumbers)) // [1]
      * ```
@@ -1167,26 +1169,26 @@ export declare const filterMap: {
      * @since 2.0.0
      * @category filtering
      */
-    <A, B>(f: (a: A, i: number) => Option<B>): (self: Chunk<A>) => Chunk<B>;
+    <A, B, X>(f: (input: A, i: number) => Result<B, X>): (self: Chunk<A>) => Chunk<B>;
     /**
      * Returns a filtered and mapped subset of the elements.
      *
      * @example
      * ```ts
      * import { Chunk } from "effect"
-     * import * as Option from "effect/Option"
+     * import * as Result from "effect/Result"
      *
      * const chunk = Chunk.make("1", "2", "hello", "3", "world")
      * const numbers = Chunk.filterMap(chunk, (str) => {
      *   const num = parseInt(str)
-     *   return isNaN(num) ? Option.none() : Option.some(num)
+     *   return isNaN(num) ? Result.failVoid : Result.succeed(num)
      * })
      * console.log(Chunk.toArray(numbers)) // [1, 2, 3]
      *
      * // With index parameter
      * const evenIndexNumbers = Chunk.filterMap(chunk, (str, i) => {
      *   const num = parseInt(str)
-     *   return isNaN(num) || i % 2 !== 0 ? Option.none() : Option.some(num)
+     *   return isNaN(num) || i % 2 !== 0 ? Result.failVoid : Result.succeed(num)
      * })
      * console.log(Chunk.toArray(evenIndexNumbers)) // [1]
      * ```
@@ -1194,7 +1196,7 @@ export declare const filterMap: {
      * @since 2.0.0
      * @category filtering
      */
-    <A, B>(self: Chunk<A>, f: (a: A, i: number) => Option<B>): Chunk<B>;
+    <A, B, X>(self: Chunk<A>, f: (input: A, i: number) => Result<B, X>): Chunk<B>;
 };
 /**
  * Returns a filtered subset of the elements.
@@ -1303,17 +1305,17 @@ export declare const filter: {
     <A>(self: Chunk<A>, predicate: Predicate<A>): Chunk<A>;
 };
 /**
- * Transforms all elements of the chunk for as long as the specified function returns some value
+ * Transforms all elements of the chunk for as long as the specified function succeeds.
  *
  * @example
  * ```ts
  * import { Chunk } from "effect"
- * import * as Option from "effect/Option"
+ * import * as Result from "effect/Result"
  *
  * const chunk = Chunk.make("1", "2", "hello", "3", "4")
  * const result = Chunk.filterMapWhile(chunk, (s) => {
  *   const num = parseInt(s)
- *   return isNaN(num) ? Option.none() : Option.some(num)
+ *   return isNaN(num) ? Result.failVoid : Result.succeed(num)
  * })
  * console.log(Chunk.toArray(result)) // [1, 2]
  * // Stops at "hello" and doesn't process "3", "4"
@@ -1321,7 +1323,7 @@ export declare const filter: {
  * // Compare with regular filterMap
  * const allNumbers = Chunk.filterMap(chunk, (s) => {
  *   const num = parseInt(s)
- *   return isNaN(num) ? Option.none() : Option.some(num)
+ *   return isNaN(num) ? Result.failVoid : Result.succeed(num)
  * })
  * console.log(Chunk.toArray(allNumbers)) // [1, 2, 3, 4]
  * ```
@@ -1331,17 +1333,17 @@ export declare const filter: {
  */
 export declare const filterMapWhile: {
     /**
-     * Transforms all elements of the chunk for as long as the specified function returns some value
+     * Transforms all elements of the chunk for as long as the specified function succeeds.
      *
      * @example
      * ```ts
      * import { Chunk } from "effect"
-     * import * as Option from "effect/Option"
+     * import * as Result from "effect/Result"
      *
      * const chunk = Chunk.make("1", "2", "hello", "3", "4")
      * const result = Chunk.filterMapWhile(chunk, (s) => {
      *   const num = parseInt(s)
-     *   return isNaN(num) ? Option.none() : Option.some(num)
+     *   return isNaN(num) ? Result.failVoid : Result.succeed(num)
      * })
      * console.log(Chunk.toArray(result)) // [1, 2]
      * // Stops at "hello" and doesn't process "3", "4"
@@ -1349,7 +1351,7 @@ export declare const filterMapWhile: {
      * // Compare with regular filterMap
      * const allNumbers = Chunk.filterMap(chunk, (s) => {
      *   const num = parseInt(s)
-     *   return isNaN(num) ? Option.none() : Option.some(num)
+     *   return isNaN(num) ? Result.failVoid : Result.succeed(num)
      * })
      * console.log(Chunk.toArray(allNumbers)) // [1, 2, 3, 4]
      * ```
@@ -1357,19 +1359,19 @@ export declare const filterMapWhile: {
      * @since 2.0.0
      * @category filtering
      */
-    <A, B>(f: (a: A) => Option<B>): (self: Chunk<A>) => Chunk<B>;
+    <A, B, X>(f: Filter.Filter<A, B, X>): (self: Chunk<A>) => Chunk<B>;
     /**
-     * Transforms all elements of the chunk for as long as the specified function returns some value
+     * Transforms all elements of the chunk for as long as the specified function succeeds.
      *
      * @example
      * ```ts
      * import { Chunk } from "effect"
-     * import * as Option from "effect/Option"
+     * import * as Result from "effect/Result"
      *
      * const chunk = Chunk.make("1", "2", "hello", "3", "4")
      * const result = Chunk.filterMapWhile(chunk, (s) => {
      *   const num = parseInt(s)
-     *   return isNaN(num) ? Option.none() : Option.some(num)
+     *   return isNaN(num) ? Result.failVoid : Result.succeed(num)
      * })
      * console.log(Chunk.toArray(result)) // [1, 2]
      * // Stops at "hello" and doesn't process "3", "4"
@@ -1377,7 +1379,7 @@ export declare const filterMapWhile: {
      * // Compare with regular filterMap
      * const allNumbers = Chunk.filterMap(chunk, (s) => {
      *   const num = parseInt(s)
-     *   return isNaN(num) ? Option.none() : Option.some(num)
+     *   return isNaN(num) ? Result.failVoid : Result.succeed(num)
      * })
      * console.log(Chunk.toArray(allNumbers)) // [1, 2, 3, 4]
      * ```
@@ -1385,7 +1387,7 @@ export declare const filterMapWhile: {
      * @since 2.0.0
      * @category filtering
      */
-    <A, B>(self: Chunk<A>, f: (a: A) => Option<B>): Chunk<B>;
+    <A, B, X>(self: Chunk<A>, f: Filter.Filter<A, B, X>): Chunk<B>;
 };
 /**
  * Filter out optional values
@@ -2281,31 +2283,21 @@ export declare const mapAccum: {
     <S, A, B>(self: Chunk<A>, s: S, f: (s: S, a: A) => readonly [S, B]): [S, Chunk<B>];
 };
 /**
- * Separate elements based on a predicate that also exposes the index of the element.
+ * Splits a chunk using a `Filter` into failures and successes.
+ *
+ * - Returns `[excluded, satisfying]`.
+ * - The filter receives `(element, index)`.
  *
  * @example
  * ```ts
- * import { Chunk } from "effect"
- *
- * const chunk = Chunk.make(1, 2, 3, 4, 5, 6)
- * const [odds, evens] = Chunk.partition(chunk, (n) => n % 2 === 0)
- * console.log(Chunk.toArray(odds)) // [1, 3, 5]
- * console.log(Chunk.toArray(evens)) // [2, 4, 6]
- *
- * // With index parameter
- * const words = Chunk.make("a", "bb", "ccc", "dddd")
- * const [short, long] = Chunk.partition(words, (word, i) => word.length > i)
- * console.log(Chunk.toArray(short)) // ["a", "bb"]
- * console.log(Chunk.toArray(long)) // ["ccc", "dddd"]
+ * import { Chunk, Result } from "effect"
  *
- * // With refinement
- * const mixed = Chunk.make("hello", 42, "world", 100)
- * const [strings, numbers] = Chunk.partition(
- *   mixed,
- *   (x): x is number => typeof x === "number"
+ * const [excluded, satisfying] = Chunk.partition(Chunk.make(1, -2, 3), (n, i) =>
+ *   n > 0 ? Result.succeed(n + i) : Result.fail(`negative:${n}`)
  * )
- * console.log(Chunk.toArray(strings)) // ["hello", "world"]
- * console.log(Chunk.toArray(numbers)) // [42, 100]
+ *
+ * console.log(Chunk.toArray(excluded)) // ["negative:-2"]
+ * console.log(Chunk.toArray(satisfying)) // [1, 5]
  * ```
  *
  * @category filtering
@@ -2313,233 +2305,49 @@ export declare const mapAccum: {
  */
 export declare const partition: {
     /**
-     * Separate elements based on a predicate that also exposes the index of the element.
+     * Splits a chunk using a `Filter` into failures and successes.
      *
-     * @example
-     * ```ts
-     * import { Chunk } from "effect"
-     *
-     * const chunk = Chunk.make(1, 2, 3, 4, 5, 6)
-     * const [odds, evens] = Chunk.partition(chunk, (n) => n % 2 === 0)
-     * console.log(Chunk.toArray(odds)) // [1, 3, 5]
-     * console.log(Chunk.toArray(evens)) // [2, 4, 6]
-     *
-     * // With index parameter
-     * const words = Chunk.make("a", "bb", "ccc", "dddd")
-     * const [short, long] = Chunk.partition(words, (word, i) => word.length > i)
-     * console.log(Chunk.toArray(short)) // ["a", "bb"]
-     * console.log(Chunk.toArray(long)) // ["ccc", "dddd"]
-     *
-     * // With refinement
-     * const mixed = Chunk.make("hello", 42, "world", 100)
-     * const [strings, numbers] = Chunk.partition(
-     *   mixed,
-     *   (x): x is number => typeof x === "number"
-     * )
-     * console.log(Chunk.toArray(strings)) // ["hello", "world"]
-     * console.log(Chunk.toArray(numbers)) // [42, 100]
-     * ```
-     *
-     * @category filtering
-     * @since 2.0.0
-     */
-    <A, B extends A>(refinement: (a: NoInfer<A>, i: number) => a is B): (self: Chunk<A>) => [excluded: Chunk<Exclude<A, B>>, satisfying: Chunk<B>];
-    /**
-     * Separate elements based on a predicate that also exposes the index of the element.
+     * - Returns `[excluded, satisfying]`.
+     * - The filter receives `(element, index)`.
      *
      * @example
      * ```ts
-     * import { Chunk } from "effect"
+     * import { Chunk, Result } from "effect"
      *
-     * const chunk = Chunk.make(1, 2, 3, 4, 5, 6)
-     * const [odds, evens] = Chunk.partition(chunk, (n) => n % 2 === 0)
-     * console.log(Chunk.toArray(odds)) // [1, 3, 5]
-     * console.log(Chunk.toArray(evens)) // [2, 4, 6]
-     *
-     * // With index parameter
-     * const words = Chunk.make("a", "bb", "ccc", "dddd")
-     * const [short, long] = Chunk.partition(words, (word, i) => word.length > i)
-     * console.log(Chunk.toArray(short)) // ["a", "bb"]
-     * console.log(Chunk.toArray(long)) // ["ccc", "dddd"]
-     *
-     * // With refinement
-     * const mixed = Chunk.make("hello", 42, "world", 100)
-     * const [strings, numbers] = Chunk.partition(
-     *   mixed,
-     *   (x): x is number => typeof x === "number"
+     * const [excluded, satisfying] = Chunk.partition(Chunk.make(1, -2, 3), (n, i) =>
+     *   n > 0 ? Result.succeed(n + i) : Result.fail(`negative:${n}`)
      * )
-     * console.log(Chunk.toArray(strings)) // ["hello", "world"]
-     * console.log(Chunk.toArray(numbers)) // [42, 100]
-     * ```
-     *
-     * @category filtering
-     * @since 2.0.0
-     */
-    <A>(predicate: (a: NoInfer<A>, i: number) => boolean): (self: Chunk<A>) => [excluded: Chunk<A>, satisfying: Chunk<A>];
-    /**
-     * Separate elements based on a predicate that also exposes the index of the element.
-     *
-     * @example
-     * ```ts
-     * import { Chunk } from "effect"
-     *
-     * const chunk = Chunk.make(1, 2, 3, 4, 5, 6)
-     * const [odds, evens] = Chunk.partition(chunk, (n) => n % 2 === 0)
-     * console.log(Chunk.toArray(odds)) // [1, 3, 5]
-     * console.log(Chunk.toArray(evens)) // [2, 4, 6]
      *
-     * // With index parameter
-     * const words = Chunk.make("a", "bb", "ccc", "dddd")
-     * const [short, long] = Chunk.partition(words, (word, i) => word.length > i)
-     * console.log(Chunk.toArray(short)) // ["a", "bb"]
-     * console.log(Chunk.toArray(long)) // ["ccc", "dddd"]
-     *
-     * // With refinement
-     * const mixed = Chunk.make("hello", 42, "world", 100)
-     * const [strings, numbers] = Chunk.partition(
-     *   mixed,
-     *   (x): x is number => typeof x === "number"
-     * )
-     * console.log(Chunk.toArray(strings)) // ["hello", "world"]
-     * console.log(Chunk.toArray(numbers)) // [42, 100]
+     * console.log(Chunk.toArray(excluded)) // ["negative:-2"]
+     * console.log(Chunk.toArray(satisfying)) // [1, 5]
      * ```
      *
      * @category filtering
      * @since 2.0.0
      */
-    <A, B extends A>(self: Chunk<A>, refinement: (a: A, i: number) => a is B): [excluded: Chunk<Exclude<A, B>>, satisfying: Chunk<B>];
+    <A, Pass, Fail>(f: (input: NoInfer<A>, i: number) => Result<Pass, Fail>): (self: Chunk<A>) => [excluded: Chunk<Fail>, satisfying: Chunk<Pass>];
     /**
-     * Separate elements based on a predicate that also exposes the index of the element.
-     *
-     * @example
-     * ```ts
-     * import { Chunk } from "effect"
-     *
-     * const chunk = Chunk.make(1, 2, 3, 4, 5, 6)
-     * const [odds, evens] = Chunk.partition(chunk, (n) => n % 2 === 0)
-     * console.log(Chunk.toArray(odds)) // [1, 3, 5]
-     * console.log(Chunk.toArray(evens)) // [2, 4, 6]
+     * Splits a chunk using a `Filter` into failures and successes.
      *
-     * // With index parameter
-     * const words = Chunk.make("a", "bb", "ccc", "dddd")
-     * const [short, long] = Chunk.partition(words, (word, i) => word.length > i)
-     * console.log(Chunk.toArray(short)) // ["a", "bb"]
-     * console.log(Chunk.toArray(long)) // ["ccc", "dddd"]
-     *
-     * // With refinement
-     * const mixed = Chunk.make("hello", 42, "world", 100)
-     * const [strings, numbers] = Chunk.partition(
-     *   mixed,
-     *   (x): x is number => typeof x === "number"
-     * )
-     * console.log(Chunk.toArray(strings)) // ["hello", "world"]
-     * console.log(Chunk.toArray(numbers)) // [42, 100]
-     * ```
-     *
-     * @category filtering
-     * @since 2.0.0
-     */
-    <A>(self: Chunk<A>, predicate: (a: A, i: number) => boolean): [excluded: Chunk<A>, satisfying: Chunk<A>];
-};
-/**
- * Partitions the elements of this chunk into two chunks using f.
- *
- * @example
- * ```ts
- * import { Chunk } from "effect"
- * import * as Result from "effect/Result"
- *
- * const chunk = Chunk.make("1", "hello", "2", "world", "3")
- * const [errors, numbers] = Chunk.partitionMap(chunk, (str) => {
- *   const num = parseInt(str)
- *   return isNaN(num)
- *     ? Result.fail(`"${str}" is not a number`)
- *     : Result.succeed(num)
- * })
- *
- * console.log(Chunk.toArray(errors)) // ['"hello" is not a number', '"world" is not a number']
- * console.log(Chunk.toArray(numbers)) // [1, 2, 3]
- *
- * // All successes
- * const validNumbers = Chunk.make("1", "2", "3")
- * const [noErrors, allNumbers] = Chunk.partitionMap(
- *   validNumbers,
- *   (str) => Result.succeed(parseInt(str))
- * )
- * console.log(Chunk.toArray(noErrors)) // []
- * console.log(Chunk.toArray(allNumbers)) // [1, 2, 3]
- * ```
- *
- * @category filtering
- * @since 2.0.0
- */
-export declare const partitionMap: {
-    /**
-     * Partitions the elements of this chunk into two chunks using f.
+     * - Returns `[excluded, satisfying]`.
+     * - The filter receives `(element, index)`.
      *
      * @example
      * ```ts
-     * import { Chunk } from "effect"
-     * import * as Result from "effect/Result"
-     *
-     * const chunk = Chunk.make("1", "hello", "2", "world", "3")
-     * const [errors, numbers] = Chunk.partitionMap(chunk, (str) => {
-     *   const num = parseInt(str)
-     *   return isNaN(num)
-     *     ? Result.fail(`"${str}" is not a number`)
-     *     : Result.succeed(num)
-     * })
-     *
-     * console.log(Chunk.toArray(errors)) // ['"hello" is not a number', '"world" is not a number']
-     * console.log(Chunk.toArray(numbers)) // [1, 2, 3]
+     * import { Chunk, Result } from "effect"
      *
-     * // All successes
-     * const validNumbers = Chunk.make("1", "2", "3")
-     * const [noErrors, allNumbers] = Chunk.partitionMap(
-     *   validNumbers,
-     *   (str) => Result.succeed(parseInt(str))
+     * const [excluded, satisfying] = Chunk.partition(Chunk.make(1, -2, 3), (n, i) =>
+     *   n > 0 ? Result.succeed(n + i) : Result.fail(`negative:${n}`)
      * )
-     * console.log(Chunk.toArray(noErrors)) // []
-     * console.log(Chunk.toArray(allNumbers)) // [1, 2, 3]
-     * ```
      *
-     * @category filtering
-     * @since 2.0.0
-     */
-    <A, B, C>(f: (a: A) => Result<C, B>): (self: Chunk<A>) => [left: Chunk<B>, right: Chunk<C>];
-    /**
-     * Partitions the elements of this chunk into two chunks using f.
-     *
-     * @example
-     * ```ts
-     * import { Chunk } from "effect"
-     * import * as Result from "effect/Result"
-     *
-     * const chunk = Chunk.make("1", "hello", "2", "world", "3")
-     * const [errors, numbers] = Chunk.partitionMap(chunk, (str) => {
-     *   const num = parseInt(str)
-     *   return isNaN(num)
-     *     ? Result.fail(`"${str}" is not a number`)
-     *     : Result.succeed(num)
-     * })
-     *
-     * console.log(Chunk.toArray(errors)) // ['"hello" is not a number', '"world" is not a number']
-     * console.log(Chunk.toArray(numbers)) // [1, 2, 3]
-     *
-     * // All successes
-     * const validNumbers = Chunk.make("1", "2", "3")
-     * const [noErrors, allNumbers] = Chunk.partitionMap(
-     *   validNumbers,
-     *   (str) => Result.succeed(parseInt(str))
-     * )
-     * console.log(Chunk.toArray(noErrors)) // []
-     * console.log(Chunk.toArray(allNumbers)) // [1, 2, 3]
+     * console.log(Chunk.toArray(excluded)) // ["negative:-2"]
+     * console.log(Chunk.toArray(satisfying)) // [1, 5]
      * ```
      *
      * @category filtering
      * @since 2.0.0
      */
-    <A, B, C>(self: Chunk<A>, f: (a: A) => Result<C, B>): [left: Chunk<B>, right: Chunk<C>];
+    <A, Pass, Fail>(self: Chunk<A>, f: (input: A, i: number) => Result<Pass, Fail>): [excluded: Chunk<Fail>, satisfying: Chunk<Pass>];
 };
 /**
  * Partitions the elements of this chunk into two chunks.
@@ -3120,7 +2928,7 @@ export declare const splitWhere: {
  * @since 2.0.0
  * @category elements
  */
-export declare const tail: <A>(self: Chunk<A>) => Chunk<A> | undefined;
+export declare const tail: <A>(self: Chunk<A>) => O.Option<Chunk<A>>;
 /**
  * Returns every elements after the first.
  *
@@ -3712,15 +3520,15 @@ export declare const remove: {
  *
  * const chunk = Chunk.make(1, 2, 3, 4)
  * const result = Chunk.modify(chunk, 1, (n) => n * 10)
- * console.log(result) // { _id: 'Chunk', values: [ 1, 20, 3, 4 ] }
+ * console.log(result) // Option.some(Chunk.make(1, 20, 3, 4))
  *
  * // Index out of bounds returns None
- * const outOfBounds = chunk?.pipe(Chunk.modify(10, (n) => n * 10))
- * console.log(outOfBounds === undefined) // true
+ * const outOfBounds = chunk.pipe(Chunk.modify(10, (n) => n * 10))
+ * console.log(outOfBounds) // Option.none()
  *
  * // Negative index returns None
- * const negative = chunk?.pipe(Chunk.modify(-1, (n) => n * 10))
- * console.log(negative === undefined) // true
+ * const negative = chunk.pipe(Chunk.modify(-1, (n) => n * 10))
+ * console.log(negative) // Option.none()
  * ```
  *
  * @category elements
@@ -3737,21 +3545,21 @@ export declare const modify: {
      *
      * const chunk = Chunk.make(1, 2, 3, 4)
      * const result = Chunk.modify(chunk, 1, (n) => n * 10)
-     * console.log(result) // { _id: 'Chunk', values: [ 1, 20, 3, 4 ] }
+     * console.log(result) // Option.some(Chunk.make(1, 20, 3, 4))
      *
      * // Index out of bounds returns None
-     * const outOfBounds = chunk?.pipe(Chunk.modify(10, (n) => n * 10))
-     * console.log(outOfBounds === undefined) // true
+     * const outOfBounds = chunk.pipe(Chunk.modify(10, (n) => n * 10))
+     * console.log(outOfBounds) // Option.none()
      *
      * // Negative index returns None
-     * const negative = chunk?.pipe(Chunk.modify(-1, (n) => n * 10))
-     * console.log(negative === undefined) // true
+     * const negative = chunk.pipe(Chunk.modify(-1, (n) => n * 10))
+     * console.log(negative) // Option.none()
      * ```
      *
      * @category elements
      * @since 2.0.0
      */
-    <A, B>(i: number, f: (a: A) => B): (self: Chunk<A>) => Chunk<A | B> | undefined;
+    <A, B>(i: number, f: (a: A) => B): (self: Chunk<A>) => O.Option<Chunk<A | B>>;
     /**
      * Applies a function to the element at the specified index, creating a new `Chunk`,
      * or returns `None` if the index is out of bounds.
@@ -3762,21 +3570,21 @@ export declare const modify: {
      *
      * const chunk = Chunk.make(1, 2, 3, 4)
      * const result = Chunk.modify(chunk, 1, (n) => n * 10)
-     * console.log(result) // { _id: 'Chunk', values: [ 1, 20, 3, 4 ] }
+     * console.log(result) // Option.some(Chunk.make(1, 20, 3, 4))
      *
      * // Index out of bounds returns None
-     * const outOfBounds = chunk?.pipe(Chunk.modify(10, (n) => n * 10))
-     * console.log(outOfBounds === undefined) // true
+     * const outOfBounds = chunk.pipe(Chunk.modify(10, (n) => n * 10))
+     * console.log(outOfBounds) // Option.none()
      *
      * // Negative index returns None
-     * const negative = chunk?.pipe(Chunk.modify(-1, (n) => n * 10))
-     * console.log(negative === undefined) // true
+     * const negative = chunk.pipe(Chunk.modify(-1, (n) => n * 10))
+     * console.log(negative) // Option.none()
      * ```
      *
      * @category elements
      * @since 2.0.0
      */
-    <A, B>(self: Chunk<A>, i: number, f: (a: A) => B): Chunk<A | B> | undefined;
+    <A, B>(self: Chunk<A>, i: number, f: (a: A) => B): O.Option<Chunk<A | B>>;
 };
 /**
  * Change the element at the specified index, creating a new `Chunk`,
@@ -3788,15 +3596,15 @@ export declare const modify: {
  *
  * const chunk = Chunk.make("a", "b", "c", "d")
  * const result = Chunk.replace(chunk, 1, "X")
- * console.log(result) // { _id: 'Chunk', values: [ 'a', 'X', 'c', 'd' ] }
+ * console.log(result) // Option.some(Chunk.make("a", "X", "c", "d"))
  *
  * // Index out of bounds returns None
- * const outOfBounds = chunk?.pipe(Chunk.replace(10, "Y"))
- * console.log(outOfBounds === undefined) // true
+ * const outOfBounds = chunk.pipe(Chunk.replace(10, "Y"))
+ * console.log(outOfBounds) // Option.none()
  *
  * // Negative index returns None
- * const negative = chunk?.pipe(Chunk.replace(-1, "Z"))
- * console.log(negative === undefined) // true
+ * const negative = chunk.pipe(Chunk.replace(-1, "Z"))
+ * console.log(negative) // Option.none()
  * ```
  *
  * @category elements
@@ -3813,21 +3621,21 @@ export declare const replace: {
      *
      * const chunk = Chunk.make("a", "b", "c", "d")
      * const result = Chunk.replace(chunk, 1, "X")
-     * console.log(result) // { _id: 'Chunk', values: [ 'a', 'X', 'c', 'd' ] }
+     * console.log(result) // Option.some(Chunk.make("a", "X", "c", "d"))
      *
      * // Index out of bounds returns None
-     * const outOfBounds = chunk?.pipe(Chunk.replace(10, "Y"))
-     * console.log(outOfBounds === undefined) // true
+     * const outOfBounds = chunk.pipe(Chunk.replace(10, "Y"))
+     * console.log(outOfBounds) // Option.none()
      *
      * // Negative index returns None
-     * const negative = chunk?.pipe(Chunk.replace(-1, "Z"))
-     * console.log(negative === undefined) // true
+     * const negative = chunk.pipe(Chunk.replace(-1, "Z"))
+     * console.log(negative) // Option.none()
      * ```
      *
      * @category elements
      * @since 2.0.0
      */
-    <B>(i: number, b: B): <A>(self: Chunk<A>) => Chunk<B | A> | undefined;
+    <B>(i: number, b: B): <A>(self: Chunk<A>) => O.Option<Chunk<B | A>>;
     /**
      * Change the element at the specified index, creating a new `Chunk`,
      * or returns `None` if the index is out of bounds.
@@ -3838,21 +3646,21 @@ export declare const replace: {
      *
      * const chunk = Chunk.make("a", "b", "c", "d")
      * const result = Chunk.replace(chunk, 1, "X")
-     * console.log(result) // { _id: 'Chunk', values: [ 'a', 'X', 'c', 'd' ] }
+     * console.log(result) // Option.some(Chunk.make("a", "X", "c", "d"))
      *
      * // Index out of bounds returns None
-     * const outOfBounds = chunk?.pipe(Chunk.replace(10, "Y"))
-     * console.log(outOfBounds === undefined) // true
+     * const outOfBounds = chunk.pipe(Chunk.replace(10, "Y"))
+     * console.log(outOfBounds) // Option.none()
      *
      * // Negative index returns None
-     * const negative = chunk?.pipe(Chunk.replace(-1, "Z"))
-     * console.log(negative === undefined) // true
+     * const negative = chunk.pipe(Chunk.replace(-1, "Z"))
+     * console.log(negative) // Option.none()
      * ```
      *
      * @category elements
      * @since 2.0.0
      */
-    <A, B>(self: Chunk<A>, i: number, b: B): Chunk<B | A> | undefined;
+    <A, B>(self: Chunk<A>, i: number, b: B): O.Option<Chunk<B | A>>;
 };
 /**
  * Return a Chunk of length n with element i initialized with f(i).
@@ -4193,15 +4001,15 @@ export declare const findFirst: {
  *
  * const chunk = Chunk.make(1, 2, 3, 4, 5)
  * const result = Chunk.findFirstIndex(chunk, (n) => n > 3)
- * console.log(result) // 3
+ * console.log(result) // Option.some(3)
  *
  * // No match found
  * const notFound = Chunk.findFirstIndex(chunk, (n) => n > 10)
- * console.log(notFound) // undefined
+ * console.log(notFound) // Option.none()
  *
  * // Find first even number
  * const firstEven = Chunk.findFirstIndex(chunk, (n) => n % 2 === 0)
- * console.log(firstEven) // 1
+ * console.log(firstEven) // Option.some(1)
  * ```
  *
  * @category elements
@@ -4217,21 +4025,21 @@ export declare const findFirstIndex: {
      *
      * const chunk = Chunk.make(1, 2, 3, 4, 5)
      * const result = Chunk.findFirstIndex(chunk, (n) => n > 3)
-     * console.log(result) // 3
+     * console.log(result) // Option.some(3)
      *
      * // No match found
      * const notFound = Chunk.findFirstIndex(chunk, (n) => n > 10)
-     * console.log(notFound) // undefined
+     * console.log(notFound) // Option.none()
      *
      * // Find first even number
      * const firstEven = Chunk.findFirstIndex(chunk, (n) => n % 2 === 0)
-     * console.log(firstEven) // 1
+     * console.log(firstEven) // Option.some(1)
      * ```
      *
      * @category elements
      * @since 2.0.0
      */
-    <A>(predicate: Predicate<A>): (self: Chunk<A>) => number | undefined;
+    <A>(predicate: Predicate<A>): (self: Chunk<A>) => O.Option<number>;
     /**
      * Return the first index for which a predicate holds.
      *
@@ -4241,21 +4049,21 @@ export declare const findFirstIndex: {
      *
      * const chunk = Chunk.make(1, 2, 3, 4, 5)
      * const result = Chunk.findFirstIndex(chunk, (n) => n > 3)
-     * console.log(result) // 3
+     * console.log(result) // Option.some(3)
      *
      * // No match found
      * const notFound = Chunk.findFirstIndex(chunk, (n) => n > 10)
-     * console.log(notFound) // undefined
+     * console.log(notFound) // Option.none()
      *
      * // Find first even number
      * const firstEven = Chunk.findFirstIndex(chunk, (n) => n % 2 === 0)
-     * console.log(firstEven) // 1
+     * console.log(firstEven) // Option.some(1)
      * ```
      *
      * @category elements
      * @since 2.0.0
      */
-    <A>(self: Chunk<A>, predicate: Predicate<A>): number | undefined;
+    <A>(self: Chunk<A>, predicate: Predicate<A>): O.Option<number>;
 };
 /**
  * Find the last element for which a predicate holds.
@@ -4397,15 +4205,15 @@ export declare const findLast: {
  *
  * const chunk = Chunk.make(1, 2, 3, 4, 5)
  * const result = Chunk.findLastIndex(chunk, (n) => n < 4)
- * console.log(result) // 2
+ * console.log(result) // Option.some(2)
  *
  * // No match found
  * const notFound = Chunk.findLastIndex(chunk, (n) => n > 10)
- * console.log(notFound) // undefined
+ * console.log(notFound) // Option.none()
  *
  * // Find last even number index
  * const lastEven = Chunk.findLastIndex(chunk, (n) => n % 2 === 0)
- * console.log(lastEven) // 3
+ * console.log(lastEven) // Option.some(3)
  * ```
  *
  * @category elements
@@ -4421,21 +4229,21 @@ export declare const findLastIndex: {
      *
      * const chunk = Chunk.make(1, 2, 3, 4, 5)
      * const result = Chunk.findLastIndex(chunk, (n) => n < 4)
-     * console.log(result) // 2
+     * console.log(result) // Option.some(2)
      *
      * // No match found
      * const notFound = Chunk.findLastIndex(chunk, (n) => n > 10)
-     * console.log(notFound) // undefined
+     * console.log(notFound) // Option.none()
      *
      * // Find last even number index
      * const lastEven = Chunk.findLastIndex(chunk, (n) => n % 2 === 0)
-     * console.log(lastEven) // 3
+     * console.log(lastEven) // Option.some(3)
      * ```
      *
      * @category elements
      * @since 2.0.0
      */
-    <A>(predicate: Predicate<A>): (self: Chunk<A>) => number | undefined;
+    <A>(predicate: Predicate<A>): (self: Chunk<A>) => O.Option<number>;
     /**
      * Return the last index for which a predicate holds.
      *
@@ -4445,21 +4253,21 @@ export declare const findLastIndex: {
      *
      * const chunk = Chunk.make(1, 2, 3, 4, 5)
      * const result = Chunk.findLastIndex(chunk, (n) => n < 4)
-     * console.log(result) // 2
+     * console.log(result) // Option.some(2)
      *
      * // No match found
      * const notFound = Chunk.findLastIndex(chunk, (n) => n > 10)
-     * console.log(notFound) // undefined
+     * console.log(notFound) // Option.none()
      *
      * // Find last even number index
      * const lastEven = Chunk.findLastIndex(chunk, (n) => n % 2 === 0)
-     * console.log(lastEven) // 3
+     * console.log(lastEven) // Option.some(3)
      * ```
      *
      * @category elements
      * @since 2.0.0
      */
-    <A>(self: Chunk<A>, predicate: Predicate<A>): number | undefined;
+    <A>(self: Chunk<A>, predicate: Predicate<A>): O.Option<number>;
 };
 /**
  * Check if a predicate holds true for every `Chunk` element.