effect 3.10.18 → 3.11.0

package/dist/esm/Array.js

@@ -19,10 +19,12 @@ import * as Tuple from "./Tuple.js";
  * 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
@@ -32,10 +34,12 @@ export 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
@@ -47,9 +51,11 @@ export 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
@@ -66,9 +72,11 @@ export 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
@@ -80,9 +88,11 @@ export const range = (start, end) => start <= end ? makeBy(end - start + 1, i =>
  * **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
@@ -94,11 +104,13 @@ export const replicate = /*#__PURE__*/dual(2, (a, n) => makeBy(n, () => a));
  * 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
@@ -108,11 +120,13 @@ export const fromIterable = collection => Array.isArray(collection) ? collection
  * 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
@@ -124,10 +138,12 @@ export 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
@@ -137,10 +153,12 @@ export const 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
@@ -150,6 +168,7 @@ export const 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({
@@ -158,6 +177,7 @@ export const fromOption = O.toArray;
  * })
  * assert.deepStrictEqual(match([]), "empty")
  * assert.deepStrictEqual(match([1, 2, 3]), "head: 1, tail: 2")
+ * ```
  *
  * @category pattern matching
  * @since 2.0.0
@@ -170,6 +190,7 @@ 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
+ * ```ts
  * import { Array } from "effect"
  *
  * const matchLeft = Array.matchLeft({
@@ -178,6 +199,7 @@ export const match = /*#__PURE__*/dual(2, (self, {
  * })
  * assert.deepStrictEqual(matchLeft([]), "empty")
  * assert.deepStrictEqual(matchLeft([1, 2, 3]), "head: 1, tail: 2")
+ * ```
  *
  * @category pattern matching
  * @since 2.0.0
@@ -190,6 +212,7 @@ 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
+ * ```ts
  * import { Array } from "effect"
  *
  * const matchRight = Array.matchRight({
@@ -198,6 +221,7 @@ export const matchLeft = /*#__PURE__*/dual(2, (self, {
  * })
  * assert.deepStrictEqual(matchRight([]), "empty")
  * assert.deepStrictEqual(matchRight([1, 2, 3]), "init: 2, last: 3")
+ * ```
  *
  * @category pattern matching
  * @since 2.0.0
@@ -210,11 +234,13 @@ export const matchRight = /*#__PURE__*/dual(2, (self, {
  * 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
@@ -225,12 +251,14 @@ export const prepend = /*#__PURE__*/dual(2, (self, head) => [head, ...self]);
  * 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
@@ -240,11 +268,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
+ * ```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
@@ -264,6 +294,7 @@ export const appendAll = /*#__PURE__*/dual(2, (self, that) => fromIterable(self)
  * a value through a series of transformations.
  *
  * @example
+ * ```ts
  * import { Array } from "effect";
  *
  * const numbers = [1, 2, 3, 4]
@@ -275,6 +306,7 @@ export const appendAll = /*#__PURE__*/dual(2, (self, that) => fromIterable(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
@@ -294,11 +326,13 @@ export const scan = /*#__PURE__*/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
@@ -318,10 +352,12 @@ export const scanRight = /*#__PURE__*/dual(3, (self, b, f) => {
  * @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
@@ -333,10 +369,12 @@ export const 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
@@ -348,10 +386,12 @@ export 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
@@ -365,10 +405,12 @@ export const 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
@@ -382,10 +424,12 @@ export const 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
@@ -427,10 +471,12 @@ 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
+ * ```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
@@ -440,10 +486,12 @@ 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
+ * ```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
@@ -460,10 +508,12 @@ export const 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
@@ -480,10 +530,12 @@ export const last = self => isNonEmptyReadonlyArray(self) ? O.some(lastNonEmpty(
  * 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
@@ -503,10 +555,12 @@ export 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
@@ -526,10 +580,12 @@ export 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
@@ -541,11 +597,13 @@ export 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
@@ -560,11 +618,13 @@ export const take = /*#__PURE__*/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
@@ -578,6 +638,7 @@ 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
+ * ```ts
  * import { Array } from "effect"
  *
  * const numbers = [1, 3, 2, 4, 1, 2]
@@ -589,6 +650,7 @@ export const takeRight = /*#__PURE__*/dual(2, (self, n) => {
  * // - 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
@@ -631,11 +693,13 @@ export const span = /*#__PURE__*/dual(2, (self, predicate) => splitAt(self, span
  * **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
@@ -650,11 +714,13 @@ export const drop = /*#__PURE__*/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
@@ -667,11 +733,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
+ * ```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
@@ -681,11 +749,13 @@ export const dropWhile = /*#__PURE__*/dual(2, (self, predicate) => fromIterable(
  * 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
@@ -704,11 +774,13 @@ export const findFirstIndex = /*#__PURE__*/dual(2, (self, predicate) => {
  * 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
@@ -727,11 +799,13 @@ export const findLastIndex = /*#__PURE__*/dual(2, (self, predicate) => {
  * 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
@@ -742,11 +816,13 @@ export const 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
@@ -773,11 +849,13 @@ export const findLast = /*#__PURE__*/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
  */
@@ -795,11 +873,13 @@ export const insertAt = /*#__PURE__*/dual(3, (self, i, b) => {
  * 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
  */
@@ -808,11 +888,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
+ * ```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
  */
@@ -822,11 +904,13 @@ export const replaceOption = /*#__PURE__*/dual(3, (self, i, b) => modifyOption(s
  * 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
  */
@@ -836,6 +920,7 @@ export const modify = /*#__PURE__*/dual(3, (self, i, f) => O.getOrElse(modifyOpt
  * or return `None` if the index is out of bounds.
  *
  * @example
+ * ```ts
  * import { Array, Option } from "effect"
  *
  * const numbers = [1, 2, 3, 4]
@@ -844,6 +929,7 @@ export const modify = /*#__PURE__*/dual(3, (self, i, f) => O.getOrElse(modifyOpt
  *
  * const outOfBoundsResult = Array.modifyOption(numbers, 5, (n) => n * 2)
  * assert.deepStrictEqual(outOfBoundsResult, Option.none())
+ * ```
  *
  * @since 2.0.0
  */
@@ -862,6 +948,7 @@ export const modifyOption = /*#__PURE__*/dual(3, (self, i, f) => {
  * 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]
@@ -870,6 +957,7 @@ export const modifyOption = /*#__PURE__*/dual(3, (self, i, f) => {
  *
  * const outOfBoundsResult = Array.remove(numbers, 5)
  * assert.deepStrictEqual(outOfBoundsResult, [1, 2, 3, 4])
+ * ```
  *
  * @since 2.0.0
  */
@@ -885,11 +973,13 @@ export const remove = /*#__PURE__*/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
@@ -913,6 +1003,7 @@ export const sort = /*#__PURE__*/dual(2, (self, O) => {
  * order defines how those values should be sorted.
  *
  * @example
+ * ```ts
  * import { Array, Order } from "effect"
  *
  * const strings = ["aaa", "b", "cc"]
@@ -923,6 +1014,7 @@ export const sort = /*#__PURE__*/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
@@ -934,6 +1026,7 @@ export const sortWith = /*#__PURE__*/dual(3, (self, f, order) => Array.from(self
  * second order if the first comparison is equal, and so on.
  *
  * @example
+ * ```ts
  * import { Array, Order } from "effect"
  *
  * const users = [
@@ -956,6 +1049,7 @@ export const sortWith = /*#__PURE__*/dual(3, (self, f, order) => Array.from(self
  * // 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
@@ -976,12 +1070,14 @@ export 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
@@ -992,12 +1088,14 @@ export const zip = /*#__PURE__*/dual(2, (self, that) => zipWith(self, that, Tupl
  * 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
@@ -1019,10 +1117,12 @@ 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
+ * ```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
  */
@@ -1044,11 +1144,13 @@ export 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
  */
@@ -1071,10 +1173,12 @@ export const intersperse = /*#__PURE__*/dual(2, (self, middle) => {
  * 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
  */
@@ -1083,10 +1187,12 @@ export const modifyNonEmptyHead = /*#__PURE__*/dual(2, (self, f) => [f(headNonEm
  * 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
  */
@@ -1095,10 +1201,12 @@ export const setNonEmptyHead = /*#__PURE__*/dual(2, (self, b) => modifyNonEmptyH
  * 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
  */
@@ -1107,10 +1215,12 @@ export const modifyNonEmptyLast = /*#__PURE__*/dual(2, (self, f) => append(initN
  * 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
  */
@@ -1120,11 +1230,13 @@ export const setNonEmptyLast = /*#__PURE__*/dual(2, (self, b) => modifyNonEmptyL
  * 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
  */
@@ -1149,6 +1261,7 @@ 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
+ * ```ts
  * import { Array } from "effect"
  *
  * const numbers = [1, 2, 3, 4]
@@ -1156,6 +1269,7 @@ export const rotate = /*#__PURE__*/dual(2, (self, n) => {
  * const containsNumber = Array.containsWith(isEquivalent)
  * const result = containsNumber(3)(numbers)
  * assert.deepStrictEqual(result, true)
+ * ```
  *
  * @category elements
  * @since 2.0.0
@@ -1173,11 +1287,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
@@ -1189,6 +1305,7 @@ export const contains = /*#__PURE__*/containsWith(_equivalence);
  * value and the rest of the `Array`.
  *
  * @example
+ * ```ts
  * import { Array } from "effect"
  *
  * const numbers = [1, 2, 3, 4, 5]
@@ -1199,6 +1316,7 @@ export const 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
  */
@@ -1222,11 +1340,13 @@ export const chop = /*#__PURE__*/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
@@ -1247,10 +1367,12 @@ export const splitAt = /*#__PURE__*/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
@@ -1263,11 +1385,13 @@ export const splitNonEmptyAt = /*#__PURE__*/dual(2, (self, n) => {
  * 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
@@ -1281,11 +1405,13 @@ export const split = /*#__PURE__*/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
@@ -1295,11 +1421,13 @@ export const splitWhere = /*#__PURE__*/dual(2, (self, predicate) => span(self, (
  * 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
  */
@@ -1311,11 +1439,13 @@ export 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
  */
@@ -1337,6 +1467,7 @@ export const pad = /*#__PURE__*/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]
@@ -1348,6 +1479,7 @@ export const pad = /*#__PURE__*/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
@@ -1363,10 +1495,12 @@ export const chunksOf = /*#__PURE__*/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
@@ -1389,10 +1523,12 @@ export const groupWith = /*#__PURE__*/dual(2, (self, isEquivalent) => chop(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
@@ -1403,6 +1539,7 @@ export const group = /*#__PURE__*/groupWith( /*#__PURE__*/Equal.equivalence());
  * function on each element, and grouping the results according to values returned
  *
  * @example
+ * ```ts
  * import { Array } from "effect"
  *
  * const people = [
@@ -1415,6 +1552,7 @@ export const group = /*#__PURE__*/groupWith( /*#__PURE__*/Equal.equivalence());
  *   A: [{ name: "Alice", group: "A" }, { name: "Charlie", group: "A" }],
  *   B: [{ name: "Bob", group: "B" }]
  * })
+ * ```
  *
  * @category grouping
  * @since 2.0.0
@@ -1435,12 +1573,14 @@ export const groupBy = /*#__PURE__*/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
  */
@@ -1460,12 +1600,14 @@ export const unionWith = /*#__PURE__*/dual(3, (self, that, isEquivalent) => {
  * 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
  */
@@ -1475,6 +1617,7 @@ export const union = /*#__PURE__*/dual(2, (self, that) => unionWith(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 }]
@@ -1482,6 +1625,7 @@ export const union = /*#__PURE__*/dual(2, (self, that) => unionWith(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
  */
@@ -1494,12 +1638,14 @@ export 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
  */
@@ -1509,12 +1655,14 @@ export const intersection = /*#__PURE__*/intersectionWith(_equivalence);
  * 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
  */
@@ -1527,12 +1675,14 @@ export 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
  */
@@ -1579,12 +1729,14 @@ export const flatMap = /*#__PURE__*/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
@@ -1595,6 +1747,7 @@ export const flatten = /*#__PURE__*/flatMap(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];
@@ -1602,6 +1755,7 @@ export const flatten = /*#__PURE__*/flatMap(identity);
  * const result = Array.filterMap(data, evenSquares);
  *
  * assert.deepStrictEqual(result, [4, 16]);
+ * ```
  *
  * @category filtering
  * @since 2.0.0
@@ -1623,6 +1777,7 @@ export const filterMap = /*#__PURE__*/dual(2, (self, f) => {
  * 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];
@@ -1630,6 +1785,7 @@ export const filterMap = /*#__PURE__*/dual(2, (self, f) => {
  * const result = Array.filterMapWhile(data, toSquareTillOdd);
  *
  * assert.deepStrictEqual(result, [4, 16]);
+ * ```
  *
  * @category filtering
  * @since 2.0.0
@@ -1655,6 +1811,7 @@ export const filterMapWhile = /*#__PURE__*/dual(2, (self, f) => {
  * into successes and failures.
  *
  * @example
+ * ```ts
  * import { Array, Either } from "effect";
  *
  * const data = [1, 2, 3, 4, 5]
@@ -1667,6 +1824,7 @@ export const filterMapWhile = /*#__PURE__*/dual(2, (self, f) => {
  *   [1, 3, 5],
  *   [2, 4]
  * ])
+ * ```
  *
  * @category filtering
  * @since 2.0.0
@@ -1689,12 +1847,14 @@ export const partitionMap = /*#__PURE__*/dual(2, (self, f) => {
  * 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
@@ -1704,12 +1864,14 @@ export const getSomes = /*#__PURE__*/filterMap(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
@@ -1727,12 +1889,14 @@ export 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
@@ -1783,11 +1947,13 @@ export const partition = /*#__PURE__*/dual(2, (self, predicate) => {
  * 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
@@ -1797,11 +1963,13 @@ export const separate = /*#__PURE__*/partitionMap(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
@@ -1811,11 +1979,13 @@ export const reduce = /*#__PURE__*/dual(3, (self, b, f) => fromIterable(self).re
  * 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
@@ -1825,12 +1995,14 @@ export const reduceRight = /*#__PURE__*/dual(3, (self, b, f) => fromIterable(sel
  * 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
@@ -1855,6 +2027,7 @@ export 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]
@@ -1865,6 +2038,7 @@ export 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
@@ -1876,6 +2050,7 @@ export const flatMapNullable = /*#__PURE__*/dual(2, (self, f) => flatMap(self, a
  * 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> =>
@@ -1893,6 +2068,7 @@ export const flatMapNullable = /*#__PURE__*/dual(2, (self, f) => flatMap(self, a
  * // 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
@@ -1919,6 +2095,7 @@ 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
+ * ```ts
  * import { Array } from "effect"
  *
  * const numbers = [1, 2, 3]
@@ -1930,6 +2107,7 @@ export const some = /*#__PURE__*/dual(2, (self, predicate) => self.some(predicat
  * // 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
  */
@@ -1938,10 +2116,12 @@ 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
+ * ```ts
  * import { Array, Order } from "effect"
  *
  * const min = Array.min([3, 1, 2], Order.number)
  * assert.deepStrictEqual(min, 1)
+ * ```
  *
  * @since 2.0.0
  */
@@ -1950,10 +2130,12 @@ 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
+ * ```ts
  * import { Array, Order } from "effect"
  *
  * const max = Array.max([3, 1, 2], Order.number)
  * assert.deepStrictEqual(max, 3)
+ * ```
  *
  * @since 2.0.0
  */
@@ -1987,12 +2169,14 @@ export const 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
@@ -2002,10 +2186,12 @@ export const 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
  */
@@ -2015,11 +2201,13 @@ export const forEach = /*#__PURE__*/dual(2, (self, f) => fromIterable(self).forE
  * 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
  */
@@ -2048,11 +2236,13 @@ export 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
  */
@@ -2071,11 +2261,13 @@ export const dedupeAdjacentWith = /*#__PURE__*/dual(2, (self, isEquivalent) => {
  * 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
  */
@@ -2084,11 +2276,13 @@ export const dedupeAdjacent = /*#__PURE__*/dedupeAdjacentWith( /*#__PURE__*/Equa
  * 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
@@ -2098,11 +2292,13 @@ export const join = /*#__PURE__*/dual(2, (self, sep) => fromIterable(self).join(
  * 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
@@ -2123,12 +2319,14 @@ export const mapAccum = /*#__PURE__*/dual(3, (self, s, f) => {
  * 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
@@ -2138,12 +2336,14 @@ export const cartesianWith = /*#__PURE__*/dual(3, (self, that, f) => flatMap(sel
  * 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
@@ -2171,6 +2371,7 @@ export const cartesian = /*#__PURE__*/dual(2, (self, that) => cartesianWith(self
  * @see {@link let_ let}
  *
  * @example
+ * ```ts
  * import { Array as Arr, pipe } from "effect"
  * const doResult = pipe(
  *   Arr.Do,
@@ -2191,6 +2392,7 @@ export const cartesian = /*#__PURE__*/dual(2, (self, that) => cartesianWith(self
  *     if(_x < _y) result.push([_x, _y] as const)
  *   }
  * }
+ * ```
  *
  * @category do notation
  * @since 3.2.0
@@ -2215,6 +2417,7 @@ export const Do = /*#__PURE__*/of({});
  * @see {@link let_ let}
  *
  * @example
+ * ```ts
  * import { Array as Arr, pipe } from "effect"
  * const doResult = pipe(
  *   Arr.Do,
@@ -2235,6 +2438,7 @@ export const Do = /*#__PURE__*/of({});
  *     if(_x < _y) result.push([_x, _y] as const)
  *   }
  * }
+ * ```
  *
  * @category do notation
  * @since 3.2.0
@@ -2259,6 +2463,7 @@ export const bind = /*#__PURE__*/doNotation.bind(map, flatMap);
  * @see {@link let_ let}
  *
  * @example
+ * ```ts
  * import { Array as Arr, pipe } from "effect"
  * const doResult = pipe(
  *   Arr.Do,
@@ -2279,6 +2484,7 @@ export const bind = /*#__PURE__*/doNotation.bind(map, flatMap);
  *     if(_x < _y) result.push([_x, _y] as const)
  *   }
  * }
+ * ```
  *
  * @category do notation
  * @since 3.2.0
@@ -2305,6 +2511,7 @@ export {
  * @see {@link Do}
  *
  * @example
+ * ```ts
  * import { Array as Arr, pipe } from "effect"
  * const doResult = pipe(
  *   Arr.Do,
@@ -2326,6 +2533,7 @@ export {
  *   }
  * }
  *
+ * ```
  * @category do notation
  * @since 3.2.0
  */