effect 4.0.0-beta.102 → 4.0.0-beta.104

package/src/Tuple.ts

@@ -32,11 +32,10 @@ import type { Apply, Lambda } from "./Struct.ts"
  *
  * **Example** (Creating a tuple)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Tuple } from "effect"
  *
- * const point = Tuple.make(10, 20, "red")
- * console.log(point) // [10, 20, "red"]
+ * Tuple.make(10, 20, "red") // => [10, 20, "red"]
  * ```
  *
  * @see {@link get} – access a single element by index
@@ -44,7 +43,8 @@ import type { Apply, Lambda } from "./Struct.ts"
  * @category constructors
  * @since 2.0.0
  */
-export const make = <Elements extends ReadonlyArray<unknown>>(...elements: Elements): Elements => elements
+export const make = <const Elements extends ReadonlyArray<unknown>>(...elements: [...Elements]): [...Elements] =>
+  elements
 
 type Indices<T extends ReadonlyArray<unknown>> = Exclude<Partial<T>["length"], T["length"]>
 
@@ -61,11 +61,10 @@ type Indices<T extends ReadonlyArray<unknown>> = Exclude<Partial<T>["length"], T
  *
  * **Example** (Extracting an element by index)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { pipe, Tuple } from "effect"
  *
- * const last = pipe(Tuple.make(1, true, "hello"), Tuple.get(2))
- * console.log(last) // "hello"
+ * pipe(Tuple.make(1, true, "hello"), Tuple.get(2)) // => "hello"
  * ```
  *
  * @see {@link make} – create a tuple
