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

package/src/Chunk.ts

@@ -72,6 +72,7 @@ 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 { format } from "./Formatter.ts"
 import { dual, identity, pipe } from "./Function.ts"
 import * as Hash from "./Hash.ts"
@@ -84,9 +85,9 @@ import * as Order from "./Order.ts"
 import type { Pipeable } from "./Pipeable.ts"
 import { pipeArguments } from "./Pipeable.ts"
 import { hasProperty, type Predicate, type Refinement } from "./Predicate.ts"
+import * as R from "./Result.ts"
 import type { Result } from "./Result.ts"
 import type { Covariant, NoInfer } from "./Types.ts"
-import * as UndefinedOr from "./UndefinedOr.ts"
 
 const TypeId = "~effect/collections/Chunk"
 
@@ -1515,19 +1516,19 @@ export 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]
  * ```
@@ -1542,19 +1543,19 @@ export 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]
    * ```
@@ -1562,26 +1563,26 @@ export 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]
    * ```
@@ -1589,16 +1590,16 @@ export 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>
 } = dual(
   2,
-  <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> => {
     const as = RA.fromIterable(self)
     const out: Array<B> = []
     for (let i = 0; i < as.length; i++) {
-      const o = f(as[i], i)
-      if (O.isSome(o)) {
-        out.push(o.value)
+      const result = f(as[i], i)
+      if (R.isSuccess(result)) {
+        out.push(result.success)
       }
     }
     return fromArrayUnsafe(out)
@@ -1716,17 +1717,17 @@ export const filter: {
 )
 
 /**
- * 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"
@@ -1734,7 +1735,7 @@ export 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]
  * ```
@@ -1744,17 +1745,17 @@ export const filter: {
  */
 export 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"
@@ -1762,7 +1763,7 @@ export 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]
    * ```
@@ -1770,19 +1771,19 @@ export 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"
@@ -1790,7 +1791,7 @@ export 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]
    * ```
