effect 3.10.18 → 3.11.0

package/dist/cjs/Array.js

@@ -29,10 +29,12 @@ function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e;
  * Builds a `NonEmptyArray` from an non-empty collection of elements.
  *
  * @example
+ * ```ts
  * import { Array } from "effect"
  *
  * const result = Array.make(1, 2, 3)
  * assert.deepStrictEqual(result, [1, 2, 3])
+ * ```
  *
  * @category constructors
  * @since 2.0.0
@@ -42,10 +44,12 @@ const make = (...elements) => elements;
  * Creates a new `Array` of the specified length.
  *
  * @example
+ * ```ts
  * import { Array } from "effect"
  *
  * const result = Array.allocate<number>(3)
  * assert.deepStrictEqual(result.length, 3)
+ * ```
  *
  * @category constructors
  * @since 2.0.0
@@ -58,9 +62,11 @@ const allocate = n => new Array(n);
  * **Note**. `n` is normalized to an integer >= 1.
  *
  * @example
+ * ```ts
  * import { makeBy } from "effect/Array"
  *
  * assert.deepStrictEqual(makeBy(5, n => n * 2), [0, 2, 4, 6, 8])
+ * ```
  *
  * @category constructors
  * @since 2.0.0
@@ -78,9 +84,11 @@ const makeBy = (n, f) => {
  * Return a `NonEmptyArray` containing a range of integers, including both endpoints.
  *
  * @example
+ * ```ts
  * import { range } from "effect/Array"
  *
  * assert.deepStrictEqual(range(1, 3), [1, 2, 3])
+ * ```
  *
  * @category constructors
  * @since 2.0.0
@@ -93,9 +101,11 @@ const range = (start, end) => start <= end ? makeBy(end - start + 1, i => start
  * **Note**. `n` is normalized to an integer >= 1.
  *
  * @example
+ * ```ts
  * import { Array } from "effect"
  *
  * assert.deepStrictEqual(Array.replicate("a", 3), ["a", "a", "a"])
+ * ```
  *
  * @category constructors
  * @since 2.0.0
@@ -108,11 +118,13 @@ const replicate = exports.replicate = /*#__PURE__*/(0, _Function.dual)(2, (a, n)
  * Otherwise, it converts the iterable collection to an array.
  *
  * @example
+ * ```ts
  * import { Array } from "effect"
  *
  * const set = new Set([1, 2, 3])
  * const result = Array.fromIterable(set)
  * assert.deepStrictEqual(result, [1, 2, 3])
+ * ```
  *
  * @category constructors
  * @since 2.0.0
@@ -122,11 +134,13 @@ const fromIterable = collection => Array.isArray(collection) ? collection : Arra
  * Creates a new `Array` from a value that might not be an iterable.
  *
  * @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"])
+ * ```
  *
  * @category constructors
  * @since 3.3.0
@@ -139,10 +153,12 @@ const ensure = self => Array.isArray(self) ? self : [self];
  * @param self - The record to transform.
  *
  * @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]])
+ * ```
  *
  * @category conversions
  * @since 2.0.0
@@ -153,10 +169,12 @@ const fromRecord = exports.fromRecord = Record.toEntries;
  * Converts an `Option` to an array.
  *
  * @example
+ * ```ts
  * import { Array, Option } from "effect"
  *
  * assert.deepStrictEqual(Array.fromOption(Option.some(1)), [1])
  * assert.deepStrictEqual(Array.fromOption(Option.none()), [])
+ * ```
  *
  * @category conversions
  * @since 2.0.0
@@ -166,6 +184,7 @@ const fromOption = exports.fromOption = O.toArray;
  * Matches the elements of an array, applying functions to cases of empty and non-empty arrays.
  *
  * @example
+ * ```ts
  * import { Array } from "effect"
  *
  * const match = Array.match({
@@ -174,6 +193,7 @@ const fromOption = exports.fromOption = O.toArray;
  * })
  * assert.deepStrictEqual(match([]), "empty")
  * assert.deepStrictEqual(match([1, 2, 3]), "head: 1, tail: 2")
+ * ```
  *
  * @category pattern matching
  * @since 2.0.0
@@ -186,6 +206,7 @@ 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
+ * ```ts
  * import { Array } from "effect"
  *
  * const matchLeft = Array.matchLeft({
@@ -194,6 +215,7 @@ const match = exports.match = /*#__PURE__*/(0, _Function.dual)(2, (self, {
  * })
  * assert.deepStrictEqual(matchLeft([]), "empty")
  * assert.deepStrictEqual(matchLeft([1, 2, 3]), "head: 1, tail: 2")
+ * ```
  *
  * @category pattern matching
  * @since 2.0.0
@@ -206,6 +228,7 @@ 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
+ * ```ts
  * import { Array } from "effect"
  *
  * const matchRight = Array.matchRight({
@@ -214,6 +237,7 @@ const matchLeft = exports.matchLeft = /*#__PURE__*/(0, _Function.dual)(2, (self,
  * })
  * assert.deepStrictEqual(matchRight([]), "empty")
  * assert.deepStrictEqual(matchRight([1, 2, 3]), "init: 2, last: 3")
+ * ```
  *
  * @category pattern matching
  * @since 2.0.0
@@ -226,11 +250,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
+ * ```ts
  * import { Array } from "effect"
  *
  * const original = [2, 3, 4];
  * const result = Array.prepend(original, 1);
  * assert.deepStrictEqual(result, [1, 2, 3, 4]);
+ * ```
  *
  * @category concatenating
  * @since 2.0.0
@@ -241,12 +267,14 @@ const prepend = exports.prepend = /*#__PURE__*/(0, _Function.dual)(2, (self, hea
  * If either array is non-empty, the result is also a non-empty array.
  *
  * @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]);
+ * ```
  *
  * @category concatenating
  * @since 2.0.0
@@ -256,11 +284,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
+ * ```ts
  * import { Array } from "effect"
  *
  * const original = [1, 2, 3];
  * const result = Array.append(original, 4);
  * assert.deepStrictEqual(result, [1, 2, 3, 4]);
+ * ```
  *
  * @category concatenating
  * @since 2.0.0
@@ -280,6 +310,7 @@ const appendAll = exports.appendAll = /*#__PURE__*/(0, _Function.dual)(2, (self,
  * a value through a series of transformations.
  *
  * @example
+ * ```ts
  * import { Array } from "effect";
  *
  * const numbers = [1, 2, 3, 4]
@@ -291,6 +322,7 @@ const appendAll = exports.appendAll = /*#__PURE__*/(0, _Function.dual)(2, (self,
  * // and adds each element of the array to this accumulator one by one,
  * // keeping track of the cumulative sum after each addition.
  * // Each of these sums is captured in the resulting array.
+ * ```
  *
  * @category folding
  * @since 2.0.0
@@ -310,11 +342,13 @@ const scan = exports.scan = /*#__PURE__*/(0, _Function.dual)(3, (self, b, f) =>
  * a value through a series of transformations.
  *
  * @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])
+ * ```
  *
  * @category folding
  * @since 2.0.0
@@ -334,10 +368,12 @@ const scanRight = exports.scanRight = /*#__PURE__*/(0, _Function.dual)(3, (self,
  * @param self - The value to check.
  *
  * @example
+ * ```ts
  * import { isArray } from "effect/Array"
  *
  * assert.deepStrictEqual(isArray(null), false);
  * assert.deepStrictEqual(isArray([1, 2, 3]), true);
+ * ```
  *
  * @category guards
  * @since 2.0.0
@@ -349,10 +385,12 @@ const isArray = exports.isArray = Array.isArray;
  * @param self - The `Array` to check.
  *
  * @example
+ * ```ts
  * import { isEmptyArray } from "effect/Array"
  *
  * assert.deepStrictEqual(isEmptyArray([]), true);
  * assert.deepStrictEqual(isEmptyArray([1, 2, 3]), false);
+ * ```
  *
  * @category guards
  * @since 2.0.0
@@ -364,10 +402,12 @@ const isEmptyArray = self => self.length === 0;
  * @param self - The `ReadonlyArray` to check.
  *
  * @example
+ * ```ts
  * import { isEmptyReadonlyArray } from "effect/Array"
  *
  * assert.deepStrictEqual(isEmptyReadonlyArray([]), true);
  * assert.deepStrictEqual(isEmptyReadonlyArray([1, 2, 3]), false);
+ * ```
  *
  * @category guards
  * @since 2.0.0
@@ -382,10 +422,12 @@ const isEmptyReadonlyArray = exports.isEmptyReadonlyArray = isEmptyArray;
  * @param self - The `Array` to check.
  *
  * @example
+ * ```ts
  * import { isNonEmptyArray } from "effect/Array"
  *
  * assert.deepStrictEqual(isNonEmptyArray([]), false);
  * assert.deepStrictEqual(isNonEmptyArray([1, 2, 3]), true);
+ * ```
  *
  * @category guards
  * @since 2.0.0
@@ -399,10 +441,12 @@ const isNonEmptyArray = exports.isNonEmptyArray = readonlyArray.isNonEmptyArray;
  * @param self - The `ReadonlyArray` to check.
  *
  * @example
+ * ```ts
  * import { isNonEmptyReadonlyArray } from "effect/Array"
  *
  * assert.deepStrictEqual(isNonEmptyReadonlyArray([]), false);
  * assert.deepStrictEqual(isNonEmptyReadonlyArray([1, 2, 3]), true);
+ * ```
  *
  * @category guards
  * @since 2.0.0
@@ -445,10 +489,12 @@ 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
+ * ```ts
  * import { Array } from "effect";
  *
  * const result = Array.unprepend([1, 2, 3, 4])
  * assert.deepStrictEqual(result, [1, [2, 3, 4]])
+ * ```
  *
  * @category splitting
  * @since 2.0.0
@@ -458,10 +504,12 @@ 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
+ * ```ts
  * import { Array } from "effect";
  *
  * const result = Array.unappend([1, 2, 3, 4])
  * assert.deepStrictEqual(result, [[1, 2, 3], 4])
+ * ```
  *
  * @category splitting
  * @since 2.0.0
@@ -480,10 +528,12 @@ const head = exports.head = /*#__PURE__*/get(0);
  * Get the first element of a non empty array.
  *
  * @example
+ * ```ts
  * import { Array } from "effect"
  *
  * const result = Array.headNonEmpty([1, 2, 3, 4])
  * assert.deepStrictEqual(result, 1)
+ * ```
  *
  * @category getters
  * @since 2.0.0
@@ -500,10 +550,12 @@ const last = self => isNonEmptyReadonlyArray(self) ? O.some(lastNonEmpty(self))
  * Get the last element of a non empty array.
  *
  * @example
+ * ```ts
  * import { Array } from "effect"
  *
  * const result = Array.lastNonEmpty([1, 2, 3, 4])
  * assert.deepStrictEqual(result, 4)
+ * ```
  *
  * @category getters
  * @since 2.0.0
@@ -525,10 +577,12 @@ const tail = self => {
  * Get all but the first element of a `NonEmptyReadonlyArray`.
  *
  * @example
+ * ```ts
  * import { Array } from "effect"
  *
  * const result = Array.tailNonEmpty([1, 2, 3, 4])
  * assert.deepStrictEqual(result, [2, 3, 4])
+ * ```
  *
  * @category getters
  * @since 2.0.0
@@ -550,10 +604,12 @@ const init = self => {
  * Get all but the last element of a non empty array, creating a new array.
  *
  * @example
+ * ```ts
  * import { Array } from "effect"
  *
  * const result = Array.initNonEmpty([1, 2, 3, 4])
  * assert.deepStrictEqual(result, [1, 2, 3])
+ * ```
  *
  * @category getters
  * @since 2.0.0
@@ -566,11 +622,13 @@ const initNonEmpty = self => self.slice(0, -1);
  * **Note**. `n` is normalized to a non negative integer.
  *
  * @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])
+ * ```
  *
  * @category getters
  * @since 2.0.0
@@ -586,11 +644,13 @@ const take = exports.take = /*#__PURE__*/(0, _Function.dual)(2, (self, n) => {
  * **Note**. `n` is normalized to a non negative integer.
  *
  * @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])
+ * ```
  *
  * @category getters
  * @since 2.0.0
@@ -604,6 +664,7 @@ 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
+ * ```ts
  * import { Array } from "effect"
  *
  * const numbers = [1, 3, 2, 4, 1, 2]
@@ -615,6 +676,7 @@ const takeRight = exports.takeRight = /*#__PURE__*/(0, _Function.dual)(2, (self,
  * // - The next element (`3`) is also less than `4`, so it adds `3`.
  * // - The next element (`2`) is again less than `4`, so it adds `2`.
  * // - The function then encounters `4`, which is not less than `4`. At this point, it stops checking further elements and finalizes the result.
+ * ```
  *
  * @category getters
  * @since 2.0.0
@@ -657,11 +719,13 @@ const span = exports.span = /*#__PURE__*/(0, _Function.dual)(2, (self, predicate
  * **Note**. `n` is normalized to a non negative integer.
  *
  * @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])
+ * ```
  *
  * @category getters
  * @since 2.0.0
@@ -676,11 +740,13 @@ const drop = exports.drop = /*#__PURE__*/(0, _Function.dual)(2, (self, n) => {
  * **Note**. `n` is normalized to a non negative integer.
  *
  * @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])
+ * ```
  *
  * @category getters
  * @since 2.0.0
@@ -693,11 +759,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
+ * ```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])
+ * ```
  *
  * @category getters
  * @since 2.0.0
@@ -707,11 +775,13 @@ const dropWhile = exports.dropWhile = /*#__PURE__*/(0, _Function.dual)(2, (self,
  * Return the first index for which a predicate holds.
  *
  * @example
+ * ```ts
  * import { Array, Option } from "effect"
  *
  * const numbers = [5, 3, 8, 9]
  * const result = Array.findFirstIndex(numbers, x => x > 5)
  * assert.deepStrictEqual(result, Option.some(2))
+ * ```
  *
  * @category elements
  * @since 2.0.0
@@ -730,11 +800,13 @@ const findFirstIndex = exports.findFirstIndex = /*#__PURE__*/(0, _Function.dual)
  * Return the last index for which a predicate holds.
  *
  * @example
+ * ```ts
  * import { Array, Option } from "effect"
  *
  * const numbers = [1, 3, 8, 9]
  * const result = Array.findLastIndex(numbers, x => x < 5)
  * assert.deepStrictEqual(result, Option.some(1))
+ * ```
  *
  * @category elements
  * @since 2.0.0
@@ -753,11 +825,13 @@ const findLastIndex = exports.findLastIndex = /*#__PURE__*/(0, _Function.dual)(2
  * predicate, or `None` if no such element exists.
  *
  * @example
+ * ```ts
  * import { Array, Option } from "effect"
  *
  * const numbers = [1, 2, 3, 4, 5]
  * const result = Array.findFirst(numbers, x => x > 3)
  * assert.deepStrictEqual(result, Option.some(4))
+ * ```
  *
  * @category elements
  * @since 2.0.0
@@ -768,11 +842,13 @@ const findFirst = exports.findFirst = EffectIterable.findFirst;
  * Returns an `Option` containing the found element, or `Option.none` if no element matches.
  *
  * @example
+ * ```ts
  * import { Array, Option } from "effect"
  *
  * const numbers = [1, 2, 3, 4, 5]
  * const result = Array.findLast(numbers, n => n % 2 === 0)
  * assert.deepStrictEqual(result, Option.some(4))
+ * ```
  *
  * @category elements
  * @since 2.0.0
@@ -799,11 +875,13 @@ const findLast = exports.findLast = /*#__PURE__*/(0, _Function.dual)(2, (self, f
  * or return `None` if the index is out of bounds.
  *
  * @example
+ * ```ts
  * import { Array, Option } 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']))
+ * ```
  *
  * @since 2.0.0
  */
@@ -821,11 +899,13 @@ const insertAt = exports.insertAt = /*#__PURE__*/(0, _Function.dual)(3, (self, i
  * or return a copy of the input if the index is out of bounds.
  *
  * @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'])
+ * ```
  *
  * @since 2.0.0
  */
@@ -834,11 +914,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
+ * ```ts
  * import { Array, Option } from "effect"
  *
  * const numbers = [1, 2, 3]
  * const result = Array.replaceOption(numbers, 1, 4)
  * assert.deepStrictEqual(result, Option.some([1, 4, 3]))
+ * ```
  *
  * @since 2.0.0
  */
@@ -848,11 +930,13 @@ const replaceOption = exports.replaceOption = /*#__PURE__*/(0, _Function.dual)(3
  * or return a copy of the input if the index is out of bounds.
  *
  * @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])
+ * ```
  *
  * @since 2.0.0
  */
@@ -862,6 +946,7 @@ const modify = exports.modify = /*#__PURE__*/(0, _Function.dual)(3, (self, i, f)
  * or return `None` if the index is out of bounds.
  *
  * @example
+ * ```ts
  * import { Array, Option } from "effect"
  *
  * const numbers = [1, 2, 3, 4]
@@ -870,6 +955,7 @@ const modify = exports.modify = /*#__PURE__*/(0, _Function.dual)(3, (self, i, f)
  *
  * const outOfBoundsResult = Array.modifyOption(numbers, 5, (n) => n * 2)
  * assert.deepStrictEqual(outOfBoundsResult, Option.none())
+ * ```
  *
  * @since 2.0.0
  */
@@ -888,6 +974,7 @@ const modifyOption = exports.modifyOption = /*#__PURE__*/(0, _Function.dual)(3,
  * or return a copy of the input if the index is out of bounds.
  *
  * @example
+ * ```ts
  * import { Array } from "effect"
  *
  * const numbers = [1, 2, 3, 4]
@@ -896,6 +983,7 @@ const modifyOption = exports.modifyOption = /*#__PURE__*/(0, _Function.dual)(3,
  *
  * const outOfBoundsResult = Array.remove(numbers, 5)
  * assert.deepStrictEqual(outOfBoundsResult, [1, 2, 3, 4])
+ * ```
  *
  * @since 2.0.0
  */
@@ -911,11 +999,13 @@ const remove = exports.remove = /*#__PURE__*/(0, _Function.dual)(2, (self, i) =>
  * Reverse an `Iterable`, creating a new `Array`.
  *
  * @example
+ * ```ts
  * import { Array } from "effect"
  *
  * const numbers = [1, 2, 3, 4]
  * const result = Array.reverse(numbers)
  * assert.deepStrictEqual(result, [4, 3, 2, 1])
+ * ```
  *
  * @category elements
  * @since 2.0.0
@@ -940,6 +1030,7 @@ const sort = exports.sort = /*#__PURE__*/(0, _Function.dual)(2, (self, O) => {
  * order defines how those values should be sorted.
  *
  * @example
+ * ```ts
  * import { Array, Order } from "effect"
  *
  * const strings = ["aaa", "b", "cc"]
@@ -950,6 +1041,7 @@ const sort = exports.sort = /*#__PURE__*/(0, _Function.dual)(2, (self, O) => {
  * // The array of strings is sorted based on their lengths. The mapping function `(s) => s.length`
  * // converts each string into its length, and the `Order.number` specifies that the lengths should
  * // be sorted in ascending order.
+ * ```
  *
  * @since 2.0.0
  * @category elements
@@ -961,6 +1053,7 @@ const sortWith = exports.sortWith = /*#__PURE__*/(0, _Function.dual)(3, (self, f
  * second order if the first comparison is equal, and so on.
  *
  * @example
+ * ```ts
  * import { Array, Order } from "effect"
  *
  * const users = [
@@ -983,6 +1076,7 @@ const sortWith = exports.sortWith = /*#__PURE__*/(0, _Function.dual)(3, (self, f
  * // Explanation:
  * // The array of users is sorted first by age in ascending order. When ages are equal,
  * // the users are further sorted by name in ascending order.
+ * ```
  *
  * @category sorting
  * @since 2.0.0
@@ -1003,12 +1097,14 @@ const sortBy = (...orders) => {
  * longer `Iterable` are discarded.
  *
  * @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']])
+ * ```
  *
  * @category zipping
  * @since 2.0.0
@@ -1020,12 +1116,14 @@ const zip = exports.zip = /*#__PURE__*/(0, _Function.dual)(2, (self, that) => zi
  * input `Iterable` is short, excess elements of the longer `Iterable` are discarded.
  *
  * @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])
+ * ```
  *
  * @category zipping
  * @since 2.0.0
@@ -1047,10 +1145,12 @@ 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
+ * ```ts
  * import { Array } from "effect"
  *
  * const result = Array.unzip([[1, "a"], [2, "b"], [3, "c"]])
  * assert.deepStrictEqual(result, [[1, 2, 3], ['a', 'b', 'c']])
+ * ```
  *
  * @since 2.0.0
  */
@@ -1072,11 +1172,13 @@ const unzip = self => {
  * If the input is a non-empty array, the result is also a non-empty array.
  *
  * @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])
+ * ```
  *
  * @since 2.0.0
  */
@@ -1100,10 +1202,12 @@ const intersperse = exports.intersperse = /*#__PURE__*/(0, _Function.dual)(2, (s
  * Apply a function to the head, creating a new `NonEmptyReadonlyArray`.
  *
  * @example
+ * ```ts
  * import { Array } from "effect"
  *
  * const result = Array.modifyNonEmptyHead([1, 2, 3], n => n * 10)
  * assert.deepStrictEqual(result, [10, 2, 3])
+ * ```
  *
  * @since 2.0.0
  */
@@ -1112,10 +1216,12 @@ const modifyNonEmptyHead = exports.modifyNonEmptyHead = /*#__PURE__*/(0, _Functi
  * Change the head, creating a new `NonEmptyReadonlyArray`.
  *
  * @example
+ * ```ts
  * import { Array } from "effect"
  *
  * const result = Array.setNonEmptyHead([1, 2, 3], 10)
  * assert.deepStrictEqual(result, [10, 2, 3])
+ * ```
  *
  * @since 2.0.0
  */
@@ -1124,10 +1230,12 @@ const setNonEmptyHead = exports.setNonEmptyHead = /*#__PURE__*/(0, _Function.dua
  * Apply a function to the last element, creating a new `NonEmptyReadonlyArray`.
  *
  * @example
+ * ```ts
  * import { Array } from "effect"
  *
  * const result = Array.modifyNonEmptyLast([1, 2, 3], n => n * 2)
  * assert.deepStrictEqual(result, [1, 2, 6])
+ * ```
  *
  * @since 2.0.0
  */
@@ -1136,10 +1244,12 @@ const modifyNonEmptyLast = exports.modifyNonEmptyLast = /*#__PURE__*/(0, _Functi
  * Change the last element, creating a new `NonEmptyReadonlyArray`.
  *
  * @example
+ * ```ts
  * import { Array } from "effect"
  *
  * const result = Array.setNonEmptyLast([1, 2, 3], 4)
  * assert.deepStrictEqual(result, [1, 2, 4])
+ * ```
  *
  * @since 2.0.0
  */
@@ -1149,11 +1259,13 @@ const setNonEmptyLast = exports.setNonEmptyLast = /*#__PURE__*/(0, _Function.dua
  * If the input is a non-empty array, the result is also a non-empty array.
  *
  * @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'])
+ * ```
  *
  * @since 2.0.0
  */
@@ -1178,6 +1290,7 @@ 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
+ * ```ts
  * import { Array } from "effect"
  *
  * const numbers = [1, 2, 3, 4]
@@ -1185,6 +1298,7 @@ const rotate = exports.rotate = /*#__PURE__*/(0, _Function.dual)(2, (self, n) =>
  * const containsNumber = Array.containsWith(isEquivalent)
  * const result = containsNumber(3)(numbers)
  * assert.deepStrictEqual(result, true)
+ * ```
  *
  * @category elements
  * @since 2.0.0
@@ -1203,11 +1317,13 @@ const _equivalence = /*#__PURE__*/Equal.equivalence();
  * Returns a function that checks if a `ReadonlyArray` contains a given value using the default `Equivalence`.
  *
  * @example
+ * ```ts
  * import { Array } from "effect"
  *
  * const letters = ['a', 'b', 'c', 'd']
  * const result = Array.contains('c')(letters)
  * assert.deepStrictEqual(result, true)
+ * ```
  *
  * @category elements
  * @since 2.0.0
@@ -1219,6 +1335,7 @@ const contains = exports.contains = /*#__PURE__*/containsWith(_equivalence);
  * value and the rest of the `Array`.
  *
  * @example
+ * ```ts
  * import { Array } from "effect"
  *
  * const numbers = [1, 2, 3, 4, 5]
@@ -1229,6 +1346,7 @@ const contains = exports.contains = /*#__PURE__*/containsWith(_equivalence);
  * // The `chopFunction` takes the first element of the array, doubles it, and then returns it along with the rest of the array.
  * // The `chop` function applies this `chopFunction` recursively to the input array `[1, 2, 3, 4, 5]`,
  * // resulting in a new array `[2, 4, 6, 8, 10]`.
+ * ```
  *
  * @since 2.0.0
  */
@@ -1252,11 +1370,13 @@ const chop = exports.chop = /*#__PURE__*/(0, _Function.dual)(2, (self, f) => {
  * The value of `n` can be `0`.
  *
  * @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]])
+ * ```
  *
  * @category splitting
  * @since 2.0.0
@@ -1277,10 +1397,12 @@ const splitAt = exports.splitAt = /*#__PURE__*/(0, _Function.dual)(2, (self, n)
  * The value of `n` must be `>= 1`.
  *
  * @example
+ * ```ts
  * import { Array } from "effect"
  *
  * const result = Array.splitNonEmptyAt(["a", "b", "c", "d", "e"], 3)
  * assert.deepStrictEqual(result, [["a", "b", "c"], ["d", "e"]])
+ * ```
  *
  * @category splitting
  * @since 2.0.0
@@ -1293,11 +1415,13 @@ const splitNonEmptyAt = exports.splitNonEmptyAt = /*#__PURE__*/(0, _Function.dua
  * Splits this iterable into `n` equally sized arrays.
  *
  * @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]])
+ * ```
  *
  * @since 2.0.0
  * @category splitting
@@ -1311,11 +1435,13 @@ const split = exports.split = /*#__PURE__*/(0, _Function.dual)(2, (self, n) => {
  * Returns a tuple containing two arrays: the first one is before the match, and the second one is from the match onward.
  *
  * @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]])
+ * ```
  *
  * @category splitting
  * @since 2.0.0
@@ -1325,11 +1451,13 @@ const splitWhere = exports.splitWhere = /*#__PURE__*/(0, _Function.dual)(2, (sel
  * Copies an array.
  *
  * @example
+ * ```ts
  * import { Array } from "effect"
  *
  * const numbers = [1, 2, 3]
  * const copy = Array.copy(numbers)
  * assert.deepStrictEqual(copy, [1, 2, 3])
+ * ```
  *
  * @since 2.0.0
  */
@@ -1341,11 +1469,13 @@ const copy = self => self.slice();
  * If `n` is less than or equal to 0, the returned array will be an empty array.
  *
  * @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])
+ * ```
  *
  * @since 3.8.4
  */
@@ -1368,6 +1498,7 @@ const pad = exports.pad = /*#__PURE__*/(0, _Function.dual)(3, (self, n, fill) =>
  * whenever `n` evenly divides the length of `self`.
  *
  * @example
+ * ```ts
  * import { Array } from "effect"
  *
  * const numbers = [1, 2, 3, 4, 5]
@@ -1379,6 +1510,7 @@ const pad = exports.pad = /*#__PURE__*/(0, _Function.dual)(3, (self, n, fill) =>
  * // It splits the array into chunks of length 2. Since the array length is not evenly divisible by 2,
  * // the last chunk contains the remaining elements.
  * // The result is `[[1, 2], [3, 4], [5]]`.
+ * ```
  *
  * @category splitting
  * @since 2.0.0
@@ -1394,10 +1526,12 @@ 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
+ * ```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"]])
+ * ```
  *
  * @category grouping
  * @since 2.0.0
@@ -1420,10 +1554,12 @@ const groupWith = exports.groupWith = /*#__PURE__*/(0, _Function.dual)(2, (self,
  * Group equal, consecutive elements of a `NonEmptyReadonlyArray` into `NonEmptyArray`s.
  *
  * @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]])
+ * ```
  *
  * @category grouping
  * @since 2.0.0
@@ -1434,6 +1570,7 @@ const group = exports.group = /*#__PURE__*/groupWith( /*#__PURE__*/Equal.equival
  * function on each element, and grouping the results according to values returned
  *
  * @example
+ * ```ts
  * import { Array } from "effect"
  *
  * const people = [
@@ -1446,6 +1583,7 @@ const group = exports.group = /*#__PURE__*/groupWith( /*#__PURE__*/Equal.equival
  *   A: [{ name: "Alice", group: "A" }, { name: "Charlie", group: "A" }],
  *   B: [{ name: "Bob", group: "B" }]
  * })
+ * ```
  *
  * @category grouping
  * @since 2.0.0
@@ -1466,12 +1604,14 @@ const groupBy = exports.groupBy = /*#__PURE__*/(0, _Function.dual)(2, (self, f)
  * Calculates the union of two arrays using the provided equivalence relation.
  *
  * @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])
+ * ```
  *
  * @since 2.0.0
  */
@@ -1491,12 +1631,14 @@ const unionWith = exports.unionWith = /*#__PURE__*/(0, _Function.dual)(3, (self,
  * Creates a union of two arrays, removing duplicates.
  *
  * @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])
+ * ```
  *
  * @since 2.0.0
  */
@@ -1506,6 +1648,7 @@ const union = exports.union = /*#__PURE__*/(0, _Function.dual)(2, (self, that) =
  * The order and references of result values are determined by the first `Iterable`.
  *
  * @example
+ * ```ts
  * import { Array } from "effect"
  *
  * const array1 = [{ id: 1 }, { id: 2 }, { id: 3 }]
@@ -1513,6 +1656,7 @@ const union = exports.union = /*#__PURE__*/(0, _Function.dual)(2, (self, that) =
  * 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 }])
+ * ```
  *
  * @since 2.0.0
  */
@@ -1525,12 +1669,14 @@ const intersectionWith = isEquivalent => {
  * The order and references of result values are determined by the first `Iterable`.
  *
  * @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])
+ * ```
  *
  * @since 2.0.0
  */
@@ -1541,12 +1687,14 @@ const intersection = exports.intersection = /*#__PURE__*/intersectionWith(_equiv
  * The order and references of result values are determined by the first `Iterable`.
  *
  * @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])
+ * ```
  *
  * @since 2.0.0
  */
@@ -1559,12 +1707,14 @@ const differenceWith = isEquivalent => {
  * The order and references of result values are determined by the first `Iterable`.
  *
  * @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])
+ * ```
  *
  * @since 2.0.0
  */
@@ -1614,12 +1764,14 @@ const flatMap = exports.flatMap = /*#__PURE__*/(0, _Function.dual)(2, (self, f)
  * arrays is collapsed into a single, flat array.
  *
  * @example
+ * ```ts
  * import { Array } from "effect";
  *
  * const nestedArrays = [[1, 2], [], [3, 4], [], [5, 6]]
  * const result = Array.flatten(nestedArrays)
  *
  * assert.deepStrictEqual(result, [1, 2, 3, 4, 5, 6]);
+ * ```
  *
  * @category sequencing
  * @since 2.0.0
@@ -1630,6 +1782,7 @@ const flatten = exports.flatten = /*#__PURE__*/flatMap(_Function.identity);
  * This method combines filtering and mapping functionalities, allowing transformations and filtering of elements based on a single function pass.
  *
  * @example
+ * ```ts
  * import { Array, Option } from "effect";
  *
  * const data = [1, 2, 3, 4, 5];
@@ -1637,6 +1790,7 @@ const flatten = exports.flatten = /*#__PURE__*/flatMap(_Function.identity);
  * const result = Array.filterMap(data, evenSquares);
  *
  * assert.deepStrictEqual(result, [4, 16]);
+ * ```
  *
  * @category filtering
  * @since 2.0.0
@@ -1658,6 +1812,7 @@ const filterMap = exports.filterMap = /*#__PURE__*/(0, _Function.dual)(2, (self,
  * This is useful when you need to transform an array but only up to the point where a certain condition holds true.
  *
  * @example
+ * ```ts
  * import { Array, Option } from "effect";
  *
  * const data = [2, 4, 5];
@@ -1665,6 +1820,7 @@ const filterMap = exports.filterMap = /*#__PURE__*/(0, _Function.dual)(2, (self,
  * const result = Array.filterMapWhile(data, toSquareTillOdd);
  *
  * assert.deepStrictEqual(result, [4, 16]);
+ * ```
  *
  * @category filtering
  * @since 2.0.0
@@ -1690,6 +1846,7 @@ const filterMapWhile = exports.filterMapWhile = /*#__PURE__*/(0, _Function.dual)
  * into successes and failures.
  *
  * @example
+ * ```ts
  * import { Array, Either } from "effect";
  *
  * const data = [1, 2, 3, 4, 5]
@@ -1702,6 +1859,7 @@ const filterMapWhile = exports.filterMapWhile = /*#__PURE__*/(0, _Function.dual)
  *   [1, 3, 5],
  *   [2, 4]
  * ])
+ * ```
  *
  * @category filtering
  * @since 2.0.0
@@ -1724,12 +1882,14 @@ 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
+ * ```ts
  * import { Array, Option } from "effect"
  *
  * assert.deepStrictEqual(
  *   Array.getSomes([Option.some(1), Option.none(), Option.some(2)]),
  *   [1, 2]
  * )
+ * ```
  *
  * @category filtering
  * @since 2.0.0
@@ -1739,12 +1899,14 @@ const getSomes = exports.getSomes = /*#__PURE__*/filterMap(_Function.identity);
  * Retrieves the `Left` values from an `Iterable` of `Either`s, collecting them into an array.
  *
  * @example
+ * ```ts
  * import { Array, Either } from "effect"
  *
  * assert.deepStrictEqual(
  *   Array.getLefts([Either.right(1), Either.left("err"), Either.right(2)]),
  *   ["err"]
  * )
+ * ```
  *
  * @category filtering
  * @since 2.0.0
@@ -1762,12 +1924,14 @@ const getLefts = self => {
  * Retrieves the `Right` values from an `Iterable` of `Either`s, collecting them into an array.
  *
  * @example
+ * ```ts
  * import { Array, Either } from "effect"
  *
  * assert.deepStrictEqual(
  *   Array.getRights([Either.right(1), Either.left("err"), Either.right(2)]),
  *   [1, 2]
  * )
+ * ```
  *
  * @category filtering
  * @since 2.0.0
@@ -1820,11 +1984,13 @@ const partition = exports.partition = /*#__PURE__*/(0, _Function.dual)(2, (self,
  * Separates an `Iterable` into two arrays based on a predicate.
  *
  * @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]])
+ * ```
  *
  * @category filtering
  * @since 2.0.0
@@ -1834,11 +2000,13 @@ const separate = exports.separate = /*#__PURE__*/partitionMap(_Function.identity
  * Reduces an array from the left.
  *
  * @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)
+ * ```
  *
  * @category folding
  * @since 2.0.0
@@ -1848,11 +2016,13 @@ const reduce = exports.reduce = /*#__PURE__*/(0, _Function.dual)(3, (self, b, f)
  * Reduces an array from the right.
  *
  * @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)
+ * ```
  *
  * @category folding
  * @since 2.0.0
@@ -1862,12 +2032,14 @@ const reduceRight = exports.reduceRight = /*#__PURE__*/(0, _Function.dual)(3, (s
  * Lifts a predicate into an array.
  *
  * @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])
+ * ```
  *
  * @category lifting
  * @since 2.0.0
@@ -1895,6 +2067,7 @@ const liftNullable = f => (...a) => fromNullable(f(...a));
  * Maps over an array and flattens the result, removing null and undefined values.
  *
  * @example
+ * ```ts
  * import { Array } from "effect"
  *
  * const numbers = [1, 2, 3]
@@ -1905,6 +2078,7 @@ const liftNullable = f => (...a) => fromNullable(f(...a));
  * // The array of numbers [1, 2, 3] is mapped with a function that returns null for even numbers
  * // and the number itself for odd numbers. The resulting array [1, null, 3] is then flattened
  * // to remove null values, resulting in [1, 3].
+ * ```
  *
  * @category sequencing
  * @since 2.0.0
@@ -1917,6 +2091,7 @@ const flatMapNullable = exports.flatMapNullable = /*#__PURE__*/(0, _Function.dua
  * If the `Either` is a right, it returns an array with the right value.
  *
  * @example
+ * ```ts
  * import { Array, Either } from "effect"
  *
  * const parseNumber = (s: string): Either.Either<number, Error> =>
@@ -1934,6 +2109,7 @@ const flatMapNullable = exports.flatMapNullable = /*#__PURE__*/(0, _Function.dua
  * // The function parseNumber is lifted to return an array.
  * // When parsing "42", it returns an Either.left with the number 42, resulting in [42].
  * // When parsing "not a number", it returns an Either.right with an error, resulting in an empty array [].
+ * ```
  *
  * @category lifting
  * @since 2.0.0
@@ -1961,6 +2137,7 @@ 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
+ * ```ts
  * import { Array } from "effect"
  *
  * const numbers = [1, 2, 3]
@@ -1972,6 +2149,7 @@ const some = exports.some = /*#__PURE__*/(0, _Function.dual)(2, (self, predicate
  * // The subarrays are: [1, 2, 3], [2, 3], [3].
  * // The lengths are: 3, 2, 1.
  * // Therefore, the result is [3, 2, 1].
+ * ```
  *
  * @since 2.0.0
  */
@@ -1980,10 +2158,12 @@ const extend = exports.extend = /*#__PURE__*/(0, _Function.dual)(2, (self, f) =>
  * Finds the minimum element in an array based on a comparator.
  *
  * @example
+ * ```ts
  * import { Array, Order } from "effect"
  *
  * const min = Array.min([3, 1, 2], Order.number)
  * assert.deepStrictEqual(min, 1)
+ * ```
  *
  * @since 2.0.0
  */
@@ -1992,10 +2172,12 @@ const min = exports.min = /*#__PURE__*/(0, _Function.dual)(2, (self, O) => self.
  * Finds the maximum element in an array based on a comparator.
  *
  * @example
+ * ```ts
  * import { Array, Order } from "effect"
  *
  * const max = Array.max([3, 1, 2], Order.number)
  * assert.deepStrictEqual(max, 3)
+ * ```
  *
  * @since 2.0.0
  */
@@ -2030,12 +2212,14 @@ const getOrder = exports.getOrder = Order.array;
  * Creates an equivalence relation for arrays.
  *
  * @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)
+ * ```
  *
  * @category instances
  * @since 2.0.0
@@ -2045,10 +2229,12 @@ const getEquivalence = exports.getEquivalence = Equivalence.array;
  * Performs a side-effect for each element of the `Iterable`.
  *
  * @example
+ * ```ts
  * import { Array } from "effect"
  *
  * const numbers = [1, 2, 3]
  * Array.forEach(numbers, n => console.log(n)) // 1, 2, 3
+ * ```
  *
  * @since 2.0.0
  */
@@ -2058,11 +2244,13 @@ const forEach = exports.forEach = /*#__PURE__*/(0, _Function.dual)(2, (self, f)
  * preserving the order of the first occurrence of each element.
  *
  * @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])
+ * ```
  *
  * @since 2.0.0
  */
@@ -2091,11 +2279,13 @@ const dedupe = self => dedupeWith(self, Equal.equivalence());
  * Deduplicates adjacent elements that are identical using the provided `isEquivalent` function.
  *
  * @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])
+ * ```
  *
  * @since 2.0.0
  */
@@ -2115,11 +2305,13 @@ const dedupeAdjacentWith = exports.dedupeAdjacentWith = /*#__PURE__*/(0, _Functi
  * Deduplicates adjacent elements that are identical.
  *
  * @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])
+ * ```
  *
  * @since 2.0.0
  */
@@ -2128,11 +2320,13 @@ const dedupeAdjacent = exports.dedupeAdjacent = /*#__PURE__*/dedupeAdjacentWith(
  * Joins the elements together with "sep" in the middle.
  *
  * @example
+ * ```ts
  * import { Array } from "effect"
  *
  * const strings = ["a", "b", "c"]
  * const joined = Array.join(strings, "-")
  * assert.deepStrictEqual(joined, "a-b-c")
+ * ```
  *
  * @since 2.0.0
  * @category folding
@@ -2142,11 +2336,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
+ * ```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]])
+ * ```
  *
  * @since 2.0.0
  * @category folding
@@ -2167,12 +2363,14 @@ const mapAccum = exports.mapAccum = /*#__PURE__*/(0, _Function.dual)(3, (self, s
  * Zips this chunk crosswise with the specified chunk using the specified combiner.
  *
  * @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"])
+ * ```
  *
  * @since 2.0.0
  * @category elements
@@ -2182,12 +2380,14 @@ const cartesianWith = exports.cartesianWith = /*#__PURE__*/(0, _Function.dual)(3
  * Zips this chunk crosswise with the specified chunk.
  *
  * @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"]])
+ * ```
  *
  * @since 2.0.0
  * @category elements
@@ -2215,6 +2415,7 @@ const cartesian = exports.cartesian = /*#__PURE__*/(0, _Function.dual)(2, (self,
  * @see {@link let_ let}
  *
  * @example
+ * ```ts
  * import { Array as Arr, pipe } from "effect"
  * const doResult = pipe(
  *   Arr.Do,
@@ -2235,6 +2436,7 @@ const cartesian = exports.cartesian = /*#__PURE__*/(0, _Function.dual)(2, (self,
  *     if(_x < _y) result.push([_x, _y] as const)
  *   }
  * }
+ * ```
  *
  * @category do notation
  * @since 3.2.0
@@ -2259,6 +2461,7 @@ const Do = exports.Do = /*#__PURE__*/of({});
  * @see {@link let_ let}
  *
  * @example
+ * ```ts
  * import { Array as Arr, pipe } from "effect"
  * const doResult = pipe(
  *   Arr.Do,
@@ -2279,6 +2482,7 @@ const Do = exports.Do = /*#__PURE__*/of({});
  *     if(_x < _y) result.push([_x, _y] as const)
  *   }
  * }
+ * ```
  *
  * @category do notation
  * @since 3.2.0
@@ -2303,6 +2507,7 @@ const bind = exports.bind = /*#__PURE__*/doNotation.bind(map, flatMap);
  * @see {@link let_ let}
  *
  * @example
+ * ```ts
  * import { Array as Arr, pipe } from "effect"
  * const doResult = pipe(
  *   Arr.Do,
@@ -2323,6 +2528,7 @@ const bind = exports.bind = /*#__PURE__*/doNotation.bind(map, flatMap);
  *     if(_x < _y) result.push([_x, _y] as const)
  *   }
  * }
+ * ```
  *
  * @category do notation
  * @since 3.2.0