effect 3.10.18 → 3.11.0

package/src/Array.ts

@@ -47,10 +47,12 @@ export type NonEmptyArray<A> = [A, ...Array<A>]
  * 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
@@ -63,10 +65,12 @@ export const make = <Elements extends NonEmptyArray<any>>(
  * 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
@@ -79,9 +83,11 @@ export const allocate = <A = never>(n: number): Array<A | undefined> => new Arra
  * **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
@@ -99,9 +105,11 @@ export const makeBy = <A>(n: number, f: (i: number) => A): NonEmptyArray<A> => {
  * 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
@@ -115,9 +123,11 @@ export const range = (start: number, end: number): NonEmptyArray<number> =>
  * **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
@@ -129,9 +139,11 @@ export const replicate: {
    * **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
@@ -143,9 +155,11 @@ export const replicate: {
    * **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
@@ -159,11 +173,13 @@ export const replicate: {
  * 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
@@ -175,11 +191,13 @@ export const fromIterable = <A>(collection: Iterable<A>): Array<A> =>
  * 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
@@ -192,10 +210,12 @@ export const ensure = <A>(self: ReadonlyArray<A> | A): Array<A> => Array.isArray
  * @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
@@ -206,10 +226,12 @@ export const fromRecord: <K extends string, A>(self: Readonly<Record<K, A>>) =>
  * 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
@@ -220,6 +242,7 @@ export const fromOption: <A>(self: Option<A>) => Array<A> = 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({
@@ -228,6 +251,7 @@ export const fromOption: <A>(self: Option<A>) => Array<A> = O.toArray
  * })
  * assert.deepStrictEqual(match([]), "empty")
  * assert.deepStrictEqual(match([1, 2, 3]), "head: 1, tail: 2")
+ * ```
  *
  * @category pattern matching
  * @since 2.0.0
@@ -237,6 +261,7 @@ export const match: {
    * 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({
@@ -245,6 +270,7 @@ export const match: {
    * })
    * assert.deepStrictEqual(match([]), "empty")
    * assert.deepStrictEqual(match([1, 2, 3]), "head: 1, tail: 2")
+   * ```
    *
    * @category pattern matching
    * @since 2.0.0
@@ -259,6 +285,7 @@ export const match: {
    * 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({
@@ -267,6 +294,7 @@ export const match: {
    * })
    * assert.deepStrictEqual(match([]), "empty")
    * assert.deepStrictEqual(match([1, 2, 3]), "head: 1, tail: 2")
+   * ```
    *
    * @category pattern matching
    * @since 2.0.0
@@ -290,6 +318,7 @@ export const match: {
  * 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({
@@ -298,6 +327,7 @@ export const match: {
  * })
  * assert.deepStrictEqual(matchLeft([]), "empty")
  * assert.deepStrictEqual(matchLeft([1, 2, 3]), "head: 1, tail: 2")
+ * ```
  *
  * @category pattern matching
  * @since 2.0.0
@@ -307,6 +337,7 @@ export const matchLeft: {
    * 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({
@@ -315,6 +346,7 @@ export const matchLeft: {
    * })
    * assert.deepStrictEqual(matchLeft([]), "empty")
    * assert.deepStrictEqual(matchLeft([1, 2, 3]), "head: 1, tail: 2")
+   * ```
    *
    * @category pattern matching
    * @since 2.0.0
@@ -329,6 +361,7 @@ export const matchLeft: {
    * 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({
@@ -337,6 +370,7 @@ export const matchLeft: {
    * })
    * assert.deepStrictEqual(matchLeft([]), "empty")
    * assert.deepStrictEqual(matchLeft([1, 2, 3]), "head: 1, tail: 2")
+   * ```
    *
    * @category pattern matching
    * @since 2.0.0
@@ -360,6 +394,7 @@ export const matchLeft: {
  * 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({
@@ -368,6 +403,7 @@ export const matchLeft: {
  * })
  * assert.deepStrictEqual(matchRight([]), "empty")
  * assert.deepStrictEqual(matchRight([1, 2, 3]), "init: 2, last: 3")
+ * ```
  *
  * @category pattern matching
  * @since 2.0.0
@@ -377,6 +413,7 @@ export const matchRight: {
    * 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({
@@ -385,6 +422,7 @@ export const matchRight: {
    * })
    * assert.deepStrictEqual(matchRight([]), "empty")
    * assert.deepStrictEqual(matchRight([1, 2, 3]), "init: 2, last: 3")
+   * ```
    *
    * @category pattern matching
    * @since 2.0.0
@@ -399,6 +437,7 @@ export const matchRight: {
    * 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({
@@ -407,6 +446,7 @@ export const matchRight: {
    * })
    * assert.deepStrictEqual(matchRight([]), "empty")
    * assert.deepStrictEqual(matchRight([1, 2, 3]), "init: 2, last: 3")
+   * ```
    *
    * @category pattern matching
    * @since 2.0.0
@@ -433,11 +473,13 @@ export const matchRight: {
  * 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
@@ -447,11 +489,13 @@ export const prepend: {
    * 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
@@ -461,11 +505,13 @@ export const prepend: {
    * 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
@@ -478,12 +524,14 @@ export const prepend: {
  * 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
@@ -494,12 +542,14 @@ export const prependAll: {
    * 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
@@ -512,12 +562,14 @@ export const prependAll: {
    * 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
@@ -528,12 +580,14 @@ export const prependAll: {
    * 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
@@ -544,12 +598,14 @@ export const prependAll: {
    * 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
@@ -564,11 +620,13 @@ export const prependAll: {
  * 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
@@ -578,11 +636,13 @@ export const append: {
    * 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
@@ -592,11 +652,13 @@ export const append: {
    * 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
@@ -657,6 +719,7 @@ export const appendAll: {
  * a value through a series of transformations.
  *
  * @example
+ * ```ts
  * import { Array } from "effect";
  *
  * const numbers = [1, 2, 3, 4]
@@ -668,6 +731,7 @@ export const appendAll: {
  * // 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
@@ -679,6 +743,7 @@ export const scan: {
    * a value through a series of transformations.
    *
    * @example
+   * ```ts
    * import { Array } from "effect";
    *
    * const numbers = [1, 2, 3, 4]
@@ -690,6 +755,7 @@ export const scan: {
    * // 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
@@ -701,6 +767,7 @@ export const scan: {
    * a value through a series of transformations.
    *
    * @example
+   * ```ts
    * import { Array } from "effect";
    *
    * const numbers = [1, 2, 3, 4]
@@ -712,6 +779,7 @@ export const scan: {
    * // 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
@@ -733,11 +801,13 @@ export const scan: {
  * 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
@@ -749,11 +819,13 @@ export const scanRight: {
    * 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
@@ -765,11 +837,13 @@ export const scanRight: {
    * 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
@@ -791,10 +865,12 @@ export const scanRight: {
  * @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
@@ -806,10 +882,12 @@ export const isArray: {
    * @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
@@ -821,10 +899,12 @@ export const isArray: {
    * @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
@@ -838,10 +918,12 @@ export const 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
@@ -854,10 +936,12 @@ export const isEmptyArray = <A>(self: Array<A>): self is [] => 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
@@ -872,10 +956,12 @@ export const isEmptyReadonlyArray: <A>(self: ReadonlyArray<A>) => self is readon
  * @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
@@ -890,10 +976,12 @@ export const isNonEmptyArray: <A>(self: Array<A>) => self is NonEmptyArray<A> =
  * @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
@@ -972,10 +1060,12 @@ export const unsafeGet: {
  * 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
@@ -988,10 +1078,12 @@ export const unprepend = <A>(
  * 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
@@ -1012,10 +1104,12 @@ export const head: <A>(self: ReadonlyArray<A>) => Option<A> = 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
@@ -1035,10 +1129,12 @@ export const last = <A>(self: ReadonlyArray<A>): Option<A> =>
  * 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
@@ -1060,10 +1156,12 @@ export const tail = <A>(self: Iterable<A>): Option<Array<A>> => {
  * 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
@@ -1085,10 +1183,12 @@ export const init = <A>(self: Iterable<A>): Option<Array<A>> => {
  * 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
@@ -1101,11 +1201,13 @@ export const initNonEmpty = <A>(self: NonEmptyReadonlyArray<A>): Array<A> => sel
  * **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
@@ -1117,11 +1219,13 @@ export const take: {
    * **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
@@ -1133,11 +1237,13 @@ export const take: {
    * **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
@@ -1154,11 +1260,13 @@ export const take: {
  * **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
@@ -1170,11 +1278,13 @@ export const takeRight: {
    * **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
@@ -1186,11 +1296,13 @@ export const takeRight: {
    * **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
@@ -1206,6 +1318,7 @@ export const takeRight: {
  * 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]
@@ -1217,6 +1330,7 @@ export const takeRight: {
  * // - 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
@@ -1226,6 +1340,7 @@ export const takeWhile: {
    * 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]
@@ -1237,6 +1352,7 @@ export const takeWhile: {
    * // - 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
@@ -1246,6 +1362,7 @@ export const takeWhile: {
    * 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]
@@ -1257,6 +1374,7 @@ export const takeWhile: {
    * // - 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
@@ -1266,6 +1384,7 @@ export const takeWhile: {
    * 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]
@@ -1277,6 +1396,7 @@ export const takeWhile: {
    * // - 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
@@ -1286,6 +1406,7 @@ export const takeWhile: {
    * 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]
@@ -1297,6 +1418,7 @@ export const takeWhile: {
    * // - 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
@@ -1393,11 +1515,13 @@ export const 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
@@ -1409,11 +1533,13 @@ export const drop: {
    * **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
@@ -1425,11 +1551,13 @@ export const drop: {
    * **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
@@ -1446,11 +1574,13 @@ export const drop: {
  * **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
@@ -1462,11 +1592,13 @@ export const dropRight: {
    * **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
@@ -1478,11 +1610,13 @@ export const dropRight: {
    * **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
@@ -1497,11 +1631,13 @@ export const dropRight: {
  * 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
@@ -1511,11 +1647,13 @@ export const dropWhile: {
    * 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
@@ -1525,11 +1663,13 @@ export const dropWhile: {
    * 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
@@ -1545,11 +1685,13 @@ export const dropWhile: {
  * 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
@@ -1559,11 +1701,13 @@ export const findFirstIndex: {
    * 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
@@ -1573,11 +1717,13 @@ export const findFirstIndex: {
    * 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
@@ -1598,11 +1744,13 @@ export const findFirstIndex: {
  * 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
@@ -1612,11 +1760,13 @@ export const findLastIndex: {
    * 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
@@ -1626,11 +1776,13 @@ export const findLastIndex: {
    * 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
@@ -1651,11 +1803,13 @@ export const findLastIndex: {
  * 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
@@ -1666,11 +1820,13 @@ export const findFirst: {
    * 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
@@ -1681,11 +1837,13 @@ export const findFirst: {
    * 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
@@ -1696,11 +1854,13 @@ export const findFirst: {
    * 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
@@ -1711,11 +1871,13 @@ export const findFirst: {
    * 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
@@ -1726,11 +1888,13 @@ export const findFirst: {
    * 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
@@ -1741,11 +1905,13 @@ export const findFirst: {
    * 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
@@ -1758,11 +1924,13 @@ export const 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
@@ -1773,11 +1941,13 @@ export const findLast: {
    * 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
@@ -1788,11 +1958,13 @@ export const findLast: {
    * 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
@@ -1803,11 +1975,13 @@ export const findLast: {
    * 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
@@ -1818,11 +1992,13 @@ export const findLast: {
    * 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
@@ -1833,11 +2009,13 @@ export const findLast: {
    * 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
@@ -1848,11 +2026,13 @@ export const findLast: {
    * 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
@@ -1884,11 +2064,13 @@ export const findLast: {
  * 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
  */
@@ -1898,11 +2080,13 @@ export const insertAt: {
    * 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
    */
@@ -1912,11 +2096,13 @@ export const insertAt: {
    * 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
    */
@@ -1936,11 +2122,13 @@ export const insertAt: {
  * 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
  */
@@ -1950,11 +2138,13 @@ export const replace: {
    * 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
    */
@@ -1966,11 +2156,13 @@ export const replace: {
    * 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
    */
@@ -1985,11 +2177,13 @@ export const replace: {
  * 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
  */
@@ -1998,11 +2192,13 @@ export const replaceOption: {
    * 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
    */
@@ -2014,11 +2210,13 @@ export const replaceOption: {
    * 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
    */
@@ -2037,11 +2235,13 @@ export const replaceOption: {
  * 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
  */
@@ -2051,11 +2251,13 @@ export const modify: {
    * 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
    */
@@ -2068,11 +2270,13 @@ export const modify: {
    * 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
    */
@@ -2092,6 +2296,7 @@ export const modify: {
  * or return `None` if the index is out of bounds.
  *
  * @example
+ * ```ts
  * import { Array, Option } from "effect"
  *
  * const numbers = [1, 2, 3, 4]
@@ -2100,6 +2305,7 @@ export const modify: {
  *
  * const outOfBoundsResult = Array.modifyOption(numbers, 5, (n) => n * 2)
  * assert.deepStrictEqual(outOfBoundsResult, Option.none())
+ * ```
  *
  * @since 2.0.0
  */
@@ -2109,6 +2315,7 @@ export const modifyOption: {
    * or return `None` if the index is out of bounds.
    *
    * @example
+   * ```ts
    * import { Array, Option } from "effect"
    *
    * const numbers = [1, 2, 3, 4]
@@ -2117,6 +2324,7 @@ export const modifyOption: {
    *
    * const outOfBoundsResult = Array.modifyOption(numbers, 5, (n) => n * 2)
    * assert.deepStrictEqual(outOfBoundsResult, Option.none())
+   * ```
    *
    * @since 2.0.0
    */
@@ -2129,6 +2337,7 @@ export const modifyOption: {
    * or return `None` if the index is out of bounds.
    *
    * @example
+   * ```ts
    * import { Array, Option } from "effect"
    *
    * const numbers = [1, 2, 3, 4]
@@ -2137,6 +2346,7 @@ export const modifyOption: {
    *
    * const outOfBoundsResult = Array.modifyOption(numbers, 5, (n) => n * 2)
    * assert.deepStrictEqual(outOfBoundsResult, Option.none())
+   * ```
    *
    * @since 2.0.0
    */
@@ -2161,6 +2371,7 @@ export const modifyOption: {
  * 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]
@@ -2169,6 +2380,7 @@ export const modifyOption: {
  *
  * const outOfBoundsResult = Array.remove(numbers, 5)
  * assert.deepStrictEqual(outOfBoundsResult, [1, 2, 3, 4])
+ * ```
  *
  * @since 2.0.0
  */
@@ -2178,6 +2390,7 @@ export const remove: {
    * 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]
@@ -2186,6 +2399,7 @@ export const remove: {
    *
    * const outOfBoundsResult = Array.remove(numbers, 5)
    * assert.deepStrictEqual(outOfBoundsResult, [1, 2, 3, 4])
+   * ```
    *
    * @since 2.0.0
    */
@@ -2195,6 +2409,7 @@ export const remove: {
    * 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]
@@ -2203,6 +2418,7 @@ export const remove: {
    *
    * const outOfBoundsResult = Array.remove(numbers, 5)
    * assert.deepStrictEqual(outOfBoundsResult, [1, 2, 3, 4])
+   * ```
    *
    * @since 2.0.0
    */
@@ -2220,11 +2436,13 @@ export const remove: {
  * 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
@@ -2280,6 +2498,7 @@ export const sort: {
  * order defines how those values should be sorted.
  *
  * @example
+ * ```ts
  * import { Array, Order } from "effect"
  *
  * const strings = ["aaa", "b", "cc"]
@@ -2290,6 +2509,7 @@ export const sort: {
  * // 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
@@ -2301,6 +2521,7 @@ export const sortWith: {
    * order defines how those values should be sorted.
    *
    * @example
+   * ```ts
    * import { Array, Order } from "effect"
    *
    * const strings = ["aaa", "b", "cc"]
@@ -2311,6 +2532,7 @@ export const sortWith: {
    * // 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
@@ -2325,6 +2547,7 @@ export const sortWith: {
    * order defines how those values should be sorted.
    *
    * @example
+   * ```ts
    * import { Array, Order } from "effect"
    *
    * const strings = ["aaa", "b", "cc"]
@@ -2335,6 +2558,7 @@ export const sortWith: {
    * // 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
@@ -2346,6 +2570,7 @@ export const sortWith: {
    * order defines how those values should be sorted.
    *
    * @example
+   * ```ts
    * import { Array, Order } from "effect"
    *
    * const strings = ["aaa", "b", "cc"]
@@ -2356,6 +2581,7 @@ export const sortWith: {
    * // 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
@@ -2373,6 +2599,7 @@ export const sortWith: {
  * second order if the first comparison is equal, and so on.
  *
  * @example
+ * ```ts
  * import { Array, Order } from "effect"
  *
  * const users = [
@@ -2395,6 +2622,7 @@ export const sortWith: {
  * // 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
@@ -2420,12 +2648,14 @@ export const sortBy = <S extends Iterable<any> | NonEmptyReadonlyArray<any>>(
  * 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
@@ -2437,12 +2667,14 @@ export const zip: {
    * 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
@@ -2454,12 +2686,14 @@ export const zip: {
    * 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
@@ -2471,12 +2705,14 @@ export const zip: {
    * 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
@@ -2488,12 +2724,14 @@ export const zip: {
    * 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
@@ -2509,12 +2747,14 @@ export const zip: {
  * 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
@@ -2525,12 +2765,14 @@ export const zipWith: {
    * 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
@@ -2541,12 +2783,14 @@ export const zipWith: {
    * 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
@@ -2557,12 +2801,14 @@ export const zipWith: {
    * 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
@@ -2577,12 +2823,14 @@ export const zipWith: {
    * 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
@@ -2606,10 +2854,12 @@ export const zipWith: {
  * 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
  */
@@ -2636,11 +2886,13 @@ export const unzip: <S extends Iterable<readonly [any, any]> | NonEmptyReadonlyA
  * 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
  */
@@ -2650,11 +2902,13 @@ export const intersperse: {
    * 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
    */
@@ -2664,11 +2918,13 @@ export const intersperse: {
    * 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
    */
@@ -2678,11 +2934,13 @@ export const intersperse: {
    * 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
    */
@@ -2707,10 +2965,12 @@ export const intersperse: {
  * 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
  */
@@ -2719,10 +2979,12 @@ export const modifyNonEmptyHead: {
    * 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
    */
@@ -2731,10 +2993,12 @@ export const modifyNonEmptyHead: {
    * 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
    */
@@ -2751,10 +3015,12 @@ export const modifyNonEmptyHead: {
  * 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
  */
@@ -2763,10 +3029,12 @@ export const setNonEmptyHead: {
    * 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
    */
@@ -2775,10 +3043,12 @@ export const setNonEmptyHead: {
    * 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
    */
@@ -2792,10 +3062,12 @@ export const setNonEmptyHead: {
  * 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
  */
@@ -2804,10 +3076,12 @@ export const modifyNonEmptyLast: {
    * 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
    */
@@ -2816,10 +3090,12 @@ export const modifyNonEmptyLast: {
    * 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
    */
@@ -2834,10 +3110,12 @@ export const modifyNonEmptyLast: {
  * 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
  */
@@ -2846,10 +3124,12 @@ export const setNonEmptyLast: {
    * 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
    */
@@ -2858,10 +3138,12 @@ export const setNonEmptyLast: {
    * 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
    */
@@ -2876,11 +3158,13 @@ export const setNonEmptyLast: {
  * 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
  */
@@ -2890,11 +3174,13 @@ export const rotate: {
    * 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
    */
@@ -2904,11 +3190,13 @@ export const rotate: {
    * 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
    */
@@ -2918,11 +3206,13 @@ export const rotate: {
    * 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
    */
@@ -2949,6 +3239,7 @@ export const rotate: {
  * 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]
@@ -2956,6 +3247,7 @@ export const rotate: {
  * const containsNumber = Array.containsWith(isEquivalent)
  * const result = containsNumber(3)(numbers)
  * assert.deepStrictEqual(result, true)
+ * ```
  *
  * @category elements
  * @since 2.0.0
@@ -2979,11 +3271,13 @@ const _equivalence = 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
@@ -2993,11 +3287,13 @@ export const contains: {
    * 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
@@ -3007,11 +3303,13 @@ export const contains: {
    * 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
@@ -3025,6 +3323,7 @@ export const contains: {
  * value and the rest of the `Array`.
  *
  * @example
+ * ```ts
  * import { Array } from "effect"
  *
  * const numbers = [1, 2, 3, 4, 5]
@@ -3035,6 +3334,7 @@ export const contains: {
  * // 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
  */
@@ -3045,6 +3345,7 @@ export const chop: {
    * value and the rest of the `Array`.
    *
    * @example
+   * ```ts
    * import { Array } from "effect"
    *
    * const numbers = [1, 2, 3, 4, 5]
@@ -3055,6 +3356,7 @@ export const chop: {
    * // 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
    */
@@ -3067,6 +3369,7 @@ export const chop: {
    * value and the rest of the `Array`.
    *
    * @example
+   * ```ts
    * import { Array } from "effect"
    *
    * const numbers = [1, 2, 3, 4, 5]
@@ -3077,6 +3380,7 @@ export const chop: {
    * // 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
    */
@@ -3090,6 +3394,7 @@ export const chop: {
    * value and the rest of the `Array`.
    *
    * @example
+   * ```ts
    * import { Array } from "effect"
    *
    * const numbers = [1, 2, 3, 4, 5]
@@ -3100,6 +3405,7 @@ export const chop: {
    * // 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
    */
@@ -3131,11 +3437,13 @@ export const chop: {
  * 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
@@ -3146,11 +3454,13 @@ export const splitAt: {
    * 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
@@ -3161,11 +3471,13 @@ export const splitAt: {
    * 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
@@ -3188,10 +3500,12 @@ export const splitAt: {
  * 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
@@ -3202,10 +3516,12 @@ export const splitNonEmptyAt: {
    * 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
@@ -3216,10 +3532,12 @@ export const splitNonEmptyAt: {
    * 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
@@ -3236,11 +3554,13 @@ export const splitNonEmptyAt: {
  * 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
@@ -3250,11 +3570,13 @@ export const split: {
    * 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
@@ -3264,11 +3586,13 @@ export const split: {
    * 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
@@ -3284,11 +3608,13 @@ export const split: {
  * 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
@@ -3299,11 +3625,13 @@ export const splitWhere: {
    * 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
@@ -3316,11 +3644,13 @@ export const splitWhere: {
    * 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
@@ -3336,11 +3666,13 @@ export const splitWhere: {
  * 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
  */
@@ -3349,11 +3681,13 @@ export const copy: {
    * 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
    */
@@ -3362,11 +3696,13 @@ export const copy: {
    * 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
    */
@@ -3380,11 +3716,13 @@ export const copy: {
  * 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
  */
@@ -3396,11 +3734,13 @@ export const pad: {
    * 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
    */
@@ -3414,11 +3754,13 @@ export const pad: {
    * 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
    */
@@ -3445,6 +3787,7 @@ export const pad: {
  * whenever `n` evenly divides the length of `self`.
  *
  * @example
+ * ```ts
  * import { Array } from "effect"
  *
  * const numbers = [1, 2, 3, 4, 5]
@@ -3456,6 +3799,7 @@ export const pad: {
  * // 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
@@ -3473,6 +3817,7 @@ export const chunksOf: {
    * whenever `n` evenly divides the length of `self`.
    *
    * @example
+   * ```ts
    * import { Array } from "effect"
    *
    * const numbers = [1, 2, 3, 4, 5]
@@ -3484,6 +3829,7 @@ export const chunksOf: {
    * // 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
@@ -3503,6 +3849,7 @@ export const chunksOf: {
    * whenever `n` evenly divides the length of `self`.
    *
    * @example
+   * ```ts
    * import { Array } from "effect"
    *
    * const numbers = [1, 2, 3, 4, 5]
@@ -3514,6 +3861,7 @@ export const chunksOf: {
    * // 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
@@ -3531,6 +3879,7 @@ export const chunksOf: {
    * whenever `n` evenly divides the length of `self`.
    *
    * @example
+   * ```ts
    * import { Array } from "effect"
    *
    * const numbers = [1, 2, 3, 4, 5]
@@ -3542,6 +3891,7 @@ export const chunksOf: {
    * // 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
@@ -3559,10 +3909,12 @@ export const chunksOf: {
  * 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
@@ -3572,10 +3924,12 @@ export const groupWith: {
    * 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
@@ -3585,10 +3939,12 @@ export const groupWith: {
    * 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
@@ -3620,10 +3976,12 @@ export const groupWith: {
  * 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
@@ -3637,6 +3995,7 @@ export const group: <A>(self: NonEmptyReadonlyArray<A>) => NonEmptyArray<NonEmpt
  * function on each element, and grouping the results according to values returned
  *
  * @example
+ * ```ts
  * import { Array } from "effect"
  *
  * const people = [
@@ -3649,6 +4008,7 @@ export const group: <A>(self: NonEmptyReadonlyArray<A>) => NonEmptyArray<NonEmpt
  *   A: [{ name: "Alice", group: "A" }, { name: "Charlie", group: "A" }],
  *   B: [{ name: "Bob", group: "B" }]
  * })
+ * ```
  *
  * @category grouping
  * @since 2.0.0
@@ -3659,6 +4019,7 @@ export const groupBy: {
    * function on each element, and grouping the results according to values returned
    *
    * @example
+   * ```ts
    * import { Array } from "effect"
    *
    * const people = [
@@ -3671,6 +4032,7 @@ export const groupBy: {
    *   A: [{ name: "Alice", group: "A" }, { name: "Charlie", group: "A" }],
    *   B: [{ name: "Bob", group: "B" }]
    * })
+   * ```
    *
    * @category grouping
    * @since 2.0.0
@@ -3683,6 +4045,7 @@ export const groupBy: {
    * function on each element, and grouping the results according to values returned
    *
    * @example
+   * ```ts
    * import { Array } from "effect"
    *
    * const people = [
@@ -3695,6 +4058,7 @@ export const groupBy: {
    *   A: [{ name: "Alice", group: "A" }, { name: "Charlie", group: "A" }],
    *   B: [{ name: "Bob", group: "B" }]
    * })
+   * ```
    *
    * @category grouping
    * @since 2.0.0
@@ -3723,12 +4087,14 @@ export const groupBy: {
  * 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
  */
@@ -3737,12 +4103,14 @@ export const unionWith: {
    * 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
    */
@@ -3754,12 +4122,14 @@ export const unionWith: {
    * 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
    */
@@ -3772,12 +4142,14 @@ export const unionWith: {
    * 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
    */
@@ -3790,12 +4162,14 @@ export const unionWith: {
    * 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
    */
@@ -3821,12 +4195,14 @@ export const unionWith: {
  * 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
  */
@@ -3835,12 +4211,14 @@ export const union: {
    * 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
    */
@@ -3851,12 +4229,14 @@ export const union: {
    * 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
    */
@@ -3865,12 +4245,14 @@ export const union: {
    * 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
    */
@@ -3879,12 +4261,14 @@ export const union: {
    * 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
    */
@@ -3896,6 +4280,7 @@ export const union: {
  * 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 }]
@@ -3903,6 +4288,7 @@ export const union: {
  * 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
  */
@@ -3922,12 +4308,14 @@ export const intersectionWith = <A>(isEquivalent: (self: A, that: A) => boolean)
  * 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
  */
@@ -3937,12 +4325,14 @@ export const intersection: {
    * 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
    */
@@ -3952,12 +4342,14 @@ export const intersection: {
    * 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
    */
@@ -3969,12 +4361,14 @@ export const intersection: {
  * 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
  */
@@ -3994,12 +4388,14 @@ export const differenceWith = <A>(isEquivalent: (self: A, that: A) => boolean):
  * 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
  */
@@ -4009,12 +4405,14 @@ export const difference: {
    * 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
    */
@@ -4024,12 +4422,14 @@ export const difference: {
    * 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
    */
@@ -4173,12 +4573,14 @@ export const flatMap: {
  * 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
@@ -4192,6 +4594,7 @@ export const flatten: <S extends ReadonlyArray<ReadonlyArray<any>>>(self: S) =>
  * 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];
@@ -4199,6 +4602,7 @@ export const flatten: <S extends ReadonlyArray<ReadonlyArray<any>>>(self: S) =>
  * const result = Array.filterMap(data, evenSquares);
  *
  * assert.deepStrictEqual(result, [4, 16]);
+ * ```
  *
  * @category filtering
  * @since 2.0.0
@@ -4209,6 +4613,7 @@ export const filterMap: {
    * 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];
@@ -4216,6 +4621,7 @@ export const filterMap: {
    * const result = Array.filterMap(data, evenSquares);
    *
    * assert.deepStrictEqual(result, [4, 16]);
+   * ```
    *
    * @category filtering
    * @since 2.0.0
@@ -4226,6 +4632,7 @@ export const filterMap: {
    * 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];
@@ -4233,6 +4640,7 @@ export const filterMap: {
    * const result = Array.filterMap(data, evenSquares);
    *
    * assert.deepStrictEqual(result, [4, 16]);
+   * ```
    *
    * @category filtering
    * @since 2.0.0
@@ -4259,6 +4667,7 @@ export const filterMap: {
  * 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];
@@ -4266,6 +4675,7 @@ export const filterMap: {
  * const result = Array.filterMapWhile(data, toSquareTillOdd);
  *
  * assert.deepStrictEqual(result, [4, 16]);
+ * ```
  *
  * @category filtering
  * @since 2.0.0
@@ -4277,6 +4687,7 @@ export const filterMapWhile: {
    * 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];
@@ -4284,6 +4695,7 @@ export const filterMapWhile: {
    * const result = Array.filterMapWhile(data, toSquareTillOdd);
    *
    * assert.deepStrictEqual(result, [4, 16]);
+   * ```
    *
    * @category filtering
    * @since 2.0.0
@@ -4295,6 +4707,7 @@ export const filterMapWhile: {
    * 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];
@@ -4302,6 +4715,7 @@ export const filterMapWhile: {
    * const result = Array.filterMapWhile(data, toSquareTillOdd);
    *
    * assert.deepStrictEqual(result, [4, 16]);
+   * ```
    *
    * @category filtering
    * @since 2.0.0
@@ -4329,6 +4743,7 @@ export const filterMapWhile: {
  * into successes and failures.
  *
  * @example
+ * ```ts
  * import { Array, Either } from "effect";
  *
  * const data = [1, 2, 3, 4, 5]
@@ -4341,6 +4756,7 @@ export const filterMapWhile: {
  *   [1, 3, 5],
  *   [2, 4]
  * ])
+ * ```
  *
  * @category filtering
  * @since 2.0.0
@@ -4353,6 +4769,7 @@ export const partitionMap: {
    * into successes and failures.
    *
    * @example
+   * ```ts
    * import { Array, Either } from "effect";
    *
    * const data = [1, 2, 3, 4, 5]
@@ -4365,6 +4782,7 @@ export const partitionMap: {
    *   [1, 3, 5],
    *   [2, 4]
    * ])
+   * ```
    *
    * @category filtering
    * @since 2.0.0
@@ -4377,6 +4795,7 @@ export const partitionMap: {
    * into successes and failures.
    *
    * @example
+   * ```ts
    * import { Array, Either } from "effect";
    *
    * const data = [1, 2, 3, 4, 5]
@@ -4389,6 +4808,7 @@ export const partitionMap: {
    *   [1, 3, 5],
    *   [2, 4]
    * ])
+   * ```
    *
    * @category filtering
    * @since 2.0.0
@@ -4416,12 +4836,14 @@ export const partitionMap: {
  * 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
@@ -4435,12 +4857,14 @@ export const getSomes: <T extends Iterable<Option<X>>, X = any>(
  * 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
@@ -4460,12 +4884,14 @@ export const getLefts = <T extends Iterable<array_<any, any>>>(self: T): Array<a
  * 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
@@ -4585,11 +5011,13 @@ export const partition: {
  * 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
@@ -4604,11 +5032,13 @@ export const separate: <T extends Iterable<array_<any, any>>>(
  * 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
@@ -4618,11 +5048,13 @@ export const reduce: {
    * 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
@@ -4632,11 +5064,13 @@ export const reduce: {
    * 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
@@ -4652,11 +5086,13 @@ export const reduce: {
  * 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
@@ -4666,11 +5102,13 @@ export const reduceRight: {
    * 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
@@ -4680,11 +5118,13 @@ export const reduceRight: {
    * 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
@@ -4700,12 +5140,14 @@ export const reduceRight: {
  * 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
@@ -4716,12 +5158,14 @@ export const liftPredicate: { // Note: I intentionally avoid using the NoInfer p
    * 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
@@ -4757,6 +5201,7 @@ export const liftNullable = <A extends Array<unknown>, B>(
  * Maps over an array and flattens the result, removing null and undefined values.
  *
  * @example
+ * ```ts
  * import { Array } from "effect"
  *
  * const numbers = [1, 2, 3]
@@ -4767,6 +5212,7 @@ export const liftNullable = <A extends Array<unknown>, B>(
  * // 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
@@ -4776,6 +5222,7 @@ export const flatMapNullable: {
    * Maps over an array and flattens the result, removing null and undefined values.
    *
    * @example
+   * ```ts
    * import { Array } from "effect"
    *
    * const numbers = [1, 2, 3]
@@ -4786,6 +5233,7 @@ export const flatMapNullable: {
    * // 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
@@ -4795,6 +5243,7 @@ export const flatMapNullable: {
    * Maps over an array and flattens the result, removing null and undefined values.
    *
    * @example
+   * ```ts
    * import { Array } from "effect"
    *
    * const numbers = [1, 2, 3]
@@ -4805,6 +5254,7 @@ export const flatMapNullable: {
    * // 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
@@ -4822,6 +5272,7 @@ export const flatMapNullable: {
  * 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> =>
@@ -4839,6 +5290,7 @@ export const flatMapNullable: {
  * // 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
@@ -4925,6 +5377,7 @@ export const some: {
  * Extends an array with a function that maps each subarray to a value.
  *
  * @example
+ * ```ts
  * import { Array } from "effect"
  *
  * const numbers = [1, 2, 3]
@@ -4936,6 +5389,7 @@ export const some: {
  * // 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
  */
@@ -4944,6 +5398,7 @@ export const extend: {
    * Extends an array with a function that maps each subarray to a value.
    *
    * @example
+   * ```ts
    * import { Array } from "effect"
    *
    * const numbers = [1, 2, 3]
@@ -4955,6 +5410,7 @@ export const extend: {
    * // 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
    */
@@ -4963,6 +5419,7 @@ export const extend: {
    * Extends an array with a function that maps each subarray to a value.
    *
    * @example
+   * ```ts
    * import { Array } from "effect"
    *
    * const numbers = [1, 2, 3]
@@ -4974,6 +5431,7 @@ export const extend: {
    * // 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
    */
@@ -4987,10 +5445,12 @@ export const extend: {
  * 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
  */
@@ -4999,10 +5459,12 @@ export const min: {
    * 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
    */
@@ -5011,10 +5473,12 @@ export const min: {
    * 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
    */
@@ -5025,10 +5489,12 @@ export const min: {
  * 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
  */
@@ -5037,10 +5503,12 @@ export const max: {
    * 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
    */
@@ -5049,10 +5517,12 @@ export const max: {
    * 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
    */
@@ -5090,12 +5560,14 @@ export const getOrder: <A>(O: Order.Order<A>) => Order.Order<ReadonlyArray<A>> =
  * 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
@@ -5108,10 +5580,12 @@ export const getEquivalence: <A>(
  * 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
  */
@@ -5120,10 +5594,12 @@ export const forEach: {
    * 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
    */
@@ -5132,10 +5608,12 @@ export const forEach: {
    * 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
    */
@@ -5147,11 +5625,13 @@ export const forEach: {
  * 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
  */
@@ -5161,11 +5641,13 @@ export const dedupeWith: {
    * 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
    */
@@ -5177,11 +5659,13 @@ export const dedupeWith: {
    * 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
    */
@@ -5194,11 +5678,13 @@ export const dedupeWith: {
    * 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
    */
@@ -5236,11 +5722,13 @@ export const dedupe = <S extends Iterable<any> | NonEmptyReadonlyArray<any>>(
  * 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
  */
@@ -5249,11 +5737,13 @@ export const dedupeAdjacentWith: {
    * 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
    */
@@ -5262,11 +5752,13 @@ export const dedupeAdjacentWith: {
    * 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
    */
@@ -5287,11 +5779,13 @@ export const dedupeAdjacentWith: {
  * 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
  */
@@ -5301,11 +5795,13 @@ export const dedupeAdjacent: <A>(self: Iterable<A>) => Array<A> = dedupeAdjacent
  * 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
@@ -5315,11 +5811,13 @@ export const join: {
    * 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
@@ -5329,11 +5827,13 @@ export const join: {
    * 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
@@ -5345,11 +5845,13 @@ export const 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
@@ -5359,11 +5861,13 @@ export const mapAccum: {
    * 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
@@ -5376,11 +5880,13 @@ export const mapAccum: {
    * 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
@@ -5410,12 +5916,14 @@ export const mapAccum: {
  * 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
@@ -5425,12 +5933,14 @@ export const cartesianWith: {
    * 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
@@ -5440,12 +5950,14 @@ export const cartesianWith: {
    * 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
@@ -5461,12 +5973,14 @@ export const cartesianWith: {
  * 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
@@ -5476,12 +5990,14 @@ export const cartesian: {
    * 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
@@ -5491,12 +6007,14 @@ export const cartesian: {
    * 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
@@ -5530,6 +6048,7 @@ export const cartesian: {
  * @see {@link let_ let}
  *
  * @example
+ * ```ts
  * import { Array as Arr, pipe } from "effect"
  * const doResult = pipe(
  *   Arr.Do,
@@ -5550,6 +6069,7 @@ export const cartesian: {
  *     if(_x < _y) result.push([_x, _y] as const)
  *   }
  * }
+ * ```
  *
  * @category do notation
  * @since 3.2.0
@@ -5575,6 +6095,7 @@ export const Do: ReadonlyArray<{}> = of({})
  * @see {@link let_ let}
  *
  * @example
+ * ```ts
  * import { Array as Arr, pipe } from "effect"
  * const doResult = pipe(
  *   Arr.Do,
@@ -5595,6 +6116,7 @@ export const Do: ReadonlyArray<{}> = of({})
  *     if(_x < _y) result.push([_x, _y] as const)
  *   }
  * }
+ * ```
  *
  * @category do notation
  * @since 3.2.0
@@ -5619,6 +6141,7 @@ export const bind: {
    * @see {@link let_ let}
    *
    * @example
+   * ```ts
    * import { Array as Arr, pipe } from "effect"
    * const doResult = pipe(
    *   Arr.Do,
@@ -5639,6 +6162,7 @@ export const bind: {
    *     if(_x < _y) result.push([_x, _y] as const)
    *   }
    * }
+   * ```
    *
    * @category do notation
    * @since 3.2.0
@@ -5665,6 +6189,7 @@ export const bind: {
    * @see {@link let_ let}
    *
    * @example
+   * ```ts
    * import { Array as Arr, pipe } from "effect"
    * const doResult = pipe(
    *   Arr.Do,
@@ -5685,6 +6210,7 @@ export const bind: {
    *     if(_x < _y) result.push([_x, _y] as const)
    *   }
    * }
+   * ```
    *
    * @category do notation
    * @since 3.2.0
@@ -5715,6 +6241,7 @@ export const bind: {
  * @see {@link let_ let}
  *
  * @example
+ * ```ts
  * import { Array as Arr, pipe } from "effect"
  * const doResult = pipe(
  *   Arr.Do,
@@ -5735,6 +6262,7 @@ export const bind: {
  *     if(_x < _y) result.push([_x, _y] as const)
  *   }
  * }
+ * ```
  *
  * @category do notation
  * @since 3.2.0
@@ -5759,6 +6287,7 @@ export const bindTo: {
    * @see {@link let_ let}
    *
    * @example
+   * ```ts
    * import { Array as Arr, pipe } from "effect"
    * const doResult = pipe(
    *   Arr.Do,
@@ -5779,6 +6308,7 @@ export const bindTo: {
    *     if(_x < _y) result.push([_x, _y] as const)
    *   }
    * }
+   * ```
    *
    * @category do notation
    * @since 3.2.0
@@ -5803,6 +6333,7 @@ export const bindTo: {
    * @see {@link let_ let}
    *
    * @example
+   * ```ts
    * import { Array as Arr, pipe } from "effect"
    * const doResult = pipe(
    *   Arr.Do,
@@ -5823,6 +6354,7 @@ export const bindTo: {
    *     if(_x < _y) result.push([_x, _y] as const)
    *   }
    * }
+   * ```
    *
    * @category do notation
    * @since 3.2.0
@@ -5862,6 +6394,7 @@ export {
    * @see {@link Do}
    *
    * @example
+   * ```ts
    * import { Array as Arr, pipe } from "effect"
    * const doResult = pipe(
    *   Arr.Do,
@@ -5883,6 +6416,7 @@ export {
    *   }
    * }
    *
+   * ```
    * @category do notation
    * @since 3.2.0
    */