effect 4.0.0-beta.101 → 4.0.0-beta.103

package/dist/Array.js

@@ -12,8 +12,10 @@
 import * as Equal from "./Equal.js";
 import * as Equivalence from "./Equivalence.js";
 import { dual, identity } from "./Function.js";
+import * as Hash from "./Hash.js";
 import * as internalArray from "./internal/array.js";
 import * as internalDoNotation from "./internal/doNotation.js";
+import * as InternalRecord from "./internal/record.js";
 import * as moduleIterable from "./Iterable.js";
 import * as Option from "./Option.js";
 import * as Order from "./Order.js";
@@ -31,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
@@ -56,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
@@ -83,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
@@ -111,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
@@ -146,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
@@ -174,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
@@ -202,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
@@ -232,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
@@ -261,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
@@ -284,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
@@ -311,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
@@ -347,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
@@ -383,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
@@ -414,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
@@ -441,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
@@ -465,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
@@ -493,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
@@ -522,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
@@ -559,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
@@ -595,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
@@ -614,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
@@ -633,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
@@ -658,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
@@ -683,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
@@ -706,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
@@ -718,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));
 /**
@@ -736,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
@@ -769,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
  * ```
  *
@@ -802,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
@@ -832,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
@@ -857,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
@@ -882,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
@@ -904,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
@@ -929,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
@@ -954,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
@@ -980,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
@@ -1007,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
@@ -1033,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
@@ -1059,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
@@ -1089,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
@@ -1122,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
@@ -1206,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
@@ -1238,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
@@ -1268,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
@@ -1297,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
@@ -1361,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) => {
@@ -1393,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) => {
@@ -1431,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;
@@ -1461,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) => {
@@ -1505,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) => {
@@ -1548,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);
 });
 /**
@@ -1582,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));
@@ -1610,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);
 });
 /**
@@ -1645,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;
 });
 /**
@@ -1680,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();
@@ -1704,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
@@ -1736,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(([_]) => _));
@@ -1766,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 = [
@@ -1775,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`
@@ -1816,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
@@ -1840,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
@@ -1869,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
@@ -1907,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) => {
@@ -1943,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)]);
@@ -1966,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));
@@ -1990,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))));
@@ -2013,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));
@@ -2043,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) => {
@@ -2082,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) => {
@@ -2113,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());
@@ -2141,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) => {
@@ -2186,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
@@ -2220,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
@@ -2249,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
@@ -2275,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
@@ -2303,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();
@@ -2332,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) => {
@@ -2366,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
@@ -2399,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
@@ -2435,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()`
@@ -2476,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
@@ -2504,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 = [
@@ -2513,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
@@ -2531,11 +2524,46 @@ export const groupBy = /*#__PURE__*/dual(2, (self, f) => {
     if (Object.hasOwn(out, k)) {
       out[k].push(a);
     } else {
-      out[k] = [a];
+      InternalRecord.assignProperty(out, k, [a]);
     }
   }
   return out;
 });