@@ -1798,13 +1799,13 @@ export const filterMapWhile: {
    * @since 2.0.0
    * @category filtering
    */
-  <A, B>(self: Chunk<A>, f: (a: A) => Option<B>): Chunk<B>
-} = dual(2, <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>
+} = dual(2, <A, B, X>(self: Chunk<A>, f: Filter.Filter<A, B, X>): Chunk<B> => {
   const out: Array<B> = []
   for (const a of self) {
-    const b = f(a)
-    if (O.isSome(b)) {
-      out.push(b.value)
+    const result = f(a)
+    if (R.isSuccess(result)) {
+      out.push(result.success)
     } else {
       break
     }
@@ -1829,7 +1830,15 @@ export const filterMapWhile: {
  * @category filtering
  * @since 2.0.0
  */
-export const compact = <A>(self: Chunk<Option<A>>): Chunk<A> => filterMap(self, identity)
+export const compact = <A>(self: Chunk<Option<A>>): Chunk<A> => {
+  const out: Array<A> = []
+  for (const option of self) {
+    if (O.isSome(option)) {
+      out.push(option.value)
+    }
+  }
+  return fromArrayUnsafe(out)
+}
 
 /**
  * Applies a function to each element in a chunk and returns a new chunk containing the concatenated mapped elements.
@@ -2769,31 +2778,21 @@ export const mapAccum: {
 })
 
 /**
- * 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"
+ * 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]
+ *
+ * console.log(Chunk.toArray(excluded)) // ["negative:-2"]
+ * console.log(Chunk.toArray(satisfying)) // [1, 5]
  * ```
  *
  * @category filtering
@@ -2801,247 +2800,60 @@ export const mapAccum: {
  */
 export const partition: {
   /**
-   * 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]
-   * ```
+   * Splits a chunk using a `Filter` into failures and successes.
    *
-   * @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.
+   * 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
    * @since 2.0.0
    */
-  <A>(self: Chunk<A>, predicate: (a: A, i: number) => boolean): [excluded: Chunk<A>, satisfying: Chunk<A>]
+  <A, Pass, Fail>(self: Chunk<A>, f: (input: A, i: number) => Result<Pass, Fail>): [excluded: Chunk<Fail>, satisfying: Chunk<Pass>]
 } = dual(
   2,
-  <A>(self: Chunk<A>, predicate: (a: A, i: number) => boolean): [excluded: Chunk<A>, satisfying: Chunk<A>] =>
-    pipe(
-      RA.partition(toReadonlyArray(self), predicate),
-      ([l, r]) => [fromArrayUnsafe(l), fromArrayUnsafe(r)]
-    )
+  <A, Pass, Fail>(
+    self: Chunk<A>,
+    f: (input: A, i: number) => Result<Pass, Fail>
+  ): [excluded: Chunk<Fail>, satisfying: Chunk<Pass>] => {
+    const [excluded, satisfying] = RA.partition(self, f)
+    return [fromArrayUnsafe(excluded), fromArrayUnsafe(satisfying)]
+  }
 )
 
-/**
- * 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 const partitionMap: {
-  /**
-   * 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
-   */
-  <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]
-   * ```
-   *
-   * @category filtering
-   * @since 2.0.0
-   */
-  <A, B, C>(self: Chunk<A>, f: (a: A) => Result<C, B>): [left: Chunk<B>, right: Chunk<C>]
-} = dual(2, <A, B, C>(self: Chunk<A>, f: (a: A) => Result<C, B>): [left: Chunk<B>, right: Chunk<C>] =>
-  pipe(
-    RA.partitionMap(toReadonlyArray(self), f),
-    ([l, r]) => [fromArrayUnsafe(l), fromArrayUnsafe(r)]
-  ))
-
 /**
  * Partitions the elements of this chunk into two chunks.
  *
@@ -3654,7 +3466,7 @@ export const splitWhere: {
  * @since 2.0.0
  * @category elements
  */
-export const tail = <A>(self: Chunk<A>): Chunk<A> | undefined => self.length > 0 ? drop(self, 1) : undefined
+export const tail = <A>(self: Chunk<A>): O.Option<Chunk<A>> => self.length > 0 ? O.some(drop(self, 1)) : O.none()
 
 /**
  * Returns every elements after the first.
@@ -4283,15 +4095,15 @@ export 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
@@ -4308,21 +4120,21 @@ export 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.
@@ -4333,25 +4145,25 @@ export 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>>
 } = dual(
   3,
-  <A, B>(self: Chunk<A>, i: number, f: (a: A) => B): Chunk<A | B> | undefined =>
-    UndefinedOr.map(RA.modify(toReadonlyArray(self), i, f), fromArrayUnsafe)
+  <A, B>(self: Chunk<A>, i: number, f: (a: A) => B): O.Option<Chunk<A | B>> =>
+    pipe(RA.modify(toReadonlyArray(self), i, f), O.map(fromArrayUnsafe))
 )
 
 /**
@@ -4364,15 +4176,15 @@ export 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
@@ -4389,21 +4201,21 @@ export 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.
@@ -4414,22 +4226,22 @@ export 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
-} = dual(3, <A, B>(self: Chunk<A>, i: number, b: B): Chunk<B | A> | undefined => modify(self, i, () => b))
+  <A, B>(self: Chunk<A>, i: number, b: B): O.Option<Chunk<B | A>>
+} = dual(3, <A, B>(self: Chunk<A>, i: number, b: B): O.Option<Chunk<B | A>> => modify(self, i, () => b))
 
 /**
  * Return a Chunk of length n with element i initialized with f(i).
@@ -4790,15 +4602,15 @@ export 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
@@ -4814,21 +4626,21 @@ export 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.
    *
@@ -4838,22 +4650,25 @@ export 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
-} = RA.findFirstIndex
+  <A>(self: Chunk<A>, predicate: Predicate<A>): O.Option<number>
+} = dual(
+  2,
+  <A>(self: Chunk<A>, predicate: Predicate<A>): O.Option<number> => RA.findFirstIndex(self, predicate)
+)
 
 /**
  * Find the last element for which a predicate holds.
@@ -4996,15 +4811,15 @@ export 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
@@ -5020,21 +4835,21 @@ export 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.
    *
@@ -5044,22 +4859,25 @@ export 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
-} = RA.findLastIndex
+  <A>(self: Chunk<A>, predicate: Predicate<A>): O.Option<number>
+} = dual(
+  2,
+  <A>(self: Chunk<A>, predicate: Predicate<A>): O.Option<number> => RA.findLastIndex(self, predicate)
+)
 
 /**
  * Check if a predicate holds true for every `Chunk` element.