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

package/dist/Trie.js.map

@@ -1 +1 @@
-{"version":3,"file":"Trie.js","names":["TR","TypeId","TrieTypeId","empty","fromIterable","make","insert","keys","values","entries","toEntries","self","Array","from","keysWithPrefix","valuesWithPrefix","entriesWithPrefix","toEntriesWithPrefix","longestPrefixOf","size","get","has","isEmpty","getUnsafe","remove","reduce","map","filter","filterMap","compact","forEach","modify","removeMany","insertMany"],"sources":["../src/Trie.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}
+{"version":3,"file":"Trie.js","names":[],"sources":["../src/Trie.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}

package/dist/Tuple.d.ts

@@ -30,11 +30,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
@@ -57,11 +56,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
@@ -83,11 +81,10 @@ export declare 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
@@ -109,11 +106,10 @@ export declare 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
@@ -141,11 +137,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)
@@ -167,11 +162,10 @@ export declare 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)
@@ -193,11 +187,10 @@ export declare 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,11 +214,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)
@@ -246,11 +238,10 @@ export declare 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)
@@ -271,11 +262,10 @@ export declare 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)
@@ -298,11 +288,10 @@ export declare 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)
@@ -324,11 +313,10 @@ export declare 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)
@@ -350,11 +338,10 @@ export declare 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)
@@ -377,11 +364,10 @@ export declare 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
@@ -403,11 +389,10 @@ export declare 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
@@ -429,11 +414,10 @@ export declare 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
@@ -464,17 +448,16 @@ type Evolved<T, E> = {
  *
  * **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
@@ -499,17 +482,16 @@ export declare 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
@@ -534,17 +516,16 @@ export declare 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
@@ -573,18 +554,17 @@ export declare 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 declare const renameIndices: {
@@ -607,18 +587,17 @@ export declare 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 {
@@ -645,18 +624,17 @@ export declare 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 {
@@ -683,7 +661,7 @@ export declare 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 {
@@ -692,8 +670,7 @@ export declare 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
@@ -721,7 +698,7 @@ export declare 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 {
@@ -730,8 +707,7 @@ export declare 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
@@ -761,7 +737,7 @@ export declare 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 {
@@ -770,8 +746,7 @@ export declare 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
@@ -795,7 +770,7 @@ export declare 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 {
@@ -804,11 +779,10 @@ export declare 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
@@ -828,7 +802,7 @@ export declare 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 {
@@ -837,11 +811,10 @@ export declare 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
@@ -863,7 +836,7 @@ export declare 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 {
@@ -872,11 +845,10 @@ export declare 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
@@ -899,7 +871,7 @@ export declare 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 {
@@ -908,11 +880,10 @@ export declare 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
@@ -932,7 +903,7 @@ export declare 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 {
@@ -941,11 +912,10 @@ export declare 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
@@ -967,7 +937,7 @@ export declare 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 {
@@ -976,11 +946,10 @@ export declare 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
@@ -1007,7 +976,7 @@ export declare const mapOmit: {
  *
  * **Example** (Comparing tuples for equivalence)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Equivalence, Tuple } from "effect"
  *
  * const eq = Tuple.makeEquivalence([
@@ -1015,8 +984,8 @@ export declare 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
@@ -1040,13 +1009,13 @@ export declare const makeEquivalence: typeof 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
@@ -1075,13 +1044,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]
  * }
  * ```
  *
@@ -1110,13 +1078,12 @@ isTupleOf,
  *
  * **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]
  * }
  * ```
  *
@@ -1137,7 +1104,7 @@ isTupleOfAtLeast } from "./Predicate.ts";
  *
  * **Example** (Combining tuple elements)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Number, String, Tuple } from "effect"
  *
  * const C = Tuple.makeCombiner<readonly [number, string]>([
@@ -1145,8 +1112,7 @@ isTupleOfAtLeast } from "./Predicate.ts";
  *   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
@@ -1169,7 +1135,7 @@ export declare function makeCombiner<A extends ReadonlyArray<unknown>>(combiners
  *
  * **Example** (Reducing a collection of tuples)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Number, String, Tuple } from "effect"
  *
  * const R = Tuple.makeReducer<readonly [number, string]>([
@@ -1177,12 +1143,11 @@ export declare function makeCombiner<A extends ReadonlyArray<unknown>>(combiners
  *   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