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

package/dist/Array.d.ts

@@ -1,5 +1,4 @@
 import * as Equivalence from "./Equivalence.ts";
-import * as Filter from "./Filter.ts";
 import type { LazyArg } from "./Function.ts";
 import type { TypeLambda } from "./HKT.ts";
 import * as Option from "./Option.ts";
@@ -1549,18 +1548,18 @@ export declare const last: <A>(self: ReadonlyArray<A>) => Option.Option<A>;
  */
 export declare const lastNonEmpty: <A>(self: NonEmptyReadonlyArray<A>) => A;
 /**
- * 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
@@ -1569,7 +1568,7 @@ export declare const lastNonEmpty: <A>(self: NonEmptyReadonlyArray<A>) => A;
  * @category getters
  * @since 2.0.0
  */
-export declare function tail<A>(self: Iterable<A>): Array<A> | undefined;
+export declare function tail<A>(self: Iterable<A>): Option.Option<Array<A>>;
 /**
  * Returns all elements except the first of a `NonEmptyReadonlyArray`.
  *
@@ -1589,18 +1588,18 @@ export declare function tail<A>(self: Iterable<A>): Array<A> | undefined;
  */
 export declare const tailNonEmpty: <A>(self: NonEmptyReadonlyArray<A>) => Array<A>;
 /**
- * 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
@@ -1609,7 +1608,7 @@ export declare const tailNonEmpty: <A>(self: NonEmptyReadonlyArray<A>) => Array<
  * @category getters
  * @since 2.0.0
  */
-export declare function init<A>(self: Iterable<A>): Array<A> | undefined;
+export declare function init<A>(self: Iterable<A>): Option.Option<Array<A>>;
 /**
  * Returns all elements except the last of a `NonEmptyReadonlyArray`.
  *
@@ -1850,7 +1849,7 @@ export declare 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.
@@ -1873,53 +1872,38 @@ export declare 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>;
+};
+/**
+ * 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 declare 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)
+     * Takes elements from the start while a `Filter` succeeds, collecting transformed values.
      *
-     * ```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>(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.
-     *
-     * - Supports refinements for type narrowing.
-     * - The predicate receives `(element, index)`.
-     *
-     * **Example** (Taking while condition holds)
+     * Takes elements from the start while a `Filter` succeeds, collecting transformed values.
      *
-     * ```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>;
+    <A, B, X>(self: Iterable<A>, f: (input: NoInfer<A>, i: number) => Result.Result<B, X>): Array<B>;
 };
 /**
  * Splits an iterable into two arrays: the longest prefix where the predicate
@@ -2229,58 +2213,49 @@ export declare 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>;
+};
+/**
+ * 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 declare const dropWhileFilter: {
     /**
-     * Drops elements from the start while the predicate holds, returning the rest.
-     *
-     * - The predicate receives `(element, index)`.
+     * Drops elements from the start while a `Filter` succeeds.
      *
-     * **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.
+     * 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, 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>;
 };
 /**
- * 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
@@ -2291,15 +2266,15 @@ export declare const dropWhile: {
  */
 export declare 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
@@ -2308,17 +2283,17 @@ export declare 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
@@ -2327,18 +2302,18 @@ export declare const findFirstIndex: {
      * @category elements
      * @since 2.0.0
      */
-    <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>;
 };
 /**
- * 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
@@ -2349,15 +2324,15 @@ export declare const findFirstIndex: {
  */
 export declare 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
@@ -2366,17 +2341,17 @@ export declare 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
@@ -2385,7 +2360,7 @@ export declare const findLastIndex: {
      * @category elements
      * @since 2.0.0
      */
-    <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>;
 };
 /**
  * Returns the first element matching a predicate, refinement, or mapping
@@ -2558,14 +2533,14 @@ export declare 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
@@ -2577,14 +2552,14 @@ export declare const findFirst: {
 export declare 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
@@ -2593,17 +2568,17 @@ export declare 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
@@ -2612,17 +2587,17 @@ export declare 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
@@ -2631,17 +2606,17 @@ export declare 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
@@ -2650,17 +2625,17 @@ export declare 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
@@ -2669,17 +2644,17 @@ export declare 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
@@ -2688,7 +2663,7 @@ export declare 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]>;
 };
 /**
  * Returns the last element matching a predicate, refinement, or mapping
@@ -2846,8 +2821,8 @@ export declare const findLast: {
     <A>(self: Iterable<A>, predicate: (a: A, i: number) => boolean): Option.Option<A>;
 };
 /**
- * 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.
@@ -2857,7 +2832,7 @@ export declare 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
@@ -2868,8 +2843,8 @@ export declare const findLast: {
  */
 export declare 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.