+const hashBucketsAdd = (buckets, value) => {
+  const hash = Hash.hash(value);
+  const bucket = buckets.get(hash);
+  if (bucket === undefined) {
+    buckets.set(hash, [value]);
+    return true;
+  }
+  // Hash collisions still require an Effect equality check.
+  for (const previous of bucket) {
+    if (Equal.equals(previous, value)) {
+      return false;
+    }
+  }
+  bucket.push(value);
+  return true;
+};
+const makeHashBuckets = values => {
+  const buckets = new Map();
+  for (const value of values) {
+    hashBucketsAdd(buckets, value);
+  }
+  return buckets;
+};
+const hashBucketsHas = (buckets, value) => {
+  const bucket = buckets.get(Hash.hash(value));
+  if (bucket === undefined) {
+    return false;
+  }
+  for (const candidate of bucket) {
+    if (Equal.equals(candidate, value)) {
+      return true;
+    }
+  }
+  return false;
+};
 /**
  * Computes the union of two arrays using a custom equivalence, removing
  * duplicates.
@@ -2547,17 +2575,17 @@ export const groupBy = /*#__PURE__*/dual(2, (self, f) => {
  *
  * **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) => {
@@ -2578,20 +2606,27 @@ 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) => unionWith(self, that, Equal.asEquivalence()));
+export const union = /*#__PURE__*/dual(2, (self, that) => {
+  const a = fromIterable(self);
+  const b = fromIterable(that);
+  if (isReadonlyArrayNonEmpty(a)) {
+    return isReadonlyArrayNonEmpty(b) ? dedupe(appendAll(a, b)) : a;
+  }
+  return b;
+});
 /**
  * Computes the intersection of two arrays using a custom equivalence. Order is
  * determined by the first array.
@@ -2603,20 +2638,21 @@ export const union = /*#__PURE__*/dual(2, (self, that) => unionWith(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 => {
@@ -2637,20 +2673,28 @@ 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__*/intersectionWith(/*#__PURE__*/Equal.asEquivalence());
+export const intersection = /*#__PURE__*/dual(2, (self, that) => {
+  const thatArray = fromIterable(that);
+  const selfArray = fromIterable(self);
+  if (selfArray.length === 0 || thatArray.length === 0) {
+    return [];
+  }
+  const buckets = makeHashBuckets(thatArray);
+  return selfArray.filter(value => hashBucketsHas(buckets, value));
+});
 /**
  * Computes elements in the first array that are not in the second, using a
  * custom equivalence.
@@ -2662,18 +2706,17 @@ export const intersection = /*#__PURE__*/intersectionWith(/*#__PURE__*/Equal.asE
  *
  * **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 => {
@@ -2694,20 +2737,31 @@ 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__*/differenceWith(/*#__PURE__*/Equal.asEquivalence());
+export const difference = /*#__PURE__*/dual(2, (self, that) => {
+  const thatArray = fromIterable(that);
+  const selfArray = fromIterable(self);
+  if (selfArray.length === 0) {
+    return [];
+  }
+  if (thatArray.length === 0) {
+    return selfArray.filter(() => true);
+  }
+  const buckets = makeHashBuckets(thatArray);
+  return selfArray.filter(value => !hashBucketsHas(buckets, value));
+});
 /**
  * Creates an empty array.
  *
@@ -2717,11 +2771,10 @@ export const difference = /*#__PURE__*/differenceWith(/*#__PURE__*/Equal.asEquiv
  *
  * **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
@@ -2736,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
@@ -2763,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
@@ -2790,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
@@ -2825,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
@@ -2847,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
@@ -2879,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
@@ -2912,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
@@ -2948,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
@@ -2987,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
@@ -3023,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
@@ -3067,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
@@ -3098,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
@@ -3124,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
@@ -3143,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
@@ -3169,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
@@ -3197,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
@@ -3218,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
@@ -3247,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
@@ -3272,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> =>
@@ -3281,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
@@ -3306,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));
@@ -3325,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));
@@ -3354,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
@@ -3372,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)));
@@ -3391,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)));
@@ -3411,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
@@ -3445,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
@@ -3465,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
@@ -3488,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)));
@@ -3511,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) => {
@@ -3548,19 +3599,32 @@ 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 => dedupeWith(self, Equal.asEquivalence());
+export const dedupe = self => {
+  const input = fromIterable(self);
+  if (input.length < 2) {
+    return [...input];
+  }
+  const buckets = new Map();
+  const out = [];
+  for (const value of input) {
+    if (hashBucketsAdd(buckets, value)) {
+      out.push(value);
+    }
+  }
+  return out;
+};
 /**
  * Removes consecutive duplicate elements using a custom equivalence.
  *
@@ -3576,17 +3640,16 @@ export const dedupe = self => dedupeWith(self, Equal.asEquivalence());
  *
  * **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) => {
@@ -3610,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());
@@ -3628,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
@@ -3657,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)
@@ -3698,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))));
@@ -3725,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]));
@@ -3757,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({});
@@ -3794,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);
@@ -3829,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);
@@ -3864,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 };
@@ -3921,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