effect 3.10.18 → 3.11.0

package/dist/dts/Array.d.ts

@@ -33,10 +33,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
@@ -46,10 +48,12 @@ export declare const make: <Elements extends NonEmptyArray<any>>(...elements: El
  * 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
@@ -61,9 +65,11 @@ export declare const allocate: <A = never>(n: number) => Array<A | undefined>;
  * **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
@@ -73,9 +79,11 @@ export declare const makeBy: <A>(n: number, f: (i: number) => A) => NonEmptyArra
  * 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
@@ -87,9 +95,11 @@ export declare 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
@@ -101,9 +111,11 @@ export declare 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
@@ -115,9 +127,11 @@ export declare 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
@@ -130,11 +144,13 @@ export declare 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
@@ -144,11 +160,13 @@ export declare 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
@@ -160,10 +178,12 @@ export declare const ensure: <A>(self: ReadonlyArray<A> | A) => Array<A>;
  * @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
@@ -173,10 +193,12 @@ export declare const fromRecord: <K extends string, A>(self: Readonly<Record<K,
  * 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
@@ -186,6 +208,7 @@ export declare const fromOption: <A>(self: Option<A>) => Array<A>;
  * 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({
@@ -194,6 +217,7 @@ export declare const fromOption: <A>(self: Option<A>) => Array<A>;
  * })
  * assert.deepStrictEqual(match([]), "empty")
  * assert.deepStrictEqual(match([1, 2, 3]), "head: 1, tail: 2")
+ * ```
  *
  * @category pattern matching
  * @since 2.0.0
@@ -203,6 +227,7 @@ export declare 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({
@@ -211,6 +236,7 @@ export declare const match: {
      * })
      * assert.deepStrictEqual(match([]), "empty")
      * assert.deepStrictEqual(match([1, 2, 3]), "head: 1, tail: 2")
+     * ```
      *
      * @category pattern matching
      * @since 2.0.0
@@ -223,6 +249,7 @@ export declare 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({
@@ -231,6 +258,7 @@ export declare const match: {
      * })
      * assert.deepStrictEqual(match([]), "empty")
      * assert.deepStrictEqual(match([1, 2, 3]), "head: 1, tail: 2")
+     * ```
      *
      * @category pattern matching
      * @since 2.0.0
@@ -244,6 +272,7 @@ export declare 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({
@@ -252,6 +281,7 @@ export declare const match: {
  * })
  * assert.deepStrictEqual(matchLeft([]), "empty")
  * assert.deepStrictEqual(matchLeft([1, 2, 3]), "head: 1, tail: 2")
+ * ```
  *
  * @category pattern matching
  * @since 2.0.0
@@ -261,6 +291,7 @@ export declare 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({
@@ -269,6 +300,7 @@ export declare const matchLeft: {
      * })
      * assert.deepStrictEqual(matchLeft([]), "empty")
      * assert.deepStrictEqual(matchLeft([1, 2, 3]), "head: 1, tail: 2")
+     * ```
      *
      * @category pattern matching
      * @since 2.0.0
@@ -281,6 +313,7 @@ export declare 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({
@@ -289,6 +322,7 @@ export declare const matchLeft: {
      * })
      * assert.deepStrictEqual(matchLeft([]), "empty")
      * assert.deepStrictEqual(matchLeft([1, 2, 3]), "head: 1, tail: 2")
+     * ```
      *
      * @category pattern matching
      * @since 2.0.0
@@ -302,6 +336,7 @@ export declare 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({
@@ -310,6 +345,7 @@ export declare const matchLeft: {
  * })
  * assert.deepStrictEqual(matchRight([]), "empty")
  * assert.deepStrictEqual(matchRight([1, 2, 3]), "init: 2, last: 3")
+ * ```
  *
  * @category pattern matching
  * @since 2.0.0
@@ -319,6 +355,7 @@ export declare 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({
@@ -327,6 +364,7 @@ export declare const matchRight: {
      * })
      * assert.deepStrictEqual(matchRight([]), "empty")
      * assert.deepStrictEqual(matchRight([1, 2, 3]), "init: 2, last: 3")
+     * ```
      *
      * @category pattern matching
      * @since 2.0.0
@@ -339,6 +377,7 @@ export declare 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({
@@ -347,6 +386,7 @@ export declare const matchRight: {
      * })
      * assert.deepStrictEqual(matchRight([]), "empty")
      * assert.deepStrictEqual(matchRight([1, 2, 3]), "init: 2, last: 3")
+     * ```
      *
      * @category pattern matching
      * @since 2.0.0
@@ -360,11 +400,13 @@ export declare 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
@@ -374,11 +416,13 @@ export declare 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
@@ -388,11 +432,13 @@ export declare 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
@@ -404,12 +450,14 @@ export declare 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
@@ -420,12 +468,14 @@ export declare 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
@@ -436,12 +486,14 @@ export declare 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
@@ -452,12 +504,14 @@ export declare 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
@@ -468,12 +522,14 @@ export declare 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
@@ -484,11 +540,13 @@ export declare 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
@@ -498,11 +556,13 @@ export declare 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
@@ -512,11 +572,13 @@ export declare 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
@@ -570,6 +632,7 @@ export declare const appendAll: {
  * a value through a series of transformations.
  *
  * @example
+ * ```ts
  * import { Array } from "effect";
  *
  * const numbers = [1, 2, 3, 4]
@@ -581,6 +644,7 @@ export declare 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
@@ -592,6 +656,7 @@ export declare const scan: {
      * a value through a series of transformations.
      *
      * @example
+     * ```ts
      * import { Array } from "effect";
      *
      * const numbers = [1, 2, 3, 4]
@@ -603,6 +668,7 @@ export declare 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
@@ -614,6 +680,7 @@ export declare const scan: {
      * a value through a series of transformations.
      *
      * @example
+     * ```ts
      * import { Array } from "effect";
      *
      * const numbers = [1, 2, 3, 4]
@@ -625,6 +692,7 @@ export declare 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
@@ -637,11 +705,13 @@ export declare 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
@@ -653,11 +723,13 @@ export declare 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
@@ -669,11 +741,13 @@ export declare 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
@@ -686,10 +760,12 @@ export declare 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
@@ -701,10 +777,12 @@ export declare 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
@@ -716,10 +794,12 @@ export declare 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
@@ -732,10 +812,12 @@ export declare 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
@@ -747,10 +829,12 @@ export declare const isEmptyArray: <A>(self: Array<A>) => self is [];
  * @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
@@ -764,10 +848,12 @@ export declare const isEmptyReadonlyArray: <A>(self: ReadonlyArray<A>) => self i
  * @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
@@ -781,10 +867,12 @@ export declare const isNonEmptyArray: <A>(self: Array<A>) => self is NonEmptyArr
  * @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
@@ -845,10 +933,12 @@ export declare 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
@@ -858,10 +948,12 @@ export declare const unprepend: <A>(self: NonEmptyReadonlyArray<A>) => [firstEle
  * 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
@@ -878,10 +970,12 @@ export declare const head: <A>(self: ReadonlyArray<A>) => Option<A>;
  * 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
@@ -898,10 +992,12 @@ export declare 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
@@ -918,10 +1014,12 @@ export declare 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
@@ -938,10 +1036,12 @@ export declare 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
@@ -953,11 +1053,13 @@ export declare const initNonEmpty: <A>(self: NonEmptyReadonlyArray<A>) => Array<
  * **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
@@ -969,11 +1071,13 @@ export declare 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
@@ -985,11 +1089,13 @@ export declare 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
@@ -1002,11 +1108,13 @@ export declare 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
@@ -1018,11 +1126,13 @@ export declare 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
@@ -1034,11 +1144,13 @@ export declare 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
@@ -1049,6 +1161,7 @@ export declare 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]
@@ -1060,6 +1173,7 @@ export declare 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
@@ -1069,6 +1183,7 @@ export declare 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]
@@ -1080,6 +1195,7 @@ export declare 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
@@ -1089,6 +1205,7 @@ export declare 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]
@@ -1100,6 +1217,7 @@ export declare 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
@@ -1109,6 +1227,7 @@ export declare 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]
@@ -1120,6 +1239,7 @@ export declare 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
@@ -1129,6 +1249,7 @@ export declare 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]
@@ -1140,6 +1261,7 @@ export declare 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
@@ -1203,11 +1325,13 @@ export declare 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
@@ -1219,11 +1343,13 @@ export declare 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
@@ -1235,11 +1361,13 @@ export declare 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
@@ -1252,11 +1380,13 @@ export declare 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
@@ -1268,11 +1398,13 @@ export declare 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
@@ -1284,11 +1416,13 @@ export declare 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
@@ -1299,11 +1433,13 @@ export declare 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
@@ -1313,11 +1449,13 @@ export declare 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
@@ -1327,11 +1465,13 @@ export declare 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
@@ -1342,11 +1482,13 @@ export declare 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
@@ -1356,11 +1498,13 @@ export declare 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
@@ -1370,11 +1514,13 @@ export declare 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
@@ -1385,11 +1531,13 @@ export declare 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
@@ -1399,11 +1547,13 @@ export declare 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
@@ -1413,11 +1563,13 @@ export declare 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
@@ -1429,11 +1581,13 @@ export declare 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
@@ -1444,11 +1598,13 @@ export declare 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
@@ -1459,11 +1615,13 @@ export declare 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
@@ -1474,11 +1632,13 @@ export declare 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
@@ -1489,11 +1649,13 @@ export declare 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
@@ -1504,11 +1666,13 @@ export declare 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
@@ -1519,11 +1683,13 @@ export declare 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
@@ -1535,11 +1701,13 @@ export declare 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
@@ -1550,11 +1718,13 @@ export declare 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
@@ -1565,11 +1735,13 @@ export declare 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
@@ -1580,11 +1752,13 @@ export declare 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
@@ -1595,11 +1769,13 @@ export declare 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
@@ -1610,11 +1786,13 @@ export declare 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
@@ -1625,11 +1803,13 @@ export declare 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
@@ -1641,11 +1821,13 @@ export declare 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
  */
@@ -1655,11 +1837,13 @@ export declare 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
      */
@@ -1669,11 +1853,13 @@ export declare 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
      */
@@ -1684,11 +1870,13 @@ export declare 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
  */
@@ -1698,11 +1886,13 @@ export declare 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
      */
@@ -1712,11 +1902,13 @@ export declare 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
      */
@@ -1726,11 +1918,13 @@ export declare 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
  */
@@ -1739,11 +1933,13 @@ export declare 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
      */
@@ -1752,11 +1948,13 @@ export declare 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
      */
@@ -1767,11 +1965,13 @@ export declare 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
  */
@@ -1781,11 +1981,13 @@ export declare 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
      */
@@ -1795,11 +1997,13 @@ export declare 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
      */
@@ -1810,6 +2014,7 @@ export declare 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]
@@ -1818,6 +2023,7 @@ export declare const modify: {
  *
  * const outOfBoundsResult = Array.modifyOption(numbers, 5, (n) => n * 2)
  * assert.deepStrictEqual(outOfBoundsResult, Option.none())
+ * ```
  *
  * @since 2.0.0
  */
@@ -1827,6 +2033,7 @@ export declare 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]
@@ -1835,6 +2042,7 @@ export declare const modifyOption: {
      *
      * const outOfBoundsResult = Array.modifyOption(numbers, 5, (n) => n * 2)
      * assert.deepStrictEqual(outOfBoundsResult, Option.none())
+     * ```
      *
      * @since 2.0.0
      */
@@ -1844,6 +2052,7 @@ export declare 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]
@@ -1852,6 +2061,7 @@ export declare const modifyOption: {
      *
      * const outOfBoundsResult = Array.modifyOption(numbers, 5, (n) => n * 2)
      * assert.deepStrictEqual(outOfBoundsResult, Option.none())
+     * ```
      *
      * @since 2.0.0
      */
@@ -1862,6 +2072,7 @@ export declare 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]
@@ -1870,6 +2081,7 @@ export declare const modifyOption: {
  *
  * const outOfBoundsResult = Array.remove(numbers, 5)
  * assert.deepStrictEqual(outOfBoundsResult, [1, 2, 3, 4])
+ * ```
  *
  * @since 2.0.0
  */
@@ -1879,6 +2091,7 @@ export declare 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]
@@ -1887,6 +2100,7 @@ export declare const remove: {
      *
      * const outOfBoundsResult = Array.remove(numbers, 5)
      * assert.deepStrictEqual(outOfBoundsResult, [1, 2, 3, 4])
+     * ```
      *
      * @since 2.0.0
      */
@@ -1896,6 +2110,7 @@ export declare 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]
@@ -1904,6 +2119,7 @@ export declare const remove: {
      *
      * const outOfBoundsResult = Array.remove(numbers, 5)
      * assert.deepStrictEqual(outOfBoundsResult, [1, 2, 3, 4])
+     * ```
      *
      * @since 2.0.0
      */
@@ -1913,11 +2129,13 @@ export declare 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
@@ -1962,6 +2180,7 @@ export declare const sort: {
  * order defines how those values should be sorted.
  *
  * @example
+ * ```ts
  * import { Array, Order } from "effect"
  *
  * const strings = ["aaa", "b", "cc"]
@@ -1972,6 +2191,7 @@ export declare 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
@@ -1983,6 +2203,7 @@ export declare const sortWith: {
      * order defines how those values should be sorted.
      *
      * @example
+     * ```ts
      * import { Array, Order } from "effect"
      *
      * const strings = ["aaa", "b", "cc"]
@@ -1993,6 +2214,7 @@ export declare 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
@@ -2004,6 +2226,7 @@ export declare const sortWith: {
      * order defines how those values should be sorted.
      *
      * @example
+     * ```ts
      * import { Array, Order } from "effect"
      *
      * const strings = ["aaa", "b", "cc"]
@@ -2014,6 +2237,7 @@ export declare 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
@@ -2025,6 +2249,7 @@ export declare const sortWith: {
      * order defines how those values should be sorted.
      *
      * @example
+     * ```ts
      * import { Array, Order } from "effect"
      *
      * const strings = ["aaa", "b", "cc"]
@@ -2035,6 +2260,7 @@ export declare 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
@@ -2047,6 +2273,7 @@ export declare const sortWith: {
  * second order if the first comparison is equal, and so on.
  *
  * @example
+ * ```ts
  * import { Array, Order } from "effect"
  *
  * const users = [
@@ -2069,6 +2296,7 @@ export declare 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
@@ -2080,12 +2308,14 @@ export declare const sortBy: <S extends Iterable<any> | NonEmptyReadonlyArray<an
  * 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
@@ -2097,12 +2327,14 @@ export declare 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
@@ -2114,12 +2346,14 @@ export declare 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
@@ -2131,12 +2365,14 @@ export declare 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
@@ -2148,12 +2384,14 @@ export declare 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
@@ -2165,12 +2403,14 @@ export declare 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
@@ -2181,12 +2421,14 @@ export declare 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
@@ -2197,12 +2439,14 @@ export declare 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
@@ -2213,12 +2457,14 @@ export declare 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
@@ -2229,12 +2475,14 @@ export declare 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
@@ -2245,10 +2493,12 @@ export declare 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
  */
@@ -2258,11 +2508,13 @@ export declare const unzip: <S extends Iterable<readonly [any, any]> | NonEmptyR
  * 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
  */
@@ -2272,11 +2524,13 @@ export declare 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
      */
@@ -2286,11 +2540,13 @@ export declare 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
      */
@@ -2300,11 +2556,13 @@ export declare 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
      */
@@ -2314,10 +2572,12 @@ export declare 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
  */
@@ -2326,10 +2586,12 @@ export declare 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
      */
@@ -2338,10 +2600,12 @@ export declare 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
      */
@@ -2351,10 +2615,12 @@ export declare 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
  */
@@ -2363,10 +2629,12 @@ export declare 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
      */
@@ -2375,10 +2643,12 @@ export declare 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
      */
@@ -2388,10 +2658,12 @@ export declare 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
  */
@@ -2400,10 +2672,12 @@ export declare 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
      */
@@ -2412,10 +2686,12 @@ export declare 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
      */
@@ -2425,10 +2701,12 @@ export declare 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
  */
@@ -2437,10 +2715,12 @@ export declare 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
      */
@@ -2449,10 +2729,12 @@ export declare 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
      */
@@ -2463,11 +2745,13 @@ export declare 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
  */
@@ -2477,11 +2761,13 @@ export declare 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
      */
@@ -2491,11 +2777,13 @@ export declare 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
      */
@@ -2505,11 +2793,13 @@ export declare 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
      */
@@ -2519,6 +2809,7 @@ export declare 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]
@@ -2526,6 +2817,7 @@ export declare const rotate: {
  * const containsNumber = Array.containsWith(isEquivalent)
  * const result = containsNumber(3)(numbers)
  * assert.deepStrictEqual(result, true)
+ * ```
  *
  * @category elements
  * @since 2.0.0
@@ -2538,11 +2830,13 @@ export declare const containsWith: <A>(isEquivalent: (self: A, that: A) => boole
  * 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
@@ -2552,11 +2846,13 @@ export declare 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
@@ -2566,11 +2862,13 @@ export declare 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
@@ -2583,6 +2881,7 @@ export declare const contains: {
  * value and the rest of the `Array`.
  *
  * @example
+ * ```ts
  * import { Array } from "effect"
  *
  * const numbers = [1, 2, 3, 4, 5]
@@ -2593,6 +2892,7 @@ export declare 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
  */
@@ -2603,6 +2903,7 @@ export declare const chop: {
      * value and the rest of the `Array`.
      *
      * @example
+     * ```ts
      * import { Array } from "effect"
      *
      * const numbers = [1, 2, 3, 4, 5]
@@ -2613,6 +2914,7 @@ export declare 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
      */
@@ -2623,6 +2925,7 @@ export declare const chop: {
      * value and the rest of the `Array`.
      *
      * @example
+     * ```ts
      * import { Array } from "effect"
      *
      * const numbers = [1, 2, 3, 4, 5]
@@ -2633,6 +2936,7 @@ export declare 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
      */
@@ -2643,6 +2947,7 @@ export declare const chop: {
      * value and the rest of the `Array`.
      *
      * @example
+     * ```ts
      * import { Array } from "effect"
      *
      * const numbers = [1, 2, 3, 4, 5]
@@ -2653,6 +2958,7 @@ export declare 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
      */
@@ -2663,11 +2969,13 @@ export declare 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
@@ -2678,11 +2986,13 @@ export declare 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
@@ -2693,11 +3003,13 @@ export declare 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
@@ -2709,10 +3021,12 @@ export declare 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
@@ -2723,10 +3037,12 @@ export declare 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
@@ -2737,10 +3053,12 @@ export declare 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
@@ -2751,11 +3069,13 @@ export declare 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
@@ -2765,11 +3085,13 @@ export declare 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
@@ -2779,11 +3101,13 @@ export declare 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
@@ -2795,11 +3119,13 @@ export declare 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
@@ -2810,11 +3136,13 @@ export declare 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
@@ -2825,11 +3153,13 @@ export declare 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
@@ -2840,11 +3170,13 @@ export declare 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
  */
@@ -2853,11 +3185,13 @@ export declare 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
      */
@@ -2866,11 +3200,13 @@ export declare 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
      */
@@ -2883,11 +3219,13 @@ export declare 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
  */
@@ -2899,11 +3237,13 @@ export declare 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
      */
@@ -2915,11 +3255,13 @@ export declare 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
      */
@@ -2937,6 +3279,7 @@ export declare const pad: {
  * whenever `n` evenly divides the length of `self`.
  *
  * @example
+ * ```ts
  * import { Array } from "effect"
  *
  * const numbers = [1, 2, 3, 4, 5]
@@ -2948,6 +3291,7 @@ export declare 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
@@ -2965,6 +3309,7 @@ export declare const chunksOf: {
      * whenever `n` evenly divides the length of `self`.
      *
      * @example
+     * ```ts
      * import { Array } from "effect"
      *
      * const numbers = [1, 2, 3, 4, 5]
@@ -2976,6 +3321,7 @@ export declare 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
@@ -2993,6 +3339,7 @@ export declare const chunksOf: {
      * whenever `n` evenly divides the length of `self`.
      *
      * @example
+     * ```ts
      * import { Array } from "effect"
      *
      * const numbers = [1, 2, 3, 4, 5]
@@ -3004,6 +3351,7 @@ export declare 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
@@ -3021,6 +3369,7 @@ export declare const chunksOf: {
      * whenever `n` evenly divides the length of `self`.
      *
      * @example
+     * ```ts
      * import { Array } from "effect"
      *
      * const numbers = [1, 2, 3, 4, 5]
@@ -3032,6 +3381,7 @@ export declare 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
@@ -3042,10 +3392,12 @@ export declare 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
@@ -3055,10 +3407,12 @@ export declare 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
@@ -3068,10 +3422,12 @@ export declare 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
@@ -3082,10 +3438,12 @@ export declare 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
@@ -3096,6 +3454,7 @@ export declare const group: <A>(self: NonEmptyReadonlyArray<A>) => NonEmptyArray
  * function on each element, and grouping the results according to values returned
  *
  * @example
+ * ```ts
  * import { Array } from "effect"
  *
  * const people = [
@@ -3108,6 +3467,7 @@ export declare const group: <A>(self: NonEmptyReadonlyArray<A>) => NonEmptyArray
  *   A: [{ name: "Alice", group: "A" }, { name: "Charlie", group: "A" }],
  *   B: [{ name: "Bob", group: "B" }]
  * })
+ * ```
  *
  * @category grouping
  * @since 2.0.0
@@ -3118,6 +3478,7 @@ export declare const groupBy: {
      * function on each element, and grouping the results according to values returned
      *
      * @example
+     * ```ts
      * import { Array } from "effect"
      *
      * const people = [
@@ -3130,6 +3491,7 @@ export declare const groupBy: {
      *   A: [{ name: "Alice", group: "A" }, { name: "Charlie", group: "A" }],
      *   B: [{ name: "Bob", group: "B" }]
      * })
+     * ```
      *
      * @category grouping
      * @since 2.0.0
@@ -3140,6 +3502,7 @@ export declare const groupBy: {
      * function on each element, and grouping the results according to values returned
      *
      * @example
+     * ```ts
      * import { Array } from "effect"
      *
      * const people = [
@@ -3152,6 +3515,7 @@ export declare const groupBy: {
      *   A: [{ name: "Alice", group: "A" }, { name: "Charlie", group: "A" }],
      *   B: [{ name: "Bob", group: "B" }]
      * })
+     * ```
      *
      * @category grouping
      * @since 2.0.0
@@ -3162,12 +3526,14 @@ export declare 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
  */
@@ -3176,12 +3542,14 @@ export declare 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
      */
@@ -3190,12 +3558,14 @@ export declare 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
      */
@@ -3204,12 +3574,14 @@ export declare 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
      */
@@ -3218,12 +3590,14 @@ export declare 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
      */
@@ -3233,12 +3607,14 @@ export declare 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
  */
@@ -3247,12 +3623,14 @@ export declare 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
      */
@@ -3261,12 +3639,14 @@ export declare 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
      */
@@ -3275,12 +3655,14 @@ export declare 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
      */
@@ -3289,12 +3671,14 @@ export declare 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
      */
@@ -3305,6 +3689,7 @@ export declare 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 }]
@@ -3312,6 +3697,7 @@ export declare 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
  */
@@ -3324,12 +3710,14 @@ export declare const intersectionWith: <A>(isEquivalent: (self: A, that: A) => b
  * 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
  */
@@ -3339,12 +3727,14 @@ export declare 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
      */
@@ -3354,12 +3744,14 @@ export declare 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
      */
@@ -3370,12 +3762,14 @@ export declare 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
  */
@@ -3388,12 +3782,14 @@ export declare const differenceWith: <A>(isEquivalent: (self: A, that: A) => boo
  * 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
  */
@@ -3403,12 +3799,14 @@ export declare 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
      */
@@ -3418,12 +3816,14 @@ export declare 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
      */
@@ -3517,12 +3917,14 @@ export declare 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
@@ -3533,6 +3935,7 @@ export declare const flatten: <S extends ReadonlyArray<ReadonlyArray<any>>>(self
  * 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];
@@ -3540,6 +3943,7 @@ export declare const flatten: <S extends ReadonlyArray<ReadonlyArray<any>>>(self
  * const result = Array.filterMap(data, evenSquares);
  *
  * assert.deepStrictEqual(result, [4, 16]);
+ * ```
  *
  * @category filtering
  * @since 2.0.0
@@ -3550,6 +3954,7 @@ export declare 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];
@@ -3557,6 +3962,7 @@ export declare const filterMap: {
      * const result = Array.filterMap(data, evenSquares);
      *
      * assert.deepStrictEqual(result, [4, 16]);
+     * ```
      *
      * @category filtering
      * @since 2.0.0
@@ -3567,6 +3973,7 @@ export declare 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];
@@ -3574,6 +3981,7 @@ export declare const filterMap: {
      * const result = Array.filterMap(data, evenSquares);
      *
      * assert.deepStrictEqual(result, [4, 16]);
+     * ```
      *
      * @category filtering
      * @since 2.0.0
@@ -3586,6 +3994,7 @@ export declare 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];
@@ -3593,6 +4002,7 @@ export declare const filterMap: {
  * const result = Array.filterMapWhile(data, toSquareTillOdd);
  *
  * assert.deepStrictEqual(result, [4, 16]);
+ * ```
  *
  * @category filtering
  * @since 2.0.0
@@ -3604,6 +4014,7 @@ export declare 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];
@@ -3611,6 +4022,7 @@ export declare const filterMapWhile: {
      * const result = Array.filterMapWhile(data, toSquareTillOdd);
      *
      * assert.deepStrictEqual(result, [4, 16]);
+     * ```
      *
      * @category filtering
      * @since 2.0.0
@@ -3622,6 +4034,7 @@ export declare 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];
@@ -3629,6 +4042,7 @@ export declare const filterMapWhile: {
      * const result = Array.filterMapWhile(data, toSquareTillOdd);
      *
      * assert.deepStrictEqual(result, [4, 16]);
+     * ```
      *
      * @category filtering
      * @since 2.0.0
@@ -3642,6 +4056,7 @@ export declare const filterMapWhile: {
  * into successes and failures.
  *
  * @example
+ * ```ts
  * import { Array, Either } from "effect";
  *
  * const data = [1, 2, 3, 4, 5]
@@ -3654,6 +4069,7 @@ export declare const filterMapWhile: {
  *   [1, 3, 5],
  *   [2, 4]
  * ])
+ * ```
  *
  * @category filtering
  * @since 2.0.0
@@ -3666,6 +4082,7 @@ export declare const partitionMap: {
      * into successes and failures.
      *
      * @example
+     * ```ts
      * import { Array, Either } from "effect";
      *
      * const data = [1, 2, 3, 4, 5]
@@ -3678,6 +4095,7 @@ export declare const partitionMap: {
      *   [1, 3, 5],
      *   [2, 4]
      * ])
+     * ```
      *
      * @category filtering
      * @since 2.0.0
@@ -3690,6 +4108,7 @@ export declare const partitionMap: {
      * into successes and failures.
      *
      * @example
+     * ```ts
      * import { Array, Either } from "effect";
      *
      * const data = [1, 2, 3, 4, 5]
@@ -3702,6 +4121,7 @@ export declare const partitionMap: {
      *   [1, 3, 5],
      *   [2, 4]
      * ])
+     * ```
      *
      * @category filtering
      * @since 2.0.0
@@ -3712,12 +4132,14 @@ export declare 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
@@ -3727,12 +4149,14 @@ export declare const getSomes: <T extends Iterable<Option<X>>, X = any>(self: T)
  * 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
@@ -3742,12 +4166,14 @@ export declare const getLefts: <T extends Iterable<array_<any, any>>>(self: T) =
  * 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
@@ -3819,11 +4245,13 @@ export declare 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
@@ -3833,11 +4261,13 @@ export declare const separate: <T extends Iterable<array_<any, any>>>(self: T) =
  * 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
@@ -3847,11 +4277,13 @@ export declare 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
@@ -3861,11 +4293,13 @@ export declare 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
@@ -3876,11 +4310,13 @@ export declare 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
@@ -3890,11 +4326,13 @@ export declare 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
@@ -3904,11 +4342,13 @@ export declare 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
@@ -3919,12 +4359,14 @@ export declare 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
@@ -3935,12 +4377,14 @@ export declare const liftPredicate: {
      * 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
@@ -3966,6 +4410,7 @@ export declare const liftNullable: <A extends Array<unknown>, B>(f: (...a: A) =>
  * Maps over an array and flattens the result, removing null and undefined values.
  *
  * @example
+ * ```ts
  * import { Array } from "effect"
  *
  * const numbers = [1, 2, 3]
@@ -3976,6 +4421,7 @@ export declare const liftNullable: <A extends Array<unknown>, B>(f: (...a: A) =>
  * // The array of numbers [1, 2, 3] is mapped with a function that returns null for even numbers
  * // and the number itself for odd numbers. The resulting array [1, null, 3] is then flattened
  * // to remove null values, resulting in [1, 3].
+ * ```
  *
  * @category sequencing
  * @since 2.0.0
@@ -3985,6 +4431,7 @@ export declare 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]
@@ -3995,6 +4442,7 @@ export declare 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
@@ -4004,6 +4452,7 @@ export declare 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]
@@ -4014,6 +4463,7 @@ export declare 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
@@ -4026,6 +4476,7 @@ export declare 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> =>
@@ -4043,6 +4494,7 @@ export declare 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
@@ -4110,6 +4562,7 @@ export declare 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]
@@ -4121,6 +4574,7 @@ export declare 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
  */
@@ -4129,6 +4583,7 @@ export declare 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]
@@ -4140,6 +4595,7 @@ export declare 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
      */
@@ -4148,6 +4604,7 @@ export declare 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]
@@ -4159,6 +4616,7 @@ export declare 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
      */
@@ -4168,10 +4626,12 @@ export declare 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
  */
@@ -4180,10 +4640,12 @@ export declare 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
      */
@@ -4192,10 +4654,12 @@ export declare 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
      */
@@ -4205,10 +4669,12 @@ export declare 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
  */
@@ -4217,10 +4683,12 @@ export declare 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
      */
@@ -4229,10 +4697,12 @@ export declare 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
      */
@@ -4257,12 +4727,14 @@ export declare const getOrder: <A>(O: Order.Order<A>) => Order.Order<ReadonlyArr
  * 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
@@ -4272,10 +4744,12 @@ export declare const getEquivalence: <A>(isEquivalent: Equivalence.Equivalence<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
  */
@@ -4284,10 +4758,12 @@ export declare 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
      */
@@ -4296,10 +4772,12 @@ export declare 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
      */
@@ -4310,11 +4788,13 @@ export declare 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
  */
@@ -4324,11 +4804,13 @@ export declare 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
      */
@@ -4338,11 +4820,13 @@ export declare 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
      */
@@ -4352,11 +4836,13 @@ export declare 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
      */
@@ -4373,11 +4859,13 @@ export declare const dedupe: <S extends Iterable<any> | NonEmptyReadonlyArray<an
  * 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
  */
@@ -4386,11 +4874,13 @@ export declare 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
      */
@@ -4399,11 +4889,13 @@ export declare 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
      */
@@ -4413,11 +4905,13 @@ export declare 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
  */
@@ -4426,11 +4920,13 @@ export declare const dedupeAdjacent: <A>(self: Iterable<A>) => Array<A>;
  * 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
@@ -4440,11 +4936,13 @@ export declare 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
@@ -4454,11 +4952,13 @@ export declare 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
@@ -4469,11 +4969,13 @@ export declare 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
@@ -4483,11 +4985,13 @@ export declare 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
@@ -4497,11 +5001,13 @@ export declare 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
@@ -4512,12 +5018,14 @@ export declare 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
@@ -4527,12 +5035,14 @@ export declare 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
@@ -4542,12 +5052,14 @@ export declare 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
@@ -4558,12 +5070,14 @@ export declare 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
@@ -4573,12 +5087,14 @@ export declare 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
@@ -4588,12 +5104,14 @@ export declare 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
@@ -4619,6 +5137,7 @@ export declare const cartesian: {
  * @see {@link let_ let}
  *
  * @example
+ * ```ts
  * import { Array as Arr, pipe } from "effect"
  * const doResult = pipe(
  *   Arr.Do,
@@ -4639,6 +5158,7 @@ export declare const cartesian: {
  *     if(_x < _y) result.push([_x, _y] as const)
  *   }
  * }
+ * ```
  *
  * @category do notation
  * @since 3.2.0
@@ -4663,6 +5183,7 @@ export declare const Do: ReadonlyArray<{}>;
  * @see {@link let_ let}
  *
  * @example
+ * ```ts
  * import { Array as Arr, pipe } from "effect"
  * const doResult = pipe(
  *   Arr.Do,
@@ -4683,6 +5204,7 @@ export declare const Do: ReadonlyArray<{}>;
  *     if(_x < _y) result.push([_x, _y] as const)
  *   }
  * }
+ * ```
  *
  * @category do notation
  * @since 3.2.0
@@ -4707,6 +5229,7 @@ export declare const bind: {
      * @see {@link let_ let}
      *
      * @example
+     * ```ts
      * import { Array as Arr, pipe } from "effect"
      * const doResult = pipe(
      *   Arr.Do,
@@ -4727,6 +5250,7 @@ export declare const bind: {
      *     if(_x < _y) result.push([_x, _y] as const)
      *   }
      * }
+     * ```
      *
      * @category do notation
      * @since 3.2.0
@@ -4753,6 +5277,7 @@ export declare const bind: {
      * @see {@link let_ let}
      *
      * @example
+     * ```ts
      * import { Array as Arr, pipe } from "effect"
      * const doResult = pipe(
      *   Arr.Do,
@@ -4773,6 +5298,7 @@ export declare const bind: {
      *     if(_x < _y) result.push([_x, _y] as const)
      *   }
      * }
+     * ```
      *
      * @category do notation
      * @since 3.2.0
@@ -4800,6 +5326,7 @@ export declare const bind: {
  * @see {@link let_ let}
  *
  * @example
+ * ```ts
  * import { Array as Arr, pipe } from "effect"
  * const doResult = pipe(
  *   Arr.Do,
@@ -4820,6 +5347,7 @@ export declare const bind: {
  *     if(_x < _y) result.push([_x, _y] as const)
  *   }
  * }
+ * ```
  *
  * @category do notation
  * @since 3.2.0
@@ -4844,6 +5372,7 @@ export declare const bindTo: {
      * @see {@link let_ let}
      *
      * @example
+     * ```ts
      * import { Array as Arr, pipe } from "effect"
      * const doResult = pipe(
      *   Arr.Do,
@@ -4864,6 +5393,7 @@ export declare const bindTo: {
      *     if(_x < _y) result.push([_x, _y] as const)
      *   }
      * }
+     * ```
      *
      * @category do notation
      * @since 3.2.0
@@ -4890,6 +5420,7 @@ export declare const bindTo: {
      * @see {@link let_ let}
      *
      * @example
+     * ```ts
      * import { Array as Arr, pipe } from "effect"
      * const doResult = pipe(
      *   Arr.Do,
@@ -4910,6 +5441,7 @@ export declare const bindTo: {
      *     if(_x < _y) result.push([_x, _y] as const)
      *   }
      * }
+     * ```
      *
      * @category do notation
      * @since 3.2.0
@@ -4946,6 +5478,7 @@ export {
  * @see {@link Do}
  *
  * @example
+ * ```ts
  * import { Array as Arr, pipe } from "effect"
  * const doResult = pipe(
  *   Arr.Do,
@@ -4967,6 +5500,7 @@ export {
  *   }
  * }
  *
+ * ```
  * @category do notation
  * @since 3.2.0
  */