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

package/src/Array.ts

@@ -85,7 +85,6 @@
  */
 import * as Equal from "./Equal.ts"
 import * as Equivalence from "./Equivalence.ts"
-import * as Filter from "./Filter.ts"
 import type { LazyArg } from "./Function.ts"
 import { dual, identity } from "./Function.ts"
 import type { TypeLambda } from "./HKT.ts"
@@ -1768,18 +1767,18 @@ export const last = <A>(self: ReadonlyArray<A>): Option.Option<A> =>
 export const lastNonEmpty = <A>(self: NonEmptyReadonlyArray<A>): A => self[self.length - 1]
 
 /**
- * Returns all elements except the first, or `undefined` if the array is empty.
+ * Returns all elements except the first, wrapped in an `Option`.
  *
  * - Allocates a new array via `slice(1)`.
- * - Returns `undefined` (not `Option`) for empty inputs.
+ * - Returns `Option.none()` for empty inputs.
  *
  * **Example** (Getting the tail)
  *
  * ```ts
  * import { Array } from "effect"
  *
- * console.log(Array.tail([1, 2, 3, 4])) // [2, 3, 4]
- * console.log(Array.tail([])) // undefined
+ * console.log(Array.tail([1, 2, 3, 4])) // Option.some([2, 3, 4])
+ * console.log(Array.tail([])) // Option.none()
  * ```
  *
  * @see {@link tailNonEmpty} — when the array is known non-empty
@@ -1788,9 +1787,9 @@ export const lastNonEmpty = <A>(self: NonEmptyReadonlyArray<A>): A => self[self.
  * @category getters
  * @since 2.0.0
  */
