effect 4.0.0-beta.98 → 4.0.0-rc.108

package/src/Iterable.ts

@@ -12,6 +12,7 @@
 import type { NonEmptyArray } from "./Array.ts"
 import * as Equal from "./Equal.ts"
 import { dual } from "./Function.ts"
+import * as InternalRecord from "./internal/record.ts"
 import type { Option } from "./Option.ts"
 import * as O from "./Option.ts"
 import { isBoolean } from "./Predicate.ts"
@@ -32,21 +33,21 @@ import type { NoInfer } from "./Types.ts"
  *
  * **Example** (Generating values by index)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Iterable } from "effect"
  *
  * // Generate first 5 even numbers
  * const evens = Iterable.makeBy((n) => n * 2, { length: 5 })
- * console.log(Array.from(evens)) // [0, 2, 4, 6, 8]
+ * Array.from(evens) // => [0, 2, 4, 6, 8]
  *
  * // Generate squares
  * const squares = Iterable.makeBy((n) => n * n, { length: 4 })
- * console.log(Array.from(squares)) // [0, 1, 4, 9]
+ * Array.from(squares) // => [0, 1, 4, 9]
  *
  * // Infinite sequence (be careful when consuming!)
  * const naturals = Iterable.makeBy((n) => n)
  * const first10 = Iterable.take(naturals, 10)
- * console.log(Array.from(first10)) // [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+ * Array.from(first10) // => [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  * ```
  *
  * @category constructors
