effect 4.0.0-beta.82 → 4.0.0-beta.84

package/dist/Array.js

@@ -29,7 +29,7 @@ import * as Tuple from "./Tuple.js";
  * Use to access native JavaScript array constructor methods such as `isArray`
  * or `from` from the Effect module namespace.
  *
- * **Example** (Using the Array constructor)
+ * **Example** (Accessing the Array constructor)
  *
  * ```ts
  * import { Array } from "effect"
@@ -259,7 +259,7 @@ export const ensure = self => Array.isArray(self) ? self : [self];
  * Key order follows `Object.entries` semantics. Empty records produce an empty
  * array.
  *
- * **Example** (Record to entries)
+ * **Example** (Converting a record to entries)
  *
  * ```ts
  * import { Array } from "effect"
@@ -282,7 +282,7 @@ export const fromRecord = Record.toEntries;
  *
  * Use to convert a single `Option` into an array for downstream array operations.
  *
- * **Example** (Option to array)
+ * **Example** (Converting an Option to an array)
  *
  * ```ts
  * import { Array, Option } from "effect"
@@ -345,7 +345,7 @@ export const match = /*#__PURE__*/dual(2, (self, {
  *
  * `onNonEmpty` receives `(head, tail)` where `tail` is the rest of the array.
  *
- * **Example** (Head and tail destructuring)
+ * **Example** (Destructuring head and tail)
  *
  * ```ts
  * import { Array } from "effect"
@@ -381,7 +381,7 @@ export const matchLeft = /*#__PURE__*/dual(2, (self, {
  *
  * `onNonEmpty` receives `(init, last)` where `init` is everything but the last element.
  *
- * **Example** (Init and last destructuring)
+ * **Example** (Destructuring init and last)
  *
  * ```ts
  * import { Array } from "effect"
@@ -557,7 +557,7 @@ export const scan = /*#__PURE__*/dual(3, (self, b, f) => {
  * The output length is `input.length + 1` because it ends with the initial
  * value. The result is always a `NonEmptyArray`.
  *
- * **Example** (Reverse running totals)
+ * **Example** (Scanning running totals in reverse)
  *
  * ```ts
  * import { Array } from "effect"
@@ -734,7 +734,7 @@ const clamp = (i, as) => Math.floor(Math.min(Math.max(0, i), as.length));
  *
  * The index is floored to an integer. This never throws.
  *
- * **Example** (Safe index access)
+ * **Example** (Accessing indexes safely)
  *
  * ```ts
  * import { Array } from "effect"
@@ -767,7 +767,7 @@ export const get = /*#__PURE__*/dual(2, (self, index) => {
  * Throws an `Error` with the message `"Index out of bounds: <i>"`. Prefer
  * `get` for safe access.
  *
- * **Example** (Unsafe index access)
+ * **Example** (Accessing indexes unsafely)
  *
  * ```ts
  * import { Array } from "effect"
@@ -1764,7 +1764,7 @@ export const sortWith = /*#__PURE__*/dual(3, (self, f, order) => Array.from(self
  * This is data-last only and returns a function. The return type preserves
  * `NonEmptyArray`.
  *
- * **Example** (Multi-key sorting)
+ * **Example** (Sorting by multiple keys)
  *
  * ```ts
  * import { Array, Order, pipe } from "effect"
@@ -2080,7 +2080,7 @@ export const rotate = /*#__PURE__*/dual(2, (self, n) => {
  * Use when checking membership with caller-provided equality instead of
  * `Equal.equivalence()`.
  *
- * **Example** (Custom equality check)
+ * **Example** (Checking with custom equality)
  *
  * ```ts
  * import { Array, pipe } from "effect"
@@ -2397,7 +2397,7 @@ export const chunksOf = /*#__PURE__*/dual(2, (self, n) => {
  * Returns an empty array if `n <= 0` or the array has fewer than `n` elements.
  * Each window is a tuple of exactly `n` elements.
  *
- * **Example** (Sliding windows)
+ * **Example** (Creating sliding windows)
  *
  * ```ts
  * import { Array } from "effect"
@@ -2545,7 +2545,7 @@ export const groupBy = /*#__PURE__*/dual(2, (self, f) => {
  * Use when you need the union of two arrays but duplicate detection must use a
  * custom equivalence instead of the default `Equal.equivalence()`.
  *
- * **Example** (Union with custom equality)
+ * **Example** (Computing unions with custom equality)
  *
  * ```ts
  * import { Array } from "effect"
@@ -2576,7 +2576,7 @@ export const unionWith = /*#__PURE__*/dual(3, (self, that, isEquivalent) => {
  * Computes the union of two arrays, removing duplicates using
  * `Equal.equivalence()`.
  *
- * **Example** (Array union)
+ * **Example** (Computing array unions)
  *
  * ```ts
  * import { Array } from "effect"
@@ -2601,7 +2601,7 @@ export const union = /*#__PURE__*/dual(2, (self, that) => unionWith(self, that,
  * Use when you need to keep only values present in both arrays and equality
  * must be defined by a custom comparator, such as matching objects by id.
  *
- * **Example** (Intersection with custom equality)
+ * **Example** (Computing intersections with custom equality)
  *
  * ```ts
  * import { Array } from "effect"
@@ -2635,7 +2635,7 @@ export const intersectionWith = isEquivalent => {
  * Use when Effect equality is the right membership test and you want to keep
  * values present in both inputs while preserving the first input's order.
  *
- * **Example** (Array intersection)
+ * **Example** (Computing array intersections)
  *
  * ```ts
  * import { Array } from "effect"
@@ -2660,7 +2660,7 @@ export const intersection = /*#__PURE__*/intersectionWith(/*#__PURE__*/Equal.asE
  * Use when you need to keep only values from the first array and equality must
  * be defined by a custom comparator, such as matching objects by id.
  *
- * **Example** (Difference with custom equality)
+ * **Example** (Computing differences with custom equality)
  *
  * ```ts
  * import { Array } from "effect"
@@ -2692,7 +2692,7 @@ export const differenceWith = isEquivalent => {
  * Use when you need to keep values from the first array that are absent from
  * the second and the default `Equal.equivalence()` comparison is appropriate.
  *
- * **Example** (Array difference)
+ * **Example** (Computing array differences)
  *
  * ```ts
  * import { Array } from "effect"
@@ -2788,7 +2788,7 @@ export const map = /*#__PURE__*/dual(2, (self, f) => self.map(f));
  * The function receives `(element, index)`. This returns `NonEmptyArray` when
  * both the input and mapped arrays are non-empty.
  *
- * **Example** (FlatMapping an array)
+ * **Example** (Flat mapping an array)
  *
  * ```ts
  * import { Array } from "effect"
@@ -2946,7 +2946,7 @@ export const getSuccesses = self => {
  *
  * The filter receives `(element, index)`. Failures are discarded.
  *
- * **Example** (Filter and transform)
+ * **Example** (Filtering and transforming)
  *
  * ```ts
  * import { Array, Result } from "effect"
@@ -3122,7 +3122,7 @@ export const reduce = /*#__PURE__*/dual(3, (self, b, f) => fromIterable(self).re
  *
  * The function receives `(accumulator, element, index)`.
  *
- * **Example** (Right-to-left fold)
+ * **Example** (Folding from right to left)
  *
  * ```ts
  * import { Array } from "effect"
@@ -3141,7 +3141,7 @@ export const reduceRight = /*#__PURE__*/dual(3, (self, b, f) => fromIterable(sel
  * Lifts a predicate into an array: returns `[value]` if the predicate holds,
  * `[]` otherwise.
  *
- * **Example** (Conditional wrapping)
+ * **Example** (Wrapping values conditionally)
  *
  * ```ts
  * import { Array } from "effect"
@@ -3195,7 +3195,7 @@ export const liftOption = f => (...a) => fromOption(f(...a));
  *
  * Use to treat a nullable single value as zero or one array element.
  *
- * **Example** (Nullable to array)
+ * **Example** (Converting nullable values to an array)
  *
  * ```ts
  * import { Array } from "effect"
@@ -3245,7 +3245,7 @@ export const liftNullishOr = f => (...a) => fromNullishOr(f(...a));
  * Use when you need to map and filter in one step, where the mapper can return
  * `null` or `undefined` to skip elements.
  *
- * **Example** (FlatMapping with nullable)
+ * **Example** (Flat mapping with nullable values)
  *
  * ```ts
  * import { Array } from "effect"
@@ -3352,7 +3352,7 @@ export const some = /*#__PURE__*/dual(2, (self, predicate) => self.some(predicat
  *
  * For index `i`, the function receives `self.slice(i)`.
  *
- * **Example** (Suffix lengths)
+ * **Example** (Computing suffix lengths)
  *
  * ```ts
  * import { Array } from "effect"
@@ -3723,7 +3723,7 @@ export const cartesianWith = /*#__PURE__*/dual(3, (self, that, f) => flatMap(sel
  * Produces every `[a, b]` combination of an element from `self` with an element
  * from `that`, so the result length is `self.length * that.length`.
  *
- * **Example** (All pairs of two arrays)
+ * **Example** (Generating all pairs from two arrays)
  *
  * ```ts
  * import { Array } from "effect"
@@ -3755,7 +3755,7 @@ export const cartesian = /*#__PURE__*/dual(2, (self, that) => cartesianWith(self
  * like nested loops. Use `filter` and `map` in the pipeline to add conditions
  * and transformations.
  *
- * **Example** (Array comprehension with do notation)
+ * **Example** (Building array comprehensions with do notation)
  *
  * ```ts
  * import { Array, pipe } from "effect"

package/dist/Cache.d.ts

@@ -123,7 +123,7 @@ export interface Entry<A, E> {
  * The timeToLive function receives both the exit result and the key, allowing
  * for flexible TTL policies based on success/failure state and key characteristics.
  *
- * **Example** (Using dynamic time to live)
+ * **Example** (Configuring dynamic time to live)
  *
  * ```ts
  * import { Cache, Effect, Exit } from "effect"

package/dist/Cache.js

@@ -33,7 +33,7 @@ const TypeId = "~effect/Cache";
  * The timeToLive function receives both the exit result and the key, allowing
  * for flexible TTL policies based on success/failure state and key characteristics.
  *
- * **Example** (Using dynamic time to live)
+ * **Example** (Configuring dynamic time to live)
  *
  * ```ts
  * import { Cache, Effect, Exit } from "effect"