-export function tail<A>(self: Iterable<A>): Array<A> | undefined {
+export function tail<A>(self: Iterable<A>): Option.Option<Array<A>> {
   const as = fromIterable(self)
-  return isReadonlyArrayNonEmpty(as) ? tailNonEmpty(as) : undefined
+  return isReadonlyArrayNonEmpty(as) ? Option.some(tailNonEmpty(as)) : Option.none()
 }
 
 /**
@@ -1813,18 +1812,18 @@ export function tail<A>(self: Iterable<A>): Array<A> | undefined {
 export const tailNonEmpty = <A>(self: NonEmptyReadonlyArray<A>): Array<A> => self.slice(1)
 
 /**
- * Returns all elements except the last, or `undefined` if the array is empty.
+ * Returns all elements except the last, wrapped in an `Option`.
  *
  * - Allocates a new array via `slice(0, -1)`.
- * - Returns `undefined` (not `Option`) for empty inputs.
+ * - Returns `Option.none()` for empty inputs.
  *
  * **Example** (Getting init)
  *
  * ```ts
  * import { Array } from "effect"
  *
- * console.log(Array.init([1, 2, 3, 4])) // [1, 2, 3]
- * console.log(Array.init([])) // undefined
+ * console.log(Array.init([1, 2, 3, 4])) // Option.some([1, 2, 3])
+ * console.log(Array.init([])) // Option.none()
  * ```
  *
  * @see {@link initNonEmpty} — when the array is known non-empty
@@ -1833,9 +1832,9 @@ export const tailNonEmpty = <A>(self: NonEmptyReadonlyArray<A>): Array<A> => sel
  * @category getters
  * @since 2.0.0
  */
-export function init<A>(self: Iterable<A>): Array<A> | undefined {
+export function init<A>(self: Iterable<A>): Option.Option<Array<A>> {
   const as = fromIterable(self)
-  return isReadonlyArrayNonEmpty(as) ? initNonEmpty(as) : undefined
+  return isReadonlyArrayNonEmpty(as) ? Option.some(initNonEmpty(as)) : Option.none()
 }
 
 /**
@@ -2088,7 +2087,7 @@ export const takeWhile: {
    * @category getters
    * @since 2.0.0
    */
-  <A, B, X>(f: Filter.Filter<NoInfer<A>, B, X>): (self: Iterable<A>) => Array<B>
+  <A, B extends A>(self: Iterable<A>, refinement: (a: A, i: number) => a is B): Array<B>
   /**
    * Takes elements from the start while the predicate holds, stopping at the
    * first element that fails.
@@ -2111,59 +2110,61 @@ export const takeWhile: {
    * @category getters
    * @since 2.0.0
    */
-  <A, B extends A>(self: Iterable<A>, refinement: (a: A, i: number) => a is B): Array<B>
+  <A>(self: Iterable<A>, predicate: (a: A, i: number) => boolean): Array<A>
+} = dual(2, <A>(self: Iterable<A>, predicate: (a: A, i: number) => boolean): Array<A> => {
+  let i = 0
+  const out: Array<A> = []
+  for (const a of self) {
+    if (!predicate(a, i)) {
+      break
+    }
+    out.push(a)
+    i++
+  }
+  return out
+})
+
+/**
+ * Takes elements from the start while a `Filter` succeeds, collecting transformed values.
+ *
+ * - The filter receives `(element, index)`.
+ * - Stops at the first filter failure.
+ *
+ * @category getters
+ * @since 4.0.0
+ */
+export const takeWhileFilter: {
   /**
-   * Takes elements from the start while the predicate holds, stopping at the
-   * first element that fails.
-   *
-   * - Supports refinements for type narrowing.
-   * - The predicate receives `(element, index)`.
-   *
-   * **Example** (Taking while condition holds)
-   *
-   * ```ts
-   * import { Array } from "effect"
+   * Takes elements from the start while a `Filter` succeeds, collecting transformed values.
    *
-   * console.log(Array.takeWhile([1, 3, 2, 4, 1, 2], (x) => x < 4)) // [1, 3, 2]
-   * ```
-   *
-   * @see {@link take} — take a fixed count
-   * @see {@link dropWhile} — drop while predicate holds
-   * @see {@link span} — split into matching prefix + rest
+   * - The filter receives `(element, index)`.
+   * - Stops at the first filter failure.
    *
    * @category getters
-   * @since 2.0.0
+   * @since 4.0.0
    */
-  <A>(self: Iterable<A>, predicate: (a: A, i: number) => boolean): Array<A>
+  <A, B, X>(f: (input: NoInfer<A>, i: number) => Result.Result<B, X>): (self: Iterable<A>) => Array<B>
   /**
-   * Takes elements from the start while the predicate holds, stopping at the
-   * first element that fails.
+   * Takes elements from the start while a `Filter` succeeds, collecting transformed values.
    *
-   * - Supports refinements for type narrowing.
-   * - The predicate receives `(element, index)`.
-   *
-   * **Example** (Taking while condition holds)
-   *
-   * ```ts
-   * import { Array } from "effect"
-   *
-   * console.log(Array.takeWhile([1, 3, 2, 4, 1, 2], (x) => x < 4)) // [1, 3, 2]
-   * ```
-   *
-   * @see {@link take} — take a fixed count
-   * @see {@link dropWhile} — drop while predicate holds
-   * @see {@link span} — split into matching prefix + rest
+   * - The filter receives `(element, index)`.
+   * - Stops at the first filter failure.
    *
    * @category getters
-   * @since 2.0.0
+   * @since 4.0.0
    */
-  <A, B, X>(self: Iterable<A>, f: Filter.Filter<A, B, X>): Array<B>
-} = dual(2, <A>(self: Iterable<A>, f: Filter.Filter<A, any, any> | ((a: A, i: number) => boolean)): Array<any> => {
+  <A, B, X>(
+    self: Iterable<A>,
+    f: (input: NoInfer<A>, i: number) => Result.Result<B, X>
+  ): Array<B>
+} = dual(2, <A, B, X>(self: Iterable<A>, f: (input: NoInfer<A>, i: number) => Result.Result<B, X>): Array<B> => {
   let i = 0
-  const out: Array<any> = []
+  const out: Array<B> = []
   for (const a of self) {
-    const result = Filter.apply(f as any, a, i)
-    if (Result.isFailure(result)) break
+    const result = f(a, i)
+    if (Result.isFailure(result)) {
+      break
+    }
     out.push(result.success)
     i++
   }
@@ -2504,54 +2505,58 @@ export const dropWhile: {
    * @category getters
    * @since 2.0.0
    */
-  <A, B, X>(f: Filter.Filter<NoInfer<A>, B, X>): (self: Iterable<A>) => Array<A>
+  <A>(self: Iterable<A>, predicate: (a: A, i: number) => boolean): Array<A>
+} = dual(2, <A>(self: Iterable<A>, predicate: (a: A, i: number) => boolean): Array<A> => {
+  const input = fromIterable(self)
+  let i = 0
+  while (i < input.length) {
+    if (!predicate(input[i], i)) {
+      break
+    }
+    i++
+  }
+  return input.slice(i)
+})
+
+/**
+ * Drops elements from the start while a `Filter` succeeds.
+ *
+ * - The filter receives `(element, index)`.
+ * - Returns the remaining original elements after the first filter failure.
+ *
+ * @category getters
+ * @since 4.0.0
+ */
+export const dropWhileFilter: {
   /**
-   * Drops elements from the start while the predicate holds, returning the rest.
+   * Drops elements from the start while a `Filter` succeeds.
    *
-   * - The predicate receives `(element, index)`.
-   *
-   * **Example** (Dropping while condition holds)
-   *
-   * ```ts
-   * import { Array } from "effect"
-   *
-   * console.log(Array.dropWhile([1, 2, 3, 4, 5], (x) => x < 4)) // [4, 5]
-   * ```
-   *
-   * @see {@link takeWhile} — keep the matching prefix instead
-   * @see {@link drop} — drop a fixed count
+   * - The filter receives `(element, index)`.
+   * - Returns the remaining original elements after the first filter failure.
    *
    * @category getters
-   * @since 2.0.0
+   * @since 4.0.0
    */
-  <A>(self: Iterable<A>, predicate: (a: A, i: number) => boolean): Array<A>
+  <A, B, X>(f: (input: NoInfer<A>, i: number) => Result.Result<B, X>): (self: Iterable<A>) => Array<A>
   /**
-   * Drops elements from the start while the predicate holds, returning the rest.
-   *
-   * - The predicate receives `(element, index)`.
-   *
-   * **Example** (Dropping while condition holds)
-   *
-   * ```ts
-   * import { Array } from "effect"
-   *
-   * console.log(Array.dropWhile([1, 2, 3, 4, 5], (x) => x < 4)) // [4, 5]
-   * ```
+   * Drops elements from the start while a `Filter` succeeds.
    *
-   * @see {@link takeWhile} — keep the matching prefix instead
-   * @see {@link drop} — drop a fixed count
+   * - The filter receives `(element, index)`.
+   * - Returns the remaining original elements after the first filter failure.
    *
    * @category getters
-   * @since 2.0.0
+   * @since 4.0.0
    */
-  <A, B, X>(self: Iterable<A>, f: Filter.Filter<A, B, X>): Array<A>
+  <A, B, X>(self: Iterable<A>, f: (input: A, i: number) => Result.Result<B, X>): Array<A>
 } = dual(
   2,
-  <A>(self: Iterable<A>, f: Filter.Filter<A, any, any> | ((a: A, i: number) => boolean)): Array<A> => {
+  <A, B, X>(self: Iterable<A>, f: (input: A, i: number) => Result.Result<B, X>): Array<A> => {
     const input = fromIterable(self)
     let i = 0
-    for (const a of input) {
-      if (Result.isFailure(Filter.apply(f as any, a, i))) break
+    while (i < input.length) {
+      if (Result.isFailure(f(input[i], i))) {
+        break
+      }
       i++
     }
     return input.slice(i)
@@ -2559,15 +2564,15 @@ export const dropWhile: {
 )
 
 /**
- * Returns the index of the first element matching the predicate, or `undefined`
- * if none match.
+ * Returns the index of the first element matching the predicate, wrapped in an
+ * `Option`.
  *
  * **Example** (Finding an index)
  *
  * ```ts
  * import { Array } from "effect"
  *
- * console.log(Array.findFirstIndex([5, 3, 8, 9], (x) => x > 5)) // 2
+ * console.log(Array.findFirstIndex([5, 3, 8, 9], (x) => x > 5)) // Option.some(2)
  * ```
  *
  * @see {@link findLastIndex} — search from the end
@@ -2578,15 +2583,15 @@ export const dropWhile: {
  */
 export const findFirstIndex: {
   /**
-   * Returns the index of the first element matching the predicate, or `undefined`
-   * if none match.
+   * Returns the index of the first element matching the predicate, wrapped in an
+   * `Option`.
    *
    * **Example** (Finding an index)
    *
    * ```ts
    * import { Array } from "effect"
    *
-   * console.log(Array.findFirstIndex([5, 3, 8, 9], (x) => x > 5)) // 2
+   * console.log(Array.findFirstIndex([5, 3, 8, 9], (x) => x > 5)) // Option.some(2)
    * ```
    *
    * @see {@link findLastIndex} — search from the end
@@ -2595,17 +2600,17 @@ export const findFirstIndex: {
    * @category elements
    * @since 2.0.0
    */
-  <A>(predicate: (a: NoInfer<A>, i: number) => boolean): (self: Iterable<A>) => number | undefined
+  <A>(predicate: (a: NoInfer<A>, i: number) => boolean): (self: Iterable<A>) => Option.Option<number>
   /**
-   * Returns the index of the first element matching the predicate, or `undefined`
-   * if none match.
+   * Returns the index of the first element matching the predicate, wrapped in an
+   * `Option`.
    *
    * **Example** (Finding an index)
    *
    * ```ts
    * import { Array } from "effect"
    *
-   * console.log(Array.findFirstIndex([5, 3, 8, 9], (x) => x > 5)) // 2
+   * console.log(Array.findFirstIndex([5, 3, 8, 9], (x) => x > 5)) // Option.some(2)
    * ```
    *
    * @see {@link findLastIndex} — search from the end
@@ -2614,27 +2619,28 @@ export const findFirstIndex: {
    * @category elements
    * @since 2.0.0
    */
-  <A>(self: Iterable<A>, predicate: (a: A, i: number) => boolean): number | undefined
-} = dual(2, <A>(self: Iterable<A>, predicate: (a: A, i: number) => boolean): number | undefined => {
+  <A>(self: Iterable<A>, predicate: (a: A, i: number) => boolean): Option.Option<number>
+} = dual(2, <A>(self: Iterable<A>, predicate: (a: A, i: number) => boolean): Option.Option<number> => {
   let i = 0
   for (const a of self) {
     if (predicate(a, i)) {
-      return i
+      return Option.some(i)
     }
     i++
   }
+  return Option.none()
 })
 
 /**
- * Returns the index of the last element matching the predicate, or `undefined`
- * if none match.
+ * Returns the index of the last element matching the predicate, wrapped in an
+ * `Option`.
  *
  * **Example** (Finding the last matching index)
  *
  * ```ts
  * import { Array } from "effect"
  *
- * console.log(Array.findLastIndex([1, 3, 8, 9], (x) => x < 5)) // 1
+ * console.log(Array.findLastIndex([1, 3, 8, 9], (x) => x < 5)) // Option.some(1)
  * ```
  *
  * @see {@link findFirstIndex} — search from the start
@@ -2645,15 +2651,15 @@ export const findFirstIndex: {
  */
 export const findLastIndex: {
   /**
-   * Returns the index of the last element matching the predicate, or `undefined`
-   * if none match.
+   * Returns the index of the last element matching the predicate, wrapped in an
+   * `Option`.
    *
    * **Example** (Finding the last matching index)
    *
    * ```ts
    * import { Array } from "effect"
    *
-   * console.log(Array.findLastIndex([1, 3, 8, 9], (x) => x < 5)) // 1
+   * console.log(Array.findLastIndex([1, 3, 8, 9], (x) => x < 5)) // Option.some(1)
    * ```
    *
    * @see {@link findFirstIndex} — search from the start
@@ -2662,17 +2668,17 @@ export const findLastIndex: {
    * @category elements
    * @since 2.0.0
    */
-  <A>(predicate: (a: NoInfer<A>, i: number) => boolean): (self: Iterable<A>) => number | undefined
+  <A>(predicate: (a: NoInfer<A>, i: number) => boolean): (self: Iterable<A>) => Option.Option<number>
   /**
-   * Returns the index of the last element matching the predicate, or `undefined`
-   * if none match.
+   * Returns the index of the last element matching the predicate, wrapped in an
+   * `Option`.
    *
    * **Example** (Finding the last matching index)
    *
    * ```ts
    * import { Array } from "effect"
    *
-   * console.log(Array.findLastIndex([1, 3, 8, 9], (x) => x < 5)) // 1
+   * console.log(Array.findLastIndex([1, 3, 8, 9], (x) => x < 5)) // Option.some(1)
    * ```
    *
    * @see {@link findFirstIndex} — search from the start
@@ -2681,14 +2687,15 @@ export const findLastIndex: {
    * @category elements
    * @since 2.0.0
    */
-  <A>(self: Iterable<A>, predicate: (a: A, i: number) => boolean): number | undefined
-} = dual(2, <A>(self: Iterable<A>, predicate: (a: A, i: number) => boolean): number | undefined => {
+  <A>(self: Iterable<A>, predicate: (a: A, i: number) => boolean): Option.Option<number>
+} = dual(2, <A>(self: Iterable<A>, predicate: (a: A, i: number) => boolean): Option.Option<number> => {
   const input = fromIterable(self)
   for (let i = input.length - 1; i >= 0; i--) {
     if (predicate(input[i], i)) {
-      return i
+      return Option.some(i)
     }
   }
+  return Option.none()
 })
 
 /**
@@ -2863,14 +2870,14 @@ export const findFirst: {
 
 /**
  * Returns a tuple `[element, index]` of the first element matching a
- * predicate, or `undefined` if none match.
+ * predicate, wrapped in an `Option`.
  *
  * **Example** (Finding element with its index)
  *
  * ```ts
  * import { Array } from "effect"
  *
- * console.log(Array.findFirstWithIndex([1, 2, 3, 4, 5], (x) => x > 3)) // [4, 3]
+ * console.log(Array.findFirstWithIndex([1, 2, 3, 4, 5], (x) => x > 3)) // Option.some([4, 3])
  * ```
  *
  * @see {@link findFirst} — get only the element
@@ -2882,14 +2889,14 @@ export const findFirst: {
 export const findFirstWithIndex: {
   /**
    * Returns a tuple `[element, index]` of the first element matching a
-   * predicate, or `undefined` if none match.
+   * predicate, wrapped in an `Option`.
    *
    * **Example** (Finding element with its index)
    *
    * ```ts
    * import { Array } from "effect"
    *
-   * console.log(Array.findFirstWithIndex([1, 2, 3, 4, 5], (x) => x > 3)) // [4, 3]
+   * console.log(Array.findFirstWithIndex([1, 2, 3, 4, 5], (x) => x > 3)) // Option.some([4, 3])
    * ```
    *
    * @see {@link findFirst} — get only the element
@@ -2898,17 +2905,17 @@ export const findFirstWithIndex: {
    * @category elements
    * @since 3.17.0
    */
-  <A, B>(f: (a: NoInfer<A>, i: number) => Option.Option<B>): (self: Iterable<A>) => [B, number] | undefined
+  <A, B>(f: (a: NoInfer<A>, i: number) => Option.Option<B>): (self: Iterable<A>) => Option.Option<[B, number]>
   /**
    * Returns a tuple `[element, index]` of the first element matching a
-   * predicate, or `undefined` if none match.
+   * predicate, wrapped in an `Option`.
    *
    * **Example** (Finding element with its index)
    *
    * ```ts
    * import { Array } from "effect"
    *
-   * console.log(Array.findFirstWithIndex([1, 2, 3, 4, 5], (x) => x > 3)) // [4, 3]
+   * console.log(Array.findFirstWithIndex([1, 2, 3, 4, 5], (x) => x > 3)) // Option.some([4, 3])
    * ```
    *
    * @see {@link findFirst} — get only the element
@@ -2917,17 +2924,17 @@ export const findFirstWithIndex: {
    * @category elements
    * @since 3.17.0
    */
-  <A, B extends A>(refinement: (a: NoInfer<A>, i: number) => a is B): (self: Iterable<A>) => [B, number] | undefined
+  <A, B extends A>(refinement: (a: NoInfer<A>, i: number) => a is B): (self: Iterable<A>) => Option.Option<[B, number]>
   /**
    * Returns a tuple `[element, index]` of the first element matching a
-   * predicate, or `undefined` if none match.
+   * predicate, wrapped in an `Option`.
    *
    * **Example** (Finding element with its index)
    *
    * ```ts
    * import { Array } from "effect"
    *
-   * console.log(Array.findFirstWithIndex([1, 2, 3, 4, 5], (x) => x > 3)) // [4, 3]
+   * console.log(Array.findFirstWithIndex([1, 2, 3, 4, 5], (x) => x > 3)) // Option.some([4, 3])
    * ```
    *
    * @see {@link findFirst} — get only the element
@@ -2936,17 +2943,17 @@ export const findFirstWithIndex: {
    * @category elements
    * @since 3.17.0
    */
-  <A>(predicate: (a: NoInfer<A>, i: number) => boolean): (self: Iterable<A>) => [A, number] | undefined
+  <A>(predicate: (a: NoInfer<A>, i: number) => boolean): (self: Iterable<A>) => Option.Option<[A, number]>
   /**
    * Returns a tuple `[element, index]` of the first element matching a
-   * predicate, or `undefined` if none match.
+   * predicate, wrapped in an `Option`.
    *
    * **Example** (Finding element with its index)
    *
    * ```ts
    * import { Array } from "effect"
    *
-   * console.log(Array.findFirstWithIndex([1, 2, 3, 4, 5], (x) => x > 3)) // [4, 3]
+   * console.log(Array.findFirstWithIndex([1, 2, 3, 4, 5], (x) => x > 3)) // Option.some([4, 3])
    * ```
    *
    * @see {@link findFirst} — get only the element
@@ -2955,17 +2962,17 @@ export const findFirstWithIndex: {
    * @category elements
    * @since 3.17.0
    */
-  <A, B>(self: Iterable<A>, f: (a: A, i: number) => Option.Option<B>): [B, number] | undefined
+  <A, B>(self: Iterable<A>, f: (a: A, i: number) => Option.Option<B>): Option.Option<[B, number]>
   /**
    * Returns a tuple `[element, index]` of the first element matching a
-   * predicate, or `undefined` if none match.
+   * predicate, wrapped in an `Option`.
    *
    * **Example** (Finding element with its index)
    *
    * ```ts
    * import { Array } from "effect"
    *
-   * console.log(Array.findFirstWithIndex([1, 2, 3, 4, 5], (x) => x > 3)) // [4, 3]
+   * console.log(Array.findFirstWithIndex([1, 2, 3, 4, 5], (x) => x > 3)) // Option.some([4, 3])
    * ```
    *
    * @see {@link findFirst} — get only the element
@@ -2974,17 +2981,17 @@ export const findFirstWithIndex: {
    * @category elements
    * @since 3.17.0
    */
-  <A, B extends A>(self: Iterable<A>, refinement: (a: A, i: number) => a is B): [B, number] | undefined
+  <A, B extends A>(self: Iterable<A>, refinement: (a: A, i: number) => a is B): Option.Option<[B, number]>
   /**
    * Returns a tuple `[element, index]` of the first element matching a
-   * predicate, or `undefined` if none match.
+   * predicate, wrapped in an `Option`.
    *
    * **Example** (Finding element with its index)
    *
    * ```ts
    * import { Array } from "effect"
    *
-   * console.log(Array.findFirstWithIndex([1, 2, 3, 4, 5], (x) => x > 3)) // [4, 3]
+   * console.log(Array.findFirstWithIndex([1, 2, 3, 4, 5], (x) => x > 3)) // Option.some([4, 3])
    * ```
    *
    * @see {@link findFirst} — get only the element
@@ -2993,27 +3000,28 @@ export const findFirstWithIndex: {
    * @category elements
    * @since 3.17.0
    */
-  <A>(self: Iterable<A>, predicate: (a: A, i: number) => boolean): [A, number] | undefined
+  <A>(self: Iterable<A>, predicate: (a: A, i: number) => boolean): Option.Option<[A, number]>
 } = dual(
   2,
   <A>(
     self: Iterable<A>,
     f: ((a: A, i: number) => boolean) | ((a: A, i: number) => Option.Option<A>)
-  ): [A, number] | undefined => {
+  ): Option.Option<[A, number]> => {
     let i = 0
     for (const a of self) {
       const o = f(a, i)
       if (typeof o === "boolean") {
         if (o) {
-          return [a, i]
+          return Option.some([a, i])
         }
       } else {
         if (Option.isSome(o)) {
-          return [o.value, i]
+          return Option.some([o.value, i])
         }
       }
       i++
     }
+    return Option.none()
   }
 )
 
@@ -3196,8 +3204,8 @@ export const findLast: {
 )
 
 /**
- * Inserts an element at the specified index, returning a new `NonEmptyArray`,
- * or `undefined` if the index is out of bounds.
+ * Inserts an element at the specified index, returning a new `NonEmptyArray`
+ * wrapped in an `Option`.
  *
  * - Valid indices: `0` to `length` (inclusive — inserting at `length` appends).
  * - Does not mutate the input.
@@ -3207,7 +3215,7 @@ export const findLast: {
  * ```ts
  * import { Array } from "effect"
  *
- * console.log(Array.insertAt(["a", "b", "c", "e"], 3, "d")) // ["a", "b", "c", "d", "e"]
+ * console.log(Array.insertAt(["a", "b", "c", "e"], 3, "d")) // Option.some(["a", "b", "c", "d", "e"])
  * ```
  *
  * @see {@link replace} — replace an existing element
@@ -3218,8 +3226,8 @@ export const findLast: {
  */
 export const insertAt: {
   /**
-   * Inserts an element at the specified index, returning a new `NonEmptyArray`,
-   * or `undefined` if the index is out of bounds.
+   * Inserts an element at the specified index, returning a new `NonEmptyArray`
+   * wrapped in an `Option`.
    *
    * - Valid indices: `0` to `length` (inclusive — inserting at `length` appends).
    * - Does not mutate the input.
@@ -3229,7 +3237,7 @@ export const insertAt: {
    * ```ts
    * import { Array } from "effect"
    *
-   * console.log(Array.insertAt(["a", "b", "c", "e"], 3, "d")) // ["a", "b", "c", "d", "e"]
+   * console.log(Array.insertAt(["a", "b", "c", "e"], 3, "d")) // Option.some(["a", "b", "c", "d", "e"])
    * ```
    *
    * @see {@link replace} — replace an existing element
@@ -3238,10 +3246,10 @@ export const insertAt: {
    * @category elements
    * @since 2.0.0
    */
-  <B>(i: number, b: B): <A>(self: Iterable<A>) => NonEmptyArray<A | B> | undefined
+  <B>(i: number, b: B): <A>(self: Iterable<A>) => Option.Option<NonEmptyArray<A | B>>
   /**
-   * Inserts an element at the specified index, returning a new `NonEmptyArray`,
-   * or `undefined` if the index is out of bounds.
+   * Inserts an element at the specified index, returning a new `NonEmptyArray`
+   * wrapped in an `Option`.
    *
    * - Valid indices: `0` to `length` (inclusive — inserting at `length` appends).
    * - Does not mutate the input.
@@ -3251,7 +3259,7 @@ export const insertAt: {
    * ```ts
    * import { Array } from "effect"
    *
-   * console.log(Array.insertAt(["a", "b", "c", "e"], 3, "d")) // ["a", "b", "c", "d", "e"]
+   * console.log(Array.insertAt(["a", "b", "c", "e"], 3, "d")) // Option.some(["a", "b", "c", "d", "e"])
    * ```
    *
    * @see {@link replace} — replace an existing element
@@ -3260,19 +3268,19 @@ export const insertAt: {
    * @category elements
    * @since 2.0.0
    */
-  <A, B>(self: Iterable<A>, i: number, b: B): NonEmptyArray<A | B> | undefined
-} = dual(3, <A, B>(self: Iterable<A>, i: number, b: B): NonEmptyArray<A | B> | undefined => {
+  <A, B>(self: Iterable<A>, i: number, b: B): Option.Option<NonEmptyArray<A | B>>
+} = dual(3, <A, B>(self: Iterable<A>, i: number, b: B): Option.Option<NonEmptyArray<A | B>> => {
   const out: Array<A | B> = Array.from(self) // copy because `splice` mutates the array
   if (i < 0 || i > out.length) {
-    return undefined
+    return Option.none()
   }
   out.splice(i, 0, b)
-  return out as any
+  return Option.some(out as any)
 })
 
 /**
  * Replaces the element at the specified index with a new value, returning a new
- * array, or `undefined` if the index is out of bounds.
+ * array, wrapped in an `Option`.
  *
  * - Does not mutate the input.
  *
@@ -3281,7 +3289,7 @@ export const insertAt: {
  * ```ts
  * import { Array } from "effect"
  *
- * console.log(Array.replace([1, 2, 3], 1, 4)) // [1, 4, 3]
+ * console.log(Array.replace([1, 2, 3], 1, 4)) // Option.some([1, 4, 3])
  * ```
  *
  * @see {@link modify} — transform an element with a function
@@ -3293,7 +3301,7 @@ export const insertAt: {
 export const replace: {
   /**
    * Replaces the element at the specified index with a new value, returning a new
-   * array, or `undefined` if the index is out of bounds.
+   * array, wrapped in an `Option`.
    *
    * - Does not mutate the input.
    *
@@ -3302,7 +3310,7 @@ export const replace: {
    * ```ts
    * import { Array } from "effect"
    *
-   * console.log(Array.replace([1, 2, 3], 1, 4)) // [1, 4, 3]
+   * console.log(Array.replace([1, 2, 3], 1, 4)) // Option.some([1, 4, 3])
    * ```
    *
    * @see {@link modify} — transform an element with a function
@@ -3313,10 +3321,10 @@ export const replace: {
    */
   <B>(i: number, b: B): <A, S extends Iterable<A> = Iterable<A>>(
     self: S
-  ) => ReadonlyArray.With<S, ReadonlyArray.Infer<S> | B> | undefined
+  ) => Option.Option<ReadonlyArray.With<S, ReadonlyArray.Infer<S> | B>>
   /**
    * Replaces the element at the specified index with a new value, returning a new
-   * array, or `undefined` if the index is out of bounds.
+   * array, wrapped in an `Option`.
    *
    * - Does not mutate the input.
    *
@@ -3325,7 +3333,7 @@ export const replace: {
    * ```ts
    * import { Array } from "effect"
    *
-   * console.log(Array.replace([1, 2, 3], 1, 4)) // [1, 4, 3]
+   * console.log(Array.replace([1, 2, 3], 1, 4)) // Option.some([1, 4, 3])
    * ```
    *
    * @see {@link modify} — transform an element with a function
@@ -3334,15 +3342,15 @@ export const replace: {
    * @category elements
    * @since 2.0.0
    */
-  <A, B, S extends Iterable<A> = Iterable<A>>(self: S, i: number, b: B): ReadonlyArray.With<S, ReadonlyArray.Infer<S> | B> | undefined
+  <A, B, S extends Iterable<A> = Iterable<A>>(self: S, i: number, b: B): Option.Option<ReadonlyArray.With<S, ReadonlyArray.Infer<S> | B>>
 } = dual(
   3,
-  <A, B>(self: Iterable<A>, i: number, b: B): Array<A | B> | undefined => modify(self, i, () => b)
+  <A, B>(self: Iterable<A>, i: number, b: B): Option.Option<Array<A | B>> => modify(self, i, () => b)
 )
 
 /**
  * Applies a function to the element at the specified index, returning a new
- * array, or `undefined` if the index is out of bounds.
+ * array, wrapped in an `Option`.
  *
  * - Does not mutate the input.
  *
@@ -3351,8 +3359,8 @@ export const replace: {
  * ```ts
  * import { Array } from "effect"
  *
- * console.log(Array.modify([1, 2, 3, 4], 2, (n) => n * 2)) // [1, 2, 6, 4]
- * console.log(Array.modify([1, 2, 3, 4], 5, (n) => n * 2)) // undefined
+ * console.log(Array.modify([1, 2, 3, 4], 2, (n) => n * 2)) // Option.some([1, 2, 6, 4])
+ * console.log(Array.modify([1, 2, 3, 4], 5, (n) => n * 2)) // Option.none()
  * ```
  *
  * @see {@link replace} — set a fixed value at an index
@@ -3365,7 +3373,7 @@ export const replace: {
 export const modify: {
   /**
    * Applies a function to the element at the specified index, returning a new
-   * array, or `undefined` if the index is out of bounds.
+   * array, wrapped in an `Option`.
    *
    * - Does not mutate the input.
    *
@@ -3374,8 +3382,8 @@ export const modify: {
    * ```ts
    * import { Array } from "effect"
    *
-   * console.log(Array.modify([1, 2, 3, 4], 2, (n) => n * 2)) // [1, 2, 6, 4]
-   * console.log(Array.modify([1, 2, 3, 4], 5, (n) => n * 2)) // undefined
+   * console.log(Array.modify([1, 2, 3, 4], 2, (n) => n * 2)) // Option.some([1, 2, 6, 4])
+   * console.log(Array.modify([1, 2, 3, 4], 5, (n) => n * 2)) // Option.none()
    * ```
    *
    * @see {@link replace} — set a fixed value at an index
@@ -3385,10 +3393,10 @@ export const modify: {
    * @category elements
    * @since 2.0.0
    */
-  <A, B, S extends Iterable<A> = Iterable<A>>(i: number, f: (a: ReadonlyArray.Infer<S>) => B): (self: S) => ReadonlyArray.With<S, ReadonlyArray.Infer<S> | B> | undefined
+  <A, B, S extends Iterable<A> = Iterable<A>>(i: number, f: (a: ReadonlyArray.Infer<S>) => B): (self: S) => Option.Option<ReadonlyArray.With<S, ReadonlyArray.Infer<S> | B>>
   /**
    * Applies a function to the element at the specified index, returning a new
-   * array, or `undefined` if the index is out of bounds.
+   * array, wrapped in an `Option`.
    *
    * - Does not mutate the input.
    *
@@ -3397,8 +3405,8 @@ export const modify: {
    * ```ts
    * import { Array } from "effect"
    *
-   * console.log(Array.modify([1, 2, 3, 4], 2, (n) => n * 2)) // [1, 2, 6, 4]
-   * console.log(Array.modify([1, 2, 3, 4], 5, (n) => n * 2)) // undefined
+   * console.log(Array.modify([1, 2, 3, 4], 2, (n) => n * 2)) // Option.some([1, 2, 6, 4])
+   * console.log(Array.modify([1, 2, 3, 4], 5, (n) => n * 2)) // Option.none()
    * ```
    *
    * @see {@link replace} — set a fixed value at an index
@@ -3408,16 +3416,16 @@ export const modify: {
    * @category elements
    * @since 2.0.0
    */
-  <A, B, S extends Iterable<A> = Iterable<A>>(self: S, i: number, f: (a: ReadonlyArray.Infer<S>) => B): ReadonlyArray.With<S, ReadonlyArray.Infer<S> | B> | undefined
-} = dual(3, <A, B>(self: Iterable<A>, i: number, f: (a: A) => B): Array<A | B> | undefined => {
+  <A, B, S extends Iterable<A> = Iterable<A>>(self: S, i: number, f: (a: ReadonlyArray.Infer<S>) => B): Option.Option<ReadonlyArray.With<S, ReadonlyArray.Infer<S> | B>>
+} = dual(3, <A, B>(self: Iterable<A>, i: number, f: (a: A) => B): Option.Option<Array<A | B>> => {
   const arr = Array.from(self)
   if (isOutOfBounds(i, arr)) {
-    return undefined
+    return Option.none()
   }
   const out: Array<A | B> = arr
   const b = f(arr[i])
   out[i] = b
-  return out
+  return Option.some(out)
 })
 
 /**
@@ -6272,98 +6280,6 @@ export const flatMap: {
 export const flatten: <const S extends ReadonlyArray<ReadonlyArray<any>>>(self: S) => ReadonlyArray.Flatten<S> =
   flatMap(identity) as any
 
-/**
- * Maps each element to a `Result`, then separates failures and successes into
- * two arrays.
- *
- * - Returns `[failures, successes]`.
- *
- * **Example** (Partitioning by Result)
- *
- * ```ts
- * import { Array, Result } from "effect"
- *
- * const result = Array.partitionMap(
- *   [1, 2, 3, 4, 5],
- *   (x) => x % 2 === 0 ? Result.succeed(x) : Result.fail(x)
- * )
- * console.log(result) // [[1, 3, 5], [2, 4]]
- * ```
- *
- * @see {@link partition} — partition by predicate
- * @see {@link separate} — partition an array of Results
- *
- * @category filtering
- * @since 2.0.0
- */
-export const partitionMap: {
-  /**
-   * Maps each element to a `Result`, then separates failures and successes into
-   * two arrays.
-   *
-   * - Returns `[failures, successes]`.
-   *
-   * **Example** (Partitioning by Result)
-   *
-   * ```ts
-   * import { Array, Result } from "effect"
-   *
-   * const result = Array.partitionMap(
-   *   [1, 2, 3, 4, 5],
-   *   (x) => x % 2 === 0 ? Result.succeed(x) : Result.fail(x)
-   * )
-   * console.log(result) // [[1, 3, 5], [2, 4]]
-   * ```
-   *
-   * @see {@link partition} — partition by predicate
-   * @see {@link separate} — partition an array of Results
-   *
-   * @category filtering
-   * @since 2.0.0
-   */
-  <A, B, C>(f: (a: A, i: number) => Result.Result<C, B>): (self: Iterable<A>) => [fails: Array<B>, successes: Array<C>]
-  /**
-   * Maps each element to a `Result`, then separates failures and successes into
-   * two arrays.
-   *
-   * - Returns `[failures, successes]`.
-   *
-   * **Example** (Partitioning by Result)
-   *
-   * ```ts
-   * import { Array, Result } from "effect"
-   *
-   * const result = Array.partitionMap(
-   *   [1, 2, 3, 4, 5],
-   *   (x) => x % 2 === 0 ? Result.succeed(x) : Result.fail(x)
-   * )
-   * console.log(result) // [[1, 3, 5], [2, 4]]
-   * ```
-   *
-   * @see {@link partition} — partition by predicate
-   * @see {@link separate} — partition an array of Results
-   *
-   * @category filtering
-   * @since 2.0.0
-   */
-  <A, B, C>(self: Iterable<A>, f: (a: A, i: number) => Result.Result<C, B>): [fails: Array<B>, successes: Array<C>]
-} = dual(
-  2,
-  <A, B, C>(self: Iterable<A>, f: (a: A, i: number) => Result.Result<C, B>): [fails: Array<B>, successes: Array<C>] => {
-    const failures: Array<B> = []
-    const successes: Array<C> = []
-    const as = fromIterable(self)
-    for (let i = 0; i < as.length; i++) {
-      const e = f(as[i], i)
-      if (Result.isFailure(e)) {
-        failures.push(e.failure)
-      } else {
-        successes.push(e.success)
-      }
-    }
-    return [failures, successes]
-  }
-)
 /**
  * Extracts all `Some` values from an iterable of `Option`s, discarding `None`s.
  *
@@ -6459,65 +6375,100 @@ export const getSuccesses = <T extends Iterable<Result.Result<any, any>>>(
 }
 
 /**
- * Keeps only elements satisfying a predicate (or refinement).
+ * Keeps transformed values for elements where a `Filter` succeeds.
  *
- * - The predicate receives `(element, index)`.
- * - Supports refinements for type narrowing.
+ * - The filter receives `(element, index)`.
+ * - Failures are discarded.
  *
- * **Example** (Filtering even numbers)
+ * **Example** (Filter and transform)
  *
  * ```ts
- * import { Array } from "effect"
+ * import { Array, Result } from "effect"
  *
- * console.log(Array.filter([1, 2, 3, 4], (x) => x % 2 === 0)) // [2, 4]
+ * console.log(Array.filterMap([1, 2, 3, 4], (n) => n % 2 === 0 ? Result.succeed(n * 10) : Result.failVoid))
+ * // [20, 40]
  * ```
  *
- * @see {@link partition} — split into matching and non-matching
+ * @see {@link filter} — keep original elements matching a predicate
  *
  * @category filtering
- * @since 2.0.0
+ * @since 4.0.0
  */
-export const filter: {
+export const filterMap: {
   /**
-   * Keeps only elements satisfying a predicate (or refinement).
+   * Keeps transformed values for elements where a `Filter` succeeds.
    *
-   * - The predicate receives `(element, index)`.
-   * - Supports refinements for type narrowing.
+   * - The filter receives `(element, index)`.
+   * - Failures are discarded.
    *
-   * **Example** (Filtering even numbers)
+   * **Example** (Filter and transform)
    *
    * ```ts
-   * import { Array } from "effect"
+   * import { Array, Result } from "effect"
    *
-   * console.log(Array.filter([1, 2, 3, 4], (x) => x % 2 === 0)) // [2, 4]
+   * console.log(Array.filterMap([1, 2, 3, 4], (n) => n % 2 === 0 ? Result.succeed(n * 10) : Result.failVoid))
+   * // [20, 40]
    * ```
    *
-   * @see {@link partition} — split into matching and non-matching
+   * @see {@link filter} — keep original elements matching a predicate
    *
    * @category filtering
-   * @since 2.0.0
+   * @since 4.0.0
    */
-  <A, B extends A>(refinement: (a: NoInfer<A>, i: number) => a is B): (self: Iterable<A>) => Array<B>
+  <A, B, X>(f: (input: NoInfer<A>, i: number) => Result.Result<B, X>): (self: Iterable<A>) => Array<B>
   /**
-   * Keeps only elements satisfying a predicate (or refinement).
+   * Keeps transformed values for elements where a `Filter` succeeds.
    *
-   * - The predicate receives `(element, index)`.
-   * - Supports refinements for type narrowing.
+   * - The filter receives `(element, index)`.
+   * - Failures are discarded.
    *
-   * **Example** (Filtering even numbers)
+   * **Example** (Filter and transform)
    *
    * ```ts
-   * import { Array } from "effect"
+   * import { Array, Result } from "effect"
    *
-   * console.log(Array.filter([1, 2, 3, 4], (x) => x % 2 === 0)) // [2, 4]
+   * console.log(Array.filterMap([1, 2, 3, 4], (n) => n % 2 === 0 ? Result.succeed(n * 10) : Result.failVoid))
+   * // [20, 40]
    * ```
    *
-   * @see {@link partition} — split into matching and non-matching
+   * @see {@link filter} — keep original elements matching a predicate
    *
    * @category filtering
-   * @since 2.0.0
+   * @since 4.0.0
    */
-  <A>(predicate: (a: NoInfer<A>, i: number) => boolean): (self: Iterable<A>) => Array<A>
+  <A, B, X>(self: Iterable<A>, f: (input: A, i: number) => Result.Result<B, X>): Array<B>
+} = dual(2, <A, B, X>(self: Iterable<A>, f: (input: A, i: number) => Result.Result<B, X>): Array<B> => {
+  const as = fromIterable(self)
+  const out: Array<B> = []
+  for (let i = 0; i < as.length; i++) {
+    const result = f(as[i], i)
+    if (Result.isSuccess(result)) {
+      out.push(result.success)
+    }
+  }
+  return out
+})
+
+/**
+ * Keeps only elements satisfying a predicate (or refinement).
+ *
+ * - The predicate receives `(element, index)`.
+ * - Supports refinements for type narrowing.
+ *
+ * **Example** (Filtering even numbers)
+ *
+ * ```ts
+ * import { Array } from "effect"
+ *
+ * console.log(Array.filter([1, 2, 3, 4], (x) => x % 2 === 0)) // [2, 4]
+ * ```
+ *
+ * @see {@link partition} — split into matching and non-matching
+ *
+ * @category filtering
+ * @since 2.0.0
+ */
+export const filter: {
   /**
    * Keeps only elements satisfying a predicate (or refinement).
    *
@@ -6537,7 +6488,7 @@ export const filter: {
    * @category filtering
    * @since 2.0.0
    */
-  <A, B, X>(f: Filter.Filter<NoInfer<A>, B, X>): (self: Iterable<A>) => Array<B>
+  <A, B extends A>(refinement: (a: NoInfer<A>, i: number) => a is B): (self: Iterable<A>) => Array<B>
   /**
    * Keeps only elements satisfying a predicate (or refinement).
    *
@@ -6557,7 +6508,7 @@ export const filter: {
    * @category filtering
    * @since 2.0.0
    */
-  <A, B extends A>(self: Iterable<A>, refinement: (a: A, i: number) => a is B): Array<B>
+  <A>(predicate: (a: NoInfer<A>, i: number) => boolean): (self: Iterable<A>) => Array<A>
   /**
    * Keeps only elements satisfying a predicate (or refinement).
    *
@@ -6577,7 +6528,7 @@ export const filter: {
    * @category filtering
    * @since 2.0.0
    */
-  <A>(self: Iterable<A>, predicate: (a: A, i: number) => boolean): Array<A>
+  <A, B extends A>(self: Iterable<A>, refinement: (a: A, i: number) => a is B): Array<B>
   /**
    * Keeps only elements satisfying a predicate (or refinement).
    *
@@ -6597,16 +6548,15 @@ export const filter: {
    * @category filtering
    * @since 2.0.0
    */
-  <A, B, X>(self: Iterable<A>, f: Filter.Filter<A, B, X>): Array<B>
+  <A>(self: Iterable<A>, predicate: (a: A, i: number) => boolean): Array<A>
 } = dual(
   2,
-  <A>(self: Iterable<A>, f: Filter.Filter<A, any, any> | ((a: A, i: number) => boolean)): Array<any> => {
+  <A>(self: Iterable<A>, predicate: (a: A, i: number) => boolean): Array<A> => {
     const as = fromIterable(self)
-    const out: Array<any> = []
+    const out: Array<A> = []
     for (let i = 0; i < as.length; i++) {
-      const result = Filter.apply(f as any, as[i], i)
-      if (!Result.isFailure(result)) {
-        out.push(result.success)
+      if (predicate(as[i], i)) {
+        out.push(as[i])
       }
     }
     return out
@@ -6614,190 +6564,93 @@ export const filter: {
 )
 
 /**
- * Splits an iterable into two arrays: elements that fail the predicate and
- * elements that satisfy it.
+ * Splits an iterable using a `Filter` into failures and successes.
  *
  * - Returns `[excluded, satisfying]`.
- * - Supports refinements for type narrowing.
+ * - The filter receives `(element, index)`.
  *
- * **Example** (Partitioning by predicate)
+ * **Example** (Partitioning with a filter)
  *
  * ```ts
- * import { Array } from "effect"
+ * import { Array, Result } from "effect"
  *
- * console.log(Array.partition([1, 2, 3, 4], (n) => n % 2 === 0)) // [[1, 3], [2, 4]]
+ * console.log(Array.partition([1, -2, 3], (n, i) =>
+ *   n > 0 ? Result.succeed(n + i) : Result.fail(`negative:${n}`)
+ * ))
+ * // [["negative:-2"], [1, 5]]
  * ```
  *
  * @see {@link filter} — keep only matching elements
  * @see {@link partitionMap} — partition using a Result-returning function
  *
- * Also accepts a `Filter` to split elements with custom pass/fail payloads.
- *
  * @category filtering
  * @since 2.0.0
  */
 export const partition: {
   /**
-   * Splits an iterable into two arrays: elements that fail the predicate and
-   * elements that satisfy it.
+   * Splits an iterable using a `Filter` into failures and successes.
    *
    * - Returns `[excluded, satisfying]`.
-   * - Supports refinements for type narrowing.
+   * - The filter receives `(element, index)`.
    *
-   * **Example** (Partitioning by predicate)
+   * **Example** (Partitioning with a filter)
    *
    * ```ts
-   * import { Array } from "effect"
-   *
-   * console.log(Array.partition([1, 2, 3, 4], (n) => n % 2 === 0)) // [[1, 3], [2, 4]]
-   * ```
-   *
-   * @see {@link filter} — keep only matching elements
-   * @see {@link partitionMap} — partition using a Result-returning function
-   *
-   * Also accepts a `Filter` to split elements with custom pass/fail payloads.
-   *
-   * @category filtering
-   * @since 2.0.0
-   */
-  <A, B extends A>(refinement: (a: NoInfer<A>, i: number) => a is B): (
-    self: Iterable<A>
-  ) => [excluded: Array<Exclude<A, B>>, satisfying: Array<B>]
-  /**
-   * Splits an iterable into two arrays: elements that fail the predicate and
-   * elements that satisfy it.
-   *
-   * - Returns `[excluded, satisfying]`.
-   * - Supports refinements for type narrowing.
-   *
-   * **Example** (Partitioning by predicate)
-   *
-   * ```ts
-   * import { Array } from "effect"
-   *
-   * console.log(Array.partition([1, 2, 3, 4], (n) => n % 2 === 0)) // [[1, 3], [2, 4]]
-   * ```
-   *
-   * @see {@link filter} — keep only matching elements
-   * @see {@link partitionMap} — partition using a Result-returning function
-   *
-   * Also accepts a `Filter` to split elements with custom pass/fail payloads.
-   *
-   * @category filtering
-   * @since 2.0.0
-   */
-  <A>(predicate: (a: NoInfer<A>, i: number) => boolean): (self: Iterable<A>) => [excluded: Array<A>, satisfying: Array<A>]
-  /**
-   * Splits an iterable into two arrays: elements that fail the predicate and
-   * elements that satisfy it.
-   *
-   * - Returns `[excluded, satisfying]`.
-   * - Supports refinements for type narrowing.
-   *
-   * **Example** (Partitioning by predicate)
-   *
-   * ```ts
-   * import { Array } from "effect"
-   *
-   * console.log(Array.partition([1, 2, 3, 4], (n) => n % 2 === 0)) // [[1, 3], [2, 4]]
-   * ```
-   *
-   * @see {@link filter} — keep only matching elements
-   * @see {@link partitionMap} — partition using a Result-returning function
-   *
-   * Also accepts a `Filter` to split elements with custom pass/fail payloads.
-   *
-   * @category filtering
-   * @since 2.0.0
-   */
-  <A, Pass, Fail>(f: Filter.Filter<A, Pass, Fail>): (self: Iterable<A>) => [excluded: Array<Fail>, satisfying: Array<Pass>]
-  /**
-   * Splits an iterable into two arrays: elements that fail the predicate and
-   * elements that satisfy it.
-   *
-   * - Returns `[excluded, satisfying]`.
-   * - Supports refinements for type narrowing.
-   *
-   * **Example** (Partitioning by predicate)
-   *
-   * ```ts
-   * import { Array } from "effect"
-   *
-   * console.log(Array.partition([1, 2, 3, 4], (n) => n % 2 === 0)) // [[1, 3], [2, 4]]
-   * ```
-   *
-   * @see {@link filter} — keep only matching elements
-   * @see {@link partitionMap} — partition using a Result-returning function
-   *
-   * Also accepts a `Filter` to split elements with custom pass/fail payloads.
-   *
-   * @category filtering
-   * @since 2.0.0
-   */
-  <A, B extends A>(self: Iterable<A>, refinement: (a: A, i: number) => a is B): [excluded: Array<Exclude<A, B>>, satisfying: Array<B>]
-  /**
-   * Splits an iterable into two arrays: elements that fail the predicate and
-   * elements that satisfy it.
-   *
-   * - Returns `[excluded, satisfying]`.
-   * - Supports refinements for type narrowing.
-   *
-   * **Example** (Partitioning by predicate)
-   *
-   * ```ts
-   * import { Array } from "effect"
+   * import { Array, Result } from "effect"
    *
-   * console.log(Array.partition([1, 2, 3, 4], (n) => n % 2 === 0)) // [[1, 3], [2, 4]]
+   * console.log(Array.partition([1, -2, 3], (n, i) =>
+   *   n > 0 ? Result.succeed(n + i) : Result.fail(`negative:${n}`)
+   * ))
+   * // [["negative:-2"], [1, 5]]
    * ```
    *
    * @see {@link filter} — keep only matching elements
    * @see {@link partitionMap} — partition using a Result-returning function
    *
-   * Also accepts a `Filter` to split elements with custom pass/fail payloads.
-   *
    * @category filtering
    * @since 2.0.0
    */
-  <A>(self: Iterable<A>, predicate: (a: A, i: number) => boolean): [excluded: Array<A>, satisfying: Array<A>]
+  <A, Pass, Fail>(f: (input: NoInfer<A>, i: number) => Result.Result<Pass, Fail>): (self: Iterable<A>) => [excluded: Array<Fail>, satisfying: Array<Pass>]
   /**
-   * Splits an iterable into two arrays: elements that fail the predicate and
-   * elements that satisfy it.
+   * Splits an iterable using a `Filter` into failures and successes.
    *
    * - Returns `[excluded, satisfying]`.
-   * - Supports refinements for type narrowing.
+   * - The filter receives `(element, index)`.
    *
-   * **Example** (Partitioning by predicate)
+   * **Example** (Partitioning with a filter)
    *
    * ```ts
-   * import { Array } from "effect"
+   * import { Array, Result } from "effect"
    *
-   * console.log(Array.partition([1, 2, 3, 4], (n) => n % 2 === 0)) // [[1, 3], [2, 4]]
+   * console.log(Array.partition([1, -2, 3], (n, i) =>
+   *   n > 0 ? Result.succeed(n + i) : Result.fail(`negative:${n}`)
+   * ))
+   * // [["negative:-2"], [1, 5]]
    * ```
    *
    * @see {@link filter} — keep only matching elements
    * @see {@link partitionMap} — partition using a Result-returning function
    *
-   * Also accepts a `Filter` to split elements with custom pass/fail payloads.
-   *
    * @category filtering
    * @since 2.0.0
    */
-  <A, Pass, Fail>(self: Iterable<A>, f: Filter.Filter<A, Pass, Fail>): [excluded: Array<Fail>, satisfying: Array<Pass>]
+  <A, Pass, Fail>(self: Iterable<A>, f: (input: A, i: number) => Result.Result<Pass, Fail>): [excluded: Array<Fail>, satisfying: Array<Pass>]
 } = dual(
   2,
-  <A>(
+  <A, Pass, Fail>(
     self: Iterable<A>,
-    f: Filter.Filter<A, any, any> | ((a: A, i: number) => boolean)
-  ): [excluded: Array<any>, satisfying: Array<any>] => {
-    const excluded: Array<any> = []
-    const satisfying: Array<any> = []
-    const as = fromIterable(self)
-    for (let i = 0; i < as.length; i++) {
-      const result = f(as[i], i)
-      if (result === true) satisfying.push(as[i])
-      else if (result === false) excluded.push(as[i])
-      else if (Result.isSuccess(result)) satisfying.push(result.success)
-      else excluded.push(result.failure)
+    f: (input: A, i: number) => Result.Result<Pass, Fail>
+  ): [excluded: Array<Fail>, satisfying: Array<Pass>] => {
+    const excluded: Array<Fail> = []
+    const satisfying: Array<Pass> = []
+    let i = 0
+    for (const a of self) {
+      const result = f(a, i++)
+      if (Result.isSuccess(result)) {
+        satisfying.push(result.success)
+      } else {
+        excluded.push(result.failure)
+      }
     }
     return [excluded, satisfying]
   }
@@ -6831,7 +6684,7 @@ export const separate: <T extends Iterable<Result.Result<any, any>>>(
 ) => [
   failures: Array<Result.Result.Failure<ReadonlyArray.Infer<T>>>,
   successes: Array<Result.Result.Success<ReadonlyArray.Infer<T>>>
-] = partitionMap(identity)
+] = partition(identity)
 
 /**
  * Folds an iterable from left to right into a single value.
@@ -7523,14 +7376,15 @@ export const max: {
 
 /**
  * Builds an array by repeatedly applying a function to a seed value. The
- * function returns `[element, nextSeed]` to continue, or `undefined` to stop.
+ * function returns `Option.some([element, nextSeed])` to continue, or
+ * `Option.none()` to stop.
  *
  * **Example** (Generating a sequence)
  *
  * ```ts
- * import { Array } from "effect"
+ * import { Array, Option } from "effect"
  *
- * console.log(Array.unfold(1, (n) => n <= 5 ? [n, n + 1] : undefined))
+ * console.log(Array.unfold(1, (n) => n <= 5 ? Option.some([n, n + 1]) : Option.none()))
  * // [1, 2, 3, 4, 5]
  * ```
  *
@@ -7540,12 +7394,15 @@ export const max: {
  * @category constructors
  * @since 2.0.0
  */
-export const unfold = <B, A>(b: B, f: (b: B) => readonly [A, B] | undefined): Array<A> => {
+export const unfold = <B, A>(b: B, f: (b: B) => Option.Option<readonly [A, B]>): Array<A> => {
   const out: Array<A> = []
   let next: B = b
-  let o: readonly [A, B] | undefined
-  while ((o = f(next))) {
-    const [a, b] = o
+  while (true) {
+    const o = f(next)
+    if (Option.isNone(o)) {
+      break
+    }
+    const [a, b] = o.value
     out.push(a)
     next = b
   }