@@ -82,11 +83,10 @@ export const makeBy = <A>(f: (i: number) => A, options?: {
  *
  * **Example** (Creating a range)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Iterable } from "effect"
- * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(Array.from(Iterable.range(1, 3)), [1, 2, 3])
+ * Array.from(Iterable.range(1, 3)) // => [1, 2, 3]
  * ```
  *
  * @category constructors
@@ -110,11 +110,10 @@ export const range = (start: number, end?: number): Iterable<number> => {
  *
  * **Example** (Repeating a value)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Iterable } from "effect"
- * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(Array.from(Iterable.replicate("a", 3)), ["a", "a", "a"])
+ * Array.from(Iterable.replicate("a", 3)) // => ["a", "a", "a"]
  * ```
  *
  * @category constructors
@@ -130,11 +129,10 @@ export const replicate: {
    *
    * **Example** (Repeating a value)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Iterable } from "effect"
-   * import * as assert from "node:assert"
    *
-   * assert.deepStrictEqual(Array.from(Iterable.replicate("a", 3)), ["a", "a", "a"])
+   * Array.from(Iterable.replicate("a", 3)) // => ["a", "a", "a"]
    * ```
    *
    * @category constructors
@@ -150,11 +148,10 @@ export const replicate: {
    *
    * **Example** (Repeating a value)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Iterable } from "effect"
-   * import * as assert from "node:assert"
    *
-   * assert.deepStrictEqual(Array.from(Iterable.replicate("a", 3)), ["a", "a", "a"])
+   * Array.from(Iterable.replicate("a", 3)) // => ["a", "a", "a"]
    * ```
    *
    * @category constructors
@@ -245,15 +242,11 @@ export const forever = <A>(self: Iterable<A>): Iterable<A> => repeat(self, Infin
  *
  * **Example** (Converting a record to entries)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Iterable } from "effect"
- * import * as assert from "node:assert"
  *
  * const x = { a: 1, b: 2, c: 3 }
- * assert.deepStrictEqual(Array.from(Iterable.fromRecord(x)), [["a", 1], ["b", 2], [
- *   "c",
- *   3
- * ]])
+ * Array.from(Iterable.fromRecord(x)) // => [["a", 1], ["b", 2], ["c", 3]]
  * ```
  *
  * @category converting
@@ -274,17 +267,17 @@ export const fromRecord = <K extends string, A>(self: Readonly<Record<K, A>>): I
  *
  * **Example** (Prepending an element)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Iterable } from "effect"
  *
  * const numbers = [2, 3, 4]
  * const withOne = Iterable.prepend(numbers, 1)
- * console.log(Array.from(withOne)) // [1, 2, 3, 4]
+ * Array.from(withOne) // => [1, 2, 3, 4]
  *
  * // Works with any iterable
  * const letters = "abc"
  * const withZ = Iterable.prepend(letters, "z")
- * console.log(Array.from(withZ)) // ["z", "a", "b", "c"]
+ * Array.from(withZ) // => ["z", "a", "b", "c"]
  * ```
  *
  * @category combining
@@ -296,17 +289,17 @@ export const prepend: {
    *
    * **Example** (Prepending an element)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Iterable } from "effect"
    *
    * const numbers = [2, 3, 4]
    * const withOne = Iterable.prepend(numbers, 1)
-   * console.log(Array.from(withOne)) // [1, 2, 3, 4]
+   * Array.from(withOne) // => [1, 2, 3, 4]
    *
    * // Works with any iterable
    * const letters = "abc"
    * const withZ = Iterable.prepend(letters, "z")
-   * console.log(Array.from(withZ)) // ["z", "a", "b", "c"]
+   * Array.from(withZ) // => ["z", "a", "b", "c"]
    * ```
    *
    * @category combining
@@ -318,17 +311,17 @@ export const prepend: {
    *
    * **Example** (Prepending an element)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Iterable } from "effect"
    *
    * const numbers = [2, 3, 4]
    * const withOne = Iterable.prepend(numbers, 1)
-   * console.log(Array.from(withOne)) // [1, 2, 3, 4]
+   * Array.from(withOne) // => [1, 2, 3, 4]
    *
    * // Works with any iterable
    * const letters = "abc"
    * const withZ = Iterable.prepend(letters, "z")
-   * console.log(Array.from(withZ)) // ["z", "a", "b", "c"]
+   * Array.from(withZ) // => ["z", "a", "b", "c"]
    * ```
    *
    * @category combining
@@ -342,14 +335,10 @@ export const prepend: {
  *
  * **Example** (Prepending another iterable)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Iterable } from "effect"
- * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(
- *   Array.from(Iterable.prependAll([1, 2], ["a", "b"])),
- *   ["a", "b", 1, 2]
- * )
+ * Array.from(Iterable.prependAll([1, 2], ["a", "b"])) // => ["a", "b", 1, 2]
  * ```
  *
  * @category combining
@@ -361,14 +350,10 @@ export const prependAll: {
    *
    * **Example** (Prepending another iterable)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Iterable } from "effect"
-   * import * as assert from "node:assert"
    *
-   * assert.deepStrictEqual(
-   *   Array.from(Iterable.prependAll([1, 2], ["a", "b"])),
-   *   ["a", "b", 1, 2]
-   * )
+   * Array.from(Iterable.prependAll([1, 2], ["a", "b"])) // => ["a", "b", 1, 2]
    * ```
    *
    * @category combining
@@ -380,14 +365,10 @@ export const prependAll: {
    *
    * **Example** (Prepending another iterable)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Iterable } from "effect"
-   * import * as assert from "node:assert"
    *
-   * assert.deepStrictEqual(
-   *   Array.from(Iterable.prependAll([1, 2], ["a", "b"])),
-   *   ["a", "b", 1, 2]
-   * )
+   * Array.from(Iterable.prependAll([1, 2], ["a", "b"])) // => ["a", "b", 1, 2]
    * ```
    *
    * @category combining
@@ -419,19 +400,11 @@ export const prependAll: {
  *
  * **Example** (Appending an element)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Iterable } from "effect"
  *
  * const numbers = [1, 2, 3]
- * const withFour = Iterable.append(numbers, 4)
- * console.log(Array.from(withFour)) // [1, 2, 3, 4]
- *
- * // Chain multiple appends
- * const result = Iterable.append(
- *   Iterable.append([1, 2], 3),
- *   4
- * )
- * console.log(Array.from(result)) // [1, 2, 3, 4]
+ * Array.from(Iterable.append(numbers, 4)) // => [1, 2, 3, 4]
  * ```
  *
  * @see {@link prepend} for adding one element before the existing elements
@@ -461,19 +434,11 @@ export const append: {
    *
    * **Example** (Appending an element)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Iterable } from "effect"
    *
    * const numbers = [1, 2, 3]
-   * const withFour = Iterable.append(numbers, 4)
-   * console.log(Array.from(withFour)) // [1, 2, 3, 4]
-   *
-   * // Chain multiple appends
-   * const result = Iterable.append(
-   *   Iterable.append([1, 2], 3),
-   *   4
-   * )
-   * console.log(Array.from(result)) // [1, 2, 3, 4]
+   * Array.from(Iterable.append(numbers, 4)) // => [1, 2, 3, 4]
    * ```
    *
    * @see {@link prepend} for adding one element before the existing elements
@@ -503,19 +468,11 @@ export const append: {
    *
    * **Example** (Appending an element)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Iterable } from "effect"
    *
    * const numbers = [1, 2, 3]
-   * const withFour = Iterable.append(numbers, 4)
-   * console.log(Array.from(withFour)) // [1, 2, 3, 4]
-   *
-   * // Chain multiple appends
-   * const result = Iterable.append(
-   *   Iterable.append([1, 2], 3),
-   *   4
-   * )
-   * console.log(Array.from(result)) // [1, 2, 3, 4]
+   * Array.from(Iterable.append(numbers, 4)) // => [1, 2, 3, 4]
    * ```
    *
    * @see {@link prepend} for adding one element before the existing elements
@@ -546,25 +503,21 @@ export const append: {
  *
  * **Example** (Concatenating iterables)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Iterable } from "effect"
  *
- * const first = [1, 2, 3]
- * const second = [4, 5, 6]
- * const combined = Iterable.appendAll(first, second)
- * console.log(Array.from(combined)) // [1, 2, 3, 4, 5, 6]
+ * Array.from(Iterable.appendAll([1, 2, 3], [4, 5, 6])) // => [1, 2, 3, 4, 5, 6]
  *
  * // Works with different iterable types
  * const numbers = [1, 2]
  * const letters = "abc"
  * const mixed = Iterable.appendAll(numbers, letters)
- * console.log(Array.from(mixed)) // [1, 2, "a", "b", "c"]
+ * Array.from(mixed) // => [1, 2, "a", "b", "c"]
  *
  * // Lazy evaluation - only consumes what's needed
  * const infinite = Iterable.range(1)
  * const finite = [0, -1, -2]
- * const result = Iterable.take(Iterable.appendAll(finite, infinite), 5)
- * console.log(Array.from(result)) // [0, -1, -2, 1, 2]
+ * Array.from(Iterable.take(Iterable.appendAll(finite, infinite), 5)) // => [0, -1, -2, 1, 2]
  * ```
  *
  * @see {@link append} for appending one value instead of another iterable
@@ -593,25 +546,21 @@ export const appendAll: {
    *
    * **Example** (Concatenating iterables)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Iterable } from "effect"
    *
-   * const first = [1, 2, 3]
-   * const second = [4, 5, 6]
-   * const combined = Iterable.appendAll(first, second)
-   * console.log(Array.from(combined)) // [1, 2, 3, 4, 5, 6]
+   * Array.from(Iterable.appendAll([1, 2, 3], [4, 5, 6])) // => [1, 2, 3, 4, 5, 6]
    *
    * // Works with different iterable types
    * const numbers = [1, 2]
    * const letters = "abc"
    * const mixed = Iterable.appendAll(numbers, letters)
-   * console.log(Array.from(mixed)) // [1, 2, "a", "b", "c"]
+   * Array.from(mixed) // => [1, 2, "a", "b", "c"]
    *
    * // Lazy evaluation - only consumes what's needed
    * const infinite = Iterable.range(1)
    * const finite = [0, -1, -2]
-   * const result = Iterable.take(Iterable.appendAll(finite, infinite), 5)
-   * console.log(Array.from(result)) // [0, -1, -2, 1, 2]
+   * Array.from(Iterable.take(Iterable.appendAll(finite, infinite), 5)) // => [0, -1, -2, 1, 2]
    * ```
    *
    * @see {@link append} for appending one value instead of another iterable
@@ -640,25 +589,21 @@ export const appendAll: {
    *
    * **Example** (Concatenating iterables)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Iterable } from "effect"
    *
-   * const first = [1, 2, 3]
-   * const second = [4, 5, 6]
-   * const combined = Iterable.appendAll(first, second)
-   * console.log(Array.from(combined)) // [1, 2, 3, 4, 5, 6]
+   * Array.from(Iterable.appendAll([1, 2, 3], [4, 5, 6])) // => [1, 2, 3, 4, 5, 6]
    *
    * // Works with different iterable types
    * const numbers = [1, 2]
    * const letters = "abc"
    * const mixed = Iterable.appendAll(numbers, letters)
-   * console.log(Array.from(mixed)) // [1, 2, "a", "b", "c"]
+   * Array.from(mixed) // => [1, 2, "a", "b", "c"]
    *
    * // Lazy evaluation - only consumes what's needed
    * const infinite = Iterable.range(1)
    * const finite = [0, -1, -2]
-   * const result = Iterable.take(Iterable.appendAll(finite, infinite), 5)
-   * console.log(Array.from(result)) // [0, -1, -2, 1, 2]
+   * Array.from(Iterable.take(Iterable.appendAll(finite, infinite), 5)) // => [0, -1, -2, 1, 2]
    * ```
    *
    * @see {@link append} for appending one value instead of another iterable
@@ -698,23 +643,23 @@ export const appendAll: {
  *
  * **Example** (Tracking running results)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Iterable } from "effect"
  *
  * // Running sum of numbers
  * const numbers = [1, 2, 3, 4, 5]
  * const runningSum = Iterable.scan(numbers, 0, (acc, n) => acc + n)
- * console.log(Array.from(runningSum)) // [0, 1, 3, 6, 10, 15]
+ * Array.from(runningSum) // => [0, 1, 3, 6, 10, 15]
  *
  * // Build strings progressively
  * const letters = ["a", "b", "c"]
  * const progressive = Iterable.scan(letters, "", (acc, letter) => acc + letter)
- * console.log(Array.from(progressive)) // ["", "a", "ab", "abc"]
+ * Array.from(progressive) // => ["", "a", "ab", "abc"]
  *
  * // Track maximum values seen so far
  * const values = [3, 1, 4, 1, 5, 9, 2]
  * const runningMax = Iterable.scan(values, -Infinity, Math.max)
- * console.log(Array.from(runningMax)) // [-Infinity, 3, 3, 4, 4, 5, 9, 9]
+ * Array.from(runningMax) // => [-Infinity, 3, 3, 4, 4, 5, 9, 9]
  * ```
  *
  * @category folding
@@ -726,23 +671,23 @@ export const scan: {
    *
    * **Example** (Tracking running results)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Iterable } from "effect"
    *
    * // Running sum of numbers
    * const numbers = [1, 2, 3, 4, 5]
    * const runningSum = Iterable.scan(numbers, 0, (acc, n) => acc + n)
-   * console.log(Array.from(runningSum)) // [0, 1, 3, 6, 10, 15]
+   * Array.from(runningSum) // => [0, 1, 3, 6, 10, 15]
    *
    * // Build strings progressively
    * const letters = ["a", "b", "c"]
    * const progressive = Iterable.scan(letters, "", (acc, letter) => acc + letter)
-   * console.log(Array.from(progressive)) // ["", "a", "ab", "abc"]
+   * Array.from(progressive) // => ["", "a", "ab", "abc"]
    *
    * // Track maximum values seen so far
    * const values = [3, 1, 4, 1, 5, 9, 2]
    * const runningMax = Iterable.scan(values, -Infinity, Math.max)
-   * console.log(Array.from(runningMax)) // [-Infinity, 3, 3, 4, 4, 5, 9, 9]
+   * Array.from(runningMax) // => [-Infinity, 3, 3, 4, 4, 5, 9, 9]
    * ```
    *
    * @category folding
@@ -754,23 +699,23 @@ export const scan: {
    *
    * **Example** (Tracking running results)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Iterable } from "effect"
    *
    * // Running sum of numbers
    * const numbers = [1, 2, 3, 4, 5]
    * const runningSum = Iterable.scan(numbers, 0, (acc, n) => acc + n)
-   * console.log(Array.from(runningSum)) // [0, 1, 3, 6, 10, 15]
+   * Array.from(runningSum) // => [0, 1, 3, 6, 10, 15]
    *
    * // Build strings progressively
    * const letters = ["a", "b", "c"]
    * const progressive = Iterable.scan(letters, "", (acc, letter) => acc + letter)
-   * console.log(Array.from(progressive)) // ["", "a", "ab", "abc"]
+   * Array.from(progressive) // => ["", "a", "ab", "abc"]
    *
    * // Track maximum values seen so far
    * const values = [3, 1, 4, 1, 5, 9, 2]
    * const runningMax = Iterable.scan(values, -Infinity, Math.max)
-   * console.log(Array.from(runningMax)) // [-Infinity, 3, 3, 4, 4, 5, 9, 9]
+   * Array.from(runningMax) // => [-Infinity, 3, 3, 4, 4, 5, 9, 9]
    * ```
    *
    * @category folding
@@ -802,12 +747,11 @@ export const scan: {
  *
  * **Example** (Checking for emptiness)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Iterable } from "effect"
- * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(Iterable.isEmpty([]), true)
- * assert.deepStrictEqual(Iterable.isEmpty([1, 2, 3]), false)
+ * Iterable.isEmpty([]) // => true
+ * Iterable.isEmpty([1, 2, 3]) // => false
  * ```
  *
  * @category guards
@@ -823,22 +767,22 @@ export const isEmpty = <A>(self: Iterable<A>): self is Iterable<never> => {
  *
  * **Example** (Counting iterable elements)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Iterable } from "effect"
  *
  * const numbers = [1, 2, 3, 4, 5]
- * console.log(Iterable.size(numbers)) // 5
+ * Iterable.size(numbers) // => 5
  *
  * const empty = Iterable.empty<number>()
- * console.log(Iterable.size(empty)) // 0
+ * Iterable.size(empty) // => 0
  *
  * // Works with any iterable
  * const letters = "hello"
- * console.log(Iterable.size(letters)) // 5
+ * Iterable.size(letters) // => 5
  *
  * // Note: This consumes the entire iterable
  * const range = Iterable.range(1, 100)
- * console.log(Iterable.size(range)) // 100
+ * Iterable.size(range) // => 100
  * ```
  *
  * @category getters
@@ -858,24 +802,24 @@ export const size = <A>(self: Iterable<A>): number => {
  *
  * **Example** (Getting the first element)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Iterable, Option } from "effect"
  *
  * const numbers = [1, 2, 3]
- * console.log(Iterable.head(numbers)) // Option.some(1)
+ * Iterable.head(numbers) // => Option.some(1)
  *
  * const empty = Iterable.empty<number>()
- * console.log(Iterable.head(empty)) // Option.none()
+ * Iterable.head(empty) // => Option.none()
  *
  * // Safe way to get first element
  * const firstEven = Iterable.head(
  *   Iterable.filter([1, 3, 4, 5], (x) => x % 2 === 0)
  * )
- * console.log(firstEven) // Option.some(4)
+ * firstEven // => Option.some(4)
  *
  * // Use with Option methods
  * const doubled = Option.map(Iterable.head([5, 10, 15]), (x) => x * 2)
- * console.log(doubled) // Option.some(10)
+ * doubled // => Option.some(10)
  * ```
  *
  * @category getters
@@ -901,21 +845,21 @@ export const head = <A>(self: Iterable<A>): Option<A> => {
  *
  * **Example** (Getting the first element unsafely)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Iterable } from "effect"
  *
  * const numbers = [1, 2, 3]
- * console.log(Iterable.headUnsafe(numbers)) // 1
+ * Iterable.headUnsafe(numbers) // => 1
  *
  * const letters = "hello"
- * console.log(Iterable.headUnsafe(letters)) // "h"
+ * Iterable.headUnsafe(letters) // => "h"
  *
  * // Iterable.headUnsafe(Iterable.empty<number>())
  * // throws Error: "headUnsafe: empty iterable"
  *
  * // Use only when you're certain the iterable is non-empty
  * const nonEmpty = Iterable.range(1, 10)
- * console.log(Iterable.headUnsafe(nonEmpty)) // 1
+ * Iterable.headUnsafe(nonEmpty) // => 1
  * ```
  *
  * @category getters
@@ -937,25 +881,25 @@ export const headUnsafe = <A>(self: Iterable<A>): A => {
  *
  * **Example** (Taking from the start)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Iterable } from "effect"
  *
  * const numbers = [1, 2, 3, 4, 5]
  * const firstThree = Iterable.take(numbers, 3)
- * console.log(Array.from(firstThree)) // [1, 2, 3]
+ * Array.from(firstThree) // => [1, 2, 3]
  *
  * // Taking more than available returns all elements
  * const firstTen = Iterable.take(numbers, 10)
- * console.log(Array.from(firstTen)) // [1, 2, 3, 4, 5]
+ * Array.from(firstTen) // => [1, 2, 3, 4, 5]
  *
  * // Taking 0 or negative returns empty
  * const none = Iterable.take(numbers, 0)
- * console.log(Array.from(none)) // []
+ * Array.from(none) // => []
  *
  * // Useful with infinite iterables
  * const naturals = Iterable.range(1)
  * const firstFive = Iterable.take(naturals, 5)
- * console.log(Array.from(firstFive)) // [1, 2, 3, 4, 5]
+ * Array.from(firstFive) // => [1, 2, 3, 4, 5]
  * ```
  *
  * @category getters
@@ -971,25 +915,25 @@ export const take: {
    *
    * **Example** (Taking from the start)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Iterable } from "effect"
    *
    * const numbers = [1, 2, 3, 4, 5]
    * const firstThree = Iterable.take(numbers, 3)
-   * console.log(Array.from(firstThree)) // [1, 2, 3]
+   * Array.from(firstThree) // => [1, 2, 3]
    *
    * // Taking more than available returns all elements
    * const firstTen = Iterable.take(numbers, 10)
-   * console.log(Array.from(firstTen)) // [1, 2, 3, 4, 5]
+   * Array.from(firstTen) // => [1, 2, 3, 4, 5]
    *
    * // Taking 0 or negative returns empty
    * const none = Iterable.take(numbers, 0)
-   * console.log(Array.from(none)) // []
+   * Array.from(none) // => []
    *
    * // Useful with infinite iterables
    * const naturals = Iterable.range(1)
    * const firstFive = Iterable.take(naturals, 5)
-   * console.log(Array.from(firstFive)) // [1, 2, 3, 4, 5]
+   * Array.from(firstFive) // => [1, 2, 3, 4, 5]
    * ```
    *
    * @category getters
@@ -1005,25 +949,25 @@ export const take: {
    *
    * **Example** (Taking from the start)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Iterable } from "effect"
    *
    * const numbers = [1, 2, 3, 4, 5]
    * const firstThree = Iterable.take(numbers, 3)
-   * console.log(Array.from(firstThree)) // [1, 2, 3]
+   * Array.from(firstThree) // => [1, 2, 3]
    *
    * // Taking more than available returns all elements
    * const firstTen = Iterable.take(numbers, 10)
-   * console.log(Array.from(firstTen)) // [1, 2, 3, 4, 5]
+   * Array.from(firstTen) // => [1, 2, 3, 4, 5]
    *
    * // Taking 0 or negative returns empty
    * const none = Iterable.take(numbers, 0)
-   * console.log(Array.from(none)) // []
+   * Array.from(none) // => []
    *
    * // Useful with infinite iterables
    * const naturals = Iterable.range(1)
    * const firstFive = Iterable.take(naturals, 5)
-   * console.log(Array.from(firstFive)) // [1, 2, 3, 4, 5]
+   * Array.from(firstFive) // => [1, 2, 3, 4, 5]
    * ```
    *
    * @category getters
@@ -1052,22 +996,22 @@ export const take: {
  *
  * **Example** (Taking while a predicate holds)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Iterable } from "effect"
  *
  * const numbers = [2, 4, 6, 8, 3, 10, 12]
  * const evenPrefix = Iterable.takeWhile(numbers, (x) => x % 2 === 0)
- * console.log(Array.from(evenPrefix)) // [2, 4, 6, 8]
+ * Array.from(evenPrefix) // => [2, 4, 6, 8]
  *
  * // With index
  * const letters = ["a", "b", "c", "d", "e"]
  * const firstThreeByIndex = Iterable.takeWhile(letters, (_, i) => i < 3)
- * console.log(Array.from(firstThreeByIndex)) // ["a", "b", "c"]
+ * Array.from(firstThreeByIndex) // => ["a", "b", "c"]
  *
  * // Stops at first non-matching element
  * const mixed = [1, 3, 5, 4, 7, 9]
  * const oddPrefix = Iterable.takeWhile(mixed, (x) => x % 2 === 1)
- * console.log(Array.from(oddPrefix)) // [1, 3, 5]
+ * Array.from(oddPrefix) // => [1, 3, 5]
  *
  * // Type refinement
  * const values: Array<string | number> = ["a", "b", "c", 1, "d"]
@@ -1075,7 +1019,7 @@ export const take: {
  *   values,
  *   (x): x is string => typeof x === "string"
  * )
- * console.log(Array.from(stringPrefix)) // ["a", "b", "c"] (typed as string[])
+ * Array.from(stringPrefix) // => ["a", "b", "c"]
  * ```
  *
  * @category getters
@@ -1088,22 +1032,22 @@ export const takeWhile: {
    *
    * **Example** (Taking while a predicate holds)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Iterable } from "effect"
    *
    * const numbers = [2, 4, 6, 8, 3, 10, 12]
    * const evenPrefix = Iterable.takeWhile(numbers, (x) => x % 2 === 0)
-   * console.log(Array.from(evenPrefix)) // [2, 4, 6, 8]
+   * Array.from(evenPrefix) // => [2, 4, 6, 8]
    *
    * // With index
    * const letters = ["a", "b", "c", "d", "e"]
    * const firstThreeByIndex = Iterable.takeWhile(letters, (_, i) => i < 3)
-   * console.log(Array.from(firstThreeByIndex)) // ["a", "b", "c"]
+   * Array.from(firstThreeByIndex) // => ["a", "b", "c"]
    *
    * // Stops at first non-matching element
    * const mixed = [1, 3, 5, 4, 7, 9]
    * const oddPrefix = Iterable.takeWhile(mixed, (x) => x % 2 === 1)
-   * console.log(Array.from(oddPrefix)) // [1, 3, 5]
+   * Array.from(oddPrefix) // => [1, 3, 5]
    *
    * // Type refinement
    * const values: Array<string | number> = ["a", "b", "c", 1, "d"]
@@ -1111,7 +1055,7 @@ export const takeWhile: {
    *   values,
    *   (x): x is string => typeof x === "string"
    * )
-   * console.log(Array.from(stringPrefix)) // ["a", "b", "c"] (typed as string[])
+   * Array.from(stringPrefix) // => ["a", "b", "c"]
    * ```
    *
    * @category getters
@@ -1124,22 +1068,22 @@ export const takeWhile: {
    *
    * **Example** (Taking while a predicate holds)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Iterable } from "effect"
    *
    * const numbers = [2, 4, 6, 8, 3, 10, 12]
    * const evenPrefix = Iterable.takeWhile(numbers, (x) => x % 2 === 0)
-   * console.log(Array.from(evenPrefix)) // [2, 4, 6, 8]
+   * Array.from(evenPrefix) // => [2, 4, 6, 8]
    *
    * // With index
    * const letters = ["a", "b", "c", "d", "e"]
    * const firstThreeByIndex = Iterable.takeWhile(letters, (_, i) => i < 3)
-   * console.log(Array.from(firstThreeByIndex)) // ["a", "b", "c"]
+   * Array.from(firstThreeByIndex) // => ["a", "b", "c"]
    *
    * // Stops at first non-matching element
    * const mixed = [1, 3, 5, 4, 7, 9]
    * const oddPrefix = Iterable.takeWhile(mixed, (x) => x % 2 === 1)
-   * console.log(Array.from(oddPrefix)) // [1, 3, 5]
+   * Array.from(oddPrefix) // => [1, 3, 5]
    *
    * // Type refinement
    * const values: Array<string | number> = ["a", "b", "c", 1, "d"]
@@ -1147,7 +1091,7 @@ export const takeWhile: {
    *   values,
    *   (x): x is string => typeof x === "string"
    * )
-   * console.log(Array.from(stringPrefix)) // ["a", "b", "c"] (typed as string[])
+   * Array.from(stringPrefix) // => ["a", "b", "c"]
    * ```
    *
    * @category getters
@@ -1160,22 +1104,22 @@ export const takeWhile: {
    *
    * **Example** (Taking while a predicate holds)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Iterable } from "effect"
    *
    * const numbers = [2, 4, 6, 8, 3, 10, 12]
    * const evenPrefix = Iterable.takeWhile(numbers, (x) => x % 2 === 0)
-   * console.log(Array.from(evenPrefix)) // [2, 4, 6, 8]
+   * Array.from(evenPrefix) // => [2, 4, 6, 8]
    *
    * // With index
    * const letters = ["a", "b", "c", "d", "e"]
    * const firstThreeByIndex = Iterable.takeWhile(letters, (_, i) => i < 3)
-   * console.log(Array.from(firstThreeByIndex)) // ["a", "b", "c"]
+   * Array.from(firstThreeByIndex) // => ["a", "b", "c"]
    *
    * // Stops at first non-matching element
    * const mixed = [1, 3, 5, 4, 7, 9]
    * const oddPrefix = Iterable.takeWhile(mixed, (x) => x % 2 === 1)
-   * console.log(Array.from(oddPrefix)) // [1, 3, 5]
+   * Array.from(oddPrefix) // => [1, 3, 5]
    *
    * // Type refinement
    * const values: Array<string | number> = ["a", "b", "c", 1, "d"]
@@ -1183,7 +1127,7 @@ export const takeWhile: {
    *   values,
    *   (x): x is string => typeof x === "string"
    * )
-   * console.log(Array.from(stringPrefix)) // ["a", "b", "c"] (typed as string[])
+   * Array.from(stringPrefix) // => ["a", "b", "c"]
    * ```
    *
    * @category getters
@@ -1196,22 +1140,22 @@ export const takeWhile: {
    *
    * **Example** (Taking while a predicate holds)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Iterable } from "effect"
    *
    * const numbers = [2, 4, 6, 8, 3, 10, 12]
    * const evenPrefix = Iterable.takeWhile(numbers, (x) => x % 2 === 0)
-   * console.log(Array.from(evenPrefix)) // [2, 4, 6, 8]
+   * Array.from(evenPrefix) // => [2, 4, 6, 8]
    *
    * // With index
    * const letters = ["a", "b", "c", "d", "e"]
    * const firstThreeByIndex = Iterable.takeWhile(letters, (_, i) => i < 3)
-   * console.log(Array.from(firstThreeByIndex)) // ["a", "b", "c"]
+   * Array.from(firstThreeByIndex) // => ["a", "b", "c"]
    *
    * // Stops at first non-matching element
    * const mixed = [1, 3, 5, 4, 7, 9]
    * const oddPrefix = Iterable.takeWhile(mixed, (x) => x % 2 === 1)
-   * console.log(Array.from(oddPrefix)) // [1, 3, 5]
+   * Array.from(oddPrefix) // => [1, 3, 5]
    *
    * // Type refinement
    * const values: Array<string | number> = ["a", "b", "c", 1, "d"]
@@ -1219,7 +1163,7 @@ export const takeWhile: {
    *   values,
    *   (x): x is string => typeof x === "string"
    * )
-   * console.log(Array.from(stringPrefix)) // ["a", "b", "c"] (typed as string[])
+   * Array.from(stringPrefix) // => ["a", "b", "c"]
    * ```
    *
    * @category getters
@@ -1251,24 +1195,24 @@ export const takeWhile: {
  *
  * **Example** (Dropping from the start)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Iterable } from "effect"
  *
  * const numbers = [1, 2, 3, 4, 5]
  * const withoutFirstTwo = Iterable.drop(numbers, 2)
- * console.log(Array.from(withoutFirstTwo)) // [3, 4, 5]
+ * Array.from(withoutFirstTwo) // => [3, 4, 5]
  *
  * // Dropping more than available returns empty
  * const withoutFirstTen = Iterable.drop(numbers, 10)
- * console.log(Array.from(withoutFirstTen)) // []
+ * Array.from(withoutFirstTen) // => []
  *
  * // Dropping 0 or negative returns all elements
  * const all = Iterable.drop(numbers, 0)
- * console.log(Array.from(all)) // [1, 2, 3, 4, 5]
+ * Array.from(all) // => [1, 2, 3, 4, 5]
  *
  * // Combine with take for slicing
  * const slice = Iterable.take(Iterable.drop(numbers, 1), 3)
- * console.log(Array.from(slice)) // [2, 3, 4]
+ * Array.from(slice) // => [2, 3, 4]
  * ```
  *
  * @category getters
@@ -1284,24 +1228,24 @@ export const drop: {
    *
    * **Example** (Dropping from the start)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Iterable } from "effect"
    *
    * const numbers = [1, 2, 3, 4, 5]
    * const withoutFirstTwo = Iterable.drop(numbers, 2)
-   * console.log(Array.from(withoutFirstTwo)) // [3, 4, 5]
+   * Array.from(withoutFirstTwo) // => [3, 4, 5]
    *
    * // Dropping more than available returns empty
    * const withoutFirstTen = Iterable.drop(numbers, 10)
-   * console.log(Array.from(withoutFirstTen)) // []
+   * Array.from(withoutFirstTen) // => []
    *
    * // Dropping 0 or negative returns all elements
    * const all = Iterable.drop(numbers, 0)
-   * console.log(Array.from(all)) // [1, 2, 3, 4, 5]
+   * Array.from(all) // => [1, 2, 3, 4, 5]
    *
    * // Combine with take for slicing
    * const slice = Iterable.take(Iterable.drop(numbers, 1), 3)
-   * console.log(Array.from(slice)) // [2, 3, 4]
+   * Array.from(slice) // => [2, 3, 4]
    * ```
    *
    * @category getters
@@ -1317,24 +1261,24 @@ export const drop: {
    *
    * **Example** (Dropping from the start)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Iterable } from "effect"
    *
    * const numbers = [1, 2, 3, 4, 5]
    * const withoutFirstTwo = Iterable.drop(numbers, 2)
-   * console.log(Array.from(withoutFirstTwo)) // [3, 4, 5]
+   * Array.from(withoutFirstTwo) // => [3, 4, 5]
    *
    * // Dropping more than available returns empty
    * const withoutFirstTen = Iterable.drop(numbers, 10)
-   * console.log(Array.from(withoutFirstTen)) // []
+   * Array.from(withoutFirstTen) // => []
    *
    * // Dropping 0 or negative returns all elements
    * const all = Iterable.drop(numbers, 0)
-   * console.log(Array.from(all)) // [1, 2, 3, 4, 5]
+   * Array.from(all) // => [1, 2, 3, 4, 5]
    *
    * // Combine with take for slicing
    * const slice = Iterable.take(Iterable.drop(numbers, 1), 3)
-   * console.log(Array.from(slice)) // [2, 3, 4]
+   * Array.from(slice) // => [2, 3, 4]
    * ```
    *
    * @category getters
@@ -1366,20 +1310,20 @@ export const drop: {
  *
  * **Example** (Finding the first match)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Iterable, Option } from "effect"
  *
  * const numbers = [1, 3, 4, 6, 8]
  * const firstEven = Iterable.findFirst(numbers, (x) => x % 2 === 0)
- * console.log(firstEven) // Option.some(4)
+ * firstEven // => Option.some(4)
  *
  * const firstGreaterThan10 = Iterable.findFirst(numbers, (x) => x > 10)
- * console.log(firstGreaterThan10) // Option.none()
+ * firstGreaterThan10 // => Option.none()
  *
  * // With index
  * const letters = ["a", "b", "c", "d"]
  * const atEvenIndex = Iterable.findFirst(letters, (_, i) => i % 2 === 0)
- * console.log(atEvenIndex) // Option.some("a")
+ * atEvenIndex // => Option.some("a")
  *
  * // Type refinement
  * const mixed: Array<string | number> = [1, "hello", 2, "world"]
@@ -1387,17 +1331,17 @@ export const drop: {
  *   mixed,
  *   (x): x is string => typeof x === "string"
  * )
- * console.log(firstString) // Option.some("hello")
+ * firstString // => Option.some("hello")
  *
  * // Transform during search
  * const findSquareRoot = Iterable.findFirst([1, 4, 9, 16], (x) => {
  *   const sqrt = Math.sqrt(x)
  *   return Number.isInteger(sqrt) ? Option.some(sqrt) : Option.none()
  * })
- * console.log(findSquareRoot) // Option.some(1)
+ * findSquareRoot // => Option.some(1)
  * ```
  *
- * @category elements
+ * @category searching
  * @since 2.0.0
  */
 export const findFirst: {
@@ -1407,20 +1351,20 @@ export const findFirst: {
    *
    * **Example** (Finding the first match)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Iterable, Option } from "effect"
    *
    * const numbers = [1, 3, 4, 6, 8]
    * const firstEven = Iterable.findFirst(numbers, (x) => x % 2 === 0)
-   * console.log(firstEven) // Option.some(4)
+   * firstEven // => Option.some(4)
    *
    * const firstGreaterThan10 = Iterable.findFirst(numbers, (x) => x > 10)
-   * console.log(firstGreaterThan10) // Option.none()
+   * firstGreaterThan10 // => Option.none()
    *
    * // With index
    * const letters = ["a", "b", "c", "d"]
    * const atEvenIndex = Iterable.findFirst(letters, (_, i) => i % 2 === 0)
-   * console.log(atEvenIndex) // Option.some("a")
+   * atEvenIndex // => Option.some("a")
    *
    * // Type refinement
    * const mixed: Array<string | number> = [1, "hello", 2, "world"]
@@ -1428,17 +1372,17 @@ export const findFirst: {
    *   mixed,
    *   (x): x is string => typeof x === "string"
    * )
-   * console.log(firstString) // Option.some("hello")
+   * firstString // => Option.some("hello")
    *
    * // Transform during search
    * const findSquareRoot = Iterable.findFirst([1, 4, 9, 16], (x) => {
    *   const sqrt = Math.sqrt(x)
    *   return Number.isInteger(sqrt) ? Option.some(sqrt) : Option.none()
    * })
-   * console.log(findSquareRoot) // Option.some(1)
+   * findSquareRoot // => Option.some(1)
    * ```
    *
-   * @category elements
+   * @category searching
    * @since 2.0.0
    */
   <A, B>(f: (a: NoInfer<A>, i: number) => Option<B>): (self: Iterable<A>) => Option<B>
@@ -1448,20 +1392,20 @@ export const findFirst: {
    *
    * **Example** (Finding the first match)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Iterable, Option } from "effect"
    *
    * const numbers = [1, 3, 4, 6, 8]
    * const firstEven = Iterable.findFirst(numbers, (x) => x % 2 === 0)
-   * console.log(firstEven) // Option.some(4)
+   * firstEven // => Option.some(4)
    *
    * const firstGreaterThan10 = Iterable.findFirst(numbers, (x) => x > 10)
-   * console.log(firstGreaterThan10) // Option.none()
+   * firstGreaterThan10 // => Option.none()
    *
    * // With index
    * const letters = ["a", "b", "c", "d"]
    * const atEvenIndex = Iterable.findFirst(letters, (_, i) => i % 2 === 0)
-   * console.log(atEvenIndex) // Option.some("a")
+   * atEvenIndex // => Option.some("a")
    *
    * // Type refinement
    * const mixed: Array<string | number> = [1, "hello", 2, "world"]
@@ -1469,17 +1413,17 @@ export const findFirst: {
    *   mixed,
    *   (x): x is string => typeof x === "string"
    * )
-   * console.log(firstString) // Option.some("hello")
+   * firstString // => Option.some("hello")
    *
    * // Transform during search
    * const findSquareRoot = Iterable.findFirst([1, 4, 9, 16], (x) => {
    *   const sqrt = Math.sqrt(x)
    *   return Number.isInteger(sqrt) ? Option.some(sqrt) : Option.none()
    * })
-   * console.log(findSquareRoot) // Option.some(1)
+   * findSquareRoot // => Option.some(1)
    * ```
    *
-   * @category elements
+   * @category searching
    * @since 2.0.0
    */
   <A, B extends A>(refinement: (a: NoInfer<A>, i: number) => a is B): (self: Iterable<A>) => Option<B>
@@ -1489,20 +1433,20 @@ export const findFirst: {
    *
    * **Example** (Finding the first match)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Iterable, Option } from "effect"
    *
    * const numbers = [1, 3, 4, 6, 8]
    * const firstEven = Iterable.findFirst(numbers, (x) => x % 2 === 0)
-   * console.log(firstEven) // Option.some(4)
+   * firstEven // => Option.some(4)
    *
    * const firstGreaterThan10 = Iterable.findFirst(numbers, (x) => x > 10)
-   * console.log(firstGreaterThan10) // Option.none()
+   * firstGreaterThan10 // => Option.none()
    *
    * // With index
    * const letters = ["a", "b", "c", "d"]
    * const atEvenIndex = Iterable.findFirst(letters, (_, i) => i % 2 === 0)
-   * console.log(atEvenIndex) // Option.some("a")
+   * atEvenIndex // => Option.some("a")
    *
    * // Type refinement
    * const mixed: Array<string | number> = [1, "hello", 2, "world"]
@@ -1510,17 +1454,17 @@ export const findFirst: {
    *   mixed,
    *   (x): x is string => typeof x === "string"
    * )
-   * console.log(firstString) // Option.some("hello")
+   * firstString // => Option.some("hello")
    *
    * // Transform during search
    * const findSquareRoot = Iterable.findFirst([1, 4, 9, 16], (x) => {
    *   const sqrt = Math.sqrt(x)
    *   return Number.isInteger(sqrt) ? Option.some(sqrt) : Option.none()
    * })
-   * console.log(findSquareRoot) // Option.some(1)
+   * findSquareRoot // => Option.some(1)
    * ```
    *
-   * @category elements
+   * @category searching
    * @since 2.0.0
    */
   <A>(predicate: (a: NoInfer<A>, i: number) => boolean): (self: Iterable<A>) => Option<A>
@@ -1530,20 +1474,20 @@ export const findFirst: {
    *
    * **Example** (Finding the first match)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Iterable, Option } from "effect"
    *
    * const numbers = [1, 3, 4, 6, 8]
    * const firstEven = Iterable.findFirst(numbers, (x) => x % 2 === 0)
-   * console.log(firstEven) // Option.some(4)
+   * firstEven // => Option.some(4)
    *
    * const firstGreaterThan10 = Iterable.findFirst(numbers, (x) => x > 10)
-   * console.log(firstGreaterThan10) // Option.none()
+   * firstGreaterThan10 // => Option.none()
    *
    * // With index
    * const letters = ["a", "b", "c", "d"]
    * const atEvenIndex = Iterable.findFirst(letters, (_, i) => i % 2 === 0)
-   * console.log(atEvenIndex) // Option.some("a")
+   * atEvenIndex // => Option.some("a")
    *
    * // Type refinement
    * const mixed: Array<string | number> = [1, "hello", 2, "world"]
@@ -1551,17 +1495,17 @@ export const findFirst: {
    *   mixed,
    *   (x): x is string => typeof x === "string"
    * )
-   * console.log(firstString) // Option.some("hello")
+   * firstString // => Option.some("hello")
    *
    * // Transform during search
    * const findSquareRoot = Iterable.findFirst([1, 4, 9, 16], (x) => {
    *   const sqrt = Math.sqrt(x)
    *   return Number.isInteger(sqrt) ? Option.some(sqrt) : Option.none()
    * })
-   * console.log(findSquareRoot) // Option.some(1)
+   * findSquareRoot // => Option.some(1)
    * ```
    *
-   * @category elements
+   * @category searching
    * @since 2.0.0
    */
   <A, B>(self: Iterable<A>, f: (a: A, i: number) => Option<B>): Option<B>
@@ -1571,20 +1515,20 @@ export const findFirst: {
    *
    * **Example** (Finding the first match)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Iterable, Option } from "effect"
    *
    * const numbers = [1, 3, 4, 6, 8]
    * const firstEven = Iterable.findFirst(numbers, (x) => x % 2 === 0)
-   * console.log(firstEven) // Option.some(4)
+   * firstEven // => Option.some(4)
    *
    * const firstGreaterThan10 = Iterable.findFirst(numbers, (x) => x > 10)
-   * console.log(firstGreaterThan10) // Option.none()
+   * firstGreaterThan10 // => Option.none()
    *
    * // With index
    * const letters = ["a", "b", "c", "d"]
    * const atEvenIndex = Iterable.findFirst(letters, (_, i) => i % 2 === 0)
-   * console.log(atEvenIndex) // Option.some("a")
+   * atEvenIndex // => Option.some("a")
    *
    * // Type refinement
    * const mixed: Array<string | number> = [1, "hello", 2, "world"]
@@ -1592,17 +1536,17 @@ export const findFirst: {
    *   mixed,
    *   (x): x is string => typeof x === "string"
    * )
-   * console.log(firstString) // Option.some("hello")
+   * firstString // => Option.some("hello")
    *
    * // Transform during search
    * const findSquareRoot = Iterable.findFirst([1, 4, 9, 16], (x) => {
    *   const sqrt = Math.sqrt(x)
    *   return Number.isInteger(sqrt) ? Option.some(sqrt) : Option.none()
    * })
-   * console.log(findSquareRoot) // Option.some(1)
+   * findSquareRoot // => Option.some(1)
    * ```
    *
-   * @category elements
+   * @category searching
    * @since 2.0.0
    */
   <A, B extends A>(self: Iterable<A>, refinement: (a: A, i: number) => a is B): Option<B>
@@ -1612,20 +1556,20 @@ export const findFirst: {
    *
    * **Example** (Finding the first match)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Iterable, Option } from "effect"
    *
    * const numbers = [1, 3, 4, 6, 8]
    * const firstEven = Iterable.findFirst(numbers, (x) => x % 2 === 0)
-   * console.log(firstEven) // Option.some(4)
+   * firstEven // => Option.some(4)
    *
    * const firstGreaterThan10 = Iterable.findFirst(numbers, (x) => x > 10)
-   * console.log(firstGreaterThan10) // Option.none()
+   * firstGreaterThan10 // => Option.none()
    *
    * // With index
    * const letters = ["a", "b", "c", "d"]
    * const atEvenIndex = Iterable.findFirst(letters, (_, i) => i % 2 === 0)
-   * console.log(atEvenIndex) // Option.some("a")
+   * atEvenIndex // => Option.some("a")
    *
    * // Type refinement
    * const mixed: Array<string | number> = [1, "hello", 2, "world"]
@@ -1633,17 +1577,17 @@ export const findFirst: {
    *   mixed,
    *   (x): x is string => typeof x === "string"
    * )
-   * console.log(firstString) // Option.some("hello")
+   * firstString // => Option.some("hello")
    *
    * // Transform during search
    * const findSquareRoot = Iterable.findFirst([1, 4, 9, 16], (x) => {
    *   const sqrt = Math.sqrt(x)
    *   return Number.isInteger(sqrt) ? Option.some(sqrt) : Option.none()
    * })
-   * console.log(findSquareRoot) // Option.some(1)
+   * findSquareRoot // => Option.some(1)
    * ```
    *
-   * @category elements
+   * @category searching
    * @since 2.0.0
    */
   <A>(self: Iterable<A>, predicate: (a: A, i: number) => boolean): Option<A>
@@ -1673,20 +1617,20 @@ export const findFirst: {
  *
  * **Example** (Finding the last match)
  *
- * ```ts
- * import { Iterable } from "effect"
+ * ```ts import.meta.vitest
+ * import { Iterable, Option } from "effect"
  *
  * const numbers = [1, 3, 4, 6, 8, 2]
  * const lastEven = Iterable.findLast(numbers, (x) => x % 2 === 0)
- * console.log(lastEven) // Option.some(2)
+ * lastEven // => Option.some(2)
  *
  * const lastGreaterThan10 = Iterable.findLast(numbers, (x) => x > 10)
- * console.log(lastGreaterThan10) // Option.none()
+ * lastGreaterThan10 // => Option.none()
  *
  * // With index
  * const letters = ["a", "b", "c", "d", "e"]
  * const lastAtEvenIndex = Iterable.findLast(letters, (_, i) => i % 2 === 0)
- * console.log(lastAtEvenIndex) // Option.some("e") (index 4)
+ * lastAtEvenIndex // => Option.some("e")
  *
  * // Type refinement
  * const mixed: Array<string | number> = [1, "hello", 2, "world", 3]
@@ -1694,10 +1638,10 @@ export const findFirst: {
  *   mixed,
  *   (x): x is string => typeof x === "string"
  * )
- * console.log(lastString) // Option.some("world")
+ * lastString // => Option.some("world")
  * ```
  *
- * @category elements
+ * @category searching
  * @since 2.0.0
  */
 export const findLast: {
@@ -1706,20 +1650,20 @@ export const findLast: {
    *
    * **Example** (Finding the last match)
    *
-   * ```ts
-   * import { Iterable } from "effect"
+   * ```ts import.meta.vitest
+   * import { Iterable, Option } from "effect"
    *
    * const numbers = [1, 3, 4, 6, 8, 2]
    * const lastEven = Iterable.findLast(numbers, (x) => x % 2 === 0)
-   * console.log(lastEven) // Option.some(2)
+   * lastEven // => Option.some(2)
    *
    * const lastGreaterThan10 = Iterable.findLast(numbers, (x) => x > 10)
-   * console.log(lastGreaterThan10) // Option.none()
+   * lastGreaterThan10 // => Option.none()
    *
    * // With index
    * const letters = ["a", "b", "c", "d", "e"]
    * const lastAtEvenIndex = Iterable.findLast(letters, (_, i) => i % 2 === 0)
-   * console.log(lastAtEvenIndex) // Option.some("e") (index 4)
+   * lastAtEvenIndex // => Option.some("e")
    *
    * // Type refinement
    * const mixed: Array<string | number> = [1, "hello", 2, "world", 3]
@@ -1727,10 +1671,10 @@ export const findLast: {
    *   mixed,
    *   (x): x is string => typeof x === "string"
    * )
-   * console.log(lastString) // Option.some("world")
+   * lastString // => Option.some("world")
    * ```
    *
-   * @category elements
+   * @category searching
    * @since 2.0.0
    */
   <A, B>(f: (a: NoInfer<A>, i: number) => Option<B>): (self: Iterable<A>) => Option<B>
@@ -1739,20 +1683,20 @@ export const findLast: {
    *
    * **Example** (Finding the last match)
    *
-   * ```ts
-   * import { Iterable } from "effect"
+   * ```ts import.meta.vitest
+   * import { Iterable, Option } from "effect"
    *
    * const numbers = [1, 3, 4, 6, 8, 2]
    * const lastEven = Iterable.findLast(numbers, (x) => x % 2 === 0)
-   * console.log(lastEven) // Option.some(2)
+   * lastEven // => Option.some(2)
    *
    * const lastGreaterThan10 = Iterable.findLast(numbers, (x) => x > 10)
-   * console.log(lastGreaterThan10) // Option.none()
+   * lastGreaterThan10 // => Option.none()
    *
    * // With index
    * const letters = ["a", "b", "c", "d", "e"]
    * const lastAtEvenIndex = Iterable.findLast(letters, (_, i) => i % 2 === 0)
-   * console.log(lastAtEvenIndex) // Option.some("e") (index 4)
+   * lastAtEvenIndex // => Option.some("e")
    *
    * // Type refinement
    * const mixed: Array<string | number> = [1, "hello", 2, "world", 3]
@@ -1760,10 +1704,10 @@ export const findLast: {
    *   mixed,
    *   (x): x is string => typeof x === "string"
    * )
-   * console.log(lastString) // Option.some("world")
+   * lastString // => Option.some("world")
    * ```
    *
-   * @category elements
+   * @category searching
    * @since 2.0.0
    */
   <A, B extends A>(refinement: (a: NoInfer<A>, i: number) => a is B): (self: Iterable<A>) => Option<B>
@@ -1772,20 +1716,20 @@ export const findLast: {
    *
    * **Example** (Finding the last match)
    *
-   * ```ts
-   * import { Iterable } from "effect"
+   * ```ts import.meta.vitest
+   * import { Iterable, Option } from "effect"
    *
    * const numbers = [1, 3, 4, 6, 8, 2]
    * const lastEven = Iterable.findLast(numbers, (x) => x % 2 === 0)
-   * console.log(lastEven) // Option.some(2)
+   * lastEven // => Option.some(2)
    *
    * const lastGreaterThan10 = Iterable.findLast(numbers, (x) => x > 10)
-   * console.log(lastGreaterThan10) // Option.none()
+   * lastGreaterThan10 // => Option.none()
    *
    * // With index
    * const letters = ["a", "b", "c", "d", "e"]
    * const lastAtEvenIndex = Iterable.findLast(letters, (_, i) => i % 2 === 0)
-   * console.log(lastAtEvenIndex) // Option.some("e") (index 4)
+   * lastAtEvenIndex // => Option.some("e")
    *
    * // Type refinement
    * const mixed: Array<string | number> = [1, "hello", 2, "world", 3]
@@ -1793,10 +1737,10 @@ export const findLast: {
    *   mixed,
    *   (x): x is string => typeof x === "string"
    * )
-   * console.log(lastString) // Option.some("world")
+   * lastString // => Option.some("world")
    * ```
    *
-   * @category elements
+   * @category searching
    * @since 2.0.0
    */
   <A>(predicate: (a: NoInfer<A>, i: number) => boolean): (self: Iterable<A>) => Option<A>
@@ -1805,20 +1749,20 @@ export const findLast: {
    *
    * **Example** (Finding the last match)
    *
-   * ```ts
-   * import { Iterable } from "effect"
+   * ```ts import.meta.vitest
+   * import { Iterable, Option } from "effect"
    *
    * const numbers = [1, 3, 4, 6, 8, 2]
    * const lastEven = Iterable.findLast(numbers, (x) => x % 2 === 0)
-   * console.log(lastEven) // Option.some(2)
+   * lastEven // => Option.some(2)
    *
    * const lastGreaterThan10 = Iterable.findLast(numbers, (x) => x > 10)
-   * console.log(lastGreaterThan10) // Option.none()
+   * lastGreaterThan10 // => Option.none()
    *
    * // With index
    * const letters = ["a", "b", "c", "d", "e"]
    * const lastAtEvenIndex = Iterable.findLast(letters, (_, i) => i % 2 === 0)
-   * console.log(lastAtEvenIndex) // Option.some("e") (index 4)
+   * lastAtEvenIndex // => Option.some("e")
    *
    * // Type refinement
    * const mixed: Array<string | number> = [1, "hello", 2, "world", 3]
@@ -1826,10 +1770,10 @@ export const findLast: {
    *   mixed,
    *   (x): x is string => typeof x === "string"
    * )
-   * console.log(lastString) // Option.some("world")
+   * lastString // => Option.some("world")
    * ```
    *
-   * @category elements
+   * @category searching
    * @since 2.0.0
    */
   <A, B>(self: Iterable<A>, f: (a: A, i: number) => Option<B>): Option<B>
@@ -1838,20 +1782,20 @@ export const findLast: {
    *
    * **Example** (Finding the last match)
    *
-   * ```ts
-   * import { Iterable } from "effect"
+   * ```ts import.meta.vitest
+   * import { Iterable, Option } from "effect"
    *
    * const numbers = [1, 3, 4, 6, 8, 2]
    * const lastEven = Iterable.findLast(numbers, (x) => x % 2 === 0)
-   * console.log(lastEven) // Option.some(2)
+   * lastEven // => Option.some(2)
    *
    * const lastGreaterThan10 = Iterable.findLast(numbers, (x) => x > 10)
-   * console.log(lastGreaterThan10) // Option.none()
+   * lastGreaterThan10 // => Option.none()
    *
    * // With index
    * const letters = ["a", "b", "c", "d", "e"]
    * const lastAtEvenIndex = Iterable.findLast(letters, (_, i) => i % 2 === 0)
-   * console.log(lastAtEvenIndex) // Option.some("e") (index 4)
+   * lastAtEvenIndex // => Option.some("e")
    *
    * // Type refinement
    * const mixed: Array<string | number> = [1, "hello", 2, "world", 3]
@@ -1859,10 +1803,10 @@ export const findLast: {
    *   mixed,
    *   (x): x is string => typeof x === "string"
    * )
-   * console.log(lastString) // Option.some("world")
+   * lastString // => Option.some("world")
    * ```
    *
-   * @category elements
+   * @category searching
    * @since 2.0.0
    */
   <A, B extends A>(self: Iterable<A>, refinement: (a: A, i: number) => a is B): Option<B>
@@ -1871,20 +1815,20 @@ export const findLast: {
    *
    * **Example** (Finding the last match)
    *
-   * ```ts
-   * import { Iterable } from "effect"
+   * ```ts import.meta.vitest
+   * import { Iterable, Option } from "effect"
    *
    * const numbers = [1, 3, 4, 6, 8, 2]
    * const lastEven = Iterable.findLast(numbers, (x) => x % 2 === 0)
-   * console.log(lastEven) // Option.some(2)
+   * lastEven // => Option.some(2)
    *
    * const lastGreaterThan10 = Iterable.findLast(numbers, (x) => x > 10)
-   * console.log(lastGreaterThan10) // Option.none()
+   * lastGreaterThan10 // => Option.none()
    *
    * // With index
    * const letters = ["a", "b", "c", "d", "e"]
    * const lastAtEvenIndex = Iterable.findLast(letters, (_, i) => i % 2 === 0)
-   * console.log(lastAtEvenIndex) // Option.some("e") (index 4)
+   * lastAtEvenIndex // => Option.some("e")
    *
    * // Type refinement
    * const mixed: Array<string | number> = [1, "hello", 2, "world", 3]
@@ -1892,10 +1836,10 @@ export const findLast: {
    *   mixed,
    *   (x): x is string => typeof x === "string"
    * )
-   * console.log(lastString) // Option.some("world")
+   * lastString // => Option.some("world")
    * ```
    *
-   * @category elements
+   * @category searching
    * @since 2.0.0
    */
   <A>(self: Iterable<A>, predicate: (a: A, i: number) => boolean): Option<A>
@@ -1926,31 +1870,31 @@ export const findLast: {
  *
  * **Example** (Zipping iterables)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Iterable } from "effect"
  *
  * const numbers = [1, 2, 3]
  * const letters = ["a", "b", "c"]
  * const zipped = Iterable.zip(numbers, letters)
- * console.log(Array.from(zipped)) // [[1, "a"], [2, "b"], [3, "c"]]
+ * Array.from(zipped) // => [[1, "a"], [2, "b"], [3, "c"]]
  *
  * // Different lengths - shorter one determines result length
  * const short = [1, 2]
  * const long = ["a", "b", "c", "d"]
  * const partial = Iterable.zip(short, long)
- * console.log(Array.from(partial)) // [[1, "a"], [2, "b"]]
+ * Array.from(partial) // => [[1, "a"], [2, "b"]]
  *
  * // Works with any iterables
  * const range = Iterable.range(1, 3)
  * const word = "abc"
  * const mixed = Iterable.zip(range, word)
- * console.log(Array.from(mixed)) // [[1, "a"], [2, "b"], [3, "c"]]
+ * Array.from(mixed) // => [[1, "a"], [2, "b"], [3, "c"]]
  *
  * // Create indexed pairs
  * const values = ["apple", "banana", "cherry"]
  * const indices = Iterable.range(0, 2)
  * const indexed = Iterable.zip(indices, values)
- * console.log(Array.from(indexed)) // [[0, "apple"], [1, "banana"], [2, "cherry"]]
+ * Array.from(indexed) // => [[0, "apple"], [1, "banana"], [2, "cherry"]]
  * ```
  *
  * @category zipping
@@ -1962,31 +1906,31 @@ export const zip: {
    *
    * **Example** (Zipping iterables)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Iterable } from "effect"
    *
    * const numbers = [1, 2, 3]
    * const letters = ["a", "b", "c"]
    * const zipped = Iterable.zip(numbers, letters)
-   * console.log(Array.from(zipped)) // [[1, "a"], [2, "b"], [3, "c"]]
+   * Array.from(zipped) // => [[1, "a"], [2, "b"], [3, "c"]]
    *
    * // Different lengths - shorter one determines result length
    * const short = [1, 2]
    * const long = ["a", "b", "c", "d"]
    * const partial = Iterable.zip(short, long)
-   * console.log(Array.from(partial)) // [[1, "a"], [2, "b"]]
+   * Array.from(partial) // => [[1, "a"], [2, "b"]]
    *
    * // Works with any iterables
    * const range = Iterable.range(1, 3)
    * const word = "abc"
    * const mixed = Iterable.zip(range, word)
-   * console.log(Array.from(mixed)) // [[1, "a"], [2, "b"], [3, "c"]]
+   * Array.from(mixed) // => [[1, "a"], [2, "b"], [3, "c"]]
    *
    * // Create indexed pairs
    * const values = ["apple", "banana", "cherry"]
    * const indices = Iterable.range(0, 2)
    * const indexed = Iterable.zip(indices, values)
-   * console.log(Array.from(indexed)) // [[0, "apple"], [1, "banana"], [2, "cherry"]]
+   * Array.from(indexed) // => [[0, "apple"], [1, "banana"], [2, "cherry"]]
    * ```
    *
    * @category zipping
@@ -1998,31 +1942,31 @@ export const zip: {
    *
    * **Example** (Zipping iterables)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Iterable } from "effect"
    *
    * const numbers = [1, 2, 3]
    * const letters = ["a", "b", "c"]
    * const zipped = Iterable.zip(numbers, letters)
-   * console.log(Array.from(zipped)) // [[1, "a"], [2, "b"], [3, "c"]]
+   * Array.from(zipped) // => [[1, "a"], [2, "b"], [3, "c"]]
    *
    * // Different lengths - shorter one determines result length
    * const short = [1, 2]
    * const long = ["a", "b", "c", "d"]
    * const partial = Iterable.zip(short, long)
-   * console.log(Array.from(partial)) // [[1, "a"], [2, "b"]]
+   * Array.from(partial) // => [[1, "a"], [2, "b"]]
    *
    * // Works with any iterables
    * const range = Iterable.range(1, 3)
    * const word = "abc"
    * const mixed = Iterable.zip(range, word)
-   * console.log(Array.from(mixed)) // [[1, "a"], [2, "b"], [3, "c"]]
+   * Array.from(mixed) // => [[1, "a"], [2, "b"], [3, "c"]]
    *
    * // Create indexed pairs
    * const values = ["apple", "banana", "cherry"]
    * const indices = Iterable.range(0, 2)
    * const indexed = Iterable.zip(indices, values)
-   * console.log(Array.from(indexed)) // [[0, "apple"], [1, "banana"], [2, "cherry"]]
+   * Array.from(indexed) // => [[0, "apple"], [1, "banana"], [2, "cherry"]]
    * ```
    *
    * @category zipping
@@ -2040,14 +1984,14 @@ export const zip: {
  *
  * **Example** (Zipping with a combining function)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Iterable } from "effect"
  *
  * // Add corresponding elements
  * const a = [1, 2, 3, 4]
  * const b = [10, 20, 30, 40]
  * const sums = Iterable.zipWith(a, b, (x, y) => x + y)
- * console.log(Array.from(sums)) // [11, 22, 33, 44]
+ * Array.from(sums) // => [11, 22, 33, 44]
  *
  * // Combine strings
  * const firstNames = ["John", "Jane", "Bob"]
@@ -2057,7 +2001,7 @@ export const zip: {
  *   lastNames,
  *   (first, last) => `${first} ${last}`
  * )
- * console.log(Array.from(fullNames)) // ["John Doe", "Jane Smith", "Bob Johnson"]
+ * Array.from(fullNames) // => ["John Doe", "Jane Smith", "Bob Johnson"]
  *
  * // Different lengths - stops at shorter
  * const short = [1, 2]
@@ -2067,7 +2011,7 @@ export const zip: {
  *   long,
  *   (num, letter) => `${num}${letter}`
  * )
- * console.log(Array.from(combined)) // ["1a", "2b"]
+ * Array.from(combined) // => ["1a", "2b"]
  *
  * // Complex transformations
  * const prices = [10.99, 25.50, 5.00]
@@ -2075,7 +2019,7 @@ export const zip: {
  * const totals = Iterable.zipWith(prices, quantities, (price, qty) => {
  *   return Math.round(price * qty * 100) / 100 // round to 2 decimal places
  * })
- * console.log(Array.from(totals)) // [21.98, 25.5, 15]
+ * Array.from(totals) // => [21.98, 25.5, 15]
  * ```
  *
  * @category zipping
@@ -2088,14 +2032,14 @@ export const zipWith: {
    *
    * **Example** (Zipping with a combining function)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Iterable } from "effect"
    *
    * // Add corresponding elements
    * const a = [1, 2, 3, 4]
    * const b = [10, 20, 30, 40]
    * const sums = Iterable.zipWith(a, b, (x, y) => x + y)
-   * console.log(Array.from(sums)) // [11, 22, 33, 44]
+   * Array.from(sums) // => [11, 22, 33, 44]
    *
    * // Combine strings
    * const firstNames = ["John", "Jane", "Bob"]
@@ -2105,7 +2049,7 @@ export const zipWith: {
    *   lastNames,
    *   (first, last) => `${first} ${last}`
    * )
-   * console.log(Array.from(fullNames)) // ["John Doe", "Jane Smith", "Bob Johnson"]
+   * Array.from(fullNames) // => ["John Doe", "Jane Smith", "Bob Johnson"]
    *
    * // Different lengths - stops at shorter
    * const short = [1, 2]
@@ -2115,7 +2059,7 @@ export const zipWith: {
    *   long,
    *   (num, letter) => `${num}${letter}`
    * )
-   * console.log(Array.from(combined)) // ["1a", "2b"]
+   * Array.from(combined) // => ["1a", "2b"]
    *
    * // Complex transformations
    * const prices = [10.99, 25.50, 5.00]
@@ -2123,7 +2067,7 @@ export const zipWith: {
    * const totals = Iterable.zipWith(prices, quantities, (price, qty) => {
    *   return Math.round(price * qty * 100) / 100 // round to 2 decimal places
    * })
-   * console.log(Array.from(totals)) // [21.98, 25.5, 15]
+   * Array.from(totals) // => [21.98, 25.5, 15]
    * ```
    *
    * @category zipping
@@ -2136,14 +2080,14 @@ export const zipWith: {
    *
    * **Example** (Zipping with a combining function)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Iterable } from "effect"
    *
    * // Add corresponding elements
    * const a = [1, 2, 3, 4]
    * const b = [10, 20, 30, 40]
    * const sums = Iterable.zipWith(a, b, (x, y) => x + y)
-   * console.log(Array.from(sums)) // [11, 22, 33, 44]
+   * Array.from(sums) // => [11, 22, 33, 44]
    *
    * // Combine strings
    * const firstNames = ["John", "Jane", "Bob"]
@@ -2153,7 +2097,7 @@ export const zipWith: {
    *   lastNames,
    *   (first, last) => `${first} ${last}`
    * )
-   * console.log(Array.from(fullNames)) // ["John Doe", "Jane Smith", "Bob Johnson"]
+   * Array.from(fullNames) // => ["John Doe", "Jane Smith", "Bob Johnson"]
    *
    * // Different lengths - stops at shorter
    * const short = [1, 2]
@@ -2163,7 +2107,7 @@ export const zipWith: {
    *   long,
    *   (num, letter) => `${num}${letter}`
    * )
-   * console.log(Array.from(combined)) // ["1a", "2b"]
+   * Array.from(combined) // => ["1a", "2b"]
    *
    * // Complex transformations
    * const prices = [10.99, 25.50, 5.00]
@@ -2171,7 +2115,7 @@ export const zipWith: {
    * const totals = Iterable.zipWith(prices, quantities, (price, qty) => {
    *   return Math.round(price * qty * 100) / 100 // round to 2 decimal places
    * })
-   * console.log(Array.from(totals)) // [21.98, 25.5, 15]
+   * Array.from(totals) // => [21.98, 25.5, 15]
    * ```
    *
    * @category zipping
@@ -2208,33 +2152,33 @@ export const zipWith: {
  *
  * **Example** (Interspersing separators)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Iterable } from "effect"
  *
  * // Join numbers with separator
  * const numbers = [1, 2, 3, 4]
  * const withCommas = Iterable.intersperse(numbers, ",")
- * console.log(Array.from(withCommas)) // [1, ",", 2, ",", 3, ",", 4]
+ * Array.from(withCommas) // => [1, ",", 2, ",", 3, ",", 4]
  *
  * // Join words with spaces
  * const words = ["hello", "world", "from", "effect"]
  * const sentence = Iterable.intersperse(words, " ")
- * console.log(Array.from(sentence).join("")) // "hello world from effect"
+ * Array.from(sentence).join("") // => "hello world from effect"
  *
  * // Empty iterable remains empty
  * const empty = Iterable.empty<string>()
  * const stillEmpty = Iterable.intersperse(empty, "-")
- * console.log(Array.from(stillEmpty)) // []
+ * Array.from(stillEmpty) // => []
  *
  * // Single element has no separators added
  * const single = [42]
  * const noSeparator = Iterable.intersperse(single, "|")
- * console.log(Array.from(noSeparator)) // [42]
+ * Array.from(noSeparator) // => [42]
  *
  * // Build CSS-like strings
  * const styles = ["color: red", "font-size: 14px", "margin: 10px"]
  * const css = Iterable.intersperse(styles, "; ")
- * console.log(Array.from(css).join("")) // "color: red; font-size: 14px; margin: 10px"
+ * Array.from(css).join("") // => "color: red; font-size: 14px; margin: 10px"
  * ```
  *
  * @category combining
@@ -2254,33 +2198,33 @@ export const intersperse: {
    *
    * **Example** (Interspersing separators)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Iterable } from "effect"
    *
    * // Join numbers with separator
    * const numbers = [1, 2, 3, 4]
    * const withCommas = Iterable.intersperse(numbers, ",")
-   * console.log(Array.from(withCommas)) // [1, ",", 2, ",", 3, ",", 4]
+   * Array.from(withCommas) // => [1, ",", 2, ",", 3, ",", 4]
    *
    * // Join words with spaces
    * const words = ["hello", "world", "from", "effect"]
    * const sentence = Iterable.intersperse(words, " ")
-   * console.log(Array.from(sentence).join("")) // "hello world from effect"
+   * Array.from(sentence).join("") // => "hello world from effect"
    *
    * // Empty iterable remains empty
    * const empty = Iterable.empty<string>()
    * const stillEmpty = Iterable.intersperse(empty, "-")
-   * console.log(Array.from(stillEmpty)) // []
+   * Array.from(stillEmpty) // => []
    *
    * // Single element has no separators added
    * const single = [42]
    * const noSeparator = Iterable.intersperse(single, "|")
-   * console.log(Array.from(noSeparator)) // [42]
+   * Array.from(noSeparator) // => [42]
    *
    * // Build CSS-like strings
    * const styles = ["color: red", "font-size: 14px", "margin: 10px"]
    * const css = Iterable.intersperse(styles, "; ")
-   * console.log(Array.from(css).join("")) // "color: red; font-size: 14px; margin: 10px"
+   * Array.from(css).join("") // => "color: red; font-size: 14px; margin: 10px"
    * ```
    *
    * @category combining
@@ -2300,33 +2244,33 @@ export const intersperse: {
    *
    * **Example** (Interspersing separators)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Iterable } from "effect"
    *
    * // Join numbers with separator
    * const numbers = [1, 2, 3, 4]
    * const withCommas = Iterable.intersperse(numbers, ",")
-   * console.log(Array.from(withCommas)) // [1, ",", 2, ",", 3, ",", 4]
+   * Array.from(withCommas) // => [1, ",", 2, ",", 3, ",", 4]
    *
    * // Join words with spaces
    * const words = ["hello", "world", "from", "effect"]
    * const sentence = Iterable.intersperse(words, " ")
-   * console.log(Array.from(sentence).join("")) // "hello world from effect"
+   * Array.from(sentence).join("") // => "hello world from effect"
    *
    * // Empty iterable remains empty
    * const empty = Iterable.empty<string>()
    * const stillEmpty = Iterable.intersperse(empty, "-")
-   * console.log(Array.from(stillEmpty)) // []
+   * Array.from(stillEmpty) // => []
    *
    * // Single element has no separators added
    * const single = [42]
    * const noSeparator = Iterable.intersperse(single, "|")
-   * console.log(Array.from(noSeparator)) // [42]
+   * Array.from(noSeparator) // => [42]
    *
    * // Build CSS-like strings
    * const styles = ["color: red", "font-size: 14px", "margin: 10px"]
    * const css = Iterable.intersperse(styles, "; ")
-   * console.log(Array.from(css).join("")) // "color: red; font-size: 14px; margin: 10px"
+   * Array.from(css).join("") // => "color: red; font-size: 14px; margin: 10px"
    * ```
    *
    * @category combining
@@ -2360,7 +2304,7 @@ export const intersperse: {
  *
  * **Example** (Checking membership with custom equivalence)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Iterable } from "effect"
  *
  * // Custom equivalence for objects
@@ -2369,7 +2313,7 @@ export const intersperse: {
  *
  * const users = [{ id: 1 }, { id: 2 }]
  * const hasUser1 = containsById(users, { id: 1 })
- * console.log(hasUser1) // true (same id)
+ * hasUser1 // => true
  *
  * // Case-insensitive string comparison
  * const caseInsensitive = (a: string, b: string) =>
@@ -2378,7 +2322,7 @@ export const intersperse: {
  *
  * const words = ["Hello", "World"]
  * const hasHello = containsCaseInsensitive(words, "hello")
- * console.log(hasHello) // true
+ * hasHello // => true
  *
  * // Approximate number comparison
  * const approxEqual = (a: number, b: number) => Math.abs(a - b) < 0.1
@@ -2386,10 +2330,10 @@ export const intersperse: {
  *
  * const values = [1.0, 2.0, 3.0]
  * const hasAlmostTwo = containsApprox(values, 2.05)
- * console.log(hasAlmostTwo) // true
+ * hasAlmostTwo // => true
  * ```
  *
- * @category elements
+ * @category predicates
  * @since 2.0.0
  */
 export const containsWith = <A>(isEquivalent: (self: A, that: A) => boolean): {
@@ -2416,29 +2360,29 @@ export const containsWith = <A>(isEquivalent: (self: A, that: A) => boolean): {
  *
  * **Example** (Checking membership)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Iterable } from "effect"
  *
  * const numbers = [1, 2, 3, 4, 5]
- * console.log(Iterable.contains(numbers, 3)) // true
- * console.log(Iterable.contains(numbers, 6)) // false
+ * Iterable.contains(numbers, 3) // => true
+ * Iterable.contains(numbers, 6) // => false
  *
  * const letters = "hello"
- * console.log(Iterable.contains(letters, "l")) // true
- * console.log(Iterable.contains(letters, "x")) // false
+ * Iterable.contains(letters, "l") // => true
+ * Iterable.contains(letters, "x") // => false
  *
  * // Works with any iterable
  * const range = Iterable.range(1, 100)
- * console.log(Iterable.contains(range, 50)) // true
- * console.log(Iterable.contains(range, 150)) // false
+ * Iterable.contains(range, 50) // => true
+ * Iterable.contains(range, 150) // => false
  *
  * // Curried version
  * const containsThree = Iterable.contains(3)
- * console.log(containsThree([1, 2, 3])) // true
- * console.log(containsThree([4, 5, 6])) // false
+ * containsThree([1, 2, 3]) // => true
+ * containsThree([4, 5, 6]) // => false
  * ```
  *
- * @category elements
+ * @category predicates
  * @since 2.0.0
  */
 export const contains: {
@@ -2453,29 +2397,29 @@ export const contains: {
    *
    * **Example** (Checking membership)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Iterable } from "effect"
    *
    * const numbers = [1, 2, 3, 4, 5]
-   * console.log(Iterable.contains(numbers, 3)) // true
-   * console.log(Iterable.contains(numbers, 6)) // false
+   * Iterable.contains(numbers, 3) // => true
+   * Iterable.contains(numbers, 6) // => false
    *
    * const letters = "hello"
-   * console.log(Iterable.contains(letters, "l")) // true
-   * console.log(Iterable.contains(letters, "x")) // false
+   * Iterable.contains(letters, "l") // => true
+   * Iterable.contains(letters, "x") // => false
    *
    * // Works with any iterable
    * const range = Iterable.range(1, 100)
-   * console.log(Iterable.contains(range, 50)) // true
-   * console.log(Iterable.contains(range, 150)) // false
+   * Iterable.contains(range, 50) // => true
+   * Iterable.contains(range, 150) // => false
    *
    * // Curried version
    * const containsThree = Iterable.contains(3)
-   * console.log(containsThree([1, 2, 3])) // true
-   * console.log(containsThree([4, 5, 6])) // false
+   * containsThree([1, 2, 3]) // => true
+   * containsThree([4, 5, 6]) // => false
    * ```
    *
-   * @category elements
+   * @category predicates
    * @since 2.0.0
    */
   <A>(a: A): (self: Iterable<A>) => boolean
@@ -2490,29 +2434,29 @@ export const contains: {
    *
    * **Example** (Checking membership)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Iterable } from "effect"
    *
    * const numbers = [1, 2, 3, 4, 5]
-   * console.log(Iterable.contains(numbers, 3)) // true
-   * console.log(Iterable.contains(numbers, 6)) // false
+   * Iterable.contains(numbers, 3) // => true
+   * Iterable.contains(numbers, 6) // => false
    *
    * const letters = "hello"
-   * console.log(Iterable.contains(letters, "l")) // true
-   * console.log(Iterable.contains(letters, "x")) // false
+   * Iterable.contains(letters, "l") // => true
+   * Iterable.contains(letters, "x") // => false
    *
    * // Works with any iterable
    * const range = Iterable.range(1, 100)
-   * console.log(Iterable.contains(range, 50)) // true
-   * console.log(Iterable.contains(range, 150)) // false
+   * Iterable.contains(range, 50) // => true
+   * Iterable.contains(range, 150) // => false
    *
    * // Curried version
    * const containsThree = Iterable.contains(3)
-   * console.log(containsThree([1, 2, 3])) // true
-   * console.log(containsThree([4, 5, 6])) // false
+   * containsThree([1, 2, 3]) // => true
+   * containsThree([4, 5, 6]) // => false
    * ```
    *
-   * @category elements
+   * @category predicates
    * @since 2.0.0
    */
   <A>(self: Iterable<A>, a: A): boolean
@@ -2524,25 +2468,22 @@ export const contains: {
  *
  * **Example** (Chunking an iterable)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Iterable } from "effect"
  *
  * const numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]
  * const chunks = Iterable.chunksOf(numbers, 3)
- * console.log(Array.from(chunks).map((chunk) => Array.from(chunk)))
- * // [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
+ * Array.from(chunks) // => [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
  *
  * // Last chunk can be shorter
  * const uneven = [1, 2, 3, 4, 5, 6, 7]
  * const chunks2 = Iterable.chunksOf(uneven, 3)
- * console.log(Array.from(chunks2).map((chunk) => Array.from(chunk)))
- * // [[1, 2, 3], [4, 5, 6], [7]]
+ * Array.from(chunks2) // => [[1, 2, 3], [4, 5, 6], [7]]
  *
  * // Chunk size larger than iterable
  * const small = [1, 2]
  * const chunks3 = Iterable.chunksOf(small, 5)
- * console.log(Array.from(chunks3).map((chunk) => Array.from(chunk)))
- * // [[1, 2]]
+ * Array.from(chunks3) // => [[1, 2]]
  *
  * // Process data in batches
  * const data = Iterable.range(1, 100)
@@ -2551,7 +2492,7 @@ export const contains: {
  *   batches,
  *   (batch) => Iterable.reduce(batch, 0, (sum, n) => sum + n)
  * )
- * console.log(Array.from(Iterable.take(batchSums, 3))) // [55, 155, 255]
+ * Array.from(Iterable.take(batchSums, 3)) // => [55, 155, 255]
  * ```
  *
  * @category splitting
@@ -2564,25 +2505,22 @@ export const chunksOf: {
    *
    * **Example** (Chunking an iterable)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Iterable } from "effect"
    *
    * const numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]
    * const chunks = Iterable.chunksOf(numbers, 3)
-   * console.log(Array.from(chunks).map((chunk) => Array.from(chunk)))
-   * // [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
+   * Array.from(chunks) // => [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
    *
    * // Last chunk can be shorter
    * const uneven = [1, 2, 3, 4, 5, 6, 7]
    * const chunks2 = Iterable.chunksOf(uneven, 3)
-   * console.log(Array.from(chunks2).map((chunk) => Array.from(chunk)))
-   * // [[1, 2, 3], [4, 5, 6], [7]]
+   * Array.from(chunks2) // => [[1, 2, 3], [4, 5, 6], [7]]
    *
    * // Chunk size larger than iterable
    * const small = [1, 2]
    * const chunks3 = Iterable.chunksOf(small, 5)
-   * console.log(Array.from(chunks3).map((chunk) => Array.from(chunk)))
-   * // [[1, 2]]
+   * Array.from(chunks3) // => [[1, 2]]
    *
    * // Process data in batches
    * const data = Iterable.range(1, 100)
@@ -2591,7 +2529,7 @@ export const chunksOf: {
    *   batches,
    *   (batch) => Iterable.reduce(batch, 0, (sum, n) => sum + n)
    * )
-   * console.log(Array.from(Iterable.take(batchSums, 3))) // [55, 155, 255]
+   * Array.from(Iterable.take(batchSums, 3)) // => [55, 155, 255]
    * ```
    *
    * @category splitting
@@ -2604,25 +2542,22 @@ export const chunksOf: {
    *
    * **Example** (Chunking an iterable)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Iterable } from "effect"
    *
    * const numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]
    * const chunks = Iterable.chunksOf(numbers, 3)
-   * console.log(Array.from(chunks).map((chunk) => Array.from(chunk)))
-   * // [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
+   * Array.from(chunks) // => [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
    *
    * // Last chunk can be shorter
    * const uneven = [1, 2, 3, 4, 5, 6, 7]
    * const chunks2 = Iterable.chunksOf(uneven, 3)
-   * console.log(Array.from(chunks2).map((chunk) => Array.from(chunk)))
-   * // [[1, 2, 3], [4, 5, 6], [7]]
+   * Array.from(chunks2) // => [[1, 2, 3], [4, 5, 6], [7]]
    *
    * // Chunk size larger than iterable
    * const small = [1, 2]
    * const chunks3 = Iterable.chunksOf(small, 5)
-   * console.log(Array.from(chunks3).map((chunk) => Array.from(chunk)))
-   * // [[1, 2]]
+   * Array.from(chunks3) // => [[1, 2]]
    *
    * // Process data in batches
    * const data = Iterable.range(1, 100)
@@ -2631,7 +2566,7 @@ export const chunksOf: {
    *   batches,
    *   (batch) => Iterable.reduce(batch, 0, (sum, n) => sum + n)
    * )
-   * console.log(Array.from(Iterable.take(batchSums, 3))) // [55, 155, 255]
+   * Array.from(Iterable.take(batchSums, 3)) // => [55, 155, 255]
    * ```
    *
    * @category splitting
@@ -2671,35 +2606,31 @@ export const chunksOf: {
  *
  * **Example** (Grouping consecutive elements with custom equivalence)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Iterable } from "effect"
  *
  * // Group consecutive equal numbers
  * const numbers = [1, 1, 2, 2, 2, 3, 1, 1]
  * const grouped = Iterable.groupWith(numbers, (a, b) => a === b)
- * console.log(Array.from(grouped))
- * // [[1, 1], [2, 2, 2], [3], [1, 1]]
+ * Array.from(grouped) // => [[1, 1], [2, 2, 2], [3], [1, 1]]
  *
  * // Case-insensitive grouping of strings
  * const words = ["Apple", "APPLE", "banana", "Banana", "cherry"]
  * const caseInsensitive = (a: string, b: string) =>
  *   a.toLowerCase() === b.toLowerCase()
  * const groupedWords = Iterable.groupWith(words, caseInsensitive)
- * console.log(Array.from(groupedWords))
- * // [["Apple", "APPLE"], ["banana", "Banana"], ["cherry"]]
+ * Array.from(groupedWords) // => [["Apple", "APPLE"], ["banana", "Banana"], ["cherry"]]
  *
  * // Group by approximate equality
  * const floats = [1.1, 1.12, 1.9, 2.01, 2.05, 3.5]
  * const approxEqual = (a: number, b: number) => Math.abs(a - b) < 0.2
  * const groupedFloats = Iterable.groupWith(floats, approxEqual)
- * console.log(Array.from(groupedFloats))
- * // [[1.1, 1.12], [1.9, 2.01, 2.05], [3.5]]
+ * Array.from(groupedFloats) // => [[1.1, 1.12], [1.9, 2.01, 2.05], [3.5]]
  *
  * // Only groups consecutive elements
  * const scattered = [1, 2, 1, 2, 1]
  * const scatteredGroups = Iterable.groupWith(scattered, (a, b) => a === b)
- * console.log(Array.from(scatteredGroups))
- * // [[1], [2], [1], [2], [1]] (no grouping since none are consecutive)
+ * Array.from(scatteredGroups) // => [[1], [2], [1], [2], [1]]
  * ```
  *
  * @category grouping
@@ -2711,35 +2642,31 @@ export const groupWith: {
    *
    * **Example** (Grouping consecutive elements with custom equivalence)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Iterable } from "effect"
    *
    * // Group consecutive equal numbers
    * const numbers = [1, 1, 2, 2, 2, 3, 1, 1]
    * const grouped = Iterable.groupWith(numbers, (a, b) => a === b)
-   * console.log(Array.from(grouped))
-   * // [[1, 1], [2, 2, 2], [3], [1, 1]]
+   * Array.from(grouped) // => [[1, 1], [2, 2, 2], [3], [1, 1]]
    *
    * // Case-insensitive grouping of strings
    * const words = ["Apple", "APPLE", "banana", "Banana", "cherry"]
    * const caseInsensitive = (a: string, b: string) =>
    *   a.toLowerCase() === b.toLowerCase()
    * const groupedWords = Iterable.groupWith(words, caseInsensitive)
-   * console.log(Array.from(groupedWords))
-   * // [["Apple", "APPLE"], ["banana", "Banana"], ["cherry"]]
+   * Array.from(groupedWords) // => [["Apple", "APPLE"], ["banana", "Banana"], ["cherry"]]
    *
    * // Group by approximate equality
    * const floats = [1.1, 1.12, 1.9, 2.01, 2.05, 3.5]
    * const approxEqual = (a: number, b: number) => Math.abs(a - b) < 0.2
    * const groupedFloats = Iterable.groupWith(floats, approxEqual)
-   * console.log(Array.from(groupedFloats))
-   * // [[1.1, 1.12], [1.9, 2.01, 2.05], [3.5]]
+   * Array.from(groupedFloats) // => [[1.1, 1.12], [1.9, 2.01, 2.05], [3.5]]
    *
    * // Only groups consecutive elements
    * const scattered = [1, 2, 1, 2, 1]
    * const scatteredGroups = Iterable.groupWith(scattered, (a, b) => a === b)
-   * console.log(Array.from(scatteredGroups))
-   * // [[1], [2], [1], [2], [1]] (no grouping since none are consecutive)
+   * Array.from(scatteredGroups) // => [[1], [2], [1], [2], [1]]
    * ```
    *
    * @category grouping
@@ -2751,35 +2678,31 @@ export const groupWith: {
    *
    * **Example** (Grouping consecutive elements with custom equivalence)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Iterable } from "effect"
    *
    * // Group consecutive equal numbers
    * const numbers = [1, 1, 2, 2, 2, 3, 1, 1]
    * const grouped = Iterable.groupWith(numbers, (a, b) => a === b)
-   * console.log(Array.from(grouped))
-   * // [[1, 1], [2, 2, 2], [3], [1, 1]]
+   * Array.from(grouped) // => [[1, 1], [2, 2, 2], [3], [1, 1]]
    *
    * // Case-insensitive grouping of strings
    * const words = ["Apple", "APPLE", "banana", "Banana", "cherry"]
    * const caseInsensitive = (a: string, b: string) =>
    *   a.toLowerCase() === b.toLowerCase()
    * const groupedWords = Iterable.groupWith(words, caseInsensitive)
-   * console.log(Array.from(groupedWords))
-   * // [["Apple", "APPLE"], ["banana", "Banana"], ["cherry"]]
+   * Array.from(groupedWords) // => [["Apple", "APPLE"], ["banana", "Banana"], ["cherry"]]
    *
    * // Group by approximate equality
    * const floats = [1.1, 1.12, 1.9, 2.01, 2.05, 3.5]
    * const approxEqual = (a: number, b: number) => Math.abs(a - b) < 0.2
    * const groupedFloats = Iterable.groupWith(floats, approxEqual)
-   * console.log(Array.from(groupedFloats))
-   * // [[1.1, 1.12], [1.9, 2.01, 2.05], [3.5]]
+   * Array.from(groupedFloats) // => [[1.1, 1.12], [1.9, 2.01, 2.05], [3.5]]
    *
    * // Only groups consecutive elements
    * const scattered = [1, 2, 1, 2, 1]
    * const scatteredGroups = Iterable.groupWith(scattered, (a, b) => a === b)
-   * console.log(Array.from(scatteredGroups))
-   * // [[1], [2], [1], [2], [1]] (no grouping since none are consecutive)
+   * Array.from(scatteredGroups) // => [[1], [2], [1], [2], [1]]
    * ```
    *
    * @category grouping
@@ -2828,18 +2751,16 @@ export const groupWith: {
  *
  * **Example** (Grouping consecutive elements)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Iterable } from "effect"
  *
  * const numbers = [1, 1, 2, 2, 2, 3, 1, 1]
  * const grouped = Iterable.group(numbers)
- * console.log(Array.from(grouped))
- * // [[1, 1], [2, 2, 2], [3], [1, 1]]
+ * Array.from(grouped) // => [[1, 1], [2, 2, 2], [3], [1, 1]]
  *
  * const letters = "aabbccaa"
  * const groupedLetters = Iterable.group(letters)
- * console.log(Array.from(groupedLetters))
- * // [["a", "a"], ["b", "b"], ["c", "c"], ["a", "a"]]
+ * Array.from(groupedLetters) // => [["a", "a"], ["b", "b"], ["c", "c"], ["a", "a"]]
  *
  * // Works with objects using deep equality
  * const objects = [
@@ -2849,7 +2770,7 @@ export const groupWith: {
  *   { type: "A", value: 1 }
  * ]
  * const groupedObjects = Iterable.group(objects)
- * console.log(Array.from(groupedObjects).length) // 3 groups
+ * Array.from(groupedObjects).length // => 3
  * // Note: Only consecutive equal objects are grouped together
  * ```
  *
@@ -2871,20 +2792,18 @@ export const group: <A>(self: Iterable<A>) => Iterable<NonEmptyArray<A>> = group
  *
  * **Example** (Grouping by a key)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Iterable } from "effect"
  *
  * // Group by string length
  * const words = ["a", "bb", "ccc", "dd", "eee", "f"]
  * const byLength = Iterable.groupBy(words, (word) => word.length.toString())
- * console.log(byLength)
- * // { "1": ["a", "f"], "2": ["bb", "dd"], "3": ["ccc", "eee"] }
+ * byLength // => { "1": ["a", "f"], "2": ["bb", "dd"], "3": ["ccc", "eee"] }
  *
  * // Group by first letter
  * const names = ["Alice", "Bob", "Charlie", "David", "Anna", "Betty"]
  * const byFirstLetter = Iterable.groupBy(names, (name) => name[0])
- * console.log(byFirstLetter)
- * // { "A": ["Alice", "Anna"], "B": ["Bob", "Betty"], "C": ["Charlie"], "D": ["David"] }
+ * byFirstLetter // => { A: ["Alice", "Anna"], B: ["Bob", "Betty"], C: ["Charlie"], D: ["David"] }
  *
  * // Group by category
  * const items = [
@@ -2894,17 +2813,12 @@ export const group: <A>(self: Iterable<A>) => Iterable<NonEmptyArray<A>> = group
  *   { name: "broccoli", category: "vegetable" }
  * ]
  * const byCategory = Iterable.groupBy(items, (item) => item.category)
- * console.log(byCategory)
- * // {
- * //   "fruit": [{ name: "apple", category: "fruit" }, { name: "banana", category: "fruit" }],
- * //   "vegetable": [{ name: "carrot", category: "vegetable" }, { name: "broccoli", category: "vegetable" }]
- * // }
+ * Object.keys(byCategory) // => ["fruit", "vegetable"]
  *
  * // Group numbers by even/odd
  * const numbers = [1, 2, 3, 4, 5, 6]
  * const evenOdd = Iterable.groupBy(numbers, (n) => n % 2 === 0 ? "even" : "odd")
- * console.log(evenOdd)
- * // { "odd": [1, 3, 5], "even": [2, 4, 6] }
+ * evenOdd // => { odd: [1, 3, 5], even: [2, 4, 6] }
  * ```
  *
  * @category grouping
@@ -2922,20 +2836,18 @@ export const groupBy: {
    *
    * **Example** (Grouping by a key)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Iterable } from "effect"
    *
    * // Group by string length
    * const words = ["a", "bb", "ccc", "dd", "eee", "f"]
    * const byLength = Iterable.groupBy(words, (word) => word.length.toString())
-   * console.log(byLength)
-   * // { "1": ["a", "f"], "2": ["bb", "dd"], "3": ["ccc", "eee"] }
+   * byLength // => { "1": ["a", "f"], "2": ["bb", "dd"], "3": ["ccc", "eee"] }
    *
    * // Group by first letter
    * const names = ["Alice", "Bob", "Charlie", "David", "Anna", "Betty"]
    * const byFirstLetter = Iterable.groupBy(names, (name) => name[0])
-   * console.log(byFirstLetter)
-   * // { "A": ["Alice", "Anna"], "B": ["Bob", "Betty"], "C": ["Charlie"], "D": ["David"] }
+   * byFirstLetter // => { A: ["Alice", "Anna"], B: ["Bob", "Betty"], C: ["Charlie"], D: ["David"] }
    *
    * // Group by category
    * const items = [
@@ -2945,17 +2857,12 @@ export const groupBy: {
    *   { name: "broccoli", category: "vegetable" }
    * ]
    * const byCategory = Iterable.groupBy(items, (item) => item.category)
-   * console.log(byCategory)
-   * // {
-   * //   "fruit": [{ name: "apple", category: "fruit" }, { name: "banana", category: "fruit" }],
-   * //   "vegetable": [{ name: "carrot", category: "vegetable" }, { name: "broccoli", category: "vegetable" }]
-   * // }
+   * Object.keys(byCategory) // => ["fruit", "vegetable"]
    *
    * // Group numbers by even/odd
    * const numbers = [1, 2, 3, 4, 5, 6]
    * const evenOdd = Iterable.groupBy(numbers, (n) => n % 2 === 0 ? "even" : "odd")
-   * console.log(evenOdd)
-   * // { "odd": [1, 3, 5], "even": [2, 4, 6] }
+   * evenOdd // => { odd: [1, 3, 5], even: [2, 4, 6] }
    * ```
    *
    * @category grouping
@@ -2973,20 +2880,18 @@ export const groupBy: {
    *
    * **Example** (Grouping by a key)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Iterable } from "effect"
    *
    * // Group by string length
    * const words = ["a", "bb", "ccc", "dd", "eee", "f"]
    * const byLength = Iterable.groupBy(words, (word) => word.length.toString())
-   * console.log(byLength)
-   * // { "1": ["a", "f"], "2": ["bb", "dd"], "3": ["ccc", "eee"] }
+   * byLength // => { "1": ["a", "f"], "2": ["bb", "dd"], "3": ["ccc", "eee"] }
    *
    * // Group by first letter
    * const names = ["Alice", "Bob", "Charlie", "David", "Anna", "Betty"]
    * const byFirstLetter = Iterable.groupBy(names, (name) => name[0])
-   * console.log(byFirstLetter)
-   * // { "A": ["Alice", "Anna"], "B": ["Bob", "Betty"], "C": ["Charlie"], "D": ["David"] }
+   * byFirstLetter // => { A: ["Alice", "Anna"], B: ["Bob", "Betty"], C: ["Charlie"], D: ["David"] }
    *
    * // Group by category
    * const items = [
@@ -2996,17 +2901,12 @@ export const groupBy: {
    *   { name: "broccoli", category: "vegetable" }
    * ]
    * const byCategory = Iterable.groupBy(items, (item) => item.category)
-   * console.log(byCategory)
-   * // {
-   * //   "fruit": [{ name: "apple", category: "fruit" }, { name: "banana", category: "fruit" }],
-   * //   "vegetable": [{ name: "carrot", category: "vegetable" }, { name: "broccoli", category: "vegetable" }]
-   * // }
+   * Object.keys(byCategory) // => ["fruit", "vegetable"]
    *
    * // Group numbers by even/odd
    * const numbers = [1, 2, 3, 4, 5, 6]
    * const evenOdd = Iterable.groupBy(numbers, (n) => n % 2 === 0 ? "even" : "odd")
-   * console.log(evenOdd)
-   * // { "odd": [1, 3, 5], "even": [2, 4, 6] }
+   * evenOdd // => { odd: [1, 3, 5], even: [2, 4, 6] }
    * ```
    *
    * @category grouping
@@ -3023,7 +2923,7 @@ export const groupBy: {
     if (Object.hasOwn(out, k)) {
       out[k].push(a)
     } else {
-      out[k] = [a]
+      InternalRecord.assignProperty(out, k, [a])
     }
   }
   return out
@@ -3050,18 +2950,10 @@ const constEmptyIterator: Iterator<never> = {
  *
  * **Example** (Creating an empty iterable)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Iterable } from "effect"
  *
- * const empty = Iterable.empty<string>()
- * console.log(Array.from(empty)) // []
- * console.log(Iterable.isEmpty(empty)) // true
- *
- * // Useful as base case for reductions
- * const hasData = true
- * const result = hasData
- *   ? Iterable.range(1, 5)
- *   : Iterable.empty<number>()
+ * Array.from(Iterable.empty<string>()) // => []
  * ```
  *
  * @category constructors
@@ -3079,11 +2971,11 @@ export const empty = <A = never>(): Iterable<A> => constEmpty
  *
  * **Example** (Wrapping a single value)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Iterable } from "effect"
  *
  * const single = Iterable.of(42)
- * console.log(Array.from(single)) // [42]
+ * Array.from(single) // => [42]
  *
  * // Useful for creating homogeneous sequences
  * const sequences = [
@@ -3098,7 +2990,7 @@ export const empty = <A = never>(): Iterable<A> => constEmpty
  *   numbers,
  *   (n) => n % 2 === 0 ? Iterable.of(n) : Iterable.empty()
  * )
- * console.log(Array.from(evensOnly)) // [2, 4]
+ * Array.from(evensOnly) // => [2, 4]
  * ```
  *
  * @category constructors
@@ -3118,24 +3010,22 @@ export const of = <A>(a: A): Iterable<A> => [a]
  *
  * **Example** (Mapping elements)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Iterable } from "effect"
  *
  * // Transform numbers to their squares
  * const numbers = [1, 2, 3, 4, 5]
  * const squares = Iterable.map(numbers, (x) => x * x)
- * console.log(Array.from(squares)) // [1, 4, 9, 16, 25]
+ * Array.from(squares) // => [1, 4, 9, 16, 25]
  *
  * // Use index in transformation
  * const indexed = Iterable.map(["a", "b", "c"], (char, i) => `${i}: ${char}`)
- * console.log(Array.from(indexed)) // ["0: a", "1: b", "2: c"]
+ * Array.from(indexed) // => ["0: a", "1: b", "2: c"]
  *
- * // Chain transformations
- * const result = Iterable.map(
+ * Array.from(Iterable.map(
  *   Iterable.map([1, 2, 3], (x) => x * 2),
  *   (x) => x + 1
- * )
- * console.log(Array.from(result)) // [3, 5, 7]
+ * )) // => [3, 5, 7]
  * ```
  *
  * @category mapping
@@ -3154,24 +3044,22 @@ export const map: {
    *
    * **Example** (Mapping elements)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Iterable } from "effect"
    *
    * // Transform numbers to their squares
    * const numbers = [1, 2, 3, 4, 5]
    * const squares = Iterable.map(numbers, (x) => x * x)
-   * console.log(Array.from(squares)) // [1, 4, 9, 16, 25]
+   * Array.from(squares) // => [1, 4, 9, 16, 25]
    *
    * // Use index in transformation
    * const indexed = Iterable.map(["a", "b", "c"], (char, i) => `${i}: ${char}`)
-   * console.log(Array.from(indexed)) // ["0: a", "1: b", "2: c"]
+   * Array.from(indexed) // => ["0: a", "1: b", "2: c"]
    *
-   * // Chain transformations
-   * const result = Iterable.map(
+   * Array.from(Iterable.map(
    *   Iterable.map([1, 2, 3], (x) => x * 2),
    *   (x) => x + 1
-   * )
-   * console.log(Array.from(result)) // [3, 5, 7]
+   * )) // => [3, 5, 7]
    * ```
    *
    * @category mapping
@@ -3190,24 +3078,22 @@ export const map: {
    *
    * **Example** (Mapping elements)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Iterable } from "effect"
    *
    * // Transform numbers to their squares
    * const numbers = [1, 2, 3, 4, 5]
    * const squares = Iterable.map(numbers, (x) => x * x)
-   * console.log(Array.from(squares)) // [1, 4, 9, 16, 25]
+   * Array.from(squares) // => [1, 4, 9, 16, 25]
    *
    * // Use index in transformation
    * const indexed = Iterable.map(["a", "b", "c"], (char, i) => `${i}: ${char}`)
-   * console.log(Array.from(indexed)) // ["0: a", "1: b", "2: c"]
+   * Array.from(indexed) // => ["0: a", "1: b", "2: c"]
    *
-   * // Chain transformations
-   * const result = Iterable.map(
+   * Array.from(Iterable.map(
    *   Iterable.map([1, 2, 3], (x) => x * 2),
    *   (x) => x + 1
-   * )
-   * console.log(Array.from(result)) // [3, 5, 7]
+   * )) // => [3, 5, 7]
    * ```
    *
    * @category mapping
@@ -3235,18 +3121,18 @@ export const map: {
  *
  * **Example** (Flat mapping iterables)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Iterable } from "effect"
  *
  * // Expand each number to a range
  * const numbers = [1, 2, 3]
  * const expanded = Iterable.flatMap(numbers, (n) => Iterable.range(1, n))
- * console.log(Array.from(expanded)) // [1, 1, 2, 1, 2, 3]
+ * Array.from(expanded) // => [1, 1, 2, 1, 2, 3]
  *
  * // Split strings into characters
  * const words = ["hi", "bye"]
  * const chars = Iterable.flatMap(words, (word) => word)
- * console.log(Array.from(chars)) // ["h", "i", "b", "y", "e"]
+ * Array.from(chars) // => ["h", "i", "b", "y", "e"]
  *
  * // Conditional expansion with empty iterables
  * const values = [1, 2, 3, 4, 5]
@@ -3254,7 +3140,7 @@ export const map: {
  *   values,
  *   (n) => n % 2 === 0 ? [n, n * 2, n * 3] : []
  * )
- * console.log(Array.from(evenMultiples)) // [2, 4, 6, 4, 8, 12]
+ * Array.from(evenMultiples) // => [2, 4, 6, 4, 8, 12]
  *
  * // Use index in transformation
  * const letters = ["a", "b", "c"]
@@ -3262,7 +3148,7 @@ export const map: {
  *   letters,
  *   (letter, i) => Iterable.replicate(letter, i + 1)
  * )
- * console.log(Array.from(indexed)) // ["a", "b", "b", "c", "c", "c"]
+ * Array.from(indexed) // => ["a", "b", "b", "c", "c", "c"]
  * ```
  *
  * @category sequencing
@@ -3274,18 +3160,18 @@ export const flatMap: {
    *
    * **Example** (Flat mapping iterables)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Iterable } from "effect"
    *
    * // Expand each number to a range
    * const numbers = [1, 2, 3]
    * const expanded = Iterable.flatMap(numbers, (n) => Iterable.range(1, n))
-   * console.log(Array.from(expanded)) // [1, 1, 2, 1, 2, 3]
+   * Array.from(expanded) // => [1, 1, 2, 1, 2, 3]
    *
    * // Split strings into characters
    * const words = ["hi", "bye"]
    * const chars = Iterable.flatMap(words, (word) => word)
-   * console.log(Array.from(chars)) // ["h", "i", "b", "y", "e"]
+   * Array.from(chars) // => ["h", "i", "b", "y", "e"]
    *
    * // Conditional expansion with empty iterables
    * const values = [1, 2, 3, 4, 5]
@@ -3293,7 +3179,7 @@ export const flatMap: {
    *   values,
    *   (n) => n % 2 === 0 ? [n, n * 2, n * 3] : []
    * )
-   * console.log(Array.from(evenMultiples)) // [2, 4, 6, 4, 8, 12]
+   * Array.from(evenMultiples) // => [2, 4, 6, 4, 8, 12]
    *
    * // Use index in transformation
    * const letters = ["a", "b", "c"]
@@ -3301,7 +3187,7 @@ export const flatMap: {
    *   letters,
    *   (letter, i) => Iterable.replicate(letter, i + 1)
    * )
-   * console.log(Array.from(indexed)) // ["a", "b", "b", "c", "c", "c"]
+   * Array.from(indexed) // => ["a", "b", "b", "c", "c", "c"]
    * ```
    *
    * @category sequencing
@@ -3313,18 +3199,18 @@ export const flatMap: {
    *
    * **Example** (Flat mapping iterables)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Iterable } from "effect"
    *
    * // Expand each number to a range
    * const numbers = [1, 2, 3]
    * const expanded = Iterable.flatMap(numbers, (n) => Iterable.range(1, n))
-   * console.log(Array.from(expanded)) // [1, 1, 2, 1, 2, 3]
+   * Array.from(expanded) // => [1, 1, 2, 1, 2, 3]
    *
    * // Split strings into characters
    * const words = ["hi", "bye"]
    * const chars = Iterable.flatMap(words, (word) => word)
-   * console.log(Array.from(chars)) // ["h", "i", "b", "y", "e"]
+   * Array.from(chars) // => ["h", "i", "b", "y", "e"]
    *
    * // Conditional expansion with empty iterables
    * const values = [1, 2, 3, 4, 5]
@@ -3332,7 +3218,7 @@ export const flatMap: {
    *   values,
    *   (n) => n % 2 === 0 ? [n, n * 2, n * 3] : []
    * )
-   * console.log(Array.from(evenMultiples)) // [2, 4, 6, 4, 8, 12]
+   * Array.from(evenMultiples) // => [2, 4, 6, 4, 8, 12]
    *
    * // Use index in transformation
    * const letters = ["a", "b", "c"]
@@ -3340,7 +3226,7 @@ export const flatMap: {
    *   letters,
    *   (letter, i) => Iterable.replicate(letter, i + 1)
    * )
-   * console.log(Array.from(indexed)) // ["a", "b", "b", "c", "c", "c"]
+   * Array.from(indexed) // => ["a", "b", "b", "c", "c", "c"]
    * ```
    *
    * @category sequencing
@@ -3357,29 +3243,29 @@ export const flatMap: {
  *
  * **Example** (Flattening nested iterables)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Iterable } from "effect"
  *
  * // Flatten nested arrays
  * const nested = [[1, 2], [3, 4], [5, 6]]
  * const flat = Iterable.flatten(nested)
- * console.log(Array.from(flat)) // [1, 2, 3, 4, 5, 6]
+ * Array.from(flat) // => [1, 2, 3, 4, 5, 6]
  *
  * // Flatten different iterable types
  * const mixed: Array<Iterable<string>> = ["ab", "cd"]
  * const flatMixed = Iterable.flatten(mixed)
- * console.log(Array.from(flatMixed)) // ["a", "b", "c", "d"]
+ * Array.from(flatMixed) // => ["a", "b", "c", "d"]
  *
  * // Flatten deeply nested (only one level)
  * const deepNested = [[[1, 2]], [[3, 4]]]
  * const oneLevelFlat = Iterable.flatten(deepNested)
- * console.log(Array.from(oneLevelFlat).map((arr) => Array.from(arr)))
+ * Array.from(oneLevelFlat) // => [[1, 2], [3, 4]]
  * // [[1, 2], [3, 4]] (still contains arrays)
  *
  * // Empty iterables are handled correctly
  * const withEmpty = [[1, 2], [], [3, 4], []]
  * const flatWithEmpty = Iterable.flatten(withEmpty)
- * console.log(Array.from(flatWithEmpty)) // [1, 2, 3, 4]
+ * Array.from(flatWithEmpty) // => [1, 2, 3, 4]
  * ```
  *
  * @category sequencing
@@ -3390,19 +3276,20 @@ export const flatten = <A>(self: Iterable<Iterable<A>>): Iterable<A> => ({
     const outerIterator = self[Symbol.iterator]()
     let innerIterator: Iterator<A> | undefined
     function next() {
-      if (innerIterator === undefined) {
-        const next = outerIterator.next()
-        if (next.done) {
-          return next
+      while (true) {
+        if (innerIterator === undefined) {
+          const next = outerIterator.next()
+          if (next.done) {
+            return next
+          }
+          innerIterator = next.value[Symbol.iterator]()
+        }
+        const result = innerIterator.next()
+        if (!result.done) {
+          return result
         }
-        innerIterator = next.value[Symbol.iterator]()
-      }
-      const result = innerIterator.next()
-      if (result.done) {
         innerIterator = undefined
-        return next()
       }
-      return result
     }
     return { next }
   }
@@ -3419,7 +3306,7 @@ export const flatten = <A>(self: Iterable<Iterable<A>>): Iterable<A> => ({
  *
  * **Example** (Filtering and transforming Result values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Iterable, Result } from "effect"
  *
  * // Parse strings to numbers, keeping only valid ones
@@ -3428,7 +3315,7 @@ export const flatten = <A>(self: Iterable<Iterable<A>>): Iterable<A> => ({
  *   const num = parseInt(s)
  *   return isNaN(num) ? Result.failVoid : Result.succeed(num)
  * })
- * console.log(Array.from(numbers)) // [1, 2, 4]
+ * Array.from(numbers) // => [1, 2, 4]
  *
  * // Extract specific properties from objects
  * const users = [
@@ -3442,7 +3329,7 @@ export const flatten = <A>(self: Iterable<Iterable<A>>): Iterable<A> => ({
  *   (user) =>
  *     user.age >= 18 && user.email ? Result.succeed(user.email) : Result.failVoid
  * )
- * console.log(Array.from(adultEmails)) // ["alice@example.com", "charlie@example.com"]
+ * Array.from(adultEmails) // => ["alice@example.com", "charlie@example.com"]
  *
  * // Use index in transformation
  * const items = ["a", "b", "c", "d", "e"]
@@ -3450,7 +3337,7 @@ export const flatten = <A>(self: Iterable<Iterable<A>>): Iterable<A> => ({
  *   items,
  *   (item, i) => i % 2 === 0 ? Result.succeed(`${i}: ${item}`) : Result.failVoid
  * )
- * console.log(Array.from(evenIndexItems)) // ["0: a", "2: c", "4: e"]
+ * Array.from(evenIndexItems) // => ["0: a", "2: c", "4: e"]
  * ```
  *
  * @category filtering
@@ -3468,7 +3355,7 @@ export const filterMap: {
    *
    * **Example** (Filtering and transforming Result values)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Iterable, Result } from "effect"
    *
    * // Parse strings to numbers, keeping only valid ones
@@ -3477,7 +3364,7 @@ export const filterMap: {
    *   const num = parseInt(s)
    *   return isNaN(num) ? Result.failVoid : Result.succeed(num)
    * })
-   * console.log(Array.from(numbers)) // [1, 2, 4]
+   * Array.from(numbers) // => [1, 2, 4]
    *
    * // Extract specific properties from objects
    * const users = [
@@ -3491,7 +3378,7 @@ export const filterMap: {
    *   (user) =>
    *     user.age >= 18 && user.email ? Result.succeed(user.email) : Result.failVoid
    * )
-   * console.log(Array.from(adultEmails)) // ["alice@example.com", "charlie@example.com"]
+   * Array.from(adultEmails) // => ["alice@example.com", "charlie@example.com"]
    *
    * // Use index in transformation
    * const items = ["a", "b", "c", "d", "e"]
@@ -3499,7 +3386,7 @@ export const filterMap: {
    *   items,
    *   (item, i) => i % 2 === 0 ? Result.succeed(`${i}: ${item}`) : Result.failVoid
    * )
-   * console.log(Array.from(evenIndexItems)) // ["0: a", "2: c", "4: e"]
+   * Array.from(evenIndexItems) // => ["0: a", "2: c", "4: e"]
    * ```
    *
    * @category filtering
@@ -3517,7 +3404,7 @@ export const filterMap: {
    *
    * **Example** (Filtering and transforming Result values)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Iterable, Result } from "effect"
    *
    * // Parse strings to numbers, keeping only valid ones
@@ -3526,7 +3413,7 @@ export const filterMap: {
    *   const num = parseInt(s)
    *   return isNaN(num) ? Result.failVoid : Result.succeed(num)
    * })
-   * console.log(Array.from(numbers)) // [1, 2, 4]
+   * Array.from(numbers) // => [1, 2, 4]
    *
    * // Extract specific properties from objects
    * const users = [
@@ -3540,7 +3427,7 @@ export const filterMap: {
    *   (user) =>
    *     user.age >= 18 && user.email ? Result.succeed(user.email) : Result.failVoid
    * )
-   * console.log(Array.from(adultEmails)) // ["alice@example.com", "charlie@example.com"]
+   * Array.from(adultEmails) // => ["alice@example.com", "charlie@example.com"]
    *
    * // Use index in transformation
    * const items = ["a", "b", "c", "d", "e"]
@@ -3548,7 +3435,7 @@ export const filterMap: {
    *   items,
    *   (item, i) => i % 2 === 0 ? Result.succeed(`${i}: ${item}`) : Result.failVoid
    * )
-   * console.log(Array.from(evenIndexItems)) // ["0: a", "2: c", "4: e"]
+   * Array.from(evenIndexItems) // => ["0: a", "2: c", "4: e"]
    * ```
    *
    * @category filtering
@@ -3583,7 +3470,7 @@ export const filterMap: {
  *
  * **Example** (Filtering and transforming until failure)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Iterable, Result } from "effect"
  *
  * // Parse numbers until we hit an invalid one
@@ -3592,7 +3479,7 @@ export const filterMap: {
  *   const num = parseInt(s)
  *   return isNaN(num) ? Result.failVoid : Result.succeed(num)
  * })
- * console.log(Array.from(numbers)) // [1, 2, 3] (stops at "invalid")
+ * Array.from(numbers) // => [1, 2, 3]
  *
  * // Take elements while they meet a condition and transform them
  * const values = [2, 4, 6, 7, 8, 10]
@@ -3600,7 +3487,7 @@ export const filterMap: {
  *   values,
  *   (n) => n % 2 === 0 ? Result.succeed(n * 2) : Result.failVoid
  * )
- * console.log(Array.from(doubledEvens)) // [4, 8, 12] (stops at 7)
+ * Array.from(doubledEvens) // => [4, 8, 12]
  *
  * // Process with index until condition fails
  * const letters = ["a", "b", "c", "d", "e"]
@@ -3608,7 +3495,7 @@ export const filterMap: {
  *   letters,
  *   (letter, i) => letter !== "c" ? Result.succeed(`${i}: ${letter}`) : Result.failVoid
  * )
- * console.log(Array.from(indexedUntilC)) // ["0: a", "1: b"] (stops at "c")
+ * Array.from(indexedUntilC) // => ["0: a", "1: b"]
  * ```
  *
  * @category filtering
@@ -3620,7 +3507,7 @@ export const filterMapWhile: {
    *
    * **Example** (Filtering and transforming until failure)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Iterable, Result } from "effect"
    *
    * // Parse numbers until we hit an invalid one
@@ -3629,7 +3516,7 @@ export const filterMapWhile: {
    *   const num = parseInt(s)
    *   return isNaN(num) ? Result.failVoid : Result.succeed(num)
    * })
-   * console.log(Array.from(numbers)) // [1, 2, 3] (stops at "invalid")
+   * Array.from(numbers) // => [1, 2, 3]
    *
    * // Take elements while they meet a condition and transform them
    * const values = [2, 4, 6, 7, 8, 10]
@@ -3637,7 +3524,7 @@ export const filterMapWhile: {
    *   values,
    *   (n) => n % 2 === 0 ? Result.succeed(n * 2) : Result.failVoid
    * )
-   * console.log(Array.from(doubledEvens)) // [4, 8, 12] (stops at 7)
+   * Array.from(doubledEvens) // => [4, 8, 12]
    *
    * // Process with index until condition fails
    * const letters = ["a", "b", "c", "d", "e"]
@@ -3645,7 +3532,7 @@ export const filterMapWhile: {
    *   letters,
    *   (letter, i) => letter !== "c" ? Result.succeed(`${i}: ${letter}`) : Result.failVoid
    * )
-   * console.log(Array.from(indexedUntilC)) // ["0: a", "1: b"] (stops at "c")
+   * Array.from(indexedUntilC) // => ["0: a", "1: b"]
    * ```
    *
    * @category filtering
@@ -3657,7 +3544,7 @@ export const filterMapWhile: {
    *
    * **Example** (Filtering and transforming until failure)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Iterable, Result } from "effect"
    *
    * // Parse numbers until we hit an invalid one
@@ -3666,7 +3553,7 @@ export const filterMapWhile: {
    *   const num = parseInt(s)
    *   return isNaN(num) ? Result.failVoid : Result.succeed(num)
    * })
-   * console.log(Array.from(numbers)) // [1, 2, 3] (stops at "invalid")
+   * Array.from(numbers) // => [1, 2, 3]
    *
    * // Take elements while they meet a condition and transform them
    * const values = [2, 4, 6, 7, 8, 10]
@@ -3674,7 +3561,7 @@ export const filterMapWhile: {
    *   values,
    *   (n) => n % 2 === 0 ? Result.succeed(n * 2) : Result.failVoid
    * )
-   * console.log(Array.from(doubledEvens)) // [4, 8, 12] (stops at 7)
+   * Array.from(doubledEvens) // => [4, 8, 12]
    *
    * // Process with index until condition fails
    * const letters = ["a", "b", "c", "d", "e"]
@@ -3682,7 +3569,7 @@ export const filterMapWhile: {
    *   letters,
    *   (letter, i) => letter !== "c" ? Result.succeed(`${i}: ${letter}`) : Result.failVoid
    * )
-   * console.log(Array.from(indexedUntilC)) // ["0: a", "1: b"] (stops at "c")
+   * Array.from(indexedUntilC) // => ["0: a", "1: b"]
    * ```
    *
    * @category filtering
@@ -3714,16 +3601,10 @@ export const filterMapWhile: {
  *
  * **Example** (Extracting Some values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Iterable, Option } from "effect"
- * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(
- *   Array.from(
- *     Iterable.getSomes([Option.some(1), Option.none(), Option.some(2)])
- *   ),
- *   [1, 2]
- * )
+ * Array.from(Iterable.getSomes([Option.some(1), Option.none(), Option.some(2)])) // => [1, 2]
  * ```
  *
  * @category filtering
@@ -3755,20 +3636,14 @@ export const getSomes = <A>(self: Iterable<Option<A>>): Iterable<A> => {
  *
  * **Example** (Extracting failures)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Iterable, Result } from "effect"
- * import * as assert from "node:assert"
- *
- * assert.deepStrictEqual(
- *   Array.from(
- *     Iterable.getFailures([
- *       Result.succeed(1),
- *       Result.fail("err"),
- *       Result.succeed(2)
- *     ])
- *   ),
- *   ["err"]
- * )
+ *
+ * Array.from(Iterable.getFailures([
+ *   Result.succeed(1),
+ *   Result.fail("err"),
+ *   Result.succeed(2)
+ * ])) // => ["err"]
  * ```
  *
  * @category filtering
@@ -3800,20 +3675,14 @@ export const getFailures = <R0, L>(self: Iterable<Result<R0, L>>): Iterable<L> =
  *
  * **Example** (Extracting successes)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Iterable, Result } from "effect"
- * import * as assert from "node:assert"
- *
- * assert.deepStrictEqual(
- *   Array.from(
- *     Iterable.getSuccesses([
- *       Result.succeed(1),
- *       Result.fail("err"),
- *       Result.succeed(2)
- *     ])
- *   ),
- *   [1, 2]
- * )
+ *
+ * Array.from(Iterable.getSuccesses([
+ *   Result.succeed(1),
+ *   Result.fail("err"),
+ *   Result.succeed(2)
+ * ])) // => [1, 2]
  * ```
  *
  * @category filtering
@@ -3850,18 +3719,18 @@ export const getSuccesses = <R0, L>(self: Iterable<Result<R0, L>>): Iterable<R0>
  *
  * **Example** (Filtering elements)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Iterable } from "effect"
  *
  * // Filter even numbers
  * const numbers = [1, 2, 3, 4, 5, 6]
  * const evens = Iterable.filter(numbers, (x) => x % 2 === 0)
- * console.log(Array.from(evens)) // [2, 4, 6]
+ * Array.from(evens) // => [2, 4, 6]
  *
  * // Filter with index
  * const items = ["a", "b", "c", "d"]
  * const oddPositions = Iterable.filter(items, (_, i) => i % 2 === 1)
- * console.log(Array.from(oddPositions)) // ["b", "d"]
+ * Array.from(oddPositions) // => ["b", "d"]
  *
  * // Type refinement
  * const mixed: Array<string | number> = ["hello", 42, "world", 100]
@@ -3869,14 +3738,14 @@ export const getSuccesses = <R0, L>(self: Iterable<Result<R0, L>>): Iterable<R0>
  *   mixed,
  *   (x): x is string => typeof x === "string"
  * )
- * console.log(Array.from(onlyStrings)) // ["hello", "world"] (typed as string[])
+ * Array.from(onlyStrings) // => ["hello", "world"]
  *
  * // Combine with map
  * const processed = Iterable.map(
  *   Iterable.filter([1, 2, 3, 4, 5], (x) => x > 2),
  *   (x) => x * 10
  * )
- * console.log(Array.from(processed)) // [30, 40, 50]
+ * Array.from(processed) // => [30, 40, 50]
  * ```
  *
  * @category filtering
@@ -3894,18 +3763,18 @@ export const filter: {
    *
    * **Example** (Filtering elements)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Iterable } from "effect"
    *
    * // Filter even numbers
    * const numbers = [1, 2, 3, 4, 5, 6]
    * const evens = Iterable.filter(numbers, (x) => x % 2 === 0)
-   * console.log(Array.from(evens)) // [2, 4, 6]
+   * Array.from(evens) // => [2, 4, 6]
    *
    * // Filter with index
    * const items = ["a", "b", "c", "d"]
    * const oddPositions = Iterable.filter(items, (_, i) => i % 2 === 1)
-   * console.log(Array.from(oddPositions)) // ["b", "d"]
+   * Array.from(oddPositions) // => ["b", "d"]
    *
    * // Type refinement
    * const mixed: Array<string | number> = ["hello", 42, "world", 100]
@@ -3913,14 +3782,14 @@ export const filter: {
    *   mixed,
    *   (x): x is string => typeof x === "string"
    * )
-   * console.log(Array.from(onlyStrings)) // ["hello", "world"] (typed as string[])
+   * Array.from(onlyStrings) // => ["hello", "world"]
    *
    * // Combine with map
    * const processed = Iterable.map(
    *   Iterable.filter([1, 2, 3, 4, 5], (x) => x > 2),
    *   (x) => x * 10
    * )
-   * console.log(Array.from(processed)) // [30, 40, 50]
+   * Array.from(processed) // => [30, 40, 50]
    * ```
    *
    * @category filtering
@@ -3938,18 +3807,18 @@ export const filter: {
    *
    * **Example** (Filtering elements)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Iterable } from "effect"
    *
    * // Filter even numbers
    * const numbers = [1, 2, 3, 4, 5, 6]
    * const evens = Iterable.filter(numbers, (x) => x % 2 === 0)
-   * console.log(Array.from(evens)) // [2, 4, 6]
+   * Array.from(evens) // => [2, 4, 6]
    *
    * // Filter with index
    * const items = ["a", "b", "c", "d"]
    * const oddPositions = Iterable.filter(items, (_, i) => i % 2 === 1)
-   * console.log(Array.from(oddPositions)) // ["b", "d"]
+   * Array.from(oddPositions) // => ["b", "d"]
    *
    * // Type refinement
    * const mixed: Array<string | number> = ["hello", 42, "world", 100]
@@ -3957,14 +3826,14 @@ export const filter: {
    *   mixed,
    *   (x): x is string => typeof x === "string"
    * )
-   * console.log(Array.from(onlyStrings)) // ["hello", "world"] (typed as string[])
+   * Array.from(onlyStrings) // => ["hello", "world"]
    *
    * // Combine with map
    * const processed = Iterable.map(
    *   Iterable.filter([1, 2, 3, 4, 5], (x) => x > 2),
    *   (x) => x * 10
    * )
-   * console.log(Array.from(processed)) // [30, 40, 50]
+   * Array.from(processed) // => [30, 40, 50]
    * ```
    *
    * @category filtering
@@ -3982,18 +3851,18 @@ export const filter: {
    *
    * **Example** (Filtering elements)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Iterable } from "effect"
    *
    * // Filter even numbers
    * const numbers = [1, 2, 3, 4, 5, 6]
    * const evens = Iterable.filter(numbers, (x) => x % 2 === 0)
-   * console.log(Array.from(evens)) // [2, 4, 6]
+   * Array.from(evens) // => [2, 4, 6]
    *
    * // Filter with index
    * const items = ["a", "b", "c", "d"]
    * const oddPositions = Iterable.filter(items, (_, i) => i % 2 === 1)
-   * console.log(Array.from(oddPositions)) // ["b", "d"]
+   * Array.from(oddPositions) // => ["b", "d"]
    *
    * // Type refinement
    * const mixed: Array<string | number> = ["hello", 42, "world", 100]
@@ -4001,14 +3870,14 @@ export const filter: {
    *   mixed,
    *   (x): x is string => typeof x === "string"
    * )
-   * console.log(Array.from(onlyStrings)) // ["hello", "world"] (typed as string[])
+   * Array.from(onlyStrings) // => ["hello", "world"]
    *
    * // Combine with map
    * const processed = Iterable.map(
    *   Iterable.filter([1, 2, 3, 4, 5], (x) => x > 2),
    *   (x) => x * 10
    * )
-   * console.log(Array.from(processed)) // [30, 40, 50]
+   * Array.from(processed) // => [30, 40, 50]
    * ```
    *
    * @category filtering
@@ -4026,18 +3895,18 @@ export const filter: {
    *
    * **Example** (Filtering elements)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Iterable } from "effect"
    *
    * // Filter even numbers
    * const numbers = [1, 2, 3, 4, 5, 6]
    * const evens = Iterable.filter(numbers, (x) => x % 2 === 0)
-   * console.log(Array.from(evens)) // [2, 4, 6]
+   * Array.from(evens) // => [2, 4, 6]
    *
    * // Filter with index
    * const items = ["a", "b", "c", "d"]
    * const oddPositions = Iterable.filter(items, (_, i) => i % 2 === 1)
-   * console.log(Array.from(oddPositions)) // ["b", "d"]
+   * Array.from(oddPositions) // => ["b", "d"]
    *
    * // Type refinement
    * const mixed: Array<string | number> = ["hello", 42, "world", 100]
@@ -4045,14 +3914,14 @@ export const filter: {
    *   mixed,
    *   (x): x is string => typeof x === "string"
    * )
-   * console.log(Array.from(onlyStrings)) // ["hello", "world"] (typed as string[])
+   * Array.from(onlyStrings) // => ["hello", "world"]
    *
    * // Combine with map
    * const processed = Iterable.map(
    *   Iterable.filter([1, 2, 3, 4, 5], (x) => x > 2),
    *   (x) => x * 10
    * )
-   * console.log(Array.from(processed)) // [30, 40, 50]
+   * Array.from(processed) // => [30, 40, 50]
    * ```
    *
    * @category filtering
@@ -4091,7 +3960,7 @@ export const filter: {
  *
  * **Example** (Flat mapping nullable results)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Iterable } from "effect"
  *
  * // Extract valid elements from nullable function results
@@ -4100,7 +3969,7 @@ export const filter: {
  *   const num = parseInt(s)
  *   return isNaN(num) ? null : num * 2
  * })
- * console.log(Array.from(parsed)) // [2, 4, 8]
+ * Array.from(parsed) // => [2, 4, 8]
  *
  * // Safe property access
  * const objects = [
@@ -4110,7 +3979,7 @@ export const filter: {
  *   {}
  * ]
  * const values = Iterable.flatMapNullishOr(objects, (obj) => obj.nested?.value)
- * console.log(Array.from(values)) // [10, 20]
+ * Array.from(values) // => [10, 20]
  *
  * // Working with Map.get (returns undefined for missing keys)
  * const map = new Map([
@@ -4120,7 +3989,7 @@ export const filter: {
  * ])
  * const keys = ["a", "x", "b", "y", "c"]
  * const foundValues = Iterable.flatMapNullishOr(keys, (key) => map.get(key))
- * console.log(Array.from(foundValues)) // [1, 2, 3]
+ * Array.from(foundValues) // => [1, 2, 3]
  * ```
  *
  * @category sequencing
@@ -4137,7 +4006,7 @@ export const flatMapNullishOr: {
    *
    * **Example** (Flat mapping nullable results)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Iterable } from "effect"
    *
    * // Extract valid elements from nullable function results
@@ -4146,7 +4015,7 @@ export const flatMapNullishOr: {
    *   const num = parseInt(s)
    *   return isNaN(num) ? null : num * 2
    * })
-   * console.log(Array.from(parsed)) // [2, 4, 8]
+   * Array.from(parsed) // => [2, 4, 8]
    *
    * // Safe property access
    * const objects = [
@@ -4156,7 +4025,7 @@ export const flatMapNullishOr: {
    *   {}
    * ]
    * const values = Iterable.flatMapNullishOr(objects, (obj) => obj.nested?.value)
-   * console.log(Array.from(values)) // [10, 20]
+   * Array.from(values) // => [10, 20]
    *
    * // Working with Map.get (returns undefined for missing keys)
    * const map = new Map([
@@ -4166,7 +4035,7 @@ export const flatMapNullishOr: {
    * ])
    * const keys = ["a", "x", "b", "y", "c"]
    * const foundValues = Iterable.flatMapNullishOr(keys, (key) => map.get(key))
-   * console.log(Array.from(foundValues)) // [1, 2, 3]
+   * Array.from(foundValues) // => [1, 2, 3]
    * ```
    *
    * @category sequencing
@@ -4183,7 +4052,7 @@ export const flatMapNullishOr: {
    *
    * **Example** (Flat mapping nullable results)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Iterable } from "effect"
    *
    * // Extract valid elements from nullable function results
@@ -4192,7 +4061,7 @@ export const flatMapNullishOr: {
    *   const num = parseInt(s)
    *   return isNaN(num) ? null : num * 2
    * })
-   * console.log(Array.from(parsed)) // [2, 4, 8]
+   * Array.from(parsed) // => [2, 4, 8]
    *
    * // Safe property access
    * const objects = [
@@ -4202,7 +4071,7 @@ export const flatMapNullishOr: {
    *   {}
    * ]
    * const values = Iterable.flatMapNullishOr(objects, (obj) => obj.nested?.value)
-   * console.log(Array.from(values)) // [10, 20]
+   * Array.from(values) // => [10, 20]
    *
    * // Working with Map.get (returns undefined for missing keys)
    * const map = new Map([
@@ -4212,7 +4081,7 @@ export const flatMapNullishOr: {
    * ])
    * const keys = ["a", "x", "b", "y", "c"]
    * const foundValues = Iterable.flatMapNullishOr(keys, (key) => map.get(key))
-   * console.log(Array.from(foundValues)) // [1, 2, 3]
+   * Array.from(foundValues) // => [1, 2, 3]
    * ```
    *
    * @category sequencing
@@ -4233,21 +4102,21 @@ export const flatMapNullishOr: {
  *
  * **Example** (Checking whether some element matches)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Iterable } from "effect"
  *
  * const numbers = [1, 3, 5, 7, 8]
  * const hasEven = Iterable.some(numbers, (x) => x % 2 === 0)
- * console.log(hasEven) // true (because of 8)
+ * hasEven // => true
  *
  * const allOdd = [1, 3, 5, 7]
  * const hasEvenInAllOdd = Iterable.some(allOdd, (x) => x % 2 === 0)
- * console.log(hasEvenInAllOdd) // false
+ * hasEvenInAllOdd // => false
  *
  * // With index
  * const letters = ["a", "b", "c"]
  * const hasElementAtIndex2 = Iterable.some(letters, (_, i) => i === 2)
- * console.log(hasElementAtIndex2) // true
+ * hasElementAtIndex2 // => true
  *
  * // Early termination - stops at first match
  * const infiniteOdds = Iterable.filter(Iterable.range(1), (x) => x % 2 === 1)
@@ -4255,7 +4124,7 @@ export const flatMapNullishOr: {
  *   Iterable.take(infiniteOdds, 1000),
  *   (x) => x % 2 === 0
  * )
- * console.log(hasEvenInInfiniteOdds) // false (quickly, doesn't check all 1000)
+ * hasEvenInInfiniteOdds // => false
  *
  * // Type guard usage
  * const mixed: Array<string | number> = [1, 2, "hello"]
@@ -4263,10 +4132,10 @@ export const flatMapNullishOr: {
  *   mixed,
  *   (x): x is string => typeof x === "string"
  * )
- * console.log(hasString) // true
+ * hasString // => true
  * ```
  *
- * @category elements
+ * @category predicates
  * @since 2.0.0
  */
 export const some: {
@@ -4275,21 +4144,21 @@ export const some: {
    *
    * **Example** (Checking whether some element matches)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Iterable } from "effect"
    *
    * const numbers = [1, 3, 5, 7, 8]
    * const hasEven = Iterable.some(numbers, (x) => x % 2 === 0)
-   * console.log(hasEven) // true (because of 8)
+   * hasEven // => true
    *
    * const allOdd = [1, 3, 5, 7]
    * const hasEvenInAllOdd = Iterable.some(allOdd, (x) => x % 2 === 0)
-   * console.log(hasEvenInAllOdd) // false
+   * hasEvenInAllOdd // => false
    *
    * // With index
    * const letters = ["a", "b", "c"]
    * const hasElementAtIndex2 = Iterable.some(letters, (_, i) => i === 2)
-   * console.log(hasElementAtIndex2) // true
+   * hasElementAtIndex2 // => true
    *
    * // Early termination - stops at first match
    * const infiniteOdds = Iterable.filter(Iterable.range(1), (x) => x % 2 === 1)
@@ -4297,7 +4166,7 @@ export const some: {
    *   Iterable.take(infiniteOdds, 1000),
    *   (x) => x % 2 === 0
    * )
-   * console.log(hasEvenInInfiniteOdds) // false (quickly, doesn't check all 1000)
+   * hasEvenInInfiniteOdds // => false
    *
    * // Type guard usage
    * const mixed: Array<string | number> = [1, 2, "hello"]
@@ -4305,10 +4174,10 @@ export const some: {
    *   mixed,
    *   (x): x is string => typeof x === "string"
    * )
-   * console.log(hasString) // true
+   * hasString // => true
    * ```
    *
-   * @category elements
+   * @category predicates
    * @since 2.0.0
    */
   <A>(predicate: (a: A, i: number) => boolean): (self: Iterable<A>) => boolean
@@ -4317,21 +4186,21 @@ export const some: {
    *
    * **Example** (Checking whether some element matches)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Iterable } from "effect"
    *
    * const numbers = [1, 3, 5, 7, 8]
    * const hasEven = Iterable.some(numbers, (x) => x % 2 === 0)
-   * console.log(hasEven) // true (because of 8)
+   * hasEven // => true
    *
    * const allOdd = [1, 3, 5, 7]
    * const hasEvenInAllOdd = Iterable.some(allOdd, (x) => x % 2 === 0)
-   * console.log(hasEvenInAllOdd) // false
+   * hasEvenInAllOdd // => false
    *
    * // With index
    * const letters = ["a", "b", "c"]
    * const hasElementAtIndex2 = Iterable.some(letters, (_, i) => i === 2)
-   * console.log(hasElementAtIndex2) // true
+   * hasElementAtIndex2 // => true
    *
    * // Early termination - stops at first match
    * const infiniteOdds = Iterable.filter(Iterable.range(1), (x) => x % 2 === 1)
@@ -4339,7 +4208,7 @@ export const some: {
    *   Iterable.take(infiniteOdds, 1000),
    *   (x) => x % 2 === 0
    * )
-   * console.log(hasEvenInInfiniteOdds) // false (quickly, doesn't check all 1000)
+   * hasEvenInInfiniteOdds // => false
    *
    * // Type guard usage
    * const mixed: Array<string | number> = [1, 2, "hello"]
@@ -4347,10 +4216,10 @@ export const some: {
    *   mixed,
    *   (x): x is string => typeof x === "string"
    * )
-   * console.log(hasString) // true
+   * hasString // => true
    * ```
    *
-   * @category elements
+   * @category predicates
    * @since 2.0.0
    */
   <A>(self: Iterable<A>, predicate: (a: A, i: number) => boolean): boolean
@@ -4379,21 +4248,21 @@ export const some: {
  *
  * **Example** (Unfolding state into values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Iterable, Option } from "effect"
  *
  * // Generate Fibonacci sequence
  * const fibonacci = Iterable.unfold([0, 1], ([a, b]) => Option.some([a, [b, a + b]]))
  * const first10Fib = Iterable.take(fibonacci, 10)
- * console.log(Array.from(first10Fib)) // [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
+ * Array.from(first10Fib) // => [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
  *
  * // Generate powers of 2 up to a limit
  * const powersOf2 = Iterable.unfold(1, (n) => n <= 1000 ? Option.some([n, n * 2]) : Option.none())
- * console.log(Array.from(powersOf2)) // [1, 2, 4, 8, 16, 32, 64, 128, 256, 512]
+ * Array.from(powersOf2) // => [1, 2, 4, 8, 16, 32, 64, 128, 256, 512]
  *
  * // Generate countdown
  * const countdown = Iterable.unfold(5, (n) => n > 0 ? Option.some([n, n - 1]) : Option.none())
- * console.log(Array.from(countdown)) // [5, 4, 3, 2, 1]
+ * Array.from(countdown) // => [5, 4, 3, 2, 1]
  *
  * // Generate collatz sequence
  * const collatz = Iterable.unfold(7, (n) => {
@@ -4401,7 +4270,7 @@ export const some: {
  *   const next = n % 2 === 0 ? n / 2 : n * 3 + 1
  *   return Option.some([n, next])
  * })
- * console.log(Array.from(collatz)) // [7, 22, 11, 34, 17, 52, 26, 13, 40, 20, 10, 5, 16, 8, 4, 2]
+ * Array.from(collatz) // => [7, 22, 11, 34, 17, 52, 26, 13, 40, 20, 10, 5, 16, 8, 4, 2]
  * ```
  *
  * @category constructors
@@ -4429,37 +4298,40 @@ export const unfold = <B, A>(b: B, f: (b: B) => Option<readonly [A, B]>): Iterab
  *
  * **Example** (Iterating with side effects)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Iterable } from "effect"
  *
- * // Print each element
+ * // Collect each visited element
  * const numbers = [1, 2, 3, 4, 5]
- * Iterable.forEach(numbers, (n) => console.log(n))
- * // Prints: 1, 2, 3, 4, 5
+ * const visited: Array<number> = []
+ * Iterable.forEach(numbers, (n) => visited.push(n))
+ * visited // => [1, 2, 3, 4, 5]
  *
  * // Use index in the callback
  * const letters = ["a", "b", "c"]
+ * const indexed: Array<string> = []
  * Iterable.forEach(letters, (letter, i) => {
- *   console.log(`${i}: ${letter}`)
+ *   indexed.push(`${i}: ${letter}`)
  * })
- * // Prints: "0: a", "1: b", "2: c"
+ * indexed // => ["0: a", "1: b", "2: c"]
  *
  * // Side effects with any iterable
  * const results: Array<number> = []
  * Iterable.forEach(Iterable.range(1, 5), (n) => {
  *   results.push(n * n)
  * })
- * console.log(results) // [1, 4, 9, 16, 25]
+ * results // => [1, 4, 9, 16, 25]
  *
  * // Process in chunks
  * const data = Iterable.chunksOf([1, 2, 3, 4, 5, 6], 2)
+ * const processed: Array<Array<number>> = []
  * Iterable.forEach(data, (chunk) => {
- *   console.log(`Processing chunk: ${Array.from(chunk)}`)
+ *   processed.push(Array.from(chunk))
  * })
- * // Prints: "Processing chunk: 1,2", "Processing chunk: 3,4", "Processing chunk: 5,6"
+ * processed // => [[1, 2], [3, 4], [5, 6]]
  * ```
  *
- * @category elements
+ * @category traversing
  * @since 2.0.0
  */
 export const forEach: {
@@ -4468,37 +4340,40 @@ export const forEach: {
    *
    * **Example** (Iterating with side effects)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Iterable } from "effect"
    *
-   * // Print each element
+   * // Collect each visited element
    * const numbers = [1, 2, 3, 4, 5]
-   * Iterable.forEach(numbers, (n) => console.log(n))
-   * // Prints: 1, 2, 3, 4, 5
+   * const visited: Array<number> = []
+   * Iterable.forEach(numbers, (n) => visited.push(n))
+   * visited // => [1, 2, 3, 4, 5]
    *
    * // Use index in the callback
    * const letters = ["a", "b", "c"]
+   * const indexed: Array<string> = []
    * Iterable.forEach(letters, (letter, i) => {
-   *   console.log(`${i}: ${letter}`)
+   *   indexed.push(`${i}: ${letter}`)
    * })
-   * // Prints: "0: a", "1: b", "2: c"
+   * indexed // => ["0: a", "1: b", "2: c"]
    *
    * // Side effects with any iterable
    * const results: Array<number> = []
    * Iterable.forEach(Iterable.range(1, 5), (n) => {
    *   results.push(n * n)
    * })
-   * console.log(results) // [1, 4, 9, 16, 25]
+   * results // => [1, 4, 9, 16, 25]
    *
    * // Process in chunks
    * const data = Iterable.chunksOf([1, 2, 3, 4, 5, 6], 2)
+   * const processed: Array<Array<number>> = []
    * Iterable.forEach(data, (chunk) => {
-   *   console.log(`Processing chunk: ${Array.from(chunk)}`)
+   *   processed.push(Array.from(chunk))
    * })
-   * // Prints: "Processing chunk: 1,2", "Processing chunk: 3,4", "Processing chunk: 5,6"
+   * processed // => [[1, 2], [3, 4], [5, 6]]
    * ```
    *
-   * @category elements
+   * @category traversing
    * @since 2.0.0
    */
   <A>(f: (a: A, i: number) => void): (self: Iterable<A>) => void
@@ -4507,37 +4382,40 @@ export const forEach: {
    *
    * **Example** (Iterating with side effects)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Iterable } from "effect"
    *
-   * // Print each element
+   * // Collect each visited element
    * const numbers = [1, 2, 3, 4, 5]
-   * Iterable.forEach(numbers, (n) => console.log(n))
-   * // Prints: 1, 2, 3, 4, 5
+   * const visited: Array<number> = []
+   * Iterable.forEach(numbers, (n) => visited.push(n))
+   * visited // => [1, 2, 3, 4, 5]
    *
    * // Use index in the callback
    * const letters = ["a", "b", "c"]
+   * const indexed: Array<string> = []
    * Iterable.forEach(letters, (letter, i) => {
-   *   console.log(`${i}: ${letter}`)
+   *   indexed.push(`${i}: ${letter}`)
    * })
-   * // Prints: "0: a", "1: b", "2: c"
+   * indexed // => ["0: a", "1: b", "2: c"]
    *
    * // Side effects with any iterable
    * const results: Array<number> = []
    * Iterable.forEach(Iterable.range(1, 5), (n) => {
    *   results.push(n * n)
    * })
-   * console.log(results) // [1, 4, 9, 16, 25]
+   * results // => [1, 4, 9, 16, 25]
    *
    * // Process in chunks
    * const data = Iterable.chunksOf([1, 2, 3, 4, 5, 6], 2)
+   * const processed: Array<Array<number>> = []
    * Iterable.forEach(data, (chunk) => {
-   *   console.log(`Processing chunk: ${Array.from(chunk)}`)
+   *   processed.push(Array.from(chunk))
    * })
-   * // Prints: "Processing chunk: 1,2", "Processing chunk: 3,4", "Processing chunk: 5,6"
+   * processed // => [[1, 2], [3, 4], [5, 6]]
    * ```
    *
-   * @category elements
+   * @category traversing
    * @since 2.0.0
    */
   <A>(self: Iterable<A>, f: (a: A, i: number) => void): void
@@ -4558,18 +4436,17 @@ export const forEach: {
  *
  * **Example** (Reducing an iterable)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Iterable } from "effect"
  *
  * // Sum all numbers
  * const numbers = [1, 2, 3, 4, 5]
  * const sum = Iterable.reduce(numbers, 0, (acc, n) => acc + n)
- * console.log(sum) // 15
+ * sum // => 15
  *
  * // Find maximum value
  * const values = [3, 1, 4, 1, 5, 9, 2]
- * const max = Iterable.reduce(values, -Infinity, Math.max)
- * console.log(max) // 9
+ * Iterable.reduce(values, -Infinity, (max, value) => Math.max(max, value)) // => 9
  *
  * // Build an object from key-value pairs
  * const pairs = [["a", 1], ["b", 2], ["c", 3]] as const
@@ -4581,7 +4458,7 @@ export const forEach: {
  *     return acc
  *   }
  * )
- * console.log(obj) // { a: 1, b: 2, c: 3 }
+ * obj // => { a: 1, b: 2, c: 3 }
  *
  * // Use index in the reducer
  * const letters = ["a", "b", "c"]
@@ -4593,7 +4470,7 @@ export const forEach: {
  *     return acc
  *   }
  * )
- * console.log(indexed) // ["0: a", "1: b", "2: c"]
+ * indexed // => ["0: a", "1: b", "2: c"]
  * ```
  *
  * @category folding
@@ -4610,18 +4487,17 @@ export const reduce: {
    *
    * **Example** (Reducing an iterable)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Iterable } from "effect"
    *
    * // Sum all numbers
    * const numbers = [1, 2, 3, 4, 5]
    * const sum = Iterable.reduce(numbers, 0, (acc, n) => acc + n)
-   * console.log(sum) // 15
+   * sum // => 15
    *
    * // Find maximum value
    * const values = [3, 1, 4, 1, 5, 9, 2]
-   * const max = Iterable.reduce(values, -Infinity, Math.max)
-   * console.log(max) // 9
+   * Iterable.reduce(values, -Infinity, (max, value) => Math.max(max, value)) // => 9
    *
    * // Build an object from key-value pairs
    * const pairs = [["a", 1], ["b", 2], ["c", 3]] as const
@@ -4633,7 +4509,7 @@ export const reduce: {
    *     return acc
    *   }
    * )
-   * console.log(obj) // { a: 1, b: 2, c: 3 }
+   * obj // => { a: 1, b: 2, c: 3 }
    *
    * // Use index in the reducer
    * const letters = ["a", "b", "c"]
@@ -4645,7 +4521,7 @@ export const reduce: {
    *     return acc
    *   }
    * )
-   * console.log(indexed) // ["0: a", "1: b", "2: c"]
+   * indexed // => ["0: a", "1: b", "2: c"]
    * ```
    *
    * @category folding
@@ -4662,18 +4538,17 @@ export const reduce: {
    *
    * **Example** (Reducing an iterable)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Iterable } from "effect"
    *
    * // Sum all numbers
    * const numbers = [1, 2, 3, 4, 5]
    * const sum = Iterable.reduce(numbers, 0, (acc, n) => acc + n)
-   * console.log(sum) // 15
+   * sum // => 15
    *
    * // Find maximum value
    * const values = [3, 1, 4, 1, 5, 9, 2]
-   * const max = Iterable.reduce(values, -Infinity, Math.max)
-   * console.log(max) // 9
+   * Iterable.reduce(values, -Infinity, (max, value) => Math.max(max, value)) // => 9
    *
    * // Build an object from key-value pairs
    * const pairs = [["a", 1], ["b", 2], ["c", 3]] as const
@@ -4685,7 +4560,7 @@ export const reduce: {
    *     return acc
    *   }
    * )
-   * console.log(obj) // { a: 1, b: 2, c: 3 }
+   * obj // => { a: 1, b: 2, c: 3 }
    *
    * // Use index in the reducer
    * const letters = ["a", "b", "c"]
@@ -4697,7 +4572,7 @@ export const reduce: {
    *     return acc
    *   }
    * )
-   * console.log(indexed) // ["0: a", "1: b", "2: c"]
+   * indexed // => ["0: a", "1: b", "2: c"]
    * ```
    *
    * @category folding
@@ -4721,20 +4596,20 @@ export const reduce: {
  *
  * **Example** (Deduplicating adjacent elements with custom equivalence)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Iterable } from "effect"
  *
  * // Remove adjacent duplicates with custom equality
  * const numbers = [1, 1, 2, 2, 3, 1, 1]
  * const dedupedNumbers = Iterable.dedupeAdjacentWith(numbers, (a, b) => a === b)
- * console.log(Array.from(dedupedNumbers)) // [1, 2, 3, 1]
+ * Array.from(dedupedNumbers) // => [1, 2, 3, 1]
  *
  * // Case-insensitive deduplication
  * const words = ["Hello", "HELLO", "world", "World", "test"]
  * const caseInsensitive = (a: string, b: string) =>
  *   a.toLowerCase() === b.toLowerCase()
  * const dedupedWords = Iterable.dedupeAdjacentWith(words, caseInsensitive)
- * console.log(Array.from(dedupedWords)) // ["Hello", "world", "test"]
+ * Array.from(dedupedWords) // => ["Hello", "world", "test"]
  *
  * // Deduplication by object property
  * const users = [
@@ -4746,13 +4621,13 @@ export const reduce: {
  * ]
  * const byId = (a: typeof users[0], b: typeof users[0]) => a.id === b.id
  * const dedupedUsers = Iterable.dedupeAdjacentWith(users, byId)
- * console.log(Array.from(dedupedUsers).map((u) => u.id)) // [1, 2, 3]
+ * Array.from(dedupedUsers, (user) => user.id) // => [1, 2, 3]
  *
  * // Approximate numeric equality
  * const floats = [1.0, 1.01, 1.02, 2.0, 2.01, 3.0]
  * const approxEqual = (a: number, b: number) => Math.abs(a - b) < 0.1
  * const dedupedFloats = Iterable.dedupeAdjacentWith(floats, approxEqual)
- * console.log(Array.from(dedupedFloats)) // [1.0, 2.0, 3.0]
+ * Array.from(dedupedFloats) // => [1, 2, 3]
  * ```
  *
  * @category filtering
@@ -4764,20 +4639,20 @@ export const dedupeAdjacentWith: {
    *
    * **Example** (Deduplicating adjacent elements with custom equivalence)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Iterable } from "effect"
    *
    * // Remove adjacent duplicates with custom equality
    * const numbers = [1, 1, 2, 2, 3, 1, 1]
    * const dedupedNumbers = Iterable.dedupeAdjacentWith(numbers, (a, b) => a === b)
-   * console.log(Array.from(dedupedNumbers)) // [1, 2, 3, 1]
+   * Array.from(dedupedNumbers) // => [1, 2, 3, 1]
    *
    * // Case-insensitive deduplication
    * const words = ["Hello", "HELLO", "world", "World", "test"]
    * const caseInsensitive = (a: string, b: string) =>
    *   a.toLowerCase() === b.toLowerCase()
    * const dedupedWords = Iterable.dedupeAdjacentWith(words, caseInsensitive)
-   * console.log(Array.from(dedupedWords)) // ["Hello", "world", "test"]
+   * Array.from(dedupedWords) // => ["Hello", "world", "test"]
    *
    * // Deduplication by object property
    * const users = [
@@ -4789,13 +4664,13 @@ export const dedupeAdjacentWith: {
    * ]
    * const byId = (a: typeof users[0], b: typeof users[0]) => a.id === b.id
    * const dedupedUsers = Iterable.dedupeAdjacentWith(users, byId)
-   * console.log(Array.from(dedupedUsers).map((u) => u.id)) // [1, 2, 3]
+   * Array.from(dedupedUsers, (user) => user.id) // => [1, 2, 3]
    *
    * // Approximate numeric equality
    * const floats = [1.0, 1.01, 1.02, 2.0, 2.01, 3.0]
    * const approxEqual = (a: number, b: number) => Math.abs(a - b) < 0.1
    * const dedupedFloats = Iterable.dedupeAdjacentWith(floats, approxEqual)
-   * console.log(Array.from(dedupedFloats)) // [1.0, 2.0, 3.0]
+   * Array.from(dedupedFloats) // => [1, 2, 3]
    * ```
    *
    * @category filtering
@@ -4807,20 +4682,20 @@ export const dedupeAdjacentWith: {
    *
    * **Example** (Deduplicating adjacent elements with custom equivalence)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Iterable } from "effect"
    *
    * // Remove adjacent duplicates with custom equality
    * const numbers = [1, 1, 2, 2, 3, 1, 1]
    * const dedupedNumbers = Iterable.dedupeAdjacentWith(numbers, (a, b) => a === b)
-   * console.log(Array.from(dedupedNumbers)) // [1, 2, 3, 1]
+   * Array.from(dedupedNumbers) // => [1, 2, 3, 1]
    *
    * // Case-insensitive deduplication
    * const words = ["Hello", "HELLO", "world", "World", "test"]
    * const caseInsensitive = (a: string, b: string) =>
    *   a.toLowerCase() === b.toLowerCase()
    * const dedupedWords = Iterable.dedupeAdjacentWith(words, caseInsensitive)
-   * console.log(Array.from(dedupedWords)) // ["Hello", "world", "test"]
+   * Array.from(dedupedWords) // => ["Hello", "world", "test"]
    *
    * // Deduplication by object property
    * const users = [
@@ -4832,13 +4707,13 @@ export const dedupeAdjacentWith: {
    * ]
    * const byId = (a: typeof users[0], b: typeof users[0]) => a.id === b.id
    * const dedupedUsers = Iterable.dedupeAdjacentWith(users, byId)
-   * console.log(Array.from(dedupedUsers).map((u) => u.id)) // [1, 2, 3]
+   * Array.from(dedupedUsers, (user) => user.id) // => [1, 2, 3]
    *
    * // Approximate numeric equality
    * const floats = [1.0, 1.01, 1.02, 2.0, 2.01, 3.0]
    * const approxEqual = (a: number, b: number) => Math.abs(a - b) < 0.1
    * const dedupedFloats = Iterable.dedupeAdjacentWith(floats, approxEqual)
-   * console.log(Array.from(dedupedFloats)) // [1.0, 2.0, 3.0]
+   * Array.from(dedupedFloats) // => [1, 2, 3]
    * ```
    *
    * @category filtering
@@ -4876,18 +4751,18 @@ export const dedupeAdjacentWith: {
  *
  * **Example** (Deduplicating adjacent elements)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Iterable } from "effect"
  *
  * // Remove adjacent duplicate numbers
  * const numbers = [1, 1, 2, 2, 2, 3, 1, 1]
  * const deduped = Iterable.dedupeAdjacent(numbers)
- * console.log(Array.from(deduped)) // [1, 2, 3, 1]
+ * Array.from(deduped) // => [1, 2, 3, 1]
  *
  * // Remove adjacent duplicate characters
  * const letters = "aabbccaa"
  * const dedupedLetters = Iterable.dedupeAdjacent(letters)
- * console.log(Array.from(dedupedLetters)) // ["a", "b", "c", "a"]
+ * Array.from(dedupedLetters) // => ["a", "b", "c", "a"]
  *
  * // Works with objects using deep equality
  * const objects = [
@@ -4898,12 +4773,12 @@ export const dedupeAdjacentWith: {
  *   { type: "A" }
  * ]
  * const dedupedObjects = Iterable.dedupeAdjacent(objects)
- * console.log(Array.from(dedupedObjects).map((o) => o.type)) // ["A", "B", "A"]
+ * Array.from(dedupedObjects, (object) => object.type) // => ["A", "B", "A"]
  *
  * // Clean up streaming data
  * const sensorData = [100, 100, 100, 101, 101, 102, 102, 102, 100]
  * const cleanedData = Iterable.dedupeAdjacent(sensorData)
- * console.log(Array.from(cleanedData)) // [100, 101, 102, 100]
+ * Array.from(cleanedData) // => [100, 101, 102, 100]
  * ```
  *
  * @category filtering
@@ -4916,14 +4791,14 @@ export const dedupeAdjacent: <A>(self: Iterable<A>) => Iterable<A> = dedupeAdjac
  *
  * **Example** (Combining cartesian products)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Iterable } from "effect"
  *
  * // Create coordinate pairs
  * const xs = [1, 2]
  * const ys = ["a", "b", "c"]
  * const coordinates = Iterable.cartesianWith(xs, ys, (x, y) => `(${x},${y})`)
- * console.log(Array.from(coordinates)) // ["(1,a)", "(1,b)", "(1,c)", "(2,a)", "(2,b)", "(2,c)"]
+ * Array.from(coordinates) // => ["(1,a)", "(1,b)", "(1,c)", "(2,a)", "(2,b)", "(2,c)"]
  *
  * // Generate all combinations of options
  * const sizes = ["S", "M", "L"]
@@ -4933,18 +4808,13 @@ export const dedupeAdjacent: <A>(self: Iterable<A>) => Iterable<A> = dedupeAdjac
  *   colors,
  *   (size, color) => ({ size, color })
  * )
- * console.log(Array.from(products))
- * // [
- * //   { size: "S", color: "red" }, { size: "S", color: "blue" },
- * //   { size: "M", color: "red" }, { size: "M", color: "blue" },
- * //   { size: "L", color: "red" }, { size: "L", color: "blue" }
- * // ]
+ * Array.from(products, ({ color, size }) => `${size}:${color}`) // => ["S:red", "S:blue", "M:red", "M:blue", "L:red", "L:blue"]
  *
  * // Mathematical operations on all pairs
  * const a = [1, 2, 3]
  * const b = [10, 20]
  * const mathProducts = Iterable.cartesianWith(a, b, (x, y) => x * y)
- * console.log(Array.from(mathProducts)) // [10, 20, 20, 40, 30, 60]
+ * Array.from(mathProducts) // => [10, 20, 20, 40, 30, 60]
  *
  * // Create test data combinations
  * const userTypes = ["admin", "user"]
@@ -4954,11 +4824,10 @@ export const dedupeAdjacent: <A>(self: Iterable<A>) => Iterable<A> = dedupeAdjac
  *   features,
  *   (user, feature) => `${user}_can_${feature}`
  * )
- * console.log(Array.from(testCases))
- * // ["admin_can_read", "admin_can_write", "admin_can_delete", "user_can_read", "user_can_write", "user_can_delete"]
+ * Array.from(testCases) // => ["admin_can_read", "admin_can_write", "admin_can_delete", "user_can_read", "user_can_write", "user_can_delete"]
  * ```
  *
- * @category elements
+ * @category combining
  * @since 2.0.0
  */
 export const cartesianWith: {
@@ -4967,14 +4836,14 @@ export const cartesianWith: {
    *
    * **Example** (Combining cartesian products)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Iterable } from "effect"
    *
    * // Create coordinate pairs
    * const xs = [1, 2]
    * const ys = ["a", "b", "c"]
    * const coordinates = Iterable.cartesianWith(xs, ys, (x, y) => `(${x},${y})`)
-   * console.log(Array.from(coordinates)) // ["(1,a)", "(1,b)", "(1,c)", "(2,a)", "(2,b)", "(2,c)"]
+   * Array.from(coordinates) // => ["(1,a)", "(1,b)", "(1,c)", "(2,a)", "(2,b)", "(2,c)"]
    *
    * // Generate all combinations of options
    * const sizes = ["S", "M", "L"]
@@ -4984,18 +4853,13 @@ export const cartesianWith: {
    *   colors,
    *   (size, color) => ({ size, color })
    * )
-   * console.log(Array.from(products))
-   * // [
-   * //   { size: "S", color: "red" }, { size: "S", color: "blue" },
-   * //   { size: "M", color: "red" }, { size: "M", color: "blue" },
-   * //   { size: "L", color: "red" }, { size: "L", color: "blue" }
-   * // ]
+   * Array.from(products, ({ color, size }) => `${size}:${color}`) // => ["S:red", "S:blue", "M:red", "M:blue", "L:red", "L:blue"]
    *
    * // Mathematical operations on all pairs
    * const a = [1, 2, 3]
    * const b = [10, 20]
    * const mathProducts = Iterable.cartesianWith(a, b, (x, y) => x * y)
-   * console.log(Array.from(mathProducts)) // [10, 20, 20, 40, 30, 60]
+   * Array.from(mathProducts) // => [10, 20, 20, 40, 30, 60]
    *
    * // Create test data combinations
    * const userTypes = ["admin", "user"]
@@ -5005,11 +4869,10 @@ export const cartesianWith: {
    *   features,
    *   (user, feature) => `${user}_can_${feature}`
    * )
-   * console.log(Array.from(testCases))
-   * // ["admin_can_read", "admin_can_write", "admin_can_delete", "user_can_read", "user_can_write", "user_can_delete"]
+   * Array.from(testCases) // => ["admin_can_read", "admin_can_write", "admin_can_delete", "user_can_read", "user_can_write", "user_can_delete"]
    * ```
    *
-   * @category elements
+   * @category combining
    * @since 2.0.0
    */
   <A, B, C>(that: Iterable<B>, f: (a: A, b: B) => C): (self: Iterable<A>) => Iterable<C>
@@ -5018,14 +4881,14 @@ export const cartesianWith: {
    *
    * **Example** (Combining cartesian products)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Iterable } from "effect"
    *
    * // Create coordinate pairs
    * const xs = [1, 2]
    * const ys = ["a", "b", "c"]
    * const coordinates = Iterable.cartesianWith(xs, ys, (x, y) => `(${x},${y})`)
-   * console.log(Array.from(coordinates)) // ["(1,a)", "(1,b)", "(1,c)", "(2,a)", "(2,b)", "(2,c)"]
+   * Array.from(coordinates) // => ["(1,a)", "(1,b)", "(1,c)", "(2,a)", "(2,b)", "(2,c)"]
    *
    * // Generate all combinations of options
    * const sizes = ["S", "M", "L"]
@@ -5035,18 +4898,13 @@ export const cartesianWith: {
    *   colors,
    *   (size, color) => ({ size, color })
    * )
-   * console.log(Array.from(products))
-   * // [
-   * //   { size: "S", color: "red" }, { size: "S", color: "blue" },
-   * //   { size: "M", color: "red" }, { size: "M", color: "blue" },
-   * //   { size: "L", color: "red" }, { size: "L", color: "blue" }
-   * // ]
+   * Array.from(products, ({ color, size }) => `${size}:${color}`) // => ["S:red", "S:blue", "M:red", "M:blue", "L:red", "L:blue"]
    *
    * // Mathematical operations on all pairs
    * const a = [1, 2, 3]
    * const b = [10, 20]
    * const mathProducts = Iterable.cartesianWith(a, b, (x, y) => x * y)
-   * console.log(Array.from(mathProducts)) // [10, 20, 20, 40, 30, 60]
+   * Array.from(mathProducts) // => [10, 20, 20, 40, 30, 60]
    *
    * // Create test data combinations
    * const userTypes = ["admin", "user"]
@@ -5056,18 +4914,47 @@ export const cartesianWith: {
    *   features,
    *   (user, feature) => `${user}_can_${feature}`
    * )
-   * console.log(Array.from(testCases))
-   * // ["admin_can_read", "admin_can_write", "admin_can_delete", "user_can_read", "user_can_write", "user_can_delete"]
+   * Array.from(testCases) // => ["admin_can_read", "admin_can_write", "admin_can_delete", "user_can_read", "user_can_write", "user_can_delete"]
    * ```
    *
-   * @category elements
+   * @category combining
    * @since 2.0.0
    */
   <A, B, C>(self: Iterable<A>, that: Iterable<B>, f: (a: A, b: B) => C): Iterable<C>
 } = dual(
   3,
-  <A, B, C>(self: Iterable<A>, that: Iterable<B>, f: (a: A, b: B) => C): Iterable<C> =>
-    flatMap(self, (a) => map(that, (b) => f(a, b)))
+  <A, B, C>(self: Iterable<A>, that: Iterable<B>, f: (a: A, b: B) => C): Iterable<C> => ({
+    [Symbol.iterator]() {
+      const cache: Array<B> = []
+      let iterator: Iterator<B> | undefined
+      let done = false
+      const replay: Iterable<B> = {
+        [Symbol.iterator]() {
+          let index = 0
+          return {
+            next(): IteratorResult<B> {
+              if (index < cache.length) {
+                return { done: false, value: cache[index++] }
+              }
+              if (done) {
+                return { done: true, value: undefined }
+              }
+              iterator ??= that[Symbol.iterator]()
+              const result = iterator.next()
+              if (result.done) {
+                done = true
+                return { done: true, value: undefined }
+              }
+              cache.push(result.value)
+              index++
+              return result
+            }
+          }
+        }
+      }
+      return flatMap(self, (a) => map(replay, (b) => f(a, b)))[Symbol.iterator]()
+    }
+  })
 )
 
 /**
@@ -5075,40 +4962,34 @@ export const cartesianWith: {
  *
  * **Example** (Generating cartesian pairs)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Iterable } from "effect"
  *
  * // All pairs of numbers and letters
  * const numbers = [1, 2, 3]
  * const letters = ["a", "b"]
  * const pairs = Iterable.cartesian(numbers, letters)
- * console.log(Array.from(pairs))
- * // [[1, "a"], [1, "b"], [2, "a"], [2, "b"], [3, "a"], [3, "b"]]
+ * Array.from(pairs) // => [[1, "a"], [1, "b"], [2, "a"], [2, "b"], [3, "a"], [3, "b"]]
  *
  * // Generate coordinate grid
  * const x = [0, 1, 2]
  * const y = [0, 1]
  * const grid = Iterable.cartesian(x, y)
- * console.log(Array.from(grid))
- * // [[0, 0], [0, 1], [1, 0], [1, 1], [2, 0], [2, 1]]
+ * Array.from(grid) // => [[0, 0], [0, 1], [1, 0], [1, 1], [2, 0], [2, 1]]
  *
  * // All combinations for testing
  * const browsers = ["chrome", "firefox"]
  * const devices = ["desktop", "mobile", "tablet"]
  * const testMatrix = Iterable.cartesian(browsers, devices)
- * console.log(Array.from(testMatrix))
- * // [
- * //   ["chrome", "desktop"], ["chrome", "mobile"], ["chrome", "tablet"],
- * //   ["firefox", "desktop"], ["firefox", "mobile"], ["firefox", "tablet"]
- * // ]
+ * Array.from(testMatrix, ([browser, device]) => `${browser}:${device}`) // => ["chrome:desktop", "chrome:mobile", "chrome:tablet", "firefox:desktop", "firefox:mobile", "firefox:tablet"]
  *
  * // Empty iterable results in empty cartesian product
  * const empty = Iterable.empty<number>()
  * const withEmpty = Iterable.cartesian([1, 2], empty)
- * console.log(Array.from(withEmpty)) // []
+ * Array.from(withEmpty) // => []
  * ```
  *
- * @category elements
+ * @category combining
  * @since 2.0.0
  */
 export const cartesian: {
@@ -5117,40 +4998,34 @@ export const cartesian: {
    *
    * **Example** (Generating cartesian pairs)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Iterable } from "effect"
    *
    * // All pairs of numbers and letters
    * const numbers = [1, 2, 3]
    * const letters = ["a", "b"]
    * const pairs = Iterable.cartesian(numbers, letters)
-   * console.log(Array.from(pairs))
-   * // [[1, "a"], [1, "b"], [2, "a"], [2, "b"], [3, "a"], [3, "b"]]
+   * Array.from(pairs) // => [[1, "a"], [1, "b"], [2, "a"], [2, "b"], [3, "a"], [3, "b"]]
    *
    * // Generate coordinate grid
    * const x = [0, 1, 2]
    * const y = [0, 1]
    * const grid = Iterable.cartesian(x, y)
-   * console.log(Array.from(grid))
-   * // [[0, 0], [0, 1], [1, 0], [1, 1], [2, 0], [2, 1]]
+   * Array.from(grid) // => [[0, 0], [0, 1], [1, 0], [1, 1], [2, 0], [2, 1]]
    *
    * // All combinations for testing
    * const browsers = ["chrome", "firefox"]
    * const devices = ["desktop", "mobile", "tablet"]
    * const testMatrix = Iterable.cartesian(browsers, devices)
-   * console.log(Array.from(testMatrix))
-   * // [
-   * //   ["chrome", "desktop"], ["chrome", "mobile"], ["chrome", "tablet"],
-   * //   ["firefox", "desktop"], ["firefox", "mobile"], ["firefox", "tablet"]
-   * // ]
+   * Array.from(testMatrix, ([browser, device]) => `${browser}:${device}`) // => ["chrome:desktop", "chrome:mobile", "chrome:tablet", "firefox:desktop", "firefox:mobile", "firefox:tablet"]
    *
    * // Empty iterable results in empty cartesian product
    * const empty = Iterable.empty<number>()
    * const withEmpty = Iterable.cartesian([1, 2], empty)
-   * console.log(Array.from(withEmpty)) // []
+   * Array.from(withEmpty) // => []
    * ```
    *
-   * @category elements
+   * @category combining
    * @since 2.0.0
    */
   <B>(that: Iterable<B>): <A>(self: Iterable<A>) => Iterable<[A, B]>
@@ -5159,40 +5034,34 @@ export const cartesian: {
    *
    * **Example** (Generating cartesian pairs)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Iterable } from "effect"
    *
    * // All pairs of numbers and letters
    * const numbers = [1, 2, 3]
    * const letters = ["a", "b"]
    * const pairs = Iterable.cartesian(numbers, letters)
-   * console.log(Array.from(pairs))
-   * // [[1, "a"], [1, "b"], [2, "a"], [2, "b"], [3, "a"], [3, "b"]]
+   * Array.from(pairs) // => [[1, "a"], [1, "b"], [2, "a"], [2, "b"], [3, "a"], [3, "b"]]
    *
    * // Generate coordinate grid
    * const x = [0, 1, 2]
    * const y = [0, 1]
    * const grid = Iterable.cartesian(x, y)
-   * console.log(Array.from(grid))
-   * // [[0, 0], [0, 1], [1, 0], [1, 1], [2, 0], [2, 1]]
+   * Array.from(grid) // => [[0, 0], [0, 1], [1, 0], [1, 1], [2, 0], [2, 1]]
    *
    * // All combinations for testing
    * const browsers = ["chrome", "firefox"]
    * const devices = ["desktop", "mobile", "tablet"]
    * const testMatrix = Iterable.cartesian(browsers, devices)
-   * console.log(Array.from(testMatrix))
-   * // [
-   * //   ["chrome", "desktop"], ["chrome", "mobile"], ["chrome", "tablet"],
-   * //   ["firefox", "desktop"], ["firefox", "mobile"], ["firefox", "tablet"]
-   * // ]
+   * Array.from(testMatrix, ([browser, device]) => `${browser}:${device}`) // => ["chrome:desktop", "chrome:mobile", "chrome:tablet", "firefox:desktop", "firefox:mobile", "firefox:tablet"]
    *
    * // Empty iterable results in empty cartesian product
    * const empty = Iterable.empty<number>()
    * const withEmpty = Iterable.cartesian([1, 2], empty)
-   * console.log(Array.from(withEmpty)) // []
+   * Array.from(withEmpty) // => []
    * ```
    *
-   * @category elements
+   * @category combining
    * @since 2.0.0
    */
   <A, B>(self: Iterable<A>, that: Iterable<B>): Iterable<[A, B]>
@@ -5206,11 +5075,10 @@ export const cartesian: {
  *
  * **Example** (Counting matching elements)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Iterable } from "effect"
  *
- * const result = Iterable.countBy([1, 2, 3, 4, 5], (n) => n % 2 === 0)
- * console.log(result) // 2
+ * Iterable.countBy([1, 2, 3, 4, 5], (n) => n % 2 === 0) // => 2
  * ```
  *
  * @category folding
@@ -5222,11 +5090,10 @@ export const countBy: {
    *
    * **Example** (Counting matching elements)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Iterable } from "effect"
    *
-   * const result = Iterable.countBy([1, 2, 3, 4, 5], (n) => n % 2 === 0)
-   * console.log(result) // 2
+   * Iterable.countBy([1, 2, 3, 4, 5], (n) => n % 2 === 0) // => 2
    * ```
    *
    * @category folding
@@ -5238,11 +5105,10 @@ export const countBy: {
    *
    * **Example** (Counting matching elements)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Iterable } from "effect"
    *
-   * const result = Iterable.countBy([1, 2, 3, 4, 5], (n) => n % 2 === 0)
-   * console.log(result) // 2
+   * Iterable.countBy([1, 2, 3, 4, 5], (n) => n % 2 === 0) // => 2
    * ```
    *
    * @category folding