@@ -2879,7 +2854,7 @@ export declare 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
@@ -2888,10 +2863,10 @@ export declare 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.
@@ -2901,7 +2876,7 @@ export declare 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
@@ -2910,11 +2885,11 @@ export declare const insertAt: {
      * @category elements
      * @since 2.0.0
      */
-    <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>>;
 };
 /**
  * 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.
  *
@@ -2923,7 +2898,7 @@ export declare 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
@@ -2935,7 +2910,7 @@ export declare const insertAt: {
 export declare 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.
      *
@@ -2944,7 +2919,7 @@ export declare 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
@@ -2953,10 +2928,10 @@ export declare const replace: {
      * @category elements
      * @since 2.0.0
      */
-    <B>(i: number, b: B): <A, S extends Iterable<A> = Iterable<A>>(self: S) => ReadonlyArray.With<S, ReadonlyArray.Infer<S> | B> | undefined;
+    <B>(i: number, b: B): <A, S extends Iterable<A> = Iterable<A>>(self: S) => 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.
      *
@@ -2965,7 +2940,7 @@ export declare 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
@@ -2974,11 +2949,11 @@ export declare 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>>;
 };
 /**
  * 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.
  *
@@ -2987,8 +2962,8 @@ export declare 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
@@ -3001,7 +2976,7 @@ export declare const replace: {
 export declare 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.
      *
@@ -3010,8 +2985,8 @@ export declare 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
@@ -3021,10 +2996,10 @@ export declare 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.
      *
@@ -3033,8 +3008,8 @@ export declare 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
@@ -3044,7 +3019,7 @@ export declare 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;
+    <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>>;
 };
 /**
  * Removes the element at the specified index, returning a new array. If the
@@ -5520,82 +5495,6 @@ export declare const flatMap: {
  * @since 2.0.0
  */
 export declare const flatten: <const S extends ReadonlyArray<ReadonlyArray<any>>>(self: S) => ReadonlyArray.Flatten<S>;
-/**
- * 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 declare 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>];
-};
 /**
  * Extracts all `Some` values from an iterable of `Option`s, discarding `None`s.
  *
@@ -5655,65 +5554,89 @@ export declare const getFailures: <T extends Iterable<Result.Result<any, any>>>(
  */
 export declare const getSuccesses: <T extends Iterable<Result.Result<any, any>>>(self: T) => Array<Result.Result.Success<ReadonlyArray.Infer<T>>>;
 /**
- * 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 declare const filter: {
+export declare 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>;
+};
+/**
+ * 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 declare const filter: {
     /**
      * Keeps only elements satisfying a predicate (or refinement).
      *
@@ -5733,7 +5656,7 @@ export declare 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).
      *
@@ -5753,7 +5676,7 @@ export declare 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).
      *
@@ -5773,7 +5696,7 @@ export declare 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).
      *
@@ -5793,176 +5716,80 @@ export declare 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>;
 };
 /**
- * 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 declare const partition: {
     /**
-     * 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>(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.
+     * 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>(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>];
 };
 /**
  * Separates an iterable of `Result`s into two arrays: failures and successes.
@@ -6634,14 +6461,15 @@ export declare 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]
  * ```
  *
@@ -6651,7 +6479,7 @@ export declare const max: {
  * @category constructors
  * @since 2.0.0
  */
-export declare const unfold: <B, A>(b: B, f: (b: B) => readonly [A, B] | undefined) => Array<A>;
+export declare const unfold: <B, A>(b: B, f: (b: B) => Option.Option<readonly [A, B]>) => Array<A>;
 /**
  * Creates an `Order` for arrays based on an element `Order`. Arrays are
  * compared element-wise; if all compared elements are equal, shorter arrays