@@ -87,11 +86,10 @@ export const get: {
    *
    * **Example** (Extracting an element by index)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { pipe, Tuple } from "effect"
    *
-   * const last = pipe(Tuple.make(1, true, "hello"), Tuple.get(2))
-   * console.log(last) // "hello"
+   * pipe(Tuple.make(1, true, "hello"), Tuple.get(2)) // => "hello"
    * ```
    *
    * @see {@link make} – create a tuple
@@ -113,11 +111,10 @@ export const get: {
    *
    * **Example** (Extracting an element by index)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { pipe, Tuple } from "effect"
    *
-   * const last = pipe(Tuple.make(1, true, "hello"), Tuple.get(2))
-   * console.log(last) // "hello"
+   * pipe(Tuple.make(1, true, "hello"), Tuple.get(2)) // => "hello"
    * ```
    *
    * @see {@link make} – create a tuple
@@ -142,7 +139,9 @@ type _BuildTuple<
     [...I, unknown]
   >
 
-type PickTuple<T extends ReadonlyArray<unknown>, K> = _BuildTuple<T, K>
+type PickTuple<T extends ReadonlyArray<unknown>, I extends ReadonlyArray<Indices<T>>> = {
+  -readonly [K in keyof I]: T[I[K] & keyof T]
+}
 
 /**
  * Creates a new tuple containing only the elements at the specified indices.
@@ -157,11 +156,10 @@ type PickTuple<T extends ReadonlyArray<unknown>, K> = _BuildTuple<T, K>
  *
  * **Example** (Selecting elements by index)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Tuple } from "effect"
  *
- * const result = Tuple.pick(["a", "b", "c", "d"], [0, 2, 3])
- * console.log(result) // ["a", "c", "d"]
+ * Tuple.pick(["a", "b", "c", "d"], [0, 2, 3]) // => ["a", "c", "d"]
  * ```
  *
  * @see {@link omit} – the inverse (exclude indices instead)
@@ -183,11 +181,10 @@ export const pick: {
    *
    * **Example** (Selecting elements by index)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Tuple } from "effect"
    *
-   * const result = Tuple.pick(["a", "b", "c", "d"], [0, 2, 3])
-   * console.log(result) // ["a", "c", "d"]
+   * Tuple.pick(["a", "b", "c", "d"], [0, 2, 3]) // => ["a", "c", "d"]
    * ```
    *
    * @see {@link omit} – the inverse (exclude indices instead)
@@ -195,7 +192,7 @@ export const pick: {
    * @category filtering
    * @since 4.0.0
    */
-  <const T extends ReadonlyArray<unknown>, const I extends ReadonlyArray<Indices<T>>>(indices: I): (self: T) => PickTuple<T, I[number]>
+  <const T extends ReadonlyArray<unknown>, const I extends ReadonlyArray<Indices<T>>>(indices: I): (self: T) => PickTuple<T, I>
   /**
    * Creates a new tuple containing only the elements at the specified indices.
    *
@@ -209,11 +206,10 @@ export const pick: {
    *
    * **Example** (Selecting elements by index)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Tuple } from "effect"
    *
-   * const result = Tuple.pick(["a", "b", "c", "d"], [0, 2, 3])
-   * console.log(result) // ["a", "c", "d"]
+   * Tuple.pick(["a", "b", "c", "d"], [0, 2, 3]) // => ["a", "c", "d"]
    * ```
    *
    * @see {@link omit} – the inverse (exclude indices instead)
@@ -221,7 +217,7 @@ export const pick: {
    * @category filtering
    * @since 4.0.0
    */
-  <const T extends ReadonlyArray<unknown>, const I extends ReadonlyArray<Indices<T>>>(self: T, indices: I): PickTuple<T, I[number]>
+  <const T extends ReadonlyArray<unknown>, const I extends ReadonlyArray<Indices<T>>>(self: T, indices: I): PickTuple<T, I>
 } = dual(
   2,
   <const T extends ReadonlyArray<unknown>>(
@@ -247,11 +243,10 @@ type OmitTuple<T extends ReadonlyArray<unknown>, K> = _BuildTuple<T, Exclude<Ind
  *
  * **Example** (Removing elements by index)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Tuple } from "effect"
  *
- * const result = Tuple.omit(["a", "b", "c", "d"], [1, 3])
- * console.log(result) // ["a", "c"]
+ * Tuple.omit(["a", "b", "c", "d"], [1, 3]) // => ["a", "c"]
  * ```
  *
  * @see {@link pick} – the inverse (keep only specified indices)
@@ -272,11 +267,10 @@ export const omit: {
    *
    * **Example** (Removing elements by index)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Tuple } from "effect"
    *
-   * const result = Tuple.omit(["a", "b", "c", "d"], [1, 3])
-   * console.log(result) // ["a", "c"]
+   * Tuple.omit(["a", "b", "c", "d"], [1, 3]) // => ["a", "c"]
    * ```
    *
    * @see {@link pick} – the inverse (keep only specified indices)
@@ -297,11 +291,10 @@ export const omit: {
    *
    * **Example** (Removing elements by index)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Tuple } from "effect"
    *
-   * const result = Tuple.omit(["a", "b", "c", "d"], [1, 3])
-   * console.log(result) // ["a", "c"]
+   * Tuple.omit(["a", "b", "c", "d"], [1, 3]) // => ["a", "c"]
    * ```
    *
    * @see {@link pick} – the inverse (keep only specified indices)
@@ -334,11 +327,10 @@ export const omit: {
  *
  * **Example** (Appending an element)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { pipe, Tuple } from "effect"
  *
- * const result = pipe(Tuple.make(1, 2), Tuple.appendElement("end"))
- * console.log(result) // [1, 2, "end"]
+ * pipe(Tuple.make(1, 2), Tuple.appendElement("end")) // => [1, 2, "end"]
  * ```
  *
  * @see {@link appendElements} – append multiple elements (another tuple)
@@ -360,11 +352,10 @@ export const appendElement: {
    *
    * **Example** (Appending an element)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { pipe, Tuple } from "effect"
    *
-   * const result = pipe(Tuple.make(1, 2), Tuple.appendElement("end"))
-   * console.log(result) // [1, 2, "end"]
+   * pipe(Tuple.make(1, 2), Tuple.appendElement("end")) // => [1, 2, "end"]
    * ```
    *
    * @see {@link appendElements} – append multiple elements (another tuple)
@@ -386,11 +377,10 @@ export const appendElement: {
    *
    * **Example** (Appending an element)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { pipe, Tuple } from "effect"
    *
-   * const result = pipe(Tuple.make(1, 2), Tuple.appendElement("end"))
-   * console.log(result) // [1, 2, "end"]
+   * pipe(Tuple.make(1, 2), Tuple.appendElement("end")) // => [1, 2, "end"]
    * ```
    *
    * @see {@link appendElements} – append multiple elements (another tuple)
@@ -414,11 +404,10 @@ export const appendElement: {
  *
  * **Example** (Concatenating tuples)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { pipe, Tuple } from "effect"
  *
- * const result = pipe(Tuple.make(1, 2), Tuple.appendElements(["a", "b"] as const))
- * console.log(result) // [1, 2, "a", "b"]
+ * pipe(Tuple.make(1, 2), Tuple.appendElements(["a", "b"] as const)) // => [1, 2, "a", "b"]
  * ```
  *
  * @see {@link appendElement} – append a single element
@@ -440,11 +429,10 @@ export const appendElements: {
    *
    * **Example** (Concatenating tuples)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { pipe, Tuple } from "effect"
    *
-   * const result = pipe(Tuple.make(1, 2), Tuple.appendElements(["a", "b"] as const))
-   * console.log(result) // [1, 2, "a", "b"]
+   * pipe(Tuple.make(1, 2), Tuple.appendElements(["a", "b"] as const)) // => [1, 2, "a", "b"]
    * ```
    *
    * @see {@link appendElement} – append a single element
@@ -466,11 +454,10 @@ export const appendElements: {
    *
    * **Example** (Concatenating tuples)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { pipe, Tuple } from "effect"
    *
-   * const result = pipe(Tuple.make(1, 2), Tuple.appendElements(["a", "b"] as const))
-   * console.log(result) // [1, 2, "a", "b"]
+   * pipe(Tuple.make(1, 2), Tuple.appendElements(["a", "b"] as const)) // => [1, 2, "a", "b"]
    * ```
    *
    * @see {@link appendElement} – append a single element
@@ -506,17 +493,16 @@ type Evolved<T, E> = { [I in keyof T]: I extends keyof E ? (E[I] extends (...a:
  *
  * **Example** (Transforming selected elements)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { pipe, Tuple } from "effect"
  *
- * const result = pipe(
+ * pipe(
  *   Tuple.make("hello", 42, true),
  *   Tuple.evolve([
  *     (s) => s.toUpperCase(),
  *     (n) => n * 2
  *   ])
- * )
- * console.log(result) // ["HELLO", 84, true]
+ * ) // => ["HELLO", 84, true]
  * ```
  *
  * @see {@link map} – apply the same transformation to all elements
@@ -541,17 +527,16 @@ export const evolve: {
    *
    * **Example** (Transforming selected elements)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { pipe, Tuple } from "effect"
    *
-   * const result = pipe(
+   * pipe(
    *   Tuple.make("hello", 42, true),
    *   Tuple.evolve([
    *     (s) => s.toUpperCase(),
    *     (n) => n * 2
    *   ])
-   * )
-   * console.log(result) // ["HELLO", 84, true]
+   * ) // => ["HELLO", 84, true]
    * ```
    *
    * @see {@link map} – apply the same transformation to all elements
@@ -576,17 +561,16 @@ export const evolve: {
    *
    * **Example** (Transforming selected elements)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { pipe, Tuple } from "effect"
    *
-   * const result = pipe(
+   * pipe(
    *   Tuple.make("hello", 42, true),
    *   Tuple.evolve([
    *     (s) => s.toUpperCase(),
    *     (n) => n * 2
    *   ])
-   * )
-   * console.log(result) // ["HELLO", 84, true]
+   * ) // => ["HELLO", 84, true]
    * ```
    *
    * @see {@link map} – apply the same transformation to all elements
@@ -621,18 +605,17 @@ export const evolve: {
  *
  * **Example** (Swapping elements)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { pipe, Tuple } from "effect"
  *
- * const result = pipe(
+ * pipe(
  *   Tuple.make("a", "b", "c"),
  *   Tuple.renameIndices(["2", "1", "0"])
- * )
- * console.log(result) // ["c", "b", "a"]
+ * ) // => ["c", "b", "a"]
  * ```
  *
  * @see {@link evolve} – transform element values instead of positions
- * @category Index utilities
+ * @category transforming
  * @since 4.0.0
  */
 export const renameIndices: {
@@ -655,18 +638,17 @@ export const renameIndices: {
    *
    * **Example** (Swapping elements)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { pipe, Tuple } from "effect"
    *
-   * const result = pipe(
+   * pipe(
    *   Tuple.make("a", "b", "c"),
    *   Tuple.renameIndices(["2", "1", "0"])
-   * )
-   * console.log(result) // ["c", "b", "a"]
+   * ) // => ["c", "b", "a"]
    * ```
    *
    * @see {@link evolve} – transform element values instead of positions
-   * @category Index utilities
+   * @category transforming
    * @since 4.0.0
    */
   <const T extends ReadonlyArray<unknown>, const M extends { readonly [I in keyof T]?: `${keyof T & string}` }>(mapping: M): (self: T) => { [I in keyof T]: I extends keyof M ? M[I] extends keyof T ? T[M[I]] : T[I] : T[I] }
@@ -689,18 +671,17 @@ export const renameIndices: {
    *
    * **Example** (Swapping elements)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { pipe, Tuple } from "effect"
    *
-   * const result = pipe(
+   * pipe(
    *   Tuple.make("a", "b", "c"),
    *   Tuple.renameIndices(["2", "1", "0"])
-   * )
-   * console.log(result) // ["c", "b", "a"]
+   * ) // => ["c", "b", "a"]
    * ```
    *
    * @see {@link evolve} – transform element values instead of positions
-   * @category Index utilities
+   * @category transforming
    * @since 4.0.0
    */
   <const T extends ReadonlyArray<unknown>, const M extends { readonly [I in keyof T]?: `${keyof T & string}` }>(self: T, mapping: M): { [I in keyof T]: I extends keyof M ? M[I] extends keyof T ? T[M[I]] : T[I] : T[I] }
@@ -732,7 +713,7 @@ export const renameIndices: {
  *
  * **Example** (Wrapping every element in an array)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { pipe, Struct, Tuple } from "effect"
  *
  * interface AsArray extends Struct.Lambda {
@@ -741,8 +722,7 @@ export const renameIndices: {
  * }
  *
  * const asArray = Struct.lambda<AsArray>((a) => [a])
- * const result = pipe(Tuple.make(1, "hello", true), Tuple.map(asArray))
- * console.log(result) // [[1], ["hello"], [true]]
+ * pipe(Tuple.make(1, "hello", true), Tuple.map(asArray)) // => [[1], ["hello"], [true]]
  * ```
  *
  * @see {@link mapPick} – apply a lambda only to selected indices
@@ -770,7 +750,7 @@ export const map: {
    *
    * **Example** (Wrapping every element in an array)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { pipe, Struct, Tuple } from "effect"
    *
    * interface AsArray extends Struct.Lambda {
@@ -779,8 +759,7 @@ export const map: {
    * }
    *
    * const asArray = Struct.lambda<AsArray>((a) => [a])
-   * const result = pipe(Tuple.make(1, "hello", true), Tuple.map(asArray))
-   * console.log(result) // [[1], ["hello"], [true]]
+   * pipe(Tuple.make(1, "hello", true), Tuple.map(asArray)) // => [[1], ["hello"], [true]]
    * ```
    *
    * @see {@link mapPick} – apply a lambda only to selected indices
@@ -810,7 +789,7 @@ export const map: {
    *
    * **Example** (Wrapping every element in an array)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { pipe, Struct, Tuple } from "effect"
    *
    * interface AsArray extends Struct.Lambda {
@@ -819,8 +798,7 @@ export const map: {
    * }
    *
    * const asArray = Struct.lambda<AsArray>((a) => [a])
-   * const result = pipe(Tuple.make(1, "hello", true), Tuple.map(asArray))
-   * console.log(result) // [[1], ["hello"], [true]]
+   * pipe(Tuple.make(1, "hello", true), Tuple.map(asArray)) // => [[1], ["hello"], [true]]
    * ```
    *
    * @see {@link mapPick} – apply a lambda only to selected indices
@@ -848,7 +826,7 @@ export const map: {
  *
  * **Example** (Wrapping only selected elements in arrays)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { pipe, Struct, Tuple } from "effect"
  *
  * interface AsArray extends Struct.Lambda {
@@ -857,11 +835,10 @@ export const map: {
  * }
  *
  * const asArray = Struct.lambda<AsArray>((a) => [a])
- * const result = pipe(
+ * pipe(
  *   Tuple.make(1, "hello", true),
  *   Tuple.mapPick([0, 2], asArray)
- * )
- * console.log(result) // [[1], "hello", [true]]
+ * ) // => [[1], "hello", [true]]
  * ```
  *
  * @see {@link map} – apply a lambda to all elements
@@ -881,7 +858,7 @@ export const mapPick: {
    *
    * **Example** (Wrapping only selected elements in arrays)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { pipe, Struct, Tuple } from "effect"
    *
    * interface AsArray extends Struct.Lambda {
@@ -890,11 +867,10 @@ export const mapPick: {
    * }
    *
    * const asArray = Struct.lambda<AsArray>((a) => [a])
-   * const result = pipe(
+   * pipe(
    *   Tuple.make(1, "hello", true),
    *   Tuple.mapPick([0, 2], asArray)
-   * )
-   * console.log(result) // [[1], "hello", [true]]
+   * ) // => [[1], "hello", [true]]
    * ```
    *
    * @see {@link map} – apply a lambda to all elements
@@ -916,7 +892,7 @@ export const mapPick: {
    *
    * **Example** (Wrapping only selected elements in arrays)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { pipe, Struct, Tuple } from "effect"
    *
    * interface AsArray extends Struct.Lambda {
@@ -925,11 +901,10 @@ export const mapPick: {
    * }
    *
    * const asArray = Struct.lambda<AsArray>((a) => [a])
-   * const result = pipe(
+   * pipe(
    *   Tuple.make(1, "hello", true),
    *   Tuple.mapPick([0, 2], asArray)
-   * )
-   * console.log(result) // [[1], "hello", [true]]
+   * ) // => [[1], "hello", [true]]
    * ```
    *
    * @see {@link map} – apply a lambda to all elements
@@ -961,7 +936,7 @@ export const mapPick: {
  *
  * **Example** (Wrapping all elements except one in arrays)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { pipe, Struct, Tuple } from "effect"
  *
  * interface AsArray extends Struct.Lambda {
@@ -970,11 +945,10 @@ export const mapPick: {
  * }
  *
  * const asArray = Struct.lambda<AsArray>((a) => [a])
- * const result = pipe(
+ * pipe(
  *   Tuple.make(1, "hello", true),
  *   Tuple.mapOmit([1], asArray)
- * )
- * console.log(result) // [[1], "hello", [true]]
+ * ) // => [[1], "hello", [true]]
  * ```
  *
  * @see {@link map} – apply a lambda to all elements
@@ -994,7 +968,7 @@ export const mapOmit: {
    *
    * **Example** (Wrapping all elements except one in arrays)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { pipe, Struct, Tuple } from "effect"
    *
    * interface AsArray extends Struct.Lambda {
@@ -1003,11 +977,10 @@ export const mapOmit: {
    * }
    *
    * const asArray = Struct.lambda<AsArray>((a) => [a])
-   * const result = pipe(
+   * pipe(
    *   Tuple.make(1, "hello", true),
    *   Tuple.mapOmit([1], asArray)
-   * )
-   * console.log(result) // [[1], "hello", [true]]
+   * ) // => [[1], "hello", [true]]
    * ```
    *
    * @see {@link map} – apply a lambda to all elements
@@ -1029,7 +1002,7 @@ export const mapOmit: {
    *
    * **Example** (Wrapping all elements except one in arrays)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { pipe, Struct, Tuple } from "effect"
    *
    * interface AsArray extends Struct.Lambda {
@@ -1038,11 +1011,10 @@ export const mapOmit: {
    * }
    *
    * const asArray = Struct.lambda<AsArray>((a) => [a])
-   * const result = pipe(
+   * pipe(
    *   Tuple.make(1, "hello", true),
    *   Tuple.mapOmit([1], asArray)
-   * )
-   * console.log(result) // [[1], "hello", [true]]
+   * ) // => [[1], "hello", [true]]
    * ```
    *
    * @see {@link map} – apply a lambda to all elements
@@ -1078,7 +1050,7 @@ export const mapOmit: {
  *
  * **Example** (Comparing tuples for equivalence)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Equivalence, Tuple } from "effect"
  *
  * const eq = Tuple.makeEquivalence([
@@ -1086,8 +1058,8 @@ export const mapOmit: {
  *   Equivalence.strictEqual<number>()
  * ])
  *
- * console.log(eq(["Alice", 30], ["Alice", 30])) // true
- * console.log(eq(["Alice", 30], ["Bob", 30]))   // false
+ * eq(["Alice", 30], ["Alice", 30]) // => true
+ * eq(["Alice", 30], ["Bob", 30]) // => false
  * ```
  *
  * @see {@link makeOrder} – create an `Order` for tuples
@@ -1112,13 +1084,13 @@ export const makeEquivalence = Equivalence.Tuple
  *
  * **Example** (Ordering tuples)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Number, String, Tuple } from "effect"
  *
  * const ord = Tuple.makeOrder([String.Order, Number.Order])
  *
- * console.log(ord(["Alice", 30], ["Bob", 25]))   // -1
- * console.log(ord(["Alice", 30], ["Alice", 30])) // 0
+ * ord(["Alice", 30], ["Bob", 25]) // => -1
+ * ord(["Alice", 30], ["Alice", 30]) // => 0
  * ```
  *
  * @see {@link makeEquivalence} – create an `Equivalence` for tuples
@@ -1148,13 +1120,12 @@ export {
    *
    * **Example** (Checking exact length)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Tuple } from "effect"
    *
    * const arr: Array<number> = [1, 2, 3]
    * if (Tuple.isTupleOf(arr, 3)) {
-   *   console.log(arr)
-   *   // ^? [number, number, number]
+   *   arr // => [1, 2, 3]
    * }
    * ```
    *
@@ -1183,13 +1154,12 @@ export {
    *
    * **Example** (Checking minimum length)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Tuple } from "effect"
    *
    * const arr: Array<number> = [1, 2, 3, 4]
    * if (Tuple.isTupleOfAtLeast(arr, 3)) {
-   *   console.log(arr)
-   *   // ^? [number, number, number, ...number[]]
+   *   arr // => [1, 2, 3, 4]
    * }
    * ```
    *
@@ -1212,7 +1182,7 @@ export {
  *
  * **Example** (Combining tuple elements)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Number, String, Tuple } from "effect"
  *
  * const C = Tuple.makeCombiner<readonly [number, string]>([
@@ -1220,8 +1190,7 @@ export {
  *   String.ReducerConcat
  * ])
  *
- * const result = C.combine([1, "hello"], [2, " world"])
- * console.log(result) // [3, "hello world"]
+ * C.combine([1, "hello"], [2, " world"]) // => [3, "hello world"]
  * ```
  *
  * @see {@link makeReducer} – like `makeCombiner` but with an initial value
@@ -1253,7 +1222,7 @@ export function makeCombiner<A extends ReadonlyArray<unknown>>(
  *
  * **Example** (Reducing a collection of tuples)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Number, String, Tuple } from "effect"
  *
  * const R = Tuple.makeReducer<readonly [number, string]>([
@@ -1261,12 +1230,11 @@ export function makeCombiner<A extends ReadonlyArray<unknown>>(
  *   String.ReducerConcat
  * ])
  *
- * const result = R.combineAll([
+ * R.combineAll([
  *   [1, "a"],
  *   [2, "b"],
  *   [3, "c"]
- * ])
- * console.log(result) // [6, "abc"]
+ * ]) // => [6, "abc"]
  * ```
  *
  * @see {@link makeCombiner} – like `makeReducer` but without an initial value