effect 3.13.8 → 3.13.10

package/dist/cjs/Array.js

@@ -28,12 +28,13 @@ function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e;
 /**
  * Builds a `NonEmptyArray` from an non-empty collection of elements.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Array } from "effect"
  *
  * const result = Array.make(1, 2, 3)
- * assert.deepStrictEqual(result, [1, 2, 3])
+ * console.log(result) // [1, 2, 3]
  * ```
  *
  * @category constructors
@@ -43,12 +44,13 @@ const make = (...elements) => elements;
 /**
  * Creates a new `Array` of the specified length.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Array } from "effect"
  *
  * const result = Array.allocate<number>(3)
- * assert.deepStrictEqual(result.length, 3)
+ * console.log(result) // [ <3 empty items> ]
  * ```
  *
  * @category constructors
@@ -61,11 +63,13 @@ const allocate = n => new Array(n);
  *
  * **Note**. `n` is normalized to an integer >= 1.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { makeBy } from "effect/Array"
  *
- * assert.deepStrictEqual(makeBy(5, n => n * 2), [0, 2, 4, 6, 8])
+ * const result = makeBy(5, n => n * 2)
+ * console.log(result) // [0, 2, 4, 6, 8]
  * ```
  *
  * @category constructors
@@ -83,11 +87,13 @@ const makeBy = exports.makeBy = /*#__PURE__*/(0, _Function.dual)(2, (n, f) => {
 /**
  * Return a `NonEmptyArray` containing a range of integers, including both endpoints.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { range } from "effect/Array"
  *
- * assert.deepStrictEqual(range(1, 3), [1, 2, 3])
+ * const result = range(1, 3)
+ * console.log(result) // [1, 2, 3]
  * ```
  *
  * @category constructors
@@ -99,11 +105,13 @@ const range = (start, end) => start <= end ? makeBy(end - start + 1, i => start
  *
  * **Note**. `n` is normalized to an integer >= 1.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Array } from "effect"
  *
- * assert.deepStrictEqual(Array.replicate("a", 3), ["a", "a", "a"])
+ * const result = Array.replicate("a", 3)
+ * console.log(result) // ["a", "a", "a"]
  * ```
  *
  * @category constructors
@@ -116,13 +124,13 @@ const replicate = exports.replicate = /*#__PURE__*/(0, _Function.dual)(2, (a, n)
  * If the input is already an array, it returns the input as-is.
  * Otherwise, it converts the iterable collection to an array.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Array } from "effect"
  *
- * const set = new Set([1, 2, 3])
- * const result = Array.fromIterable(set)
- * assert.deepStrictEqual(result, [1, 2, 3])
+ * const result = Array.fromIterable(new Set([1, 2, 3]))
+ * console.log(result) // [1, 2, 3]
  * ```
  *
  * @category constructors
@@ -132,13 +140,14 @@ const fromIterable = collection => Array.isArray(collection) ? collection : Arra
 /**
  * Creates a new `Array` from a value that might not be an iterable.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Array } from "effect"
  *
- * assert.deepStrictEqual(Array.ensure("a"), ["a"])
- * assert.deepStrictEqual(Array.ensure(["a"]), ["a"])
- * assert.deepStrictEqual(Array.ensure(["a", "b", "c"]), ["a", "b", "c"])
+ * console.log(Array.ensure("a")) // ["a"]
+ * console.log(Array.ensure(["a"])) // ["a"]
+ * console.log(Array.ensure(["a", "b", "c"])) // ["a", "b", "c"]
  * ```
  *
  * @category constructors
@@ -149,14 +158,13 @@ const ensure = self => Array.isArray(self) ? self : [self];
 /**
  * Takes a record and returns an array of tuples containing its keys and values.
  *
- * @param self - The record to transform.
+ * **Example**
  *
- * @example
  * ```ts
  * import { Array } from "effect"
  *
- * const x = { a: 1, b: 2, c: 3 }
- * assert.deepStrictEqual(Array.fromRecord(x), [["a", 1], ["b", 2], ["c", 3]])
+ * const result = Array.fromRecord({ a: 1, b: 2, c: 3 })
+ * console.log(result) // [["a", 1], ["b", 2], ["c", 3]]
  * ```
  *
  * @category conversions
@@ -167,12 +175,13 @@ const fromRecord = exports.fromRecord = Record.toEntries;
 /**
  * Converts an `Option` to an array.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Array, Option } from "effect"
  *
- * assert.deepStrictEqual(Array.fromOption(Option.some(1)), [1])
- * assert.deepStrictEqual(Array.fromOption(Option.none()), [])
+ * console.log(Array.fromOption(Option.some(1))) // [1]
+ * console.log(Array.fromOption(Option.none())) // []
  * ```
  *
  * @category conversions
@@ -182,7 +191,8 @@ const fromOption = exports.fromOption = O.toArray;
 /**
  * Matches the elements of an array, applying functions to cases of empty and non-empty arrays.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Array } from "effect"
  *
@@ -190,8 +200,8 @@ const fromOption = exports.fromOption = O.toArray;
  *   onEmpty: () => "empty",
  *   onNonEmpty: ([head, ...tail]) => `head: ${head}, tail: ${tail.length}`
  * })
- * assert.deepStrictEqual(match([]), "empty")
- * assert.deepStrictEqual(match([1, 2, 3]), "head: 1, tail: 2")
+ * console.log(match([])) // "empty"
+ * console.log(match([1, 2, 3])) // "head: 1, tail: 2"
  * ```
  *
  * @category pattern matching
@@ -204,7 +214,8 @@ const match = exports.match = /*#__PURE__*/(0, _Function.dual)(2, (self, {
 /**
  * Matches the elements of an array from the left, applying functions to cases of empty and non-empty arrays.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Array } from "effect"
  *
@@ -212,8 +223,8 @@ const match = exports.match = /*#__PURE__*/(0, _Function.dual)(2, (self, {
  *   onEmpty: () => "empty",
  *   onNonEmpty: (head, tail) => `head: ${head}, tail: ${tail.length}`
  * })
- * assert.deepStrictEqual(matchLeft([]), "empty")
- * assert.deepStrictEqual(matchLeft([1, 2, 3]), "head: 1, tail: 2")
+ * console.log(matchLeft([])) // "empty"
+ * console.log(matchLeft([1, 2, 3])) // "head: 1, tail: 2"
  * ```
  *
  * @category pattern matching
@@ -226,7 +237,8 @@ const matchLeft = exports.matchLeft = /*#__PURE__*/(0, _Function.dual)(2, (self,
 /**
  * Matches the elements of an array from the right, applying functions to cases of empty and non-empty arrays.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Array } from "effect"
  *
@@ -234,8 +246,8 @@ const matchLeft = exports.matchLeft = /*#__PURE__*/(0, _Function.dual)(2, (self,
  *   onEmpty: () => "empty",
  *   onNonEmpty: (init, last) => `init: ${init.length}, last: ${last}`
  * })
- * assert.deepStrictEqual(matchRight([]), "empty")
- * assert.deepStrictEqual(matchRight([1, 2, 3]), "init: 2, last: 3")
+ * console.log(matchRight([])) // "empty"
+ * console.log(matchRight([1, 2, 3])) // "init: 2, last: 3"
  * ```
  *
  * @category pattern matching
@@ -248,13 +260,13 @@ const matchRight = exports.matchRight = /*#__PURE__*/(0, _Function.dual)(2, (sel
 /**
  * Prepend an element to the front of an `Iterable`, creating a new `NonEmptyArray`.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Array } from "effect"
  *
- * const original = [2, 3, 4];
- * const result = Array.prepend(original, 1);
- * assert.deepStrictEqual(result, [1, 2, 3, 4]);
+ * const result = Array.prepend([2, 3, 4], 1)
+ * console.log(result) // [1, 2, 3, 4]
  * ```
  *
  * @category concatenating
@@ -265,14 +277,13 @@ const prepend = exports.prepend = /*#__PURE__*/(0, _Function.dual)(2, (self, hea
  * Prepends the specified prefix array (or iterable) to the beginning of the specified array (or iterable).
  * If either array is non-empty, the result is also a non-empty array.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Array } from "effect"
  *
- * const prefix = [0, 1];
- * const array = [2, 3];
- * const result = Array.prependAll(array, prefix);
- * assert.deepStrictEqual(result, [0, 1, 2, 3]);
+ * const result = Array.prependAll([2, 3], [0, 1])
+ * console.log(result) // [0, 1, 2, 3]
  * ```
  *
  * @category concatenating
@@ -282,13 +293,13 @@ const prependAll = exports.prependAll = /*#__PURE__*/(0, _Function.dual)(2, (sel
 /**
  * Append an element to the end of an `Iterable`, creating a new `NonEmptyArray`.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Array } from "effect"
  *
- * const original = [1, 2, 3];
- * const result = Array.append(original, 4);
- * assert.deepStrictEqual(result, [1, 2, 3, 4]);
+ * const result = Array.append([1, 2, 3], 4);
+ * console.log(result) // [1, 2, 3, 4]
  * ```
  *
  * @category concatenating
@@ -308,13 +319,13 @@ const appendAll = exports.appendAll = /*#__PURE__*/(0, _Function.dual)(2, (self,
  * each intermediate result in an array. Useful for tracking the progression of
  * a value through a series of transformations.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Array } from "effect";
  *
- * const numbers = [1, 2, 3, 4]
- * const result = Array.scan(numbers, 0, (acc, value) => acc + value)
- * assert.deepStrictEqual(result, [0, 1, 3, 6, 10])
+ * const result = Array.scan([1, 2, 3, 4], 0, (acc, value) => acc + value)
+ * console.log(result) // [0, 1, 3, 6, 10]
  *
  * // Explanation:
  * // This function starts with the initial value (0 in this case)
@@ -340,13 +351,13 @@ const scan = exports.scan = /*#__PURE__*/(0, _Function.dual)(3, (self, b, f) =>
  * each intermediate result in an array. Useful for tracking the progression of
  * a value through a series of transformations.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Array } from "effect";
  *
- * const numbers = [1, 2, 3, 4]
- * const result = Array.scanRight(numbers, 0, (acc, value) => acc + value)
- * assert.deepStrictEqual(result, [10, 9, 7, 4, 0])
+ * const result = Array.scanRight([1, 2, 3, 4], 0, (acc, value) => acc + value)
+ * console.log(result) // [10, 9, 7, 4, 0]
  * ```
  *
  * @category folding
@@ -364,14 +375,13 @@ const scanRight = exports.scanRight = /*#__PURE__*/(0, _Function.dual)(3, (self,
 /**
  * Determine if `unknown` is an Array.
  *
- * @param self - The value to check.
+ * **Example**
  *
- * @example
  * ```ts
- * import { isArray } from "effect/Array"
+ * import { Array } from "effect"
  *
- * assert.deepStrictEqual(isArray(null), false);
- * assert.deepStrictEqual(isArray([1, 2, 3]), true);
+ * console.log(Array.isArray(null)) // false
+ * console.log(Array.isArray([1, 2, 3])) // true
  * ```
  *
  * @category guards
@@ -381,14 +391,13 @@ const isArray = exports.isArray = Array.isArray;
 /**
  * Determine if an `Array` is empty narrowing down the type to `[]`.
  *
- * @param self - The `Array` to check.
+ * **Example**
  *
- * @example
  * ```ts
- * import { isEmptyArray } from "effect/Array"
+ * import { Array } from "effect"
  *
- * assert.deepStrictEqual(isEmptyArray([]), true);
- * assert.deepStrictEqual(isEmptyArray([1, 2, 3]), false);
+ * console.log(Array.isEmptyArray([])) // true
+ * console.log(Array.isEmptyArray([1, 2, 3])) // false
  * ```
  *
  * @category guards
@@ -398,14 +407,13 @@ const isEmptyArray = self => self.length === 0;
 /**
  * Determine if a `ReadonlyArray` is empty narrowing down the type to `readonly []`.
  *
- * @param self - The `ReadonlyArray` to check.
+ * **Example**
  *
- * @example
  * ```ts
- * import { isEmptyReadonlyArray } from "effect/Array"
+ * import { Array } from "effect"
  *
- * assert.deepStrictEqual(isEmptyReadonlyArray([]), true);
- * assert.deepStrictEqual(isEmptyReadonlyArray([1, 2, 3]), false);
+ * console.log(Array.isEmptyReadonlyArray([])) // true
+ * console.log(Array.isEmptyReadonlyArray([1, 2, 3])) // false
  * ```
  *
  * @category guards
@@ -418,14 +426,13 @@ const isEmptyReadonlyArray = exports.isEmptyReadonlyArray = isEmptyArray;
  *
  * An `Array` is considered to be a `NonEmptyArray` if it contains at least one element.
  *
- * @param self - The `Array` to check.
+ * **Example**
  *
- * @example
  * ```ts
- * import { isNonEmptyArray } from "effect/Array"
+ * import { Array } from "effect"
  *
- * assert.deepStrictEqual(isNonEmptyArray([]), false);
- * assert.deepStrictEqual(isNonEmptyArray([1, 2, 3]), true);
+ * console.log(Array.isNonEmptyArray([])) // false
+ * console.log(Array.isNonEmptyArray([1, 2, 3])) // true
  * ```
  *
  * @category guards
@@ -437,14 +444,13 @@ const isNonEmptyArray = exports.isNonEmptyArray = readonlyArray.isNonEmptyArray;
  *
  * A `ReadonlyArray` is considered to be a `NonEmptyReadonlyArray` if it contains at least one element.
  *
- * @param self - The `ReadonlyArray` to check.
+ * **Example**
  *
- * @example
  * ```ts
- * import { isNonEmptyReadonlyArray } from "effect/Array"
+ * import { Array } from "effect"
  *
- * assert.deepStrictEqual(isNonEmptyReadonlyArray([]), false);
- * assert.deepStrictEqual(isNonEmptyReadonlyArray([1, 2, 3]), true);
+ * console.log(Array.isNonEmptyReadonlyArray([])) // false
+ * console.log(Array.isNonEmptyReadonlyArray([1, 2, 3])) // true
  * ```
  *
  * @category guards
@@ -487,12 +493,13 @@ const unsafeGet = exports.unsafeGet = /*#__PURE__*/(0, _Function.dual)(2, (self,
 /**
  * Return a tuple containing the first element, and a new `Array` of the remaining elements, if any.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Array } from "effect";
  *
  * const result = Array.unprepend([1, 2, 3, 4])
- * assert.deepStrictEqual(result, [1, [2, 3, 4]])
+ * console.log(result) // [1, [2, 3, 4]]
  * ```
  *
  * @category splitting
@@ -502,12 +509,13 @@ const unprepend = self => [headNonEmpty(self), tailNonEmpty(self)];
 /**
  * Return a tuple containing a copy of the `NonEmptyReadonlyArray` without its last element, and that last element.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Array } from "effect";
  *
  * const result = Array.unappend([1, 2, 3, 4])
- * assert.deepStrictEqual(result, [[1, 2, 3], 4])
+ * console.log(result) // [[1, 2, 3], 4]
  * ```
  *
  * @category splitting
@@ -526,12 +534,13 @@ const head = exports.head = /*#__PURE__*/get(0);
 /**
  * Get the first element of a non empty array.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Array } from "effect"
  *
  * const result = Array.headNonEmpty([1, 2, 3, 4])
- * assert.deepStrictEqual(result, 1)
+ * console.log(result) // 1
  * ```
  *
  * @category getters
@@ -548,12 +557,13 @@ const last = self => isNonEmptyReadonlyArray(self) ? O.some(lastNonEmpty(self))
 /**
  * Get the last element of a non empty array.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Array } from "effect"
  *
  * const result = Array.lastNonEmpty([1, 2, 3, 4])
- * assert.deepStrictEqual(result, 4)
+ * console.log(result) // 4
  * ```
  *
  * @category getters
@@ -575,12 +585,13 @@ const tail = self => {
 /**
  * Get all but the first element of a `NonEmptyReadonlyArray`.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Array } from "effect"
  *
  * const result = Array.tailNonEmpty([1, 2, 3, 4])
- * assert.deepStrictEqual(result, [2, 3, 4])
+ * console.log(result) // [2, 3, 4]
  * ```
  *
  * @category getters
@@ -602,12 +613,13 @@ const init = self => {
 /**
  * Get all but the last element of a non empty array, creating a new array.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Array } from "effect"
  *
  * const result = Array.initNonEmpty([1, 2, 3, 4])
- * assert.deepStrictEqual(result, [1, 2, 3])
+ * console.log(result) // [1, 2, 3]
  * ```
  *
  * @category getters
@@ -620,13 +632,13 @@ const initNonEmpty = self => self.slice(0, -1);
  *
  * **Note**. `n` is normalized to a non negative integer.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Array } from "effect"
  *
- * const numbers = [1, 2, 3, 4, 5]
- * const result = Array.take(numbers, 3)
- * assert.deepStrictEqual(result, [1, 2, 3])
+ * const result = Array.take([1, 2, 3, 4, 5], 3)
+ * console.log(result) // [1, 2, 3]
  * ```
  *
  * @category getters
@@ -642,13 +654,13 @@ const take = exports.take = /*#__PURE__*/(0, _Function.dual)(2, (self, n) => {
  *
  * **Note**. `n` is normalized to a non negative integer.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Array } from "effect"
  *
- * const numbers = [1, 2, 3, 4, 5]
- * const result = Array.takeRight(numbers, 3)
- * assert.deepStrictEqual(result, [3, 4, 5])
+ * const result = Array.takeRight([1, 2, 3, 4, 5], 3)
+ * console.log(result) // [3, 4, 5]
  * ```
  *
  * @category getters
@@ -662,13 +674,13 @@ const takeRight = exports.takeRight = /*#__PURE__*/(0, _Function.dual)(2, (self,
 /**
  * Calculate the longest initial subarray for which all element satisfy the specified predicate, creating a new `Array`.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Array } from "effect"
  *
- * const numbers = [1, 3, 2, 4, 1, 2]
- * const result = Array.takeWhile(numbers, x => x < 4)
- * assert.deepStrictEqual(result, [1, 3, 2])
+ * const result = Array.takeWhile([1, 3, 2, 4, 1, 2], x => x < 4)
+ * console.log(result) // [1, 3, 2]
  *
  * // Explanation:
  * // - The function starts with the first element (`1`), which is less than `4`, so it adds `1` to the result.
@@ -717,13 +729,13 @@ const span = exports.span = /*#__PURE__*/(0, _Function.dual)(2, (self, predicate
  *
  * **Note**. `n` is normalized to a non negative integer.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Array } from "effect"
  *
- * const numbers = [1, 2, 3, 4, 5]
- * const result = Array.drop(numbers, 2)
- * assert.deepStrictEqual(result, [3, 4, 5])
+ * const result = Array.drop([1, 2, 3, 4, 5], 2)
+ * console.log(result) // [3, 4, 5]
  * ```
  *
  * @category getters
@@ -738,13 +750,13 @@ const drop = exports.drop = /*#__PURE__*/(0, _Function.dual)(2, (self, n) => {
  *
  * **Note**. `n` is normalized to a non negative integer.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Array } from "effect"
  *
- * const numbers = [1, 2, 3, 4, 5]
- * const result = Array.dropRight(numbers, 2)
- * assert.deepStrictEqual(result, [1, 2, 3])
+ * const result = Array.dropRight([1, 2, 3, 4, 5], 2)
+ * console.log(result) // [1, 2, 3]
  * ```
  *
  * @category getters
@@ -757,13 +769,13 @@ const dropRight = exports.dropRight = /*#__PURE__*/(0, _Function.dual)(2, (self,
 /**
  * Remove the longest initial subarray for which all element satisfy the specified predicate, creating a new `Array`.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Array } from "effect"
  *
- * const numbers = [1, 2, 3, 4, 5]
- * const result = Array.dropWhile(numbers, x => x < 4)
- * assert.deepStrictEqual(result, [4, 5])
+ * const result = Array.dropWhile([1, 2, 3, 4, 5], x => x < 4)
+ * console.log(result) // [4, 5]
  * ```
  *
  * @category getters
@@ -773,13 +785,13 @@ const dropWhile = exports.dropWhile = /*#__PURE__*/(0, _Function.dual)(2, (self,
 /**
  * Return the first index for which a predicate holds.
  *
- * @example
+ * **Example**
+ *
  * ```ts
- * import { Array, Option } from "effect"
+ * import { Array } from "effect"
  *
- * const numbers = [5, 3, 8, 9]
- * const result = Array.findFirstIndex(numbers, x => x > 5)
- * assert.deepStrictEqual(result, Option.some(2))
+ * const result = Array.findFirstIndex([5, 3, 8, 9], x => x > 5)
+ * console.log(result) // Option.some(2)
  * ```
  *
  * @category elements
@@ -798,13 +810,13 @@ const findFirstIndex = exports.findFirstIndex = /*#__PURE__*/(0, _Function.dual)
 /**
  * Return the last index for which a predicate holds.
  *
- * @example
+ * **Example**
+ *
  * ```ts
- * import { Array, Option } from "effect"
+ * import { Array } from "effect"
  *
- * const numbers = [1, 3, 8, 9]
- * const result = Array.findLastIndex(numbers, x => x < 5)
- * assert.deepStrictEqual(result, Option.some(1))
+ * const result = Array.findLastIndex([1, 3, 8, 9], x => x < 5)
+ * console.log(result) // Option.some(1)
  * ```
  *
  * @category elements
@@ -823,13 +835,13 @@ const findLastIndex = exports.findLastIndex = /*#__PURE__*/(0, _Function.dual)(2
  * Returns the first element that satisfies the specified
  * predicate, or `None` if no such element exists.
  *
- * @example
+ * **Example**
+ *
  * ```ts
- * import { Array, Option } from "effect"
+ * import { Array } from "effect"
  *
- * const numbers = [1, 2, 3, 4, 5]
- * const result = Array.findFirst(numbers, x => x > 3)
- * assert.deepStrictEqual(result, Option.some(4))
+ * const result = Array.findFirst([1, 2, 3, 4, 5], x => x > 3)
+ * console.log(result) // Option.some(4)
  * ```
  *
  * @category elements
@@ -840,13 +852,13 @@ const findFirst = exports.findFirst = EffectIterable.findFirst;
  * Finds the last element in an iterable collection that satisfies the given predicate or refinement.
  * Returns an `Option` containing the found element, or `Option.none` if no element matches.
  *
- * @example
+ * **Example**
+ *
  * ```ts
- * import { Array, Option } from "effect"
+ * import { Array } from "effect"
  *
- * const numbers = [1, 2, 3, 4, 5]
- * const result = Array.findLast(numbers, n => n % 2 === 0)
- * assert.deepStrictEqual(result, Option.some(4))
+ * const result = Array.findLast([1, 2, 3, 4, 5], n => n % 2 === 0)
+ * console.log(result) // Option.some(4)
  * ```
  *
  * @category elements
@@ -873,13 +885,13 @@ const findLast = exports.findLast = /*#__PURE__*/(0, _Function.dual)(2, (self, f
  * Insert an element at the specified index, creating a new `NonEmptyArray`,
  * or return `None` if the index is out of bounds.
  *
- * @example
+ * **Example**
+ *
  * ```ts
- * import { Array, Option } from "effect"
+ * import { Array } from "effect"
  *
- * const letters = ['a', 'b', 'c', 'e']
- * const result = Array.insertAt(letters, 3, 'd')
- * assert.deepStrictEqual(result, Option.some(['a', 'b', 'c', 'd', 'e']))
+ * const result = Array.insertAt(['a', 'b', 'c', 'e'], 3, 'd')
+ * console.log(result) // Option.some(['a', 'b', 'c', 'd', 'e'])
  * ```
  *
  * @since 2.0.0
@@ -897,13 +909,13 @@ const insertAt = exports.insertAt = /*#__PURE__*/(0, _Function.dual)(3, (self, i
  * Change the element at the specified index, creating a new `Array`,
  * or return a copy of the input if the index is out of bounds.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Array } from "effect"
  *
- * const letters = ['a', 'b', 'c', 'd']
- * const result = Array.replace(letters, 1, 'z')
- * assert.deepStrictEqual(result, ['a', 'z', 'c', 'd'])
+ * const result = Array.replace(['a', 'b', 'c', 'd'], 1, 'z')
+ * console.log(result) // ['a', 'z', 'c', 'd']
  * ```
  *
  * @since 2.0.0
@@ -912,13 +924,13 @@ const replace = exports.replace = /*#__PURE__*/(0, _Function.dual)(3, (self, i,
 /**
  * Replaces an element in an array with the given value, returning an option of the updated array.
  *
- * @example
+ * **Example**
+ *
  * ```ts
- * import { Array, Option } from "effect"
+ * import { Array } from "effect"
  *
- * const numbers = [1, 2, 3]
- * const result = Array.replaceOption(numbers, 1, 4)
- * assert.deepStrictEqual(result, Option.some([1, 4, 3]))
+ * const result = Array.replaceOption([1, 2, 3], 1, 4)
+ * console.log(result) // Option.some([1, 4, 3])
  * ```
  *
  * @since 2.0.0
@@ -928,13 +940,13 @@ const replaceOption = exports.replaceOption = /*#__PURE__*/(0, _Function.dual)(3
  * Apply a function to the element at the specified index, creating a new `Array`,
  * or return a copy of the input if the index is out of bounds.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Array } from "effect"
  *
- * const numbers = [1, 2, 3, 4]
- * const result = Array.modify(numbers, 2, (n) => n * 2)
- * assert.deepStrictEqual(result, [1, 2, 6, 4])
+ * const result = Array.modify([1, 2, 3, 4], 2, (n) => n * 2)
+ * console.log(result) // [1, 2, 6, 4]
  * ```
  *
  * @since 2.0.0
@@ -944,16 +956,17 @@ const modify = exports.modify = /*#__PURE__*/(0, _Function.dual)(3, (self, i, f)
  * Apply a function to the element at the specified index, creating a new `Array`,
  * or return `None` if the index is out of bounds.
  *
- * @example
+ * **Example**
+ *
  * ```ts
- * import { Array, Option } from "effect"
+ * import { Array } from "effect"
  *
- * const numbers = [1, 2, 3, 4]
- * const result = Array.modifyOption(numbers, 2, (n) => n * 2)
- * assert.deepStrictEqual(result, Option.some([1, 2, 6, 4]))
+ * const input = [1, 2, 3, 4]
+ * const result = Array.modifyOption(input, 2, (n) => n * 2)
+ * console.log(result) // Option.some([1, 2, 6, 4])
  *
- * const outOfBoundsResult = Array.modifyOption(numbers, 5, (n) => n * 2)
- * assert.deepStrictEqual(outOfBoundsResult, Option.none())
+ * const outOfBoundsResult = Array.modifyOption(input, 5, (n) => n * 2)
+ * console.log(outOfBoundsResult) // Option.none()
  * ```
  *
  * @since 2.0.0
@@ -972,16 +985,17 @@ const modifyOption = exports.modifyOption = /*#__PURE__*/(0, _Function.dual)(3,
  * Delete the element at the specified index, creating a new `Array`,
  * or return a copy of the input if the index is out of bounds.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Array } from "effect"
  *
- * const numbers = [1, 2, 3, 4]
- * const result = Array.remove(numbers, 2)
- * assert.deepStrictEqual(result, [1, 2, 4])
+ * const input = [1, 2, 3, 4]
+ * const result = Array.remove(input, 2)
+ * console.log(result) // [1, 2, 4]
  *
- * const outOfBoundsResult = Array.remove(numbers, 5)
- * assert.deepStrictEqual(outOfBoundsResult, [1, 2, 3, 4])
+ * const outOfBoundsResult = Array.remove(input, 5)
+ * console.log(outOfBoundsResult) // [1, 2, 3, 4]
  * ```
  *
  * @since 2.0.0
@@ -997,13 +1011,13 @@ const remove = exports.remove = /*#__PURE__*/(0, _Function.dual)(2, (self, i) =>
 /**
  * Reverse an `Iterable`, creating a new `Array`.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Array } from "effect"
  *
- * const numbers = [1, 2, 3, 4]
- * const result = Array.reverse(numbers)
- * assert.deepStrictEqual(result, [4, 3, 2, 1])
+ * const result = Array.reverse([1, 2, 3, 4])
+ * console.log(result) // [4, 3, 2, 1]
  * ```
  *
  * @category elements
@@ -1028,13 +1042,13 @@ const sort = exports.sort = /*#__PURE__*/(0, _Function.dual)(2, (self, O) => {
  * function transforms the elements into a value that can be compared, and the
  * order defines how those values should be sorted.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Array, Order } from "effect"
  *
- * const strings = ["aaa", "b", "cc"]
- * const result = Array.sortWith(strings, (s) => s.length, Order.number)
- * assert.deepStrictEqual(result, ["b", "cc", "aaa"])
+ * const result = Array.sortWith(["aaa", "b", "cc"], (s) => s.length, Order.number)
+ * console.log(result) // ["b", "cc", "aaa"]
  *
  * // Explanation:
  * // The array of strings is sorted based on their lengths. The mapping function `(s) => s.length`
@@ -1051,9 +1065,10 @@ const sortWith = exports.sortWith = /*#__PURE__*/(0, _Function.dual)(3, (self, f
  * orders. The elements are compared using the first order in `orders`, then the
  * second order if the first comparison is equal, and so on.
  *
- * @example
+ * **Example**
+ *
  * ```ts
- * import { Array, Order } from "effect"
+ * import { Array, Order, pipe } from "effect"
  *
  * const users = [
  *   { name: "Alice", age: 30 },
@@ -1061,16 +1076,20 @@ const sortWith = exports.sortWith = /*#__PURE__*/(0, _Function.dual)(3, (self, f
  *   { name: "Charlie", age: 30 }
  * ]
  *
- * const result = Array.sortBy(
- *   Order.mapInput(Order.number, (user: (typeof users)[number]) => user.age),
- *   Order.mapInput(Order.string, (user: (typeof users)[number]) => user.name)
- * )(users)
+ * const result = pipe(
+ *   users,
+ *   Array.sortBy(
+ *     Order.mapInput(Order.number, (user: (typeof users)[number]) => user.age),
+ *     Order.mapInput(Order.string, (user: (typeof users)[number]) => user.name)
+ *   )
+ * )
  *
- * assert.deepStrictEqual(result, [
- *   { name: "Bob", age: 25 },
- *   { name: "Alice", age: 30 },
- *   { name: "Charlie", age: 30 }
- * ])
+ * console.log(result)
+ * // [
+ * //   { name: "Bob", age: 25 },
+ * //   { name: "Alice", age: 30 },
+ * //   { name: "Charlie", age: 30 }
+ * // ]
  *
  * // Explanation:
  * // The array of users is sorted first by age in ascending order. When ages are equal,
@@ -1095,14 +1114,13 @@ const sortBy = (...orders) => {
  * If one input `Iterable` is short, excess elements of the
  * longer `Iterable` are discarded.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Array } from "effect"
  *
- * const array1 = [1, 2, 3]
- * const array2 = ['a', 'b']
- * const result = Array.zip(array1, array2)
- * assert.deepStrictEqual(result, [[1, 'a'], [2, 'b']])
+ * const result = Array.zip([1, 2, 3], ['a', 'b'])
+ * console.log(result) // [[1, 'a'], [2, 'b']]
  * ```
  *
  * @category zipping
@@ -1114,14 +1132,13 @@ const zip = exports.zip = /*#__PURE__*/(0, _Function.dual)(2, (self, that) => zi
  * Apply a function to pairs of elements at the same index in two `Iterable`s, collecting the results in a new `Array`. If one
  * input `Iterable` is short, excess elements of the longer `Iterable` are discarded.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Array } from "effect"
  *
- * const array1 = [1, 2, 3]
- * const array2 = [4, 5, 6]
- * const result = Array.zipWith(array1, array2, (a, b) => a + b)
- * assert.deepStrictEqual(result, [5, 7, 9])
+ * const result = Array.zipWith([1, 2, 3], [4, 5, 6], (a, b) => a + b)
+ * console.log(result) // [5, 7, 9]
  * ```
  *
  * @category zipping
@@ -1143,12 +1160,13 @@ const zipWith = exports.zipWith = /*#__PURE__*/(0, _Function.dual)(3, (self, tha
 /**
  * This function is the inverse of `zip`. Takes an `Iterable` of pairs and return two corresponding `Array`s.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Array } from "effect"
  *
  * const result = Array.unzip([[1, "a"], [2, "b"], [3, "c"]])
- * assert.deepStrictEqual(result, [[1, 2, 3], ['a', 'b', 'c']])
+ * console.log(result) // [[1, 2, 3], ['a', 'b', 'c']]
  * ```
  *
  * @since 2.0.0
@@ -1170,13 +1188,13 @@ const unzip = self => {
  * Places an element in between members of an `Iterable`.
  * If the input is a non-empty array, the result is also a non-empty array.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Array } from "effect"
  *
- * const numbers = [1, 2, 3]
- * const result = Array.intersperse(numbers, 0)
- * assert.deepStrictEqual(result, [1, 0, 2, 0, 3])
+ * const result = Array.intersperse([1, 2, 3], 0)
+ * console.log(result) // [1, 0, 2, 0, 3]
  * ```
  *
  * @since 2.0.0
@@ -1200,12 +1218,13 @@ const intersperse = exports.intersperse = /*#__PURE__*/(0, _Function.dual)(2, (s
 /**
  * Apply a function to the head, creating a new `NonEmptyReadonlyArray`.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Array } from "effect"
  *
  * const result = Array.modifyNonEmptyHead([1, 2, 3], n => n * 10)
- * assert.deepStrictEqual(result, [10, 2, 3])
+ * console.log(result) // [10, 2, 3]
  * ```
  *
  * @since 2.0.0
@@ -1214,12 +1233,13 @@ const modifyNonEmptyHead = exports.modifyNonEmptyHead = /*#__PURE__*/(0, _Functi
 /**
  * Change the head, creating a new `NonEmptyReadonlyArray`.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Array } from "effect"
  *
  * const result = Array.setNonEmptyHead([1, 2, 3], 10)
- * assert.deepStrictEqual(result, [10, 2, 3])
+ * console.log(result) // [10, 2, 3]
  * ```
  *
  * @since 2.0.0
@@ -1228,12 +1248,13 @@ const setNonEmptyHead = exports.setNonEmptyHead = /*#__PURE__*/(0, _Function.dua
 /**
  * Apply a function to the last element, creating a new `NonEmptyReadonlyArray`.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Array } from "effect"
  *
  * const result = Array.modifyNonEmptyLast([1, 2, 3], n => n * 2)
- * assert.deepStrictEqual(result, [1, 2, 6])
+ * console.log(result) // [1, 2, 6]
  * ```
  *
  * @since 2.0.0
@@ -1242,12 +1263,13 @@ const modifyNonEmptyLast = exports.modifyNonEmptyLast = /*#__PURE__*/(0, _Functi
 /**
  * Change the last element, creating a new `NonEmptyReadonlyArray`.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Array } from "effect"
  *
  * const result = Array.setNonEmptyLast([1, 2, 3], 4)
- * assert.deepStrictEqual(result, [1, 2, 4])
+ * console.log(result) // [1, 2, 4]
  * ```
  *
  * @since 2.0.0
@@ -1257,13 +1279,13 @@ const setNonEmptyLast = exports.setNonEmptyLast = /*#__PURE__*/(0, _Function.dua
  * Rotate an `Iterable` by `n` steps.
  * If the input is a non-empty array, the result is also a non-empty array.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Array } from "effect"
  *
- * const letters = ['a', 'b', 'c', 'd']
- * const result = Array.rotate(letters, 2)
- * assert.deepStrictEqual(result, ['c', 'd', 'a', 'b'])
+ * const result = Array.rotate(['a', 'b', 'c', 'd'], 2)
+ * console.log(result) // ['c', 'd', 'a', 'b']
  * ```
  *
  * @since 2.0.0
@@ -1288,15 +1310,15 @@ const rotate = exports.rotate = /*#__PURE__*/(0, _Function.dual)(2, (self, n) =>
 /**
  * Returns a function that checks if a `ReadonlyArray` contains a given value using a provided `isEquivalent` function.
  *
- * @example
+ * **Example**
+ *
  * ```ts
- * import { Array } from "effect"
+ * import { Array, pipe } from "effect"
  *
- * const numbers = [1, 2, 3, 4]
  * const isEquivalent = (a: number, b: number) => a === b
  * const containsNumber = Array.containsWith(isEquivalent)
- * const result = containsNumber(3)(numbers)
- * assert.deepStrictEqual(result, true)
+ * const result = pipe([1, 2, 3, 4], containsNumber(3))
+ * console.log(result) // true
  * ```
  *
  * @category elements
@@ -1315,13 +1337,13 @@ const _equivalence = /*#__PURE__*/Equal.equivalence();
 /**
  * Returns a function that checks if a `ReadonlyArray` contains a given value using the default `Equivalence`.
  *
- * @example
+ * **Example**
+ *
  * ```ts
- * import { Array } from "effect"
+ * import { Array, pipe } from "effect"
  *
- * const letters = ['a', 'b', 'c', 'd']
- * const result = Array.contains('c')(letters)
- * assert.deepStrictEqual(result, true)
+ * const result = pipe(['a', 'b', 'c', 'd'], Array.contains('c'))
+ * console.log(result) // true
  * ```
  *
  * @category elements
@@ -1333,13 +1355,13 @@ const contains = exports.contains = /*#__PURE__*/containsWith(_equivalence);
  * `Iterable`. Typically chop is called with some function that will consume an initial prefix of the `Iterable` and produce a
  * value and the rest of the `Array`.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Array } from "effect"
  *
- * const numbers = [1, 2, 3, 4, 5]
- * const result = Array.chop(numbers, (as): [number, Array<number>] => [as[0] * 2, as.slice(1)])
- * assert.deepStrictEqual(result, [2, 4, 6, 8, 10])
+ * const result = Array.chop([1, 2, 3, 4, 5], (as): [number, Array<number>] => [as[0] * 2, as.slice(1)])
+ * console.log(result) // [2, 4, 6, 8, 10]
  *
  * // Explanation:
  * // The `chopFunction` takes the first element of the array, doubles it, and then returns it along with the rest of the array.
@@ -1368,13 +1390,13 @@ const chop = exports.chop = /*#__PURE__*/(0, _Function.dual)(2, (self, f) => {
  * Splits an `Iterable` into two segments, with the first segment containing a maximum of `n` elements.
  * The value of `n` can be `0`.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Array } from "effect"
  *
- * const numbers = [1, 2, 3, 4, 5]
- * const result = Array.splitAt(numbers, 3)
- * assert.deepStrictEqual(result, [[1, 2, 3], [4, 5]])
+ * const result = Array.splitAt([1, 2, 3, 4, 5], 3)
+ * console.log(result) // [[1, 2, 3], [4, 5]]
  * ```
  *
  * @category splitting
@@ -1395,12 +1417,13 @@ const splitAt = exports.splitAt = /*#__PURE__*/(0, _Function.dual)(2, (self, n)
  * Splits a `NonEmptyReadonlyArray` into two segments, with the first segment containing a maximum of `n` elements.
  * The value of `n` must be `>= 1`.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Array } from "effect"
  *
  * const result = Array.splitNonEmptyAt(["a", "b", "c", "d", "e"], 3)
- * assert.deepStrictEqual(result, [["a", "b", "c"], ["d", "e"]])
+ * console.log(result) // [["a", "b", "c"], ["d", "e"]]
  * ```
  *
  * @category splitting
@@ -1413,13 +1436,13 @@ const splitNonEmptyAt = exports.splitNonEmptyAt = /*#__PURE__*/(0, _Function.dua
 /**
  * Splits this iterable into `n` equally sized arrays.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Array } from "effect"
  *
- * const numbers = [1, 2, 3, 4, 5, 6, 7, 8]
- * const result = Array.split(numbers, 3)
- * assert.deepStrictEqual(result, [[1, 2, 3], [4, 5, 6], [7, 8]])
+ * const result = Array.split([1, 2, 3, 4, 5, 6, 7, 8], 3)
+ * console.log(result) // [[1, 2, 3], [4, 5, 6], [7, 8]]
  * ```
  *
  * @since 2.0.0
@@ -1433,13 +1456,13 @@ const split = exports.split = /*#__PURE__*/(0, _Function.dual)(2, (self, n) => {
  * Splits this iterable on the first element that matches this predicate.
  * Returns a tuple containing two arrays: the first one is before the match, and the second one is from the match onward.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Array } from "effect"
  *
- * const numbers = [1, 2, 3, 4, 5]
- * const result = Array.splitWhere(numbers, n => n > 3)
- * assert.deepStrictEqual(result, [[1, 2, 3], [4, 5]])
+ * const result = Array.splitWhere([1, 2, 3, 4, 5], n => n > 3)
+ * console.log(result) // [[1, 2, 3], [4, 5]]
  * ```
  *
  * @category splitting
@@ -1449,13 +1472,13 @@ const splitWhere = exports.splitWhere = /*#__PURE__*/(0, _Function.dual)(2, (sel
 /**
  * Copies an array.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Array } from "effect"
  *
- * const numbers = [1, 2, 3]
- * const copy = Array.copy(numbers)
- * assert.deepStrictEqual(copy, [1, 2, 3])
+ * const result = Array.copy([1, 2, 3])
+ * console.log(result) // [1, 2, 3]
  * ```
  *
  * @since 2.0.0
@@ -1467,13 +1490,13 @@ const copy = self => self.slice();
  * If `array` is longer than `n`, the returned array will be a slice of `array` containing the `n` first elements of `array`.
  * If `n` is less than or equal to 0, the returned array will be an empty array.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Array } from "effect"
  *
- * const arr = [1, 2, 3]
- * const result = Array.pad(arr, 6, 0)
- * assert.deepStrictEqual(result, [1, 2, 3, 0, 0, 0])
+ * const result = Array.pad([1, 2, 3], 6, 0)
+ * console.log(result) // [1, 2, 3, 0, 0, 0]
  * ```
  *
  * @since 3.8.4
@@ -1490,19 +1513,19 @@ const pad = exports.pad = /*#__PURE__*/(0, _Function.dual)(3, (self, n, fill) =>
  * the `Iterable`. Note that `chunksOf(n)([])` is `[]`, not `[[]]`. This is intentional, and is consistent with a recursive
  * definition of `chunksOf`; it satisfies the property that
  *
- * ```ts
+ * ```ts skip-type-checking
  * chunksOf(n)(xs).concat(chunksOf(n)(ys)) == chunksOf(n)(xs.concat(ys)))
  * ```
  *
  * whenever `n` evenly divides the length of `self`.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Array } from "effect"
  *
- * const numbers = [1, 2, 3, 4, 5]
- * const result = Array.chunksOf(numbers, 2)
- * assert.deepStrictEqual(result, [[1, 2], [3, 4], [5]])
+ * const result = Array.chunksOf([1, 2, 3, 4, 5], 2)
+ * console.log(result) // [[1, 2], [3, 4], [5]]
  *
  * // Explanation:
  * // The `chunksOf` function takes an array of numbers `[1, 2, 3, 4, 5]` and a number `2`.
@@ -1524,12 +1547,13 @@ const chunksOf = exports.chunksOf = /*#__PURE__*/(0, _Function.dual)(2, (self, n
 /**
  * Group equal, consecutive elements of a `NonEmptyReadonlyArray` into `NonEmptyArray`s using the provided `isEquivalent` function.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Array } from "effect"
  *
  * const result = Array.groupWith(["a", "a", "b", "b", "b", "c", "a"], (x, y) => x === y)
- * assert.deepStrictEqual(result, [["a", "a"], ["b", "b", "b"], ["c"], ["a"]])
+ * console.log(result) // [["a", "a"], ["b", "b", "b"], ["c"], ["a"]]
  * ```
  *
  * @category grouping
@@ -1552,12 +1576,13 @@ const groupWith = exports.groupWith = /*#__PURE__*/(0, _Function.dual)(2, (self,
 /**
  * Group equal, consecutive elements of a `NonEmptyReadonlyArray` into `NonEmptyArray`s.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Array } from "effect"
  *
  * const result = Array.group([1, 1, 2, 2, 2, 3, 1])
- * assert.deepStrictEqual(result, [[1, 1], [2, 2, 2], [3], [1]])
+ * console.log(result) // [[1, 1], [2, 2, 2], [3], [1]]
  * ```
  *
  * @category grouping
@@ -1568,7 +1593,8 @@ const group = exports.group = /*#__PURE__*/groupWith( /*#__PURE__*/Equal.equival
  * Splits an `Iterable` into sub-non-empty-arrays stored in an object, based on the result of calling a `string`-returning
  * function on each element, and grouping the results according to values returned
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Array } from "effect"
  *
@@ -1577,11 +1603,13 @@ const group = exports.group = /*#__PURE__*/groupWith( /*#__PURE__*/Equal.equival
  *   { name: "Bob", group: "B" },
  *   { name: "Charlie", group: "A" }
  * ]
+ *
  * const result = Array.groupBy(people, person => person.group)
- * assert.deepStrictEqual(result, {
- *   A: [{ name: "Alice", group: "A" }, { name: "Charlie", group: "A" }],
- *   B: [{ name: "Bob", group: "B" }]
- * })
+ * console.log(result)
+ * // {
+ * //  A: [{ name: "Alice", group: "A" }, { name: "Charlie", group: "A" }],
+ * //  B: [{ name: "Bob", group: "B" }]
+ * // }
  * ```
  *
  * @category grouping
@@ -1602,14 +1630,13 @@ const groupBy = exports.groupBy = /*#__PURE__*/(0, _Function.dual)(2, (self, f)
 /**
  * Calculates the union of two arrays using the provided equivalence relation.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Array } from "effect"
  *
- * const array1 = [1, 2]
- * const array2 = [2, 3]
- * const union = Array.unionWith(array1, array2, (a, b) => a === b)
- * assert.deepStrictEqual(union, [1, 2, 3])
+ * const union = Array.unionWith([1, 2], [2, 3], (a, b) => a === b)
+ * console.log(union) // [1, 2, 3]
  * ```
  *
  * @since 2.0.0
@@ -1629,14 +1656,13 @@ const unionWith = exports.unionWith = /*#__PURE__*/(0, _Function.dual)(3, (self,
 /**
  * Creates a union of two arrays, removing duplicates.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Array } from "effect"
  *
- * const array1 = [1, 2]
- * const array2 = [2, 3]
- * const result = Array.union(array1, array2)
- * assert.deepStrictEqual(result, [1, 2, 3])
+ * const result = Array.union([1, 2], [2, 3])
+ * console.log(result) // [1, 2, 3]
  * ```
  *
  * @since 2.0.0
@@ -1646,7 +1672,8 @@ const union = exports.union = /*#__PURE__*/(0, _Function.dual)(2, (self, that) =
  * Creates an `Array` of unique values that are included in all given `Iterable`s using the provided `isEquivalent` function.
  * The order and references of result values are determined by the first `Iterable`.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Array } from "effect"
  *
@@ -1654,7 +1681,7 @@ const union = exports.union = /*#__PURE__*/(0, _Function.dual)(2, (self, that) =
  * const array2 = [{ id: 3 }, { id: 4 }, { id: 1 }]
  * const isEquivalent = (a: { id: number }, b: { id: number }) => a.id === b.id
  * const result = Array.intersectionWith(isEquivalent)(array2)(array1)
- * assert.deepStrictEqual(result, [{ id: 1 }, { id: 3 }])
+ * console.log(result) // [{ id: 1 }, { id: 3 }]
  * ```
  *
  * @since 2.0.0
@@ -1667,14 +1694,13 @@ const intersectionWith = isEquivalent => {
  * Creates an `Array` of unique values that are included in all given `Iterable`s.
  * The order and references of result values are determined by the first `Iterable`.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Array } from "effect"
  *
- * const array1 = [1, 2, 3]
- * const array2 = [3, 4, 1]
- * const result = Array.intersection(array1, array2)
- * assert.deepStrictEqual(result, [1, 3])
+ * const result = Array.intersection([1, 2, 3], [3, 4, 1])
+ * console.log(result) // [1, 3]
  * ```
  *
  * @since 2.0.0
@@ -1685,14 +1711,15 @@ const intersection = exports.intersection = /*#__PURE__*/intersectionWith(_equiv
  * Creates a `Array` of values not included in the other given `Iterable` using the provided `isEquivalent` function.
  * The order and references of result values are determined by the first `Iterable`.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Array } from "effect"
  *
  * const array1 = [1, 2, 3]
  * const array2 = [2, 3, 4]
  * const difference = Array.differenceWith<number>((a, b) => a === b)(array1, array2)
- * assert.deepStrictEqual(difference, [1])
+ * console.log(difference) // [1]
  * ```
  *
  * @since 2.0.0
@@ -1705,14 +1732,13 @@ const differenceWith = isEquivalent => {
  * Creates a `Array` of values not included in the other given `Iterable`.
  * The order and references of result values are determined by the first `Iterable`.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Array } from "effect"
  *
- * const array1 = [1, 2, 3]
- * const array2 = [2, 3, 4]
- * const difference = Array.difference(array1, array2)
- * assert.deepStrictEqual(difference, [1])
+ * const difference = Array.difference([1, 2, 3], [2, 3, 4])
+ * console.log(difference) // [1]
  * ```
  *
  * @since 2.0.0
@@ -1762,14 +1788,13 @@ const flatMap = exports.flatMap = /*#__PURE__*/(0, _Function.dual)(2, (self, f)
  * from each nested array. This function ensures that the structure of nested
  * arrays is collapsed into a single, flat array.
  *
- * @example
- * ```ts
- * import { Array } from "effect";
+ * **Example**
  *
- * const nestedArrays = [[1, 2], [], [3, 4], [], [5, 6]]
- * const result = Array.flatten(nestedArrays)
+ * ```ts
+ * import { Array } from "effect"
  *
- * assert.deepStrictEqual(result, [1, 2, 3, 4, 5, 6]);
+ * const result = Array.flatten([[1, 2], [], [3, 4], [], [5, 6]])
+ * console.log(result) // [1, 2, 3, 4, 5, 6]
  * ```
  *
  * @category sequencing
@@ -1780,15 +1805,15 @@ const flatten = exports.flatten = /*#__PURE__*/flatMap(_Function.identity);
  * Applies a function to each element of the `Iterable` and filters based on the result, keeping the transformed values where the function returns `Some`.
  * This method combines filtering and mapping functionalities, allowing transformations and filtering of elements based on a single function pass.
  *
- * @example
+ * **Example**
+ *
  * ```ts
- * import { Array, Option } from "effect";
+ * import { Array, Option } from "effect"
  *
- * const data = [1, 2, 3, 4, 5];
- * const evenSquares = (x: number) => x % 2 === 0 ? Option.some(x * x) : Option.none();
- * const result = Array.filterMap(data, evenSquares);
+ * const evenSquares = (x: number) => x % 2 === 0 ? Option.some(x * x) : Option.none()
  *
- * assert.deepStrictEqual(result, [4, 16]);
+ * const result = Array.filterMap([1, 2, 3, 4, 5], evenSquares);
+ * console.log(result) // [4, 16]
  * ```
  *
  * @category filtering
@@ -1810,15 +1835,15 @@ const filterMap = exports.filterMap = /*#__PURE__*/(0, _Function.dual)(2, (self,
  * This method combines filtering and mapping in a single pass, and short-circuits, i.e., stops processing, as soon as the function returns `None`.
  * This is useful when you need to transform an array but only up to the point where a certain condition holds true.
  *
- * @example
+ * **Example**
+ *
  * ```ts
- * import { Array, Option } from "effect";
+ * import { Array, Option } from "effect"
  *
- * const data = [2, 4, 5];
- * const toSquareTillOdd = (x: number) => x % 2 === 0 ? Option.some(x * x) : Option.none();
- * const result = Array.filterMapWhile(data, toSquareTillOdd);
+ * const toSquareTillOdd = (x: number) => x % 2 === 0 ? Option.some(x * x) : Option.none()
  *
- * assert.deepStrictEqual(result, [4, 16]);
+ * const result = Array.filterMapWhile([2, 4, 5], toSquareTillOdd)
+ * console.log(result) // [4, 16]
  * ```
  *
  * @category filtering
@@ -1844,20 +1869,21 @@ const filterMapWhile = exports.filterMapWhile = /*#__PURE__*/(0, _Function.dual)
  * and you want to separate these types into different collections. For instance, separating validation results
  * into successes and failures.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Array, Either } from "effect";
  *
- * const data = [1, 2, 3, 4, 5]
  * const isEven = (x: number) => x % 2 === 0
- * const partitioned = Array.partitionMap(data, x =>
+ *
+ * const result = Array.partitionMap([1, 2, 3, 4, 5], x =>
  *   isEven(x) ? Either.right(x) : Either.left(x)
  * )
- *
- * assert.deepStrictEqual(partitioned, [
- *   [1, 3, 5],
- *   [2, 4]
- * ])
+ * console.log(result)
+ * // [
+ * //   [1, 3, 5],
+ * //   [2, 4]
+ * // ]
  * ```
  *
  * @category filtering
@@ -1880,14 +1906,13 @@ const partitionMap = exports.partitionMap = /*#__PURE__*/(0, _Function.dual)(2,
 /**
  * Retrieves the `Some` values from an `Iterable` of `Option`s, collecting them into an array.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Array, Option } from "effect"
  *
- * assert.deepStrictEqual(
- *   Array.getSomes([Option.some(1), Option.none(), Option.some(2)]),
- *   [1, 2]
- * )
+ * const result = Array.getSomes([Option.some(1), Option.none(), Option.some(2)])
+ * console.log(result) // [1, 2]
  * ```
  *
  * @category filtering
@@ -1897,14 +1922,13 @@ const getSomes = exports.getSomes = /*#__PURE__*/filterMap(_Function.identity);
 /**
  * Retrieves the `Left` values from an `Iterable` of `Either`s, collecting them into an array.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Array, Either } from "effect"
  *
- * assert.deepStrictEqual(
- *   Array.getLefts([Either.right(1), Either.left("err"), Either.right(2)]),
- *   ["err"]
- * )
+ * const result = Array.getLefts([Either.right(1), Either.left("err"), Either.right(2)])
+ * console.log(result) // ["err"]
  * ```
  *
  * @category filtering
@@ -1922,14 +1946,13 @@ const getLefts = self => {
 /**
  * Retrieves the `Right` values from an `Iterable` of `Either`s, collecting them into an array.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Array, Either } from "effect"
  *
- * assert.deepStrictEqual(
- *   Array.getRights([Either.right(1), Either.left("err"), Either.right(2)]),
- *   [1, 2]
- * )
+ * const result = Array.getRights([Either.right(1), Either.left("err"), Either.right(2)])
+ * console.log(result) // [1, 2]
  * ```
  *
  * @category filtering
@@ -1963,15 +1986,13 @@ const filter = exports.filter = /*#__PURE__*/(0, _Function.dual)(2, (self, predi
 /**
  * Separate elements based on a predicate that also exposes the index of the element.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Array } from "effect"
  *
- * const numbers = [1, 2, 3, 4]
- *
- * const result = Array.partition(numbers, n => n % 2 === 0)
- *
- * assert.deepStrictEqual(result, [[1, 3], [2, 4]])
+ * const result = Array.partition([1, 2, 3, 4], n => n % 2 === 0)
+ * console.log(result) // [[1, 3], [2, 4]]
  * ```
  *
  * @category filtering
@@ -2000,13 +2021,13 @@ const separate = exports.separate = /*#__PURE__*/partitionMap(_Function.identity
 /**
  * Reduces an array from the left.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Array } from "effect"
  *
- * const numbers = [1, 2, 3]
- * const result = Array.reduce(numbers, 0, (acc, n) => acc + n)
- * assert.deepStrictEqual(result, 6)
+ * const result = Array.reduce([1, 2, 3], 0, (acc, n) => acc + n)
+ * console.log(result) // 6
  * ```
  *
  * @category folding
@@ -2016,13 +2037,13 @@ const reduce = exports.reduce = /*#__PURE__*/(0, _Function.dual)(3, (self, b, f)
 /**
  * Reduces an array from the right.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Array } from "effect"
  *
- * const numbers = [1, 2, 3]
- * const result = Array.reduceRight(numbers, 0, (acc, n) => acc + n)
- * assert.deepStrictEqual(result, 6)
+ * const result = Array.reduceRight([1, 2, 3], 0, (acc, n) => acc + n)
+ * console.log(result) // 6
  * ```
  *
  * @category folding
@@ -2032,14 +2053,15 @@ const reduceRight = exports.reduceRight = /*#__PURE__*/(0, _Function.dual)(3, (s
 /**
  * Lifts a predicate into an array.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Array } from "effect"
  *
  * const isEven = (n: number) => n % 2 === 0
  * const to = Array.liftPredicate(isEven)
- * assert.deepStrictEqual(to(1), [])
- * assert.deepStrictEqual(to(2), [2])
+ * console.log(to(1)) // []
+ * console.log(to(2)) // [2]
  * ```
  *
  * @category lifting
@@ -2067,13 +2089,13 @@ const liftNullable = f => (...a) => fromNullable(f(...a));
 /**
  * Maps over an array and flattens the result, removing null and undefined values.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Array } from "effect"
  *
- * const numbers = [1, 2, 3]
- * const result = Array.flatMapNullable(numbers, n => (n % 2 === 0 ? null : n))
- * assert.deepStrictEqual(result, [1, 3])
+ * const result = Array.flatMapNullable([1, 2, 3], n => (n % 2 === 0 ? null : n))
+ * console.log(result) // [1, 3]
  *
  * // Explanation:
  * // The array of numbers [1, 2, 3] is mapped with a function that returns null for even numbers
@@ -2091,7 +2113,8 @@ const flatMapNullable = exports.flatMapNullable = /*#__PURE__*/(0, _Function.dua
  * If the `Either` is a left, it returns an empty array.
  * If the `Either` is a right, it returns an array with the right value.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Array, Either } from "effect"
  *
@@ -2101,10 +2124,10 @@ const flatMapNullable = exports.flatMapNullable = /*#__PURE__*/(0, _Function.dua
  * const liftedParseNumber = Array.liftEither(parseNumber)
  *
  * const result1 = liftedParseNumber("42")
- * assert.deepStrictEqual(result1, [42])
+ * console.log(result1) // [42]
  *
  * const result2 = liftedParseNumber("not a number")
- * assert.deepStrictEqual(result2, [])
+ * console.log(result2) // []
  *
  * // Explanation:
  * // The function parseNumber is lifted to return an array.
@@ -2137,13 +2160,13 @@ const some = exports.some = /*#__PURE__*/(0, _Function.dual)(2, (self, predicate
 /**
  * Extends an array with a function that maps each subarray to a value.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Array } from "effect"
  *
- * const numbers = [1, 2, 3]
- * const result = Array.extend(numbers, as => as.length)
- * assert.deepStrictEqual(result, [3, 2, 1])
+ * const result = Array.extend([1, 2, 3], as => as.length)
+ * console.log(result) // [3, 2, 1]
  *
  * // Explanation:
  * // The function maps each subarray starting from each element to its length.
@@ -2158,12 +2181,13 @@ const extend = exports.extend = /*#__PURE__*/(0, _Function.dual)(2, (self, f) =>
 /**
  * Finds the minimum element in an array based on a comparator.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Array, Order } from "effect"
  *
- * const min = Array.min([3, 1, 2], Order.number)
- * assert.deepStrictEqual(min, 1)
+ * const result = Array.min([3, 1, 2], Order.number)
+ * console.log(result) // 1
  * ```
  *
  * @since 2.0.0
@@ -2172,12 +2196,13 @@ const min = exports.min = /*#__PURE__*/(0, _Function.dual)(2, (self, O) => self.
 /**
  * Finds the maximum element in an array based on a comparator.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Array, Order } from "effect"
  *
- * const max = Array.max([3, 1, 2], Order.number)
- * assert.deepStrictEqual(max, 3)
+ * const result = Array.max([3, 1, 2], Order.number)
+ * console.log(result) // 3
  * ```
  *
  * @since 2.0.0
@@ -2212,14 +2237,13 @@ const getOrder = exports.getOrder = Order.array;
 /**
  * Creates an equivalence relation for arrays.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Array } from "effect"
  *
- * const numbers1 = [1, 2, 3]
- * const numbers2 = [1, 2, 3]
  * const eq = Array.getEquivalence<number>((a, b) => a === b)
- * assert.deepStrictEqual(eq(numbers1, numbers2), true)
+ * console.log(eq([1, 2, 3], [1, 2, 3])) // true
  * ```
  *
  * @category instances
@@ -2229,12 +2253,12 @@ const getEquivalence = exports.getEquivalence = Equivalence.array;
 /**
  * Performs a side-effect for each element of the `Iterable`.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Array } from "effect"
  *
- * const numbers = [1, 2, 3]
- * Array.forEach(numbers, n => console.log(n)) // 1, 2, 3
+ * Array.forEach([1, 2, 3], n => console.log(n)) // 1, 2, 3
  * ```
  *
  * @since 2.0.0
@@ -2244,13 +2268,13 @@ const forEach = exports.forEach = /*#__PURE__*/(0, _Function.dual)(2, (self, f)
  * Remove duplicates from an `Iterable` using the provided `isEquivalent` function,
  * preserving the order of the first occurrence of each element.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Array } from "effect"
  *
- * const numbers = [1, 2, 2, 3, 3, 3]
- * const unique = Array.dedupeWith(numbers, (a, b) => a === b)
- * assert.deepStrictEqual(unique, [1, 2, 3])
+ * const result = Array.dedupeWith([1, 2, 2, 3, 3, 3], (a, b) => a === b)
+ * console.log(result) // [1, 2, 3]
  * ```
  *
  * @since 2.0.0
@@ -2279,13 +2303,13 @@ const dedupe = self => dedupeWith(self, Equal.equivalence());
 /**
  * Deduplicates adjacent elements that are identical using the provided `isEquivalent` function.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Array } from "effect"
  *
- * const numbers = [1, 1, 2, 2, 3, 3]
- * const unique = Array.dedupeAdjacentWith(numbers, (a, b) => a === b)
- * assert.deepStrictEqual(unique, [1, 2, 3])
+ * const result = Array.dedupeAdjacentWith([1, 1, 2, 2, 3, 3], (a, b) => a === b)
+ * console.log(result) // [1, 2, 3]
  * ```
  *
  * @since 2.0.0
@@ -2305,13 +2329,13 @@ const dedupeAdjacentWith = exports.dedupeAdjacentWith = /*#__PURE__*/(0, _Functi
 /**
  * Deduplicates adjacent elements that are identical.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Array } from "effect"
  *
- * const numbers = [1, 1, 2, 2, 3, 3]
- * const unique = Array.dedupeAdjacent(numbers)
- * assert.deepStrictEqual(unique, [1, 2, 3])
+ * const result = Array.dedupeAdjacent([1, 1, 2, 2, 3, 3])
+ * console.log(result) // [1, 2, 3]
  * ```
  *
  * @since 2.0.0
@@ -2320,13 +2344,14 @@ const dedupeAdjacent = exports.dedupeAdjacent = /*#__PURE__*/dedupeAdjacentWith(
 /**
  * Joins the elements together with "sep" in the middle.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Array } from "effect"
  *
  * const strings = ["a", "b", "c"]
  * const joined = Array.join(strings, "-")
- * assert.deepStrictEqual(joined, "a-b-c")
+ * console.log(joined) // "a-b-c"
  * ```
  *
  * @since 2.0.0
@@ -2336,13 +2361,13 @@ const join = exports.join = /*#__PURE__*/(0, _Function.dual)(2, (self, sep) => f
 /**
  * Statefully maps over the chunk, producing new elements of type `B`.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Array } from "effect"
  *
- * const numbers = [1, 2, 3]
- * const result = Array.mapAccum(numbers, 0, (acc, n) => [acc + n, acc + n])
- * assert.deepStrictEqual(result, [6, [1, 3, 6]])
+ * const result = Array.mapAccum([1, 2, 3], 0, (acc, n) => [acc + n, acc + n])
+ * console.log(result) // [6, [1, 3, 6]]
  * ```
  *
  * @since 2.0.0
@@ -2363,14 +2388,13 @@ const mapAccum = exports.mapAccum = /*#__PURE__*/(0, _Function.dual)(3, (self, s
 /**
  * Zips this chunk crosswise with the specified chunk using the specified combiner.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Array } from "effect"
  *
- * const array1 = [1, 2]
- * const array2 = ["a", "b"]
- * const product = Array.cartesianWith(array1, array2, (a, b) => `${a}-${b}`)
- * assert.deepStrictEqual(product, ["1-a", "1-b", "2-a", "2-b"])
+ * const result = Array.cartesianWith([1, 2], ["a", "b"], (a, b) => `${a}-${b}`)
+ * console.log(result) // ["1-a", "1-b", "2-a", "2-b"]
  * ```
  *
  * @since 2.0.0
@@ -2380,14 +2404,13 @@ const cartesianWith = exports.cartesianWith = /*#__PURE__*/(0, _Function.dual)(3
 /**
  * Zips this chunk crosswise with the specified chunk.
  *
- * @example
+ * **Example**
+ *
  * ```ts
  * import { Array } from "effect"
  *
- * const array1 = [1, 2]
- * const array2 = ["a", "b"]
- * const product = Array.cartesian(array1, array2)
- * assert.deepStrictEqual(product, [[1, "a"], [1, "b"], [2, "a"], [2, "b"]])
+ * const result = Array.cartesian([1, 2], ["a", "b"])
+ * console.log(result) // [[1, "a"], [1, "b"], [2, "a"], [2, "b"]]
  * ```
  *
  * @since 2.0.0
@@ -2411,21 +2434,19 @@ const cartesian = exports.cartesian = /*#__PURE__*/(0, _Function.dual)(2, (self,
  * 4. Inside the do simulation scope, you can also use the `let` function to define variables and bind them to simple values
  * 5. Regular `Option` functions like `map` and `filter` can still be used within the do simulation. These functions will receive the accumulated variables as arguments within the scope
  *
- * @see {@link bindTo}
- * @see {@link bind}
- * @see {@link let_ let}
+ * **Example**
  *
- * @example
  * ```ts
- * import { Array as Arr, pipe } from "effect"
+ * import { Array, pipe } from "effect"
+ *
  * const doResult = pipe(
- *   Arr.Do,
- *   Arr.bind("x", () => [1, 3, 5]),
- *   Arr.bind("y", () => [2, 4, 6]),
- *   Arr.filter(({ x, y }) => x < y), // condition
- *   Arr.map(({ x, y }) => [x, y] as const) // transformation
+ *   Array.Do,
+ *   Array.bind("x", () => [1, 3, 5]),
+ *   Array.bind("y", () => [2, 4, 6]),
+ *   Array.filter(({ x, y }) => x < y), // condition
+ *   Array.map(({ x, y }) => [x, y] as const) // transformation
  * )
- * assert.deepStrictEqual(doResult, [[1, 2], [1, 4], [1, 6], [3, 4], [3, 6], [5, 6]])
+ * console.log(doResult) // [[1, 2], [1, 4], [1, 6], [3, 4], [3, 6], [5, 6]]
  *
  * // equivalent
  * const x = [1, 3, 5],
@@ -2439,6 +2460,10 @@ const cartesian = exports.cartesian = /*#__PURE__*/(0, _Function.dual)(2, (self,
  * }
  * ```
  *
+ * @see {@link bindTo}
+ * @see {@link bind}
+ * @see {@link let_ let}
+ *
  * @category do notation
  * @since 3.2.0
  */
@@ -2457,21 +2482,19 @@ const Do = exports.Do = /*#__PURE__*/of({});
  * 4. Inside the do simulation scope, you can also use the `let` function to define variables and bind them to simple values
  * 5. Regular `Option` functions like `map` and `filter` can still be used within the do simulation. These functions will receive the accumulated variables as arguments within the scope
  *
- * @see {@link bindTo}
- * @see {@link Do}
- * @see {@link let_ let}
+ * **Example**
  *
- * @example
  * ```ts
- * import { Array as Arr, pipe } from "effect"
+ * import { Array, pipe } from "effect"
+ *
  * const doResult = pipe(
- *   Arr.Do,
- *   Arr.bind("x", () => [1, 3, 5]),
- *   Arr.bind("y", () => [2, 4, 6]),
- *   Arr.filter(({ x, y }) => x < y), // condition
- *   Arr.map(({ x, y }) => [x, y] as const) // transformation
+ *   Array.Do,
+ *   Array.bind("x", () => [1, 3, 5]),
+ *   Array.bind("y", () => [2, 4, 6]),
+ *   Array.filter(({ x, y }) => x < y), // condition
+ *   Array.map(({ x, y }) => [x, y] as const) // transformation
  * )
- * assert.deepStrictEqual(doResult, [[1, 2], [1, 4], [1, 6], [3, 4], [3, 6], [5, 6]])
+ * console.log(doResult) // [[1, 2], [1, 4], [1, 6], [3, 4], [3, 6], [5, 6]]
  *
  * // equivalent
  * const x = [1, 3, 5],
@@ -2485,6 +2508,10 @@ const Do = exports.Do = /*#__PURE__*/of({});
  * }
  * ```
  *
+ * @see {@link bindTo}
+ * @see {@link Do}
+ * @see {@link let_ let}
+ *
  * @category do notation
  * @since 3.2.0
  */
@@ -2503,21 +2530,19 @@ const bind = exports.bind = /*#__PURE__*/doNotation.bind(map, flatMap);
  * 4. Inside the do simulation scope, you can also use the `let` function to define variables and bind them to simple values
  * 5. Regular `Option` functions like `map` and `filter` can still be used within the do simulation. These functions will receive the accumulated variables as arguments within the scope
  *
- * @see {@link bindTo}
- * @see {@link Do}
- * @see {@link let_ let}
+ * **Example**
  *
- * @example
  * ```ts
- * import { Array as Arr, pipe } from "effect"
+ * import { Array, pipe } from "effect"
+ *
  * const doResult = pipe(
- *   Arr.Do,
- *   Arr.bind("x", () => [1, 3, 5]),
- *   Arr.bind("y", () => [2, 4, 6]),
- *   Arr.filter(({ x, y }) => x < y), // condition
- *   Arr.map(({ x, y }) => [x, y] as const) // transformation
+ *   Array.Do,
+ *   Array.bind("x", () => [1, 3, 5]),
+ *   Array.bind("y", () => [2, 4, 6]),
+ *   Array.filter(({ x, y }) => x < y), // condition
+ *   Array.map(({ x, y }) => [x, y] as const) // transformation
  * )
- * assert.deepStrictEqual(doResult, [[1, 2], [1, 4], [1, 6], [3, 4], [3, 6], [5, 6]])
+ * console.log(doResult) // [[1, 2], [1, 4], [1, 6], [3, 4], [3, 6], [5, 6]]
  *
  * // equivalent
  * const x = [1, 3, 5],
@@ -2531,6 +2556,10 @@ const bind = exports.bind = /*#__PURE__*/doNotation.bind(map, flatMap);
  * }
  * ```
  *
+ * @see {@link bindTo}
+ * @see {@link Do}
+ * @see {@link let_ let}
+ *
  * @category do notation
  * @since 3.2.0
  */