effect 4.0.0-beta.102 → 4.0.0-beta.103

package/dist/Array.js

@@ -33,11 +33,10 @@ import * as Tuple from "./Tuple.js";
  *
  * **Example** (Accessing the Array constructor)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * const arr = new Array.Array(3)
- * console.log(arr) // [undefined, undefined, undefined]
+ * Array.Array === globalThis.Array // => true
  * ```
  *
  * @category constructors
@@ -58,11 +57,10 @@ export const Array = globalThis.Array;
  *
  * **Example** (Creating an array from values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * const result = Array.make(1, 2, 3)
- * console.log(result) // [1, 2, 3]
+ * Array.make(1, 2, 3) // => [1, 2, 3]
  * ```
  *
  * @see {@link of} — create a single-element array
@@ -85,11 +83,10 @@ export const make = (...elements) => elements;
  *
  * **Example** (Allocating a fixed-size array)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * const result = Array.allocate<number>(3)
- * console.log(result.length) // 3
+ * Array.allocate<number>(3).length // => 3
  * ```
  *
  * @see {@link makeBy} — create an array by computing each element
@@ -113,11 +110,10 @@ export const allocate = n => new Array(n);
  *
  * **Example** (Generating values from indices)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * const result = Array.makeBy(5, (n) => n * 2)
- * console.log(result) // [0, 2, 4, 6, 8]
+ * Array.makeBy(5, (n) => n * 2) // => [0, 2, 4, 6, 8]
  * ```
  *
  * @see {@link range} — create a range of integers
@@ -148,11 +144,10 @@ export const makeBy = /*#__PURE__*/dual(2, (n, f) => {
  *
  * **Example** (Creating a range)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * const result = Array.range(1, 3)
- * console.log(result) // [1, 2, 3]
+ * Array.range(1, 3) // => [1, 2, 3]
  * ```
  *
  * @see {@link makeBy} — generate values from a function
@@ -176,11 +171,10 @@ export const range = (start, end) => start <= end ? makeBy(end - start + 1, i =>
  *
  * **Example** (Repeating a value)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * const result = Array.replicate("a", 3)
- * console.log(result) // ["a", "a", "a"]
+ * Array.replicate("a", 3) // => ["a", "a", "a"]
  * ```
  *
  * @see {@link makeBy} — vary values based on index
@@ -204,11 +198,10 @@ export const replicate = /*#__PURE__*/dual(2, (a, n) => makeBy(n, () => a));
  *
  * **Example** (Converting a Set to an array)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * const result = Array.fromIterable(new Set([1, 2, 3]))
- * console.log(result) // [1, 2, 3]
+ * Array.fromIterable(new Set([1, 2, 3])) // => [1, 2, 3]
  * ```
  *
  * @see {@link ensure} — wrap a single value or return an existing array
@@ -234,11 +227,11 @@ export const fromIterable = collection => Array.isArray(collection) ? collection
  *
  * **Example** (Normalizing input)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * console.log(Array.ensure("a")) // ["a"]
- * console.log(Array.ensure(["a", "b", "c"])) // ["a", "b", "c"]
+ * Array.ensure("a") // => ["a"]
+ * Array.ensure(["a", "b", "c"]) // => ["a", "b", "c"]
  * ```
  *
  * @see {@link of} — always wrap in a single-element array
@@ -263,11 +256,10 @@ export const ensure = self => Array.isArray(self) ? self : [self];
  *
  * **Example** (Converting a record to entries)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * const result = Array.fromRecord({ a: 1, b: 2, c: 3 })
- * console.log(result) // [["a", 1], ["b", 2], ["c", 3]]
+ * Array.fromRecord({ a: 1, b: 2, c: 3 }) // => [["a", 1], ["b", 2], ["c", 3]]
  * ```
  *
  * @see {@link Record.toEntries} the equivalent function from the Record module
@@ -286,11 +278,11 @@ export const fromRecord = Record.toEntries;
  *
  * **Example** (Converting an Option to an array)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array, Option } from "effect"
  *
- * console.log(Array.fromOption(Option.some(1))) // [1]
- * console.log(Array.fromOption(Option.none())) // []
+ * Array.fromOption(Option.some(1)) // => [1]
+ * Array.fromOption(Option.none()) // => []
  * ```
  *
  * @see {@link getSomes} — extract `Some` values from an array of Options
@@ -313,15 +305,16 @@ export const fromOption = Option.toArray;
  *
  * **Example** (Branching on emptiness)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
  * const describe = Array.match({
  *   onEmpty: () => "empty",
  *   onNonEmpty: ([head, ...tail]) => `head: ${head}, tail: ${tail.length}`
  * })
- * console.log(describe([])) // "empty"
- * console.log(describe([1, 2, 3])) // "head: 1, tail: 2"
+ *
+ * describe([]) // => "empty"
+ * describe([1, 2, 3]) // => "head: 1, tail: 2"
  * ```
  *
  * @see {@link matchLeft} — destructures into head + tail
@@ -349,15 +342,16 @@ export const match = /*#__PURE__*/dual(2, (self, {
  *
  * **Example** (Destructuring head and tail)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
  * const matchLeft = Array.matchLeft({
  *   onEmpty: () => "empty",
  *   onNonEmpty: (head, tail) => `head: ${head}, tail: ${tail.length}`
  * })
- * console.log(matchLeft([])) // "empty"
- * console.log(matchLeft([1, 2, 3])) // "head: 1, tail: 2"
+ *
+ * matchLeft([]) // => "empty"
+ * matchLeft([1, 2, 3]) // => "head: 1, tail: 2"
  * ```
  *
  * @see {@link match} — receives the full non-empty array
@@ -385,15 +379,16 @@ export const matchLeft = /*#__PURE__*/dual(2, (self, {
  *
  * **Example** (Destructuring init and last)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
  * const matchRight = Array.matchRight({
  *   onEmpty: () => "empty",
  *   onNonEmpty: (init, last) => `init: ${init.length}, last: ${last}`
  * })
- * console.log(matchRight([])) // "empty"
- * console.log(matchRight([1, 2, 3])) // "init: 2, last: 3"
+ *
+ * matchRight([]) // => "empty"
+ * matchRight([1, 2, 3]) // => "init: 2, last: 3"
  * ```
  *
  * @see {@link match} — receives the full non-empty array
@@ -416,11 +411,10 @@ export const matchRight = /*#__PURE__*/dual(2, (self, {
  *
  * **Example** (Prepending an element)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * const result = Array.prepend([2, 3, 4], 1)
- * console.log(result) // [1, 2, 3, 4]
+ * Array.prepend([2, 3, 4], 1) // => [1, 2, 3, 4]
  * ```
  *
  * @see {@link append} — add to the end
@@ -443,11 +437,10 @@ export const prepend = /*#__PURE__*/dual(2, (self, head) => [head, ...self]);
  *
  * **Example** (Prepending multiple elements)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * const result = Array.prependAll([2, 3], [0, 1])
- * console.log(result) // [0, 1, 2, 3]
+ * Array.prependAll([2, 3], [0, 1]) // => [0, 1, 2, 3]
  * ```
  *
  * @see {@link prepend} — add a single element to the front
@@ -467,11 +460,10 @@ export const prependAll = /*#__PURE__*/dual(2, (self, that) => fromIterable(that
  *
  * **Example** (Appending an element)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * const result = Array.append([1, 2, 3], 4)
- * console.log(result) // [1, 2, 3, 4]
+ * Array.append([1, 2, 3], 4) // => [1, 2, 3, 4]
  * ```
  *
  * @see {@link prepend} — add to the front
@@ -495,11 +487,10 @@ export const append = /*#__PURE__*/dual(2, (self, last) => [...self, last]);
  *
  * **Example** (Concatenating arrays)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * const result = Array.appendAll([1, 2], [3, 4])
- * console.log(result) // [1, 2, 3, 4]
+ * Array.appendAll([1, 2], [3, 4]) // => [1, 2, 3, 4]
  * ```
  *
  * @see {@link append} — add a single element to the end
@@ -524,11 +515,10 @@ export const appendAll = /*#__PURE__*/dual(2, (self, that) => fromIterable(self)
  *
  * **Example** (Running totals)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * const result = Array.scan([1, 2, 3, 4], 0, (acc, value) => acc + value)
- * console.log(result) // [0, 1, 3, 6, 10]
+ * Array.scan([1, 2, 3, 4], 0, (acc, value) => acc + value) // => [0, 1, 3, 6, 10]
  * ```
  *
  * @see {@link scanRight} — right-to-left scan
@@ -561,11 +551,10 @@ export const scan = /*#__PURE__*/dual(3, (self, b, f) => {
  *
  * **Example** (Scanning running totals in reverse)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * const result = Array.scanRight([1, 2, 3, 4], 0, (acc, value) => acc + value)
- * console.log(result) // [10, 9, 7, 4, 0]
+ * Array.scanRight([1, 2, 3, 4], 0, (acc, value) => acc + value) // => [10, 9, 7, 4, 0]
  * ```
  *
  * @see {@link scan} — left-to-right scan
@@ -597,11 +586,11 @@ export const scanRight = /*#__PURE__*/dual(3, (self, b, f) => {
  *
  * **Example** (Type-guarding an unknown value)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * console.log(Array.isArray(null)) // false
- * console.log(Array.isArray([1, 2, 3])) // true
+ * Array.isArray(null) // => false
+ * Array.isArray([1, 2, 3]) // => true
  * ```
  *
  * @see {@link isArrayEmpty} — check for an empty array
@@ -616,11 +605,11 @@ export const isArray = Array.isArray;
  *
  * **Example** (Checking for an empty array)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * console.log(Array.isArrayEmpty([])) // true
- * console.log(Array.isArrayEmpty([1, 2, 3])) // false
+ * Array.isArrayEmpty([]) // => true
+ * Array.isArrayEmpty([1, 2, 3]) // => false
  * ```
  *
  * @see {@link isReadonlyArrayEmpty} — readonly variant
@@ -635,11 +624,11 @@ export const isArrayEmpty = self => self.length === 0;
  *
  * **Example** (Checking for an empty readonly array)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * console.log(Array.isReadonlyArrayEmpty([])) // true
- * console.log(Array.isReadonlyArrayEmpty([1, 2, 3])) // false
+ * Array.isReadonlyArrayEmpty([]) // => true
+ * Array.isReadonlyArrayEmpty([1, 2, 3]) // => false
  * ```
  *
  * @see {@link isArrayEmpty} — mutable variant
@@ -660,11 +649,11 @@ export const isReadonlyArrayEmpty = isArrayEmpty;
  *
  * **Example** (Checking for a non-empty array)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * console.log(Array.isArrayNonEmpty([])) // false
- * console.log(Array.isArrayNonEmpty([1, 2, 3])) // true
+ * Array.isArrayNonEmpty([]) // => false
+ * Array.isArrayNonEmpty([1, 2, 3]) // => true
  * ```
  *
  * @see {@link isReadonlyArrayNonEmpty} — readonly variant
@@ -685,11 +674,11 @@ export const isArrayNonEmpty = internalArray.isArrayNonEmpty;
  *
  * **Example** (Checking for a non-empty readonly array)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * console.log(Array.isReadonlyArrayNonEmpty([])) // false
- * console.log(Array.isReadonlyArrayNonEmpty([1, 2, 3])) // true
+ * Array.isReadonlyArrayNonEmpty([]) // => false
+ * Array.isReadonlyArrayNonEmpty([1, 2, 3]) // => true
  * ```
  *
  * @see {@link isArrayNonEmpty} — mutable variant
@@ -708,10 +697,10 @@ export const isReadonlyArrayNonEmpty = internalArray.isArrayNonEmpty;
  *
  * **Example** (Getting the length)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * console.log(Array.length([1, 2, 3])) // 3
+ * Array.length([1, 2, 3]) // => 3
  * ```
  *
  * @category getters
@@ -720,7 +709,7 @@ export const isReadonlyArrayNonEmpty = internalArray.isArrayNonEmpty;
 export const length = self => self.length;
 /** @internal */
 export function isOutOfBounds(i, as) {
-  return i < 0 || i >= as.length;
+  return !Number.isFinite(i) || i < 0 || i >= as.length;
 }
 const clamp = (i, as) => Math.floor(Math.min(Math.max(0, i), as.length));
 /**
@@ -738,11 +727,11 @@ const clamp = (i, as) => Math.floor(Math.min(Math.max(0, i), as.length));
  *
  * **Example** (Accessing indexes safely)
  *
- * ```ts
- * import { Array } from "effect"
+ * ```ts import.meta.vitest
+ * import { Array, Option } from "effect"
  *
- * console.log(Array.get([1, 2, 3], 1)) // Some(2)
- * console.log(Array.get([1, 2, 3], 10)) // None
+ * Array.get([1, 2, 3], 1) // => Option.some(2)
+ * Array.get([1, 2, 3], 10) // => Option.none()
  * ```
  *
  * @see {@link getUnsafe} for indexed access that throws when the index is out of bounds
@@ -771,10 +760,10 @@ export const get = /*#__PURE__*/dual(2, (self, index) => {
  *
  * **Example** (Accessing indexes unsafely)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * console.log(Array.getUnsafe([1, 2, 3], 1)) // 2
+ * Array.getUnsafe([1, 2, 3], 1) // => 2
  * // Array.getUnsafe([1, 2, 3], 10) // throws Error
  * ```
  *
@@ -804,11 +793,10 @@ export const getUnsafe = /*#__PURE__*/dual(2, (self, index) => {
  *
  * **Example** (Destructuring head and tail)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * const result = Array.unprepend([1, 2, 3, 4])
- * console.log(result) // [1, [2, 3, 4]]
+ * Array.unprepend([1, 2, 3, 4]) // => [1, [2, 3, 4]]
  * ```
  *
  * @see {@link unappend} for splitting a non-empty array into init and last
@@ -834,11 +822,10 @@ export const unprepend = self => [headNonEmpty(self), tailNonEmpty(self)];
  *
  * **Example** (Destructuring init and last)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * const result = Array.unappend([1, 2, 3, 4])
- * console.log(result) // [[1, 2, 3], 4]
+ * Array.unappend([1, 2, 3, 4]) // => [[1, 2, 3], 4]
  * ```
  *
  * @see {@link unprepend} for splitting a non-empty array into head and tail
@@ -859,11 +846,11 @@ export const unappend = self => [initNonEmpty(self), lastNonEmpty(self)];
  *
  * **Example** (Getting the first element)
  *
- * ```ts
- * import { Array } from "effect"
+ * ```ts import.meta.vitest
+ * import { Array, Option } from "effect"
  *
- * console.log(Array.head([1, 2, 3])) // Some(1)
- * console.log(Array.head([])) // None
+ * Array.head([1, 2, 3]) // => Option.some(1)
+ * Array.head([]) // => Option.none()
  * ```
  *
  * @see {@link headNonEmpty} — direct access when array is known non-empty
@@ -884,10 +871,10 @@ export const head = /*#__PURE__*/get(0);
  *
  * **Example** (Getting the head of a non-empty array)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * console.log(Array.headNonEmpty([1, 2, 3, 4])) // 1
+ * Array.headNonEmpty([1, 2, 3, 4]) // => 1
  * ```
  *
  * @see {@link head} — safe version for possibly-empty arrays
@@ -906,11 +893,11 @@ export const headNonEmpty = /*#__PURE__*/getUnsafe(0);
  *
  * **Example** (Getting the last element)
  *
- * ```ts
- * import { Array } from "effect"
+ * ```ts import.meta.vitest
+ * import { Array, Option } from "effect"
  *
- * console.log(Array.last([1, 2, 3])) // Some(3)
- * console.log(Array.last([])) // None
+ * Array.last([1, 2, 3]) // => Option.some(3)
+ * Array.last([]) // => Option.none()
  * ```
  *
  * @see {@link lastNonEmpty} — direct access when array is known non-empty
@@ -931,10 +918,10 @@ export const last = self => isReadonlyArrayNonEmpty(self) ? Option.some(lastNonE
  *
  * **Example** (Getting the last of a non-empty array)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * console.log(Array.lastNonEmpty([1, 2, 3, 4])) // 4
+ * Array.lastNonEmpty([1, 2, 3, 4]) // => 4
  * ```
  *
  * @see {@link last} — safe version for possibly-empty arrays
@@ -956,11 +943,11 @@ export const lastNonEmpty = self => self[self.length - 1];
  *
  * **Example** (Getting the tail)
  *
- * ```ts
- * import { Array } from "effect"
+ * ```ts import.meta.vitest
+ * import { Array, Option } from "effect"
  *
- * console.log(Array.tail([1, 2, 3, 4])) // Option.some([2, 3, 4])
- * console.log(Array.tail([])) // Option.none()
+ * Array.tail([1, 2, 3, 4]) // => Option.some([2, 3, 4])
+ * Array.tail([]) // => Option.none()
  * ```
  *
  * @see {@link tailNonEmpty} — when the array is known non-empty
@@ -982,10 +969,10 @@ export function tail(self) {
  *
  * **Example** (Getting the tail of a non-empty array)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * console.log(Array.tailNonEmpty([1, 2, 3, 4])) // [2, 3, 4]
+ * Array.tailNonEmpty([1, 2, 3, 4]) // => [2, 3, 4]
  * ```
  *
  * @see {@link tail} — safe version for possibly-empty arrays
@@ -1009,11 +996,11 @@ export const tailNonEmpty = self => self.slice(1);
  *
  * **Example** (Getting init)
  *
- * ```ts
- * import { Array } from "effect"
+ * ```ts import.meta.vitest
+ * import { Array, Option } from "effect"
  *
- * console.log(Array.init([1, 2, 3, 4])) // Option.some([1, 2, 3])
- * console.log(Array.init([])) // Option.none()
+ * Array.init([1, 2, 3, 4]) // => Option.some([1, 2, 3])
+ * Array.init([]) // => Option.none()
  * ```
  *
  * @see {@link initNonEmpty} — when the array is known non-empty
@@ -1035,10 +1022,10 @@ export function init(self) {
  *
  * **Example** (Getting init of a non-empty array)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * console.log(Array.initNonEmpty([1, 2, 3, 4])) // [1, 2, 3]
+ * Array.initNonEmpty([1, 2, 3, 4]) // => [1, 2, 3]
  * ```
  *
  * @see {@link init} — safe version for possibly-empty arrays
@@ -1061,10 +1048,10 @@ export const initNonEmpty = self => self.slice(0, -1);
  *
  * **Example** (Taking from the start)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * console.log(Array.take([1, 2, 3, 4, 5], 3)) // [1, 2, 3]
+ * Array.take([1, 2, 3, 4, 5], 3) // => [1, 2, 3]
  * ```
  *
  * @see {@link takeRight} for keeping elements from the end
@@ -1091,10 +1078,10 @@ export const take = /*#__PURE__*/dual(2, (self, n) => {
  *
  * **Example** (Taking from the end)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * console.log(Array.takeRight([1, 2, 3, 4, 5], 3)) // [3, 4, 5]
+ * Array.takeRight([1, 2, 3, 4, 5], 3) // => [3, 4, 5]
  * ```
  *
  * @see {@link take} — keep from the start
@@ -1124,10 +1111,10 @@ export const takeRight = /*#__PURE__*/dual(2, (self, n) => {
  *
  * **Example** (Taking while condition holds)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * console.log(Array.takeWhile([1, 3, 2, 4, 1, 2], (x) => x < 4)) // [1, 3, 2]
+ * Array.takeWhile([1, 3, 2, 4, 1, 2], (x) => x < 4) // => [1, 3, 2]
  * ```
  *
  * @see {@link take} for keeping a fixed number of leading elements
@@ -1208,10 +1195,10 @@ const spanIndex = (self, predicate) => {
  *
  * **Example** (Splitting at predicate boundary)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * console.log(Array.span([1, 3, 2, 4, 5], (x) => x % 2 === 1)) // [[1, 3], [2, 4, 5]]
+ * Array.span([1, 3, 2, 4, 5], (x) => x % 2 === 1) // => [[1, 3], [2, 4, 5]]
  * ```
  *
  * @see {@link takeWhile} for keeping only the matching prefix
@@ -1240,10 +1227,10 @@ export const span = /*#__PURE__*/dual(2, (self, predicate) => {
  *
  * **Example** (Dropping from the start)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * console.log(Array.drop([1, 2, 3, 4, 5], 2)) // [3, 4, 5]
+ * Array.drop([1, 2, 3, 4, 5], 2) // => [3, 4, 5]
  * ```
  *
  * @see {@link dropRight} for removing a fixed number of elements from the end
@@ -1270,10 +1257,10 @@ export const drop = /*#__PURE__*/dual(2, (self, n) => {
  *
  * **Example** (Dropping from the end)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * console.log(Array.dropRight([1, 2, 3, 4, 5], 2)) // [1, 2, 3]
+ * Array.dropRight([1, 2, 3, 4, 5], 2) // => [1, 2, 3]
  * ```
  *
  * @see {@link drop} — remove from the start
@@ -1299,10 +1286,10 @@ export const dropRight = /*#__PURE__*/dual(2, (self, n) => {
  *
  * **Example** (Dropping while condition holds)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * console.log(Array.dropWhile([1, 2, 3, 4, 5], (x) => x < 4)) // [4, 5]
+ * Array.dropWhile([1, 2, 3, 4, 5], (x) => x < 4) // => [4, 5]
  * ```
  *
  * @see {@link takeWhile} — keep the matching prefix instead
@@ -1363,16 +1350,16 @@ export const dropWhileFilter = /*#__PURE__*/dual(2, (self, f) => {
  *
  * **Example** (Finding an index)
  *
- * ```ts
- * import { Array } from "effect"
+ * ```ts import.meta.vitest
+ * import { Array, Option } from "effect"
  *
- * console.log(Array.findFirstIndex([5, 3, 8, 9], (x) => x > 5)) // Option.some(2)
+ * Array.findFirstIndex([5, 3, 8, 9], (x) => x > 5) // => Option.some(2)
  * ```
  *
  * @see {@link findLastIndex} — search from the end
  * @see {@link findFirst} — get the element itself
  *
- * @category elements
+ * @category searching
  * @since 2.0.0
  */
 export const findFirstIndex = /*#__PURE__*/dual(2, (self, predicate) => {
@@ -1395,16 +1382,16 @@ export const findFirstIndex = /*#__PURE__*/dual(2, (self, predicate) => {
  *
  * **Example** (Finding the last matching index)
  *
- * ```ts
- * import { Array } from "effect"
+ * ```ts import.meta.vitest
+ * import { Array, Option } from "effect"
  *
- * console.log(Array.findLastIndex([1, 3, 8, 9], (x) => x < 5)) // Option.some(1)
+ * Array.findLastIndex([1, 3, 8, 9], (x) => x < 5) // => Option.some(1)
  * ```
  *
  * @see {@link findFirstIndex} — search from the start
  * @see {@link findLast} — get the element itself
  *
- * @category elements
+ * @category searching
  * @since 2.0.0
  */
 export const findLastIndex = /*#__PURE__*/dual(2, (self, predicate) => {
@@ -1433,17 +1420,17 @@ export const findLastIndex = /*#__PURE__*/dual(2, (self, predicate) => {
  *
  * **Example** (Finding the first match)
  *
- * ```ts
- * import { Array } from "effect"
+ * ```ts import.meta.vitest
+ * import { Array, Option } from "effect"
  *
- * console.log(Array.findFirst([1, 2, 3, 4, 5], (x) => x > 3)) // Option.some(4)
+ * Array.findFirst([1, 2, 3, 4, 5], (x) => x > 3) // => Option.some(4)
  * ```
  *
  * @see {@link findLast} — search from the end
  * @see {@link findFirstIndex} — get the index instead
  * @see {@link findFirstWithIndex} — get both element and index
  *
- * @category elements
+ * @category searching
  * @since 2.0.0
  */
 export const findFirst = moduleIterable.findFirst;
@@ -1463,16 +1450,16 @@ export const findFirst = moduleIterable.findFirst;
  *
  * **Example** (Finding element with its index)
  *
- * ```ts
- * import { Array } from "effect"
+ * ```ts import.meta.vitest
+ * import { Array, Option } from "effect"
  *
- * console.log(Array.findFirstWithIndex([1, 2, 3, 4, 5], (x) => x > 3)) // Option.some([4, 3])
+ * Array.findFirstWithIndex([1, 2, 3, 4, 5], (x) => x > 3) // => Option.some([4, 3])
  * ```
  *
  * @see {@link findFirst} — get only the element
  * @see {@link findFirstIndex} — get only the index
  *
- * @category elements
+ * @category searching
  * @since 3.17.0
  */
 export const findFirstWithIndex = /*#__PURE__*/dual(2, (self, f) => {
@@ -1507,16 +1494,16 @@ export const findFirstWithIndex = /*#__PURE__*/dual(2, (self, f) => {
  *
  * **Example** (Finding the last match)
  *
- * ```ts
- * import { Array } from "effect"
+ * ```ts import.meta.vitest
+ * import { Array, Option } from "effect"
  *
- * console.log(Array.findLast([1, 2, 3, 4, 5], (n) => n % 2 === 0)) // Option.some(4)
+ * Array.findLast([1, 2, 3, 4, 5], (n) => n % 2 === 0) // => Option.some(4)
  * ```
  *
  * @see {@link findFirst} — search from the start
  * @see {@link findLastIndex} — get the index instead
  *
- * @category elements
+ * @category searching
  * @since 2.0.0
  */
 export const findLast = /*#__PURE__*/dual(2, (self, f) => {
@@ -1550,24 +1537,25 @@ export const findLast = /*#__PURE__*/dual(2, (self, f) => {
  *
  * **Example** (Inserting at an index)
  *
- * ```ts
- * import { Array } from "effect"
+ * ```ts import.meta.vitest
+ * import { Array, Option } from "effect"
  *
- * console.log(Array.insertAt(["a", "b", "c", "e"], 3, "d")) // Option.some(["a", "b", "c", "d", "e"])
+ * Array.insertAt(["a", "b", "c", "e"], 3, "d") // => Option.some(["a", "b", "c", "d", "e"])
  * ```
  *
  * @see {@link replace} — replace an existing element
  * @see {@link modify} — transform an element at an index
  *
- * @category elements
+ * @category transforming
  * @since 2.0.0
  */
 export const insertAt = /*#__PURE__*/dual(3, (self, i, b) => {
   const out = Array.from(self); // copy because `splice` mutates the array
-  if (i < 0 || i > out.length) {
+  const index = Math.floor(i);
+  if (index !== out.length && isOutOfBounds(index, out)) {
     return Option.none();
   }
-  out.splice(i, 0, b);
+  out.splice(index, 0, b);
   return Option.some(out);
 });
 /**
@@ -1584,16 +1572,16 @@ export const insertAt = /*#__PURE__*/dual(3, (self, i, b) => {
  *
  * **Example** (Replacing an element)
  *
- * ```ts
- * import { Array } from "effect"
+ * ```ts import.meta.vitest
+ * import { Array, Option } from "effect"
  *
- * console.log(Array.replace([1, 2, 3], 1, 4)) // Option.some([1, 4, 3])
+ * Array.replace([1, 2, 3], 1, 4) // => Option.some([1, 4, 3])
  * ```
  *
  * @see {@link modify} — transform an element with a function
  * @see {@link insertAt} — insert without removing
  *
- * @category elements
+ * @category transforming
  * @since 2.0.0
  */
 export const replace = /*#__PURE__*/dual(3, (self, i, b) => modify(self, i, () => b));
@@ -1612,28 +1600,32 @@ export const replace = /*#__PURE__*/dual(3, (self, i, b) => modify(self, i, () =
  *
  * **Example** (Modifying an element)
  *
- * ```ts
- * import { Array } from "effect"
+ * ```ts import.meta.vitest
+ * import { Array, Option } from "effect"
+ *
+ * const values = [1, 2, 3, 4]
+ * const double = (n: number) => n * 2
  *
- * console.log(Array.modify([1, 2, 3, 4], 2, (n) => n * 2)) // Option.some([1, 2, 6, 4])
- * console.log(Array.modify([1, 2, 3, 4], 5, (n) => n * 2)) // Option.none()
+ * Array.modify(values, 2, double) // => Option.some([1, 2, 6, 4])
+ * Array.modify(values, 5, double) // => Option.none()
  * ```
  *
  * @see {@link replace} — set a fixed value at an index
  * @see {@link modifyHeadNonEmpty} — modify the first element
  * @see {@link modifyLastNonEmpty} — modify the last element
  *
- * @category elements
+ * @category transforming
  * @since 2.0.0
  */
 export const modify = /*#__PURE__*/dual(3, (self, i, f) => {
   const arr = Array.from(self);
-  if (isOutOfBounds(i, arr)) {
+  const index = Math.floor(i);
+  if (isOutOfBounds(index, arr)) {
     return Option.none();
   }
   const out = arr;
-  const b = f(arr[i]);
-  out[i] = b;
+  const b = f(arr[index]);
+  out[index] = b;
   return Option.some(out);
 });
 /**
@@ -1647,25 +1639,26 @@ export const modify = /*#__PURE__*/dual(3, (self, i, f) => {
  *
  * **Example** (Removing an element)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * console.log(Array.remove([1, 2, 3, 4], 2)) // [1, 2, 4]
- * console.log(Array.remove([1, 2, 3, 4], 5)) // [1, 2, 3, 4]
+ * Array.remove([1, 2, 3, 4], 2) // => [1, 2, 4]
+ * Array.remove([1, 2, 3, 4], 5) // => [1, 2, 3, 4]
  * ```
  *
  * @see {@link insertAt} — insert an element
  * @see {@link filter} — remove elements by predicate
  *
- * @category elements
+ * @category transforming
  * @since 2.0.0
  */
 export const remove = /*#__PURE__*/dual(2, (self, i) => {
   const out = Array.from(self);
-  if (isOutOfBounds(i, out)) {
+  const index = Math.floor(i);
+  if (isOutOfBounds(index, out)) {
     return out;
   }
-  out.splice(i, 1);
+  out.splice(index, 1);
   return out;
 });
 /**
@@ -1682,13 +1675,13 @@ export const remove = /*#__PURE__*/dual(2, (self, i) => {
  *
  * **Example** (Reversing an array)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * console.log(Array.reverse([1, 2, 3, 4])) // [4, 3, 2, 1]
+ * Array.reverse([1, 2, 3, 4]) // => [4, 3, 2, 1]
  * ```
  *
- * @category elements
+ * @category transforming
  * @since 2.0.0
  */
 export const reverse = self => Array.from(self).reverse();
@@ -1706,10 +1699,10 @@ export const reverse = self => Array.from(self).reverse();
  *
  * **Example** (Sorting numbers)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array, Order } from "effect"
  *
- * console.log(Array.sort([3, 1, 4, 1, 5], Order.Number)) // [1, 1, 3, 4, 5]
+ * Array.sort([3, 1, 4, 1, 5], Order.Number) // => [1, 1, 3, 4, 5]
  * ```
  *
  * @see {@link sortWith} — sort by a mapping function
@@ -1738,17 +1731,16 @@ export const sort = /*#__PURE__*/dual(2, (self, O) => {
  *
  * **Example** (Sorting strings by length)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array, Order } from "effect"
  *
- * console.log(Array.sortWith(["aaa", "b", "cc"], (s) => s.length, Order.Number))
- * // ["b", "cc", "aaa"]
+ * Array.sortWith(["aaa", "b", "cc"], (s) => s.length, Order.Number) // => ["b", "cc", "aaa"]
  * ```
  *
  * @see {@link sort} for sorting with an `Order` that compares the elements directly
  * @see {@link sortBy} for sorting with multiple `Order`s applied in sequence
  *
- * @category elements
+ * @category sorting
  * @since 2.0.0
  */
 export const sortWith = /*#__PURE__*/dual(3, (self, f, order) => Array.from(self).map(a => [a, f(a)]).sort(([, a], [, b]) => order(a, b)).map(([_]) => _));
@@ -1768,7 +1760,7 @@ export const sortWith = /*#__PURE__*/dual(3, (self, f, order) => Array.from(self
  *
  * **Example** (Sorting by multiple keys)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array, Order, pipe } from "effect"
  *
  * const users = [
@@ -1777,15 +1769,15 @@ export const sortWith = /*#__PURE__*/dual(3, (self, f, order) => Array.from(self
  *   { name: "Charlie", age: 30 }
  * ]
  *
- * const result = pipe(
+ * const sortedUsers = pipe(
  *   users,
  *   Array.sortBy(
  *     Order.mapInput(Order.Number, (user: (typeof users)[number]) => user.age),
  *     Order.mapInput(Order.String, (user: (typeof users)[number]) => user.name)
  *   )
  * )
- * console.log(result)
- * // [{ name: "Bob", age: 25 }, { name: "Alice", age: 30 }, { name: "Charlie", age: 30 }]
+ *
+ * sortedUsers.map((user) => user.name).join(",") // => "Bob,Alice,Charlie"
  * ```
  *
  * @see {@link sort} — sort by a single `Order`
@@ -1818,10 +1810,10 @@ export const sortBy = (...orders) => {
  *
  * **Example** (Zipping two arrays)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * console.log(Array.zip([1, 2, 3], ["a", "b"])) // [[1, "a"], [2, "b"]]
+ * Array.zip([1, 2, 3], ["a", "b"]) // => [[1, "a"], [2, "b"]]
  * ```
  *
  * @see {@link zipWith} — zip with a combiner function
@@ -1842,10 +1834,10 @@ export const zip = /*#__PURE__*/dual(2, (self, that) => zipWith(self, that, Tupl
  *
  * **Example** (Zipping with addition)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * console.log(Array.zipWith([1, 2, 3], [4, 5, 6], (a, b) => a + b)) // [5, 7, 9]
+ * Array.zipWith([1, 2, 3], [4, 5, 6], (a, b) => a + b) // => [5, 7, 9]
  * ```
  *
  * @see {@link zip} — zip into tuples
@@ -1871,10 +1863,10 @@ export const zipWith = /*#__PURE__*/dual(3, (self, that, f) => {
  *
  * **Example** (Unzipping pairs)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * console.log(Array.unzip([[1, "a"], [2, "b"], [3, "c"]])) // [[1, 2, 3], ["a", "b", "c"]]
+ * Array.unzip([[1, "a"], [2, "b"], [3, "c"]]) // => [[1, 2, 3], ["a", "b", "c"]]
  * ```
  *
  * @see {@link zip} — combine two arrays into pairs
@@ -1909,15 +1901,15 @@ export const unzip = self => {
  *
  * **Example** (Interspersing a separator)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * console.log(Array.intersperse([1, 2, 3], 0)) // [1, 0, 2, 0, 3]
+ * Array.intersperse([1, 2, 3], 0) // => [1, 0, 2, 0, 3]
  * ```
  *
  * @see {@link join} — intersperse and join into a string
  *
- * @category elements
+ * @category transforming
  * @since 2.0.0
  */
 export const intersperse = /*#__PURE__*/dual(2, (self, middle) => {
@@ -1945,16 +1937,16 @@ export const intersperse = /*#__PURE__*/dual(2, (self, middle) => {
  *
  * **Example** (Modifying the head)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * console.log(Array.modifyHeadNonEmpty([1, 2, 3], (n) => n * 10)) // [10, 2, 3]
+ * Array.modifyHeadNonEmpty([1, 2, 3], (n) => n * 10) // => [10, 2, 3]
  * ```
  *
  * @see {@link setHeadNonEmpty} — replace with a fixed value
  * @see {@link modifyLastNonEmpty} — modify the last element
  *
- * @category elements
+ * @category transforming
  * @since 4.0.0
  */
 export const modifyHeadNonEmpty = /*#__PURE__*/dual(2, (self, f) => [f(headNonEmpty(self)), ...tailNonEmpty(self)]);
@@ -1968,16 +1960,16 @@ export const modifyHeadNonEmpty = /*#__PURE__*/dual(2, (self, f) => [f(headNonEm
  *
  * **Example** (Setting the head)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * console.log(Array.setHeadNonEmpty([1, 2, 3], 10)) // [10, 2, 3]
+ * Array.setHeadNonEmpty([1, 2, 3], 10) // => [10, 2, 3]
  * ```
  *
  * @see {@link modifyHeadNonEmpty} — transform the head with a function
  * @see {@link setLastNonEmpty} — replace the last element
  *
- * @category elements
+ * @category transforming
  * @since 4.0.0
  */
 export const setHeadNonEmpty = /*#__PURE__*/dual(2, (self, b) => modifyHeadNonEmpty(self, () => b));
@@ -1992,16 +1984,16 @@ export const setHeadNonEmpty = /*#__PURE__*/dual(2, (self, b) => modifyHeadNonEm
  *
  * **Example** (Modifying the last element)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * console.log(Array.modifyLastNonEmpty([1, 2, 3], (n) => n * 2)) // [1, 2, 6]
+ * Array.modifyLastNonEmpty([1, 2, 3], (n) => n * 2) // => [1, 2, 6]
  * ```
  *
  * @see {@link setLastNonEmpty} — replace with a fixed value
  * @see {@link modifyHeadNonEmpty} — modify the first element
  *
- * @category elements
+ * @category transforming
  * @since 4.0.0
  */
 export const modifyLastNonEmpty = /*#__PURE__*/dual(2, (self, f) => append(initNonEmpty(self), f(lastNonEmpty(self))));
@@ -2015,16 +2007,16 @@ export const modifyLastNonEmpty = /*#__PURE__*/dual(2, (self, f) => append(initN
  *
  * **Example** (Setting the last element)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * console.log(Array.setLastNonEmpty([1, 2, 3], 4)) // [1, 2, 4]
+ * Array.setLastNonEmpty([1, 2, 3], 4) // => [1, 2, 4]
  * ```
  *
  * @see {@link modifyLastNonEmpty} — transform the last element with a function
  * @see {@link setHeadNonEmpty} — replace the first element
  *
- * @category elements
+ * @category transforming
  * @since 4.0.0
  */
 export const setLastNonEmpty = /*#__PURE__*/dual(2, (self, b) => modifyLastNonEmpty(self, () => b));
@@ -2045,16 +2037,16 @@ export const setLastNonEmpty = /*#__PURE__*/dual(2, (self, b) => modifyLastNonEm
  *
  * **Example** (Rotating elements)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * console.log(Array.rotate(["a", "b", "c", "d"], 2)) // ["c", "d", "a", "b"]
+ * Array.rotate(["a", "b", "c", "d"], 2) // => ["c", "d", "a", "b"]
  * ```
  *
  * @see {@link take} for taking a fixed number of elements from the start
  * @see {@link drop} for dropping a fixed number of elements from the start
  *
- * @category elements
+ * @category transforming
  * @since 2.0.0
  */
 export const rotate = /*#__PURE__*/dual(2, (self, n) => {
@@ -2084,16 +2076,17 @@ export const rotate = /*#__PURE__*/dual(2, (self, n) => {
  *
  * **Example** (Checking with custom equality)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array, pipe } from "effect"
  *
  * const containsNumber = Array.containsWith((a: number, b: number) => a === b)
- * console.log(pipe([1, 2, 3, 4], containsNumber(3))) // true
+ *
+ * pipe([1, 2, 3, 4], containsNumber(3)) // => true
  * ```
  *
  * @see {@link contains} for the `Equal.equivalence()` variant
  *
- * @category elements
+ * @category predicates
  * @since 2.0.0
  */
 export const containsWith = isEquivalent => dual(2, (self, a) => {
@@ -2115,15 +2108,15 @@ export const containsWith = isEquivalent => dual(2, (self, a) => {
  *
  * **Example** (Checking membership)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array, pipe } from "effect"
  *
- * console.log(pipe(["a", "b", "c", "d"], Array.contains("c"))) // true
+ * pipe(["a", "b", "c", "d"], Array.contains("c")) // => true
  * ```
  *
  * @see {@link containsWith} — use custom equality
  *
- * @category elements
+ * @category predicates
  * @since 2.0.0
  */
 export const contains = /*#__PURE__*/containsWith(/*#__PURE__*/Equal.asEquivalence());
@@ -2143,20 +2136,16 @@ export const contains = /*#__PURE__*/containsWith(/*#__PURE__*/Equal.asEquivalen
  *
  * **Example** (Chopping an array)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * const result = Array.chop(
- *   [1, 2, 3, 4, 5],
- *   (as): [number, Array<number>] => [as[0] * 2, as.slice(1)]
- * )
- * console.log(result) // [2, 4, 6, 8, 10]
+ * Array.chop([1, 2, 3, 4, 5], (as): [number, Array<number>] => [as[0] * 2, as.slice(1)]) // => [2, 4, 6, 8, 10]
  * ```
  *
  * @see {@link chunksOf} — split into fixed-size chunks
  * @see {@link splitAt} — split at an index
  *
- * @category elements
+ * @category splitting
  * @since 2.0.0
  */
 export const chop = /*#__PURE__*/dual(2, (self, f) => {
@@ -2188,10 +2177,10 @@ export const chop = /*#__PURE__*/dual(2, (self, f) => {
  *
  * **Example** (Splitting at an index)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * console.log(Array.splitAt([1, 2, 3, 4, 5], 3)) // [[1, 2, 3], [4, 5]]
+ * Array.splitAt([1, 2, 3, 4, 5], 3) // => [[1, 2, 3], [4, 5]]
  * ```
  *
  * @see {@link splitAtNonEmpty} — for non-empty arrays
@@ -2222,11 +2211,10 @@ export const splitAt = /*#__PURE__*/dual(2, (self, n) => {
  *
  * **Example** (Splitting a non-empty array)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * console.log(Array.splitAtNonEmpty(["a", "b", "c", "d", "e"], 3))
- * // [["a", "b", "c"], ["d", "e"]]
+ * Array.splitAtNonEmpty(["a", "b", "c", "d", "e"], 3) // => [["a", "b", "c"], ["d", "e"]]
  * ```
  *
  * @see {@link splitAt} — for possibly-empty arrays
@@ -2251,10 +2239,10 @@ export const splitAtNonEmpty = /*#__PURE__*/dual(2, (self, n) => {
  *
  * **Example** (Splitting into groups)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * console.log(Array.split([1, 2, 3, 4, 5, 6, 7, 8], 3)) // [[1, 2, 3], [4, 5, 6], [7, 8]]
+ * Array.split([1, 2, 3, 4, 5, 6, 7, 8], 3) // => [[1, 2, 3], [4, 5, 6], [7, 8]]
  * ```
  *
  * @see {@link chunksOf} — split into fixed-size chunks
@@ -2277,10 +2265,10 @@ export const split = /*#__PURE__*/dual(2, (self, n) => {
  *
  * **Example** (Splitting at a condition)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * console.log(Array.splitWhere([1, 2, 3, 4, 5], (n) => n > 3)) // [[1, 2, 3], [4, 5]]
+ * Array.splitWhere([1, 2, 3, 4, 5], (n) => n > 3) // => [[1, 2, 3], [4, 5]]
  * ```
  *
  * @see {@link span} — splits at the first element that fails the predicate
@@ -2305,18 +2293,19 @@ export const splitWhere = /*#__PURE__*/dual(2, (self, predicate) => span(self, (
  *
  * **Example** (Copying an array)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
  * const original = [1, 2, 3]
  * const copied = Array.copy(original)
- * console.log(copied) // [1, 2, 3]
- * console.log(original === copied) // false
+ *
+ * copied // => [1, 2, 3]
+ * original === copied // => false
  * ```
  *
  * @see {@link fromIterable} — returns the same reference for arrays
  *
- * @category elements
+ * @category transforming
  * @since 2.0.0
  */
 export const copy = self => self.slice();
@@ -2334,16 +2323,16 @@ export const copy = self => self.slice();
  *
  * **Example** (Padding an array)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * console.log(Array.pad([1, 2, 3], 6, 0)) // [1, 2, 3, 0, 0, 0]
+ * Array.pad([1, 2, 3], 6, 0) // => [1, 2, 3, 0, 0, 0]
  * ```
  *
  * @see {@link take} — truncate without padding
  * @see {@link replicate} — create an array of a single repeated value
  *
- * @category elements
+ * @category transforming
  * @since 3.8.4
  */
 export const pad = /*#__PURE__*/dual(3, (self, n, fill) => {
@@ -2368,10 +2357,10 @@ export const pad = /*#__PURE__*/dual(3, (self, n, fill) => {
  *
  * **Example** (Chunking an array)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * console.log(Array.chunksOf([1, 2, 3, 4, 5], 2)) // [[1, 2], [3, 4], [5]]
+ * Array.chunksOf([1, 2, 3, 4, 5], 2) // => [[1, 2], [3, 4], [5]]
  * ```
  *
  * @see {@link split} — split into a given number of groups
@@ -2401,11 +2390,13 @@ export const chunksOf = /*#__PURE__*/dual(2, (self, n) => {
  *
  * **Example** (Creating sliding windows)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * console.log(Array.window([1, 2, 3, 4, 5], 3)) // [[1, 2, 3], [2, 3, 4], [3, 4, 5]]
- * console.log(Array.window([1, 2, 3, 4, 5], 6)) // []
+ * const values = [1, 2, 3, 4, 5]
+ *
+ * Array.window(values, 3) // => [[1, 2, 3], [2, 3, 4], [3, 4, 5]]
+ * Array.window(values, 6) // => []
  * ```
  *
  * @see {@link chunksOf} — non-overlapping chunks
@@ -2437,11 +2428,13 @@ export const window = /*#__PURE__*/dual(2, (self, n) => {
  *
  * **Example** (Grouping consecutive equal elements)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * console.log(Array.groupWith(["a", "a", "b", "b", "b", "c", "a"], (x, y) => x === y))
- * // [["a", "a"], ["b", "b", "b"], ["c"], ["a"]]
+ * Array.groupWith(
+ *   ["a", "a", "b", "b", "b", "c", "a"],
+ *   (x, y) => x === y
+ * ) // => [["a", "a"], ["b", "b", "b"], ["c"], ["a"]]
  * ```
  *
  * @see {@link group} for grouping adjacent elements with `Equal.equivalence()`
@@ -2478,10 +2471,10 @@ export const groupWith = /*#__PURE__*/dual(2, (self, isEquivalent) => chop(self,
  *
  * **Example** (Grouping adjacent equal elements)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * console.log(Array.group([1, 1, 2, 2, 2, 3, 1])) // [[1, 1], [2, 2, 2], [3], [1]]
+ * Array.group([1, 1, 2, 2, 2, 3, 1]) // => [[1, 1], [2, 2, 2], [3], [1]]
  * ```
  *
  * @see {@link groupWith} — use custom equality
@@ -2506,7 +2499,7 @@ export const group = /*#__PURE__*/groupWith(/*#__PURE__*/Equal.asEquivalence());
  *
  * **Example** (Grouping by a property)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
  * const people = [
@@ -2515,9 +2508,7 @@ export const group = /*#__PURE__*/groupWith(/*#__PURE__*/Equal.asEquivalence());
  *   { name: "Charlie", group: "A" }
  * ]
  *
- * const result = Array.groupBy(people, (person) => person.group)
- * console.log(result)
- * // { A: [{ name: "Alice", group: "A" }, { name: "Charlie", group: "A" }], B: [{ name: "Bob", group: "B" }] }
+ * Object.keys(Array.groupBy(people, (person) => person.group)).join(",") // => "A,B"
  * ```
  *
  * @see {@link group} — group adjacent equal elements
@@ -2584,17 +2575,17 @@ const hashBucketsHas = (buckets, value) => {
  *
  * **Example** (Computing unions with custom equality)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * console.log(Array.unionWith([1, 2], [2, 3], (a, b) => a === b)) // [1, 2, 3]
+ * Array.unionWith([1, 2], [2, 3], (a, b) => a === b) // => [1, 2, 3]
  * ```
  *
  * @see {@link union} for the `Equal.equivalence()` variant
  * @see {@link intersectionWith} for keeping elements present in both arrays
  * @see {@link differenceWith} for keeping elements present only in the first array
  *
- * @category elements
+ * @category set operations
  * @since 2.0.0
  */
 export const unionWith = /*#__PURE__*/dual(3, (self, that, isEquivalent) => {
@@ -2615,17 +2606,17 @@ export const unionWith = /*#__PURE__*/dual(3, (self, that, isEquivalent) => {
  *
  * **Example** (Computing array unions)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * console.log(Array.union([1, 2], [2, 3])) // [1, 2, 3]
+ * Array.union([1, 2], [2, 3]) // => [1, 2, 3]
  * ```
  *
  * @see {@link unionWith} — use custom equality
  * @see {@link intersection} — elements in both arrays
  * @see {@link difference} — elements only in the first array
  *
- * @category elements
+ * @category set operations
  * @since 2.0.0
  */
 export const union = /*#__PURE__*/dual(2, (self, that) => {
@@ -2647,20 +2638,21 @@ export const union = /*#__PURE__*/dual(2, (self, that) => {
  *
  * **Example** (Computing intersections with custom equality)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
  * const array1 = [{ id: 1 }, { id: 2 }, { id: 3 }]
  * const array2 = [{ id: 3 }, { id: 4 }, { id: 1 }]
  * const isEquivalent = (a: { id: number }, b: { id: number }) => a.id === b.id
- * console.log(Array.intersectionWith(isEquivalent)(array2)(array1)) // [{ id: 1 }, { id: 3 }]
+ *
+ * Array.intersectionWith(isEquivalent)(array2)(array1) // => [{ id: 1 }, { id: 3 }]
  * ```
  *
  * @see {@link intersection} for the `Equal.equivalence()` variant
  * @see {@link unionWith} for keeping values from either array with custom equality
  * @see {@link differenceWith} for keeping values only from the first array with custom equality
  *
- * @category elements
+ * @category set operations
  * @since 2.0.0
  */
 export const intersectionWith = isEquivalent => {
@@ -2681,17 +2673,17 @@ export const intersectionWith = isEquivalent => {
  *
  * **Example** (Computing array intersections)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * console.log(Array.intersection([1, 2, 3], [3, 4, 1])) // [1, 3]
+ * Array.intersection([1, 2, 3], [3, 4, 1]) // => [1, 3]
  * ```
  *
  * @see {@link intersectionWith} — use custom equality
  * @see {@link union} — elements in either array
  * @see {@link difference} — elements only in the first array
  *
- * @category elements
+ * @category set operations
  * @since 2.0.0
  */
 export const intersection = /*#__PURE__*/dual(2, (self, that) => {
@@ -2714,18 +2706,17 @@ export const intersection = /*#__PURE__*/dual(2, (self, that) => {
  *
  * **Example** (Computing differences with custom equality)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * const diff = Array.differenceWith<number>((a, b) => a === b)([1, 2, 3], [2, 3, 4])
- * console.log(diff) // [1]
+ * Array.differenceWith<number>((a, b) => a === b)([1, 2, 3], [2, 3, 4]) // => [1]
  * ```
  *
  * @see {@link difference} for the `Equal.equivalence()` variant
  * @see {@link unionWith} for keeping values from either array with custom equality
  * @see {@link intersectionWith} for keeping values present in both arrays with custom equality
  *
- * @category elements
+ * @category set operations
  * @since 2.0.0
  */
 export const differenceWith = isEquivalent => {
@@ -2746,17 +2737,17 @@ export const differenceWith = isEquivalent => {
  *
  * **Example** (Computing array differences)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * console.log(Array.difference([1, 2, 3], [2, 3, 4])) // [1]
+ * Array.difference([1, 2, 3], [2, 3, 4]) // => [1]
  * ```
  *
  * @see {@link differenceWith} — use custom equality
  * @see {@link union} — elements in either array
  * @see {@link intersection} — elements in both arrays
  *
- * @category elements
+ * @category set operations
  * @since 2.0.0
  */
 export const difference = /*#__PURE__*/dual(2, (self, that) => {
@@ -2780,11 +2771,10 @@ export const difference = /*#__PURE__*/dual(2, (self, that) => {
  *
  * **Example** (Creating an empty array)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * const result = Array.empty<number>()
- * console.log(result) // []
+ * Array.empty<number>() // => []
  * ```
  *
  * @see {@link of} — create a single-element array
@@ -2799,10 +2789,10 @@ export const empty = () => [];
  *
  * **Example** (Creating a single-element array)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * console.log(Array.of(1)) // [1]
+ * Array.of(1) // => [1]
  * ```
  *
  * @see {@link make} — create from multiple values
@@ -2826,10 +2816,10 @@ export const of = a => [a];
  *
  * **Example** (Doubling values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * console.log(Array.map([1, 2, 3], (x) => x * 2)) // [2, 4, 6]
+ * Array.map([1, 2, 3], (x) => x * 2) // => [2, 4, 6]
  * ```
  *
  * @see {@link flatMap} — map and flatten
@@ -2853,10 +2843,10 @@ export const map = /*#__PURE__*/dual(2, (self, f) => self.map(f));
  *
  * **Example** (Flat mapping an array)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * console.log(Array.flatMap([1, 2, 3], (x) => [x, x * 2])) // [1, 2, 2, 4, 3, 6]
+ * Array.flatMap([1, 2, 3], (x) => [x, x * 2]) // => [1, 2, 2, 4, 3, 6]
  * ```
  *
  * @see {@link map} — transform without flattening
@@ -2888,10 +2878,10 @@ export const flatMap = /*#__PURE__*/dual(2, (self, f) => {
  *
  * **Example** (Flattening nested arrays)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * console.log(Array.flatten([[1, 2], [], [3, 4], [], [5, 6]])) // [1, 2, 3, 4, 5, 6]
+ * Array.flatten([[1, 2], [], [3, 4], [], [5, 6]]) // => [1, 2, 3, 4, 5, 6]
  * ```
  *
  * @see {@link flatMap} — map then flatten in one step
@@ -2910,10 +2900,10 @@ export const flatten = /*#__PURE__*/flatMap(identity);
  *
  * **Example** (Extracting Some values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array, Option } from "effect"
  *
- * console.log(Array.getSomes([Option.some(1), Option.none(), Option.some(2)])) // [1, 2]
+ * Array.getSomes([Option.some(1), Option.none(), Option.some(2)]) // => [1, 2]
  * ```
  *
  * @see {@link fromOption} — convert a single Option
@@ -2942,11 +2932,10 @@ export const getSomes = self => {
  *
  * **Example** (Extracting failures)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array, Result } from "effect"
  *
- * console.log(Array.getFailures([Result.succeed(1), Result.fail("err"), Result.succeed(2)]))
- * // ["err"]
+ * Array.getFailures([Result.succeed(1), Result.fail("err"), Result.succeed(2)]) // => ["err"]
  * ```
  *
  * @see {@link getSuccesses} — extract success values
@@ -2975,11 +2964,10 @@ export const getFailures = self => {
  *
  * **Example** (Extracting successes)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array, Result } from "effect"
  *
- * console.log(Array.getSuccesses([Result.succeed(1), Result.fail("err"), Result.succeed(2)]))
- * // [1, 2]
+ * Array.getSuccesses([Result.succeed(1), Result.fail("err"), Result.succeed(2)]) // => [1, 2]
  * ```
  *
  * @see {@link getFailures} — extract failure values
@@ -3011,11 +2999,10 @@ export const getSuccesses = self => {
  *
  * **Example** (Filtering and transforming)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array, Result } from "effect"
  *
- * console.log(Array.filterMap([1, 2, 3, 4], (n) => n % 2 === 0 ? Result.succeed(n * 10) : Result.failVoid))
- * // [20, 40]
+ * Array.filterMap([1, 2, 3, 4], (n) => n % 2 === 0 ? Result.succeed(n * 10) : Result.failVoid) // => [20, 40]
  * ```
  *
  * @see {@link filter} — keep original elements matching a predicate
@@ -3050,10 +3037,10 @@ export const filterMap = /*#__PURE__*/dual(2, (self, f) => {
  *
  * **Example** (Filtering even numbers)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * console.log(Array.filter([1, 2, 3, 4], (x) => x % 2 === 0)) // [2, 4]
+ * Array.filter([1, 2, 3, 4], (x) => x % 2 === 0) // => [2, 4]
  * ```
  *
  * @see {@link partition} — split into matching and non-matching
@@ -3086,13 +3073,12 @@ export const filter = /*#__PURE__*/dual(2, (self, predicate) => {
  *
  * **Example** (Partitioning with a filter)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array, Result } from "effect"
  *
- * console.log(Array.partition([1, -2, 3], (n, i) =>
+ * Array.partition([1, -2, 3], (n, i) =>
  *   n > 0 ? Result.succeed(n + i) : Result.fail(`negative:${n}`)
- * ))
- * // [["negative:-2"], [1, 5]]
+ * ) // => [["negative:-2"], [1, 5]]
  * ```
  *
  * @see {@link filter} — keep only matching elements
@@ -3130,14 +3116,10 @@ export const partition = /*#__PURE__*/dual(2, (self, f) => {
  *
  * **Example** (Separating Results)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array, Result } from "effect"
  *
- * const [failures, successes] = Array.separate([
- *   Result.succeed(1), Result.fail("error"), Result.succeed(2)
- * ])
- * console.log(failures) // ["error"]
- * console.log(successes) // [1, 2]
+ * Array.separate([Result.succeed(1), Result.fail("error"), Result.succeed(2)]) // => [["error"], [1, 2]]
  * ```
  *
  * @see {@link getFailures} — extract only failures
@@ -3161,10 +3143,10 @@ export const separate = /*#__PURE__*/partition(identity);
  *
  * **Example** (Summing an array)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * console.log(Array.reduce([1, 2, 3], 0, (acc, n) => acc + n)) // 6
+ * Array.reduce([1, 2, 3], 0, (acc, n) => acc + n) // => 6
  * ```
  *
  * @see {@link reduceRight} — fold from right to left
@@ -3187,10 +3169,10 @@ export const reduce = /*#__PURE__*/dual(3, (self, b, f) => fromIterable(self).re
  *
  * **Example** (Folding from right to left)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * console.log(Array.reduceRight([1, 2, 3], 0, (acc, n) => acc + n)) // 6
+ * Array.reduceRight([1, 2, 3], 0, (acc, n) => acc + n) // => 6
  * ```
  *
  * @see {@link reduce} — fold from left to right
@@ -3206,13 +3188,13 @@ export const reduceRight = /*#__PURE__*/dual(3, (self, b, f) => fromIterable(sel
  *
  * **Example** (Wrapping values conditionally)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * const isEven = (n: number) => n % 2 === 0
- * const to = Array.liftPredicate(isEven)
- * console.log(to(1)) // []
- * console.log(to(2)) // [2]
+ * const fromEven = Array.liftPredicate((n: number) => n % 2 === 0)
+ *
+ * fromEven(1) // => []
+ * fromEven(2) // => [2]
  * ```
  *
  * @see {@link liftOption} — lift an Option-returning function
@@ -3232,15 +3214,16 @@ export const liftPredicate = predicate => b => predicate(b) ? [b] : [];
  *
  * **Example** (Lifting an Option function)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array, Option } from "effect"
  *
  * const parseNumber = Array.liftOption((s: string) => {
  *   const n = Number(s)
  *   return isNaN(n) ? Option.none() : Option.some(n)
  * })
- * console.log(parseNumber("123")) // [123]
- * console.log(parseNumber("abc")) // []
+ *
+ * parseNumber("123") // => [123]
+ * parseNumber("abc") // => []
  * ```
  *
  * @see {@link liftPredicate} — lift a boolean predicate
@@ -3260,12 +3243,12 @@ export const liftOption = f => (...a) => fromOption(f(...a));
  *
  * **Example** (Converting nullable values to an array)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * console.log(Array.fromNullishOr(1)) // [1]
- * console.log(Array.fromNullishOr(null)) // []
- * console.log(Array.fromNullishOr(undefined)) // []
+ * Array.fromNullishOr(1) // => [1]
+ * Array.fromNullishOr(null) // => []
+ * Array.fromNullishOr(undefined) // => []
  * ```
  *
  * @see {@link liftNullishOr} — lift a nullable-returning function
@@ -3281,15 +3264,16 @@ export const fromNullishOr = a => a == null ? empty() : [a];
  *
  * **Example** (Lifting a nullable function)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
  * const parseNumber = Array.liftNullishOr((s: string) => {
  *   const n = Number(s)
  *   return isNaN(n) ? null : n
  * })
- * console.log(parseNumber("123")) // [123]
- * console.log(parseNumber("abc")) // []
+ *
+ * parseNumber("123") // => [123]
+ * parseNumber("abc") // => []
  * ```
  *
  * @see {@link fromNullishOr} — convert a single nullable value
@@ -3310,11 +3294,10 @@ export const liftNullishOr = f => (...a) => fromNullishOr(f(...a));
  *
  * **Example** (Flat mapping with nullable values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * console.log(Array.flatMapNullishOr([1, 2, 3], (n) => (n % 2 === 0 ? null : n)))
- * // [1, 3]
+ * Array.flatMapNullishOr([1, 2, 3], (n) => (n % 2 === 0 ? null : n)) // => [1, 3]
  * ```
  *
  * @see {@link flatMap} for mapping each element to an array and flattening
@@ -3335,7 +3318,7 @@ export const flatMapNullishOr = /*#__PURE__*/dual(2, (self, f) => flatMap(self,
  *
  * **Example** (Lifting a Result function)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array, Result } from "effect"
  *
  * const parseNumber = (s: string): Result.Result<number, Error> =>
@@ -3344,8 +3327,9 @@ export const flatMapNullishOr = /*#__PURE__*/dual(2, (self, f) => flatMap(self,
  *     : Result.succeed(Number(s))
  *
  * const liftedParseNumber = Array.liftResult(parseNumber)
- * console.log(liftedParseNumber("42")) // [42]
- * console.log(liftedParseNumber("not a number")) // []
+ *
+ * liftedParseNumber("42") // => [42]
+ * liftedParseNumber("not a number") // => []
  * ```
  *
  * @see {@link liftOption} — lift an Option-returning function
@@ -3369,16 +3353,16 @@ export const liftResult = f => (...a) => {
  *
  * **Example** (Testing all elements)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * console.log(Array.every([2, 4, 6], (x) => x % 2 === 0)) // true
- * console.log(Array.every([2, 3, 6], (x) => x % 2 === 0)) // false
+ * Array.every([2, 4, 6], (x) => x % 2 === 0) // => true
+ * Array.every([2, 3, 6], (x) => x % 2 === 0) // => false
  * ```
  *
  * @see {@link some} — test if any element matches
  *
- * @category elements
+ * @category guards
  * @since 2.0.0
  */
 export const every = /*#__PURE__*/dual(2, (self, refinement) => self.every(refinement));
@@ -3388,17 +3372,17 @@ export const every = /*#__PURE__*/dual(2, (self, refinement) => self.every(refin
  *
  * **Example** (Testing for any match)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * console.log(Array.some([1, 3, 4], (x) => x % 2 === 0)) // true
- * console.log(Array.some([1, 3, 5], (x) => x % 2 === 0)) // false
+ * Array.some([1, 3, 4], (x) => x % 2 === 0) // => true
+ * Array.some([1, 3, 5], (x) => x % 2 === 0) // => false
  * ```
  *
  * @see {@link every} — test if all elements match
  * @see {@link contains} — test for a specific value
  *
- * @category elements
+ * @category guards
  * @since 2.0.0
  */
 export const some = /*#__PURE__*/dual(2, (self, predicate) => self.some(predicate));
@@ -3417,10 +3401,10 @@ export const some = /*#__PURE__*/dual(2, (self, predicate) => self.some(predicat
  *
  * **Example** (Computing suffix lengths)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * console.log(Array.extend([1, 2, 3], (as) => as.length)) // [3, 2, 1]
+ * Array.extend([1, 2, 3], (as) => as.length) // => [3, 2, 1]
  * ```
  *
  * @see {@link scan} for keeping intermediate accumulator values during a fold
@@ -3435,16 +3419,16 @@ export const extend = /*#__PURE__*/dual(2, (self, f) => self.map((_, i, as) => f
  *
  * **Example** (Finding the minimum)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array, Order } from "effect"
  *
- * console.log(Array.min([3, 1, 2], Order.Number)) // 1
+ * Array.min([3, 1, 2], Order.Number) // => 1
  * ```
  *
  * @see {@link max} — find the maximum
  * @see {@link sort} — sort the entire array
  *
- * @category elements
+ * @category getters
  * @since 2.0.0
  */
 export const min = /*#__PURE__*/dual(2, (self, O) => self.reduce(Order.min(O)));
@@ -3454,16 +3438,16 @@ export const min = /*#__PURE__*/dual(2, (self, O) => self.reduce(Order.min(O)));
  *
  * **Example** (Finding the maximum)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array, Order } from "effect"
  *
- * console.log(Array.max([3, 1, 2], Order.Number)) // 3
+ * Array.max([3, 1, 2], Order.Number) // => 3
  * ```
  *
  * @see {@link min} — find the minimum
  * @see {@link sort} — sort the entire array
  *
- * @category elements
+ * @category getters
  * @since 2.0.0
  */
 export const max = /*#__PURE__*/dual(2, (self, O) => self.reduce(Order.max(O)));
@@ -3474,11 +3458,10 @@ export const max = /*#__PURE__*/dual(2, (self, O) => self.reduce(Order.max(O)));
  *
  * **Example** (Generating a sequence)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array, Option } from "effect"
  *
- * console.log(Array.unfold(1, (n) => n <= 5 ? Option.some([n, n + 1]) : Option.none()))
- * // [1, 2, 3, 4, 5]
+ * Array.unfold(1, (n) => n <= 5 ? Option.some([n, n + 1]) : Option.none()) // => [1, 2, 3, 4, 5]
  * ```
  *
  * @see {@link makeBy} — generate from index
@@ -3508,11 +3491,12 @@ export const unfold = (b, f) => {
  *
  * **Example** (Comparing arrays)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array, Order } from "effect"
  *
  * const arrayOrder = Array.makeOrder(Order.Number)
- * console.log(arrayOrder([1, 2], [1, 3])) // -1
+ *
+ * arrayOrder([1, 2], [1, 3]) // => -1
  * ```
  *
  * @see {@link makeEquivalence} — create an equivalence for arrays
@@ -3528,11 +3512,12 @@ export const makeOrder = Order.Array;
  *
  * **Example** (Comparing arrays for equality)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
  * const eq = Array.makeEquivalence<number>((a, b) => a === b)
- * console.log(eq([1, 2, 3], [1, 2, 3])) // true
+ *
+ * eq([1, 2, 3], [1, 2, 3]) // => true
  * ```
  *
  * @see {@link makeOrder} — create an ordering for arrays
@@ -3551,15 +3536,18 @@ export const makeEquivalence = Equivalence.Array;
  *
  * **Example** (Iterating with side-effects)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * Array.forEach([1, 2, 3], (n) => console.log(n)) // 1, 2, 3
+ * const visited: Array<number> = []
+ * Array.forEach([1, 2, 3], (n) => visited.push(n))
+ *
+ * visited // => [1, 2, 3]
  * ```
  *
  * @see {@link map} for transforming each element into a new array
  *
- * @category elements
+ * @category traversing
  * @since 2.0.0
  */
 export const forEach = /*#__PURE__*/dual(2, (self, f) => fromIterable(self).forEach((a, i) => f(a, i)));
@@ -3574,16 +3562,16 @@ export const forEach = /*#__PURE__*/dual(2, (self, f) => fromIterable(self).forE
  *
  * **Example** (Deduplicating with custom equality)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * console.log(Array.dedupeWith([1, 2, 2, 3, 3, 3], (a, b) => a === b)) // [1, 2, 3]
+ * Array.dedupeWith([1, 2, 2, 3, 3, 3], (a, b) => a === b) // => [1, 2, 3]
  * ```
  *
  * @see {@link dedupe} — uses default equality
  * @see {@link dedupeAdjacentWith} — only dedupes consecutive elements
  *
- * @category elements
+ * @category deduplication
  * @since 2.0.0
  */
 export const dedupeWith = /*#__PURE__*/dual(2, (self, isEquivalent) => {
@@ -3611,16 +3599,16 @@ export const dedupeWith = /*#__PURE__*/dual(2, (self, isEquivalent) => {
  *
  * **Example** (Removing duplicates)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * console.log(Array.dedupe([1, 2, 1, 3, 2, 4])) // [1, 2, 3, 4]
+ * Array.dedupe([1, 2, 1, 3, 2, 4]) // => [1, 2, 3, 4]
  * ```
  *
  * @see {@link dedupeWith} — use custom equality
  * @see {@link dedupeAdjacent} — only dedupes consecutive elements
  *
- * @category elements
+ * @category deduplication
  * @since 2.0.0
  */
 export const dedupe = self => {
@@ -3652,17 +3640,16 @@ export const dedupe = self => {
  *
  * **Example** (Deduplicating adjacent elements)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * console.log(Array.dedupeAdjacentWith([1, 1, 2, 2, 3, 3], (a, b) => a === b))
- * // [1, 2, 3]
+ * Array.dedupeAdjacentWith([1, 1, 2, 2, 3, 3], (a, b) => a === b) // => [1, 2, 3]
  * ```
  *
  * @see {@link dedupeAdjacent} — uses default equality
  * @see {@link dedupeWith} — dedupes all duplicates, not just adjacent
  *
- * @category elements
+ * @category deduplication
  * @since 2.0.0
  */
 export const dedupeAdjacentWith = /*#__PURE__*/dual(2, (self, isEquivalent) => {
@@ -3686,16 +3673,16 @@ export const dedupeAdjacentWith = /*#__PURE__*/dual(2, (self, isEquivalent) => {
  *
  * **Example** (Removing adjacent duplicates)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * console.log(Array.dedupeAdjacent([1, 1, 2, 2, 3, 3])) // [1, 2, 3]
+ * Array.dedupeAdjacent([1, 1, 2, 2, 3, 3]) // => [1, 2, 3]
  * ```
  *
  * @see {@link dedupeAdjacentWith} — use custom equality
  * @see {@link dedupe} — remove all duplicates
  *
- * @category elements
+ * @category deduplication
  * @since 2.0.0
  */
 export const dedupeAdjacent = /*#__PURE__*/dedupeAdjacentWith(/*#__PURE__*/Equal.asEquivalence());
@@ -3704,10 +3691,10 @@ export const dedupeAdjacent = /*#__PURE__*/dedupeAdjacentWith(/*#__PURE__*/Equal
  *
  * **Example** (Joining strings)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * console.log(Array.join(["a", "b", "c"], "-")) // "a-b-c"
+ * Array.join(["a", "b", "c"], "-") // => "a-b-c"
  * ```
  *
  * @see {@link intersperse} — insert separator elements without joining
@@ -3733,11 +3720,10 @@ export const join = /*#__PURE__*/dual(2, (self, sep) => fromIterable(self).join(
  *
  * **Example** (Running sum alongside mapped values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * const result = Array.mapAccum([1, 2, 3], 0, (acc, n) => [acc + n, acc + n])
- * console.log(result) // [6, [1, 3, 6]]
+ * Array.mapAccum([1, 2, 3], 0, (acc, n) => [acc + n, acc + n]) // => [6, [1, 3, 6]]
  * ```
  *
  * @see {@link scan} — when you only need the accumulated results (not the final state)
@@ -3774,16 +3760,15 @@ export const mapAccum = /*#__PURE__*/dual(3, (self, s, f) => {
  *
  * **Example** (Combining numbers and letters)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * const result = Array.cartesianWith([1, 2], ["a", "b"], (a, b) => `${a}-${b}`)
- * console.log(result) // ["1-a", "1-b", "2-a", "2-b"]
+ * Array.cartesianWith([1, 2], ["a", "b"], (a, b) => `${a}-${b}`) // => ["1-a", "1-b", "2-a", "2-b"]
  * ```
  *
  * @see {@link cartesian} for returning tuples instead of applying a combiner
  *
- * @category elements
+ * @category combining
  * @since 2.0.0
  */
 export const cartesianWith = /*#__PURE__*/dual(3, (self, that, f) => flatMap(self, a => map(that, b => f(a, b))));
@@ -3801,16 +3786,15 @@ export const cartesianWith = /*#__PURE__*/dual(3, (self, that, f) => flatMap(sel
  *
  * **Example** (Generating all pairs from two arrays)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * const result = Array.cartesian([1, 2], ["a", "b"])
- * console.log(result) // [[1, "a"], [1, "b"], [2, "a"], [2, "b"]]
+ * Array.cartesian([1, 2], ["a", "b"]) // => [[1, "a"], [1, "b"], [2, "a"], [2, "b"]]
  * ```
  *
  * @see {@link cartesianWith} — apply a combiner to each pair
  *
- * @category elements
+ * @category combining
  * @since 2.0.0
  */
 export const cartesian = /*#__PURE__*/dual(2, (self, that) => cartesianWith(self, that, (a, b) => [a, b]));
@@ -3833,24 +3817,23 @@ export const cartesian = /*#__PURE__*/dual(2, (self, that) => cartesianWith(self
  *
  * **Example** (Building array comprehensions with do notation)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array, pipe } from "effect"
  *
- * const result = pipe(
+ * pipe(
  *   Array.Do,
  *   Array.bind("x", () => [1, 3, 5]),
  *   Array.bind("y", () => [2, 4, 6]),
  *   Array.filter(({ x, y }) => x < y),
  *   Array.map(({ x, y }) => [x, y] as const)
- * )
- * console.log(result) // [[1, 2], [1, 4], [1, 6], [3, 4], [3, 6], [5, 6]]
+ * ) // => [[1, 2], [1, 4], [1, 6], [3, 4], [3, 6], [5, 6]]
  * ```
  *
  * @see {@link bind} — introduce an array variable into the scope
  * @see {@link bindTo} — start a pipeline by naming the first array
  * @see {@link let_ let} — introduce a plain computed value
  *
- * @category do notation
+ * @category constructors
  * @since 3.2.0
  */
 export const Do = /*#__PURE__*/of({});
@@ -3870,23 +3853,21 @@ export const Do = /*#__PURE__*/of({});
  *
  * **Example** (Binding two arrays)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array, pipe } from "effect"
  *
- * const result = pipe(
+ * pipe(
  *   Array.Do,
  *   Array.bind("x", () => [1, 2]),
  *   Array.bind("y", () => ["a", "b"])
- * )
- * console.log(result)
- * // [{ x: 1, y: "a" }, { x: 1, y: "b" }, { x: 2, y: "a" }, { x: 2, y: "b" }]
+ * ) // => [{ x: 1, y: "a" }, { x: 1, y: "b" }, { x: 2, y: "a" }, { x: 2, y: "b" }]
  * ```
  *
  * @see {@link Do} — start a do-notation pipeline
  * @see {@link bindTo} — name the first array in a pipeline
  * @see {@link let_ let} — add a plain computed value
  *
- * @category do notation
+ * @category sequencing
  * @since 3.2.0
  */
 export const bind = /*#__PURE__*/internalDoNotation.bind(map, flatMap);
@@ -3905,20 +3886,16 @@ export const bind = /*#__PURE__*/internalDoNotation.bind(map, flatMap);
  *
  * **Example** (Naming an existing array)
  *
- * ```ts
- * import { Array, pipe } from "effect"
+ * ```ts import.meta.vitest
+ * import { Array } from "effect"
  *
- * const result = pipe(
- *   [1, 2, 3],
- *   Array.bindTo("x")
- * )
- * console.log(result) // [{ x: 1 }, { x: 2 }, { x: 3 }]
+ * Array.bindTo([1, 2, 3], "x") // => [{ x: 1 }, { x: 2 }, { x: 3 }]
  * ```
  *
  * @see {@link Do} — start with an empty scope
  * @see {@link bind} — add another array variable to the scope
  *
- * @category do notation
+ * @category mapping
  * @since 3.2.0
  */
 export const bindTo = /*#__PURE__*/internalDoNotation.bindTo(map);
@@ -3940,22 +3917,20 @@ export {
  *
  * **Example** (Adding a computed value)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array, pipe } from "effect"
  *
- * const result = pipe(
+ * pipe(
  *   Array.Do,
  *   Array.bind("x", () => [1, 2, 3]),
  *   Array.let("doubled", ({ x }) => x * 2)
- * )
- * console.log(result)
- * // [{ x: 1, doubled: 2 }, { x: 2, doubled: 4 }, { x: 3, doubled: 6 }]
+ * ) // => [{ x: 1, doubled: 2 }, { x: 2, doubled: 4 }, { x: 3, doubled: 6 }]
  * ```
  *
  * @see {@link Do} — start a do-notation pipeline
  * @see {@link bind} — introduce an array variable (produces cartesian product)
  *
- * @category do notation
+ * @category mapping
  * @since 3.2.0
  */
 let_ as let };
@@ -3997,11 +3972,10 @@ export function makeReducerConcat() {
  *
  * **Example** (Counting even numbers)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Array } from "effect"
  *
- * const result = Array.countBy([1, 2, 3, 4, 5], (n) => n % 2 === 0)
- * console.log(result) // 2
+ * Array.countBy([1, 2, 3, 4, 5], (n) => n % 2 === 0) // => 2
  * ```
  *
  * @see {@link filter} — when you need the matching elements, not just the count