effect 3.13.8 → 3.13.9

package/dist/esm/Array.js

@@ -18,12 +18,13 @@ import * as Tuple from "./Tuple.js";
 /**
  * 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
@@ -33,12 +34,13 @@ export 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
@@ -50,11 +52,13 @@ export 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
@@ -71,11 +75,13 @@ export const makeBy = /*#__PURE__*/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
@@ -87,11 +93,13 @@ export const range = (start, end) => start <= end ? makeBy(end - start + 1, i =>
  *
  * **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
@@ -103,13 +111,13 @@ export const replicate = /*#__PURE__*/dual(2, (a, n) => makeBy(n, () => a));
  * 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
@@ -119,13 +127,14 @@ export const fromIterable = collection => Array.isArray(collection) ? collection
 /**
  * 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
@@ -135,14 +144,13 @@ export 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
@@ -152,12 +160,13 @@ export const 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
@@ -167,7 +176,8 @@ export const 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"
  *
@@ -175,8 +185,8 @@ export const 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
@@ -189,7 +199,8 @@ export const match = /*#__PURE__*/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"
  *
@@ -197,8 +208,8 @@ export const match = /*#__PURE__*/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
@@ -211,7 +222,8 @@ export const matchLeft = /*#__PURE__*/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"
  *
@@ -219,8 +231,8 @@ export const matchLeft = /*#__PURE__*/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
@@ -233,13 +245,13 @@ export const matchRight = /*#__PURE__*/dual(2, (self, {
 /**
  * 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
@@ -250,14 +262,13 @@ export const prepend = /*#__PURE__*/dual(2, (self, head) => [head, ...self]);
  * 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
@@ -267,13 +278,13 @@ export const prependAll = /*#__PURE__*/dual(2, (self, that) => fromIterable(that
 /**
  * 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
@@ -293,13 +304,13 @@ export const appendAll = /*#__PURE__*/dual(2, (self, that) => fromIterable(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)
@@ -325,13 +336,13 @@ export const scan = /*#__PURE__*/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
@@ -349,14 +360,13 @@ export const scanRight = /*#__PURE__*/dual(3, (self, b, f) => {
 /**
  * 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
@@ -366,14 +376,13 @@ export const 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
@@ -383,14 +392,13 @@ export 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
@@ -402,14 +410,13 @@ export const 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
@@ -421,14 +428,13 @@ export const 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
@@ -470,12 +476,13 @@ export const unsafeGet = /*#__PURE__*/dual(2, (self, index) => {
 /**
  * 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
@@ -485,12 +492,13 @@ export 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
@@ -507,12 +515,13 @@ export const 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
@@ -529,12 +538,13 @@ export const last = self => isNonEmptyReadonlyArray(self) ? O.some(lastNonEmpty(
 /**
  * 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
@@ -554,12 +564,13 @@ export 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
@@ -579,12 +590,13 @@ export 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
@@ -596,13 +608,13 @@ export 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
@@ -617,13 +629,13 @@ export const take = /*#__PURE__*/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
@@ -637,13 +649,13 @@ export const takeRight = /*#__PURE__*/dual(2, (self, n) => {
 /**
  * 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.
@@ -692,13 +704,13 @@ export const span = /*#__PURE__*/dual(2, (self, predicate) => splitAt(self, span
  *
  * **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
@@ -713,13 +725,13 @@ export const drop = /*#__PURE__*/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
@@ -732,13 +744,13 @@ export const dropRight = /*#__PURE__*/dual(2, (self, n) => {
 /**
  * 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
@@ -748,13 +760,13 @@ export const dropWhile = /*#__PURE__*/dual(2, (self, predicate) => fromIterable(
 /**
  * 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
@@ -773,13 +785,13 @@ export const findFirstIndex = /*#__PURE__*/dual(2, (self, predicate) => {
 /**
  * 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
@@ -798,13 +810,13 @@ export const findLastIndex = /*#__PURE__*/dual(2, (self, predicate) => {
  * 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
@@ -815,13 +827,13 @@ export const 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
@@ -848,13 +860,13 @@ export const findLast = /*#__PURE__*/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
@@ -872,13 +884,13 @@ export const insertAt = /*#__PURE__*/dual(3, (self, i, b) => {
  * 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
@@ -887,13 +899,13 @@ export const replace = /*#__PURE__*/dual(3, (self, i, b) => modify(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
@@ -903,13 +915,13 @@ export const replaceOption = /*#__PURE__*/dual(3, (self, i, b) => modifyOption(s
  * 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
@@ -919,16 +931,17 @@ export const modify = /*#__PURE__*/dual(3, (self, i, f) => O.getOrElse(modifyOpt
  * 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
@@ -947,16 +960,17 @@ export const modifyOption = /*#__PURE__*/dual(3, (self, i, f) => {
  * 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
@@ -972,13 +986,13 @@ export const remove = /*#__PURE__*/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
@@ -1002,13 +1016,13 @@ export const sort = /*#__PURE__*/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`
@@ -1025,9 +1039,10 @@ export const sortWith = /*#__PURE__*/dual(3, (self, f, order) => Array.from(self
  * 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 },
@@ -1035,16 +1050,20 @@ export const sortWith = /*#__PURE__*/dual(3, (self, f, order) => Array.from(self
  *   { 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,
@@ -1069,14 +1088,13 @@ export 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
@@ -1087,14 +1105,13 @@ export const zip = /*#__PURE__*/dual(2, (self, that) => zipWith(self, that, Tupl
  * 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
@@ -1116,12 +1133,13 @@ export const zipWith = /*#__PURE__*/dual(3, (self, that, f) => {
 /**
  * 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
@@ -1143,13 +1161,13 @@ export 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
@@ -1172,12 +1190,13 @@ export const intersperse = /*#__PURE__*/dual(2, (self, middle) => {
 /**
  * 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
@@ -1186,12 +1205,13 @@ export const modifyNonEmptyHead = /*#__PURE__*/dual(2, (self, f) => [f(headNonEm
 /**
  * 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
@@ -1200,12 +1220,13 @@ export const setNonEmptyHead = /*#__PURE__*/dual(2, (self, b) => modifyNonEmptyH
 /**
  * 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
@@ -1214,12 +1235,13 @@ export const modifyNonEmptyLast = /*#__PURE__*/dual(2, (self, f) => append(initN
 /**
  * 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
@@ -1229,13 +1251,13 @@ export const setNonEmptyLast = /*#__PURE__*/dual(2, (self, b) => modifyNonEmptyL
  * 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
@@ -1260,15 +1282,15 @@ export const rotate = /*#__PURE__*/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
@@ -1286,13 +1308,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
@@ -1304,13 +1326,13 @@ export const 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.
@@ -1339,13 +1361,13 @@ export const chop = /*#__PURE__*/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
@@ -1366,12 +1388,13 @@ export const splitAt = /*#__PURE__*/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
@@ -1384,13 +1407,13 @@ export const splitNonEmptyAt = /*#__PURE__*/dual(2, (self, n) => {
 /**
  * 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
@@ -1404,13 +1427,13 @@ export const split = /*#__PURE__*/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
@@ -1420,13 +1443,13 @@ export const splitWhere = /*#__PURE__*/dual(2, (self, predicate) => span(self, (
 /**
  * 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
@@ -1438,13 +1461,13 @@ export 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
@@ -1460,19 +1483,19 @@ export const pad = /*#__PURE__*/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`.
@@ -1494,12 +1517,13 @@ export const chunksOf = /*#__PURE__*/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
@@ -1522,12 +1546,13 @@ export const groupWith = /*#__PURE__*/dual(2, (self, isEquivalent) => chop(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
@@ -1538,7 +1563,8 @@ export const group = /*#__PURE__*/groupWith( /*#__PURE__*/Equal.equivalence());
  * 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"
  *
@@ -1547,11 +1573,13 @@ export const group = /*#__PURE__*/groupWith( /*#__PURE__*/Equal.equivalence());
  *   { 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
@@ -1572,14 +1600,13 @@ export const groupBy = /*#__PURE__*/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
@@ -1599,14 +1626,13 @@ export const unionWith = /*#__PURE__*/dual(3, (self, that, isEquivalent) => {
 /**
  * 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
@@ -1616,7 +1642,8 @@ export const union = /*#__PURE__*/dual(2, (self, that) => unionWith(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"
  *
@@ -1624,7 +1651,7 @@ export const union = /*#__PURE__*/dual(2, (self, that) => unionWith(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
@@ -1637,14 +1664,13 @@ export 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
@@ -1654,14 +1680,15 @@ export const intersection = /*#__PURE__*/intersectionWith(_equivalence);
  * 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
@@ -1674,14 +1701,13 @@ export 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
@@ -1728,14 +1754,13 @@ export const flatMap = /*#__PURE__*/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
@@ -1746,15 +1771,15 @@ export const flatten = /*#__PURE__*/flatMap(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
@@ -1776,15 +1801,15 @@ export const filterMap = /*#__PURE__*/dual(2, (self, f) => {
  * 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
@@ -1810,20 +1835,21 @@ export const filterMapWhile = /*#__PURE__*/dual(2, (self, f) => {
  * 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
@@ -1846,14 +1872,13 @@ export const partitionMap = /*#__PURE__*/dual(2, (self, f) => {
 /**
  * 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
@@ -1863,14 +1888,13 @@ export const getSomes = /*#__PURE__*/filterMap(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
@@ -1888,14 +1912,13 @@ export 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
@@ -1927,15 +1950,13 @@ export const filter = /*#__PURE__*/dual(2, (self, predicate) => {
 /**
  * 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
@@ -1964,13 +1985,13 @@ export const separate = /*#__PURE__*/partitionMap(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
@@ -1980,13 +2001,13 @@ export const reduce = /*#__PURE__*/dual(3, (self, b, f) => fromIterable(self).re
 /**
  * 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
@@ -1996,14 +2017,15 @@ export const reduceRight = /*#__PURE__*/dual(3, (self, b, f) => fromIterable(sel
 /**
  * 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
@@ -2028,13 +2050,13 @@ export 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
@@ -2051,7 +2073,8 @@ export const flatMapNullable = /*#__PURE__*/dual(2, (self, f) => flatMap(self, a
  * 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"
  *
@@ -2061,10 +2084,10 @@ export const flatMapNullable = /*#__PURE__*/dual(2, (self, f) => flatMap(self, a
  * 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.
@@ -2096,13 +2119,13 @@ export const some = /*#__PURE__*/dual(2, (self, predicate) => self.some(predicat
 /**
  * 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.
@@ -2117,12 +2140,13 @@ export const extend = /*#__PURE__*/dual(2, (self, f) => self.map((_, i, as) => 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
@@ -2131,12 +2155,13 @@ export const min = /*#__PURE__*/dual(2, (self, O) => self.reduce(Order.min(O)));
 /**
  * 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
@@ -2170,14 +2195,13 @@ export const 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
@@ -2187,12 +2211,12 @@ export const 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
@@ -2202,13 +2226,13 @@ export const forEach = /*#__PURE__*/dual(2, (self, f) => fromIterable(self).forE
  * 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
@@ -2237,13 +2261,13 @@ export 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
@@ -2262,13 +2286,13 @@ export const dedupeAdjacentWith = /*#__PURE__*/dual(2, (self, isEquivalent) => {
 /**
  * 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
@@ -2277,13 +2301,14 @@ export const dedupeAdjacent = /*#__PURE__*/dedupeAdjacentWith( /*#__PURE__*/Equa
 /**
  * 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
@@ -2293,13 +2318,13 @@ export const join = /*#__PURE__*/dual(2, (self, sep) => fromIterable(self).join(
 /**
  * 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
@@ -2320,14 +2345,13 @@ export const mapAccum = /*#__PURE__*/dual(3, (self, s, f) => {
 /**
  * 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
@@ -2337,14 +2361,13 @@ export const cartesianWith = /*#__PURE__*/dual(3, (self, that, f) => flatMap(sel
 /**
  * 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
@@ -2368,21 +2391,19 @@ export const cartesian = /*#__PURE__*/dual(2, (self, that) => cartesianWith(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],
@@ -2396,6 +2417,10 @@ export const cartesian = /*#__PURE__*/dual(2, (self, that) => cartesianWith(self
  * }
  * ```
  *
+ * @see {@link bindTo}
+ * @see {@link bind}
+ * @see {@link let_ let}
+ *
  * @category do notation
  * @since 3.2.0
  */
@@ -2414,21 +2439,19 @@ export const 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],
@@ -2442,6 +2465,10 @@ export const Do = /*#__PURE__*/of({});
  * }
  * ```
  *
+ * @see {@link bindTo}
+ * @see {@link Do}
+ * @see {@link let_ let}
+ *
  * @category do notation
  * @since 3.2.0
  */
@@ -2460,21 +2487,19 @@ export const 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],
@@ -2488,6 +2513,10 @@ export const bind = /*#__PURE__*/doNotation.bind(map, flatMap);
  * }
  * ```
  *
+ * @see {@link bindTo}
+ * @see {@link Do}
+ * @see {@link let_ let}
+ *
  * @category do notation
  * @since 3.2.0
  */
@@ -2508,21 +2537,19 @@ export {
  * 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 Do}
+ * **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],
@@ -2536,6 +2563,11 @@ export {
  * }
  *
  * ```
+ *
+ * @see {@link bindTo}
+ * @see {@link bind}
+ * @see {@link Do}
+ *
  * @category do notation
  * @since 3.2.0
  */