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

package/dist/Array.js

@@ -85,7 +85,6 @@
  */
 import * as Equal from "./Equal.js";
 import * as Equivalence from "./Equivalence.js";
-import * as Filter from "./Filter.js";
 import { dual, identity } from "./Function.js";
 import * as internalArray from "./internal/array.js";
 import * as internalDoNotation from "./internal/doNotation.js";
@@ -856,18 +855,18 @@ export const last = self => isReadonlyArrayNonEmpty(self) ? Option.some(lastNonE
  */
 export const lastNonEmpty = self => 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
@@ -878,7 +877,7 @@ export const lastNonEmpty = self => self[self.length - 1];
  */
 export function tail(self) {
   const as = fromIterable(self);
-  return isReadonlyArrayNonEmpty(as) ? tailNonEmpty(as) : undefined;
+  return isReadonlyArrayNonEmpty(as) ? Option.some(tailNonEmpty(as)) : Option.none();
 }
 /**
  * Returns all elements except the first of a `NonEmptyReadonlyArray`.
@@ -899,18 +898,18 @@ export function tail(self) {
  */
 export const tailNonEmpty = self => 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
@@ -921,7 +920,7 @@ export const tailNonEmpty = self => self.slice(1);
  */
 export function init(self) {
   const as = fromIterable(self);
-  return isReadonlyArrayNonEmpty(as) ? initNonEmpty(as) : undefined;
+  return isReadonlyArrayNonEmpty(as) ? Option.some(initNonEmpty(as)) : Option.none();
 }
 /**
  * Returns all elements except the last of a `NonEmptyReadonlyArray`.
@@ -1013,12 +1012,35 @@ export const takeRight = /*#__PURE__*/dual(2, (self, n) => {
  * @category getters
  * @since 2.0.0
  */
-export const takeWhile = /*#__PURE__*/dual(2, (self, f) => {
+export const takeWhile = /*#__PURE__*/dual(2, (self, predicate) => {
   let i = 0;
   const out = [];
   for (const a of self) {
-    const result = Filter.apply(f, a, i);
-    if (Result.isFailure(result)) break;
+    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 = /*#__PURE__*/dual(2, (self, f) => {
+  let i = 0;
+  const out = [];
+  for (const a of self) {
+    const result = f(a, i);
+    if (Result.isFailure(result)) {
+      break;
+    }
     out.push(result.success);
     i++;
   }
@@ -1128,25 +1150,47 @@ export const dropRight = /*#__PURE__*/dual(2, (self, n) => {
  * @category getters
  * @since 2.0.0
  */
-export const dropWhile = /*#__PURE__*/dual(2, (self, f) => {
+export const dropWhile = /*#__PURE__*/dual(2, (self, predicate) => {
+  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 = /*#__PURE__*/dual(2, (self, f) => {
   const input = fromIterable(self);
   let i = 0;
-  for (const a of input) {
-    if (Result.isFailure(Filter.apply(f, a, i))) break;
+  while (i < input.length) {
+    if (Result.isFailure(f(input[i], i))) {
+      break;
+    }
     i++;
   }
   return input.slice(i);
 });
 /**
- * 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
@@ -1159,21 +1203,22 @@ export const findFirstIndex = /*#__PURE__*/dual(2, (self, predicate) => {
   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
@@ -1186,9 +1231,10 @@ export const findLastIndex = /*#__PURE__*/dual(2, (self, predicate) => {
   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();
 });
 /**
  * Returns the first element matching a predicate, refinement, or mapping
@@ -1216,14 +1262,14 @@ export const findLastIndex = /*#__PURE__*/dual(2, (self, predicate) => {
 export const findFirst = moduleIterable.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
@@ -1238,15 +1284,16 @@ export const findFirstWithIndex = /*#__PURE__*/dual(2, (self, f) => {
     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();
 });
 /**
  * Returns the last element matching a predicate, refinement, or mapping
@@ -1287,8 +1334,8 @@ export const findLast = /*#__PURE__*/dual(2, (self, f) => {
   return Option.none();
 });
 /**
- * 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.
@@ -1298,7 +1345,7 @@ export const findLast = /*#__PURE__*/dual(2, (self, f) => {
  * ```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
@@ -1310,14 +1357,14 @@ export const findLast = /*#__PURE__*/dual(2, (self, f) => {
 export const insertAt = /*#__PURE__*/dual(3, (self, i, b) => {
   const out = 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;
+  return Option.some(out);
 });
 /**
  * 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.
  *
@@ -1326,7 +1373,7 @@ export const insertAt = /*#__PURE__*/dual(3, (self, i, b) => {
  * ```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
@@ -1338,7 +1385,7 @@ export const insertAt = /*#__PURE__*/dual(3, (self, i, b) => {
 export const replace = /*#__PURE__*/dual(3, (self, i, 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.
  *
@@ -1347,8 +1394,8 @@ export const replace = /*#__PURE__*/dual(3, (self, i, b) => modify(self, i, () =
  * ```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
@@ -1361,12 +1408,12 @@ export const replace = /*#__PURE__*/dual(3, (self, i, b) => modify(self, i, () =
 export const modify = /*#__PURE__*/dual(3, (self, i, f) => {
   const arr = Array.from(self);
   if (isOutOfBounds(i, arr)) {
-    return undefined;
+    return Option.none();
   }
   const out = arr;
   const b = f(arr[i]);
   out[i] = b;
-  return out;
+  return Option.some(out);
 });
 /**
  * Removes the element at the specified index, returning a new array. If the
@@ -2371,44 +2418,6 @@ export const flatMap = /*#__PURE__*/dual(2, (self, f) => {
  * @since 2.0.0
  */
 export const flatten = /*#__PURE__*/flatMap(identity);
-/**
- * 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 = /*#__PURE__*/dual(2, (self, f) => {
-  const failures = [];
-  const successes = [];
-  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.
  *
@@ -2491,6 +2500,37 @@ export const getSuccesses = self => {
   }
   return out;
 };
+/**
+ * Keeps transformed values for elements where a `Filter` succeeds.
+ *
+ * - The filter receives `(element, index)`.
+ * - Failures are discarded.
+ *
+ * **Example** (Filter and transform)
+ *
+ * ```ts
+ * import { Array, Result } from "effect"
+ *
+ * console.log(Array.filterMap([1, 2, 3, 4], (n) => n % 2 === 0 ? Result.succeed(n * 10) : Result.failVoid))
+ * // [20, 40]
+ * ```
+ *
+ * @see {@link filter} — keep original elements matching a predicate
+ *
+ * @category filtering
+ * @since 4.0.0
+ */
+export const filterMap = /*#__PURE__*/dual(2, (self, f) => {
+  const as = fromIterable(self);
+  const out = [];
+  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).
  *
@@ -2510,47 +2550,50 @@ export const getSuccesses = self => {
  * @category filtering
  * @since 2.0.0
  */
-export const filter = /*#__PURE__*/dual(2, (self, f) => {
+export const filter = /*#__PURE__*/dual(2, (self, predicate) => {
   const as = fromIterable(self);
   const out = [];
   for (let i = 0; i < as.length; i++) {
-    const result = Filter.apply(f, as[i], i);
-    if (!Result.isFailure(result)) {
-      out.push(result.success);
+    if (predicate(as[i], i)) {
+      out.push(as[i]);
     }
   }
   return out;
 });
 /**
- * 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 = /*#__PURE__*/dual(2, (self, f) => {
   const excluded = [];
   const satisfying = [];
-  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);
+  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];
 });
@@ -2577,7 +2620,7 @@ export const partition = /*#__PURE__*/dual(2, (self, f) => {
  * @category filtering
  * @since 2.0.0
  */
-export const separate = /*#__PURE__*/partitionMap(identity);
+export const separate = /*#__PURE__*/partition(identity);
 /**
  * Folds an iterable from left to right into a single value.
  *
@@ -2851,14 +2894,15 @@ export const min = /*#__PURE__*/dual(2, (self, O) => self.reduce(Order.min(O)));
 export const max = /*#__PURE__*/dual(2, (self, O) => self.reduce(Order.max(O)));
 /**
  * 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]
  * ```
  *
@@ -2871,9 +2915,12 @@ export const max = /*#__PURE__*/dual(2, (self, O) => self.reduce(Order.max(O)));
 export const unfold = (b, f) => {
   const out = [];
   let next = b;
-  let o;
-  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;
   }