rubico 2.2.0 → 2.2.2

package/monad/Struct.js

@@ -0,0 +1,249 @@
+/* rubico v1.5.0
+ * https://github.com/a-synchronous/rubico
+ * (c) 2019-2020 Richard Tong
+ * rubico may be freely distributed under the MIT license.
+ */
+
+'use strict'
+
+const Instance = require('./Instance')
+
+const { isArray, isObject, isSet, isMap } = Instance
+
+/**
+ * @synopsis
+ * isStruct(x any) -> boolean
+ */
+const isStruct = x => isArray(x) || isObject(x) || isSet(x) || isMap(x)
+
+/**
+ * @name Struct
+ *
+ * @synopsis
+ * new Struct(x Array|Object|Set|Map) -> Struct
+ *
+ * @catchphrase
+ * Finite data structure
+ */
+const Struct = function(x) {
+  if (!isStruct(x)) {
+    throw new TypeError(`cannot convert ${x} to Struct`)
+  }
+  this.value = x
+}
+
+/**
+ * @name Struct.isStruct
+ *
+ * @synopsis
+ * Struct.isStruct(x any) -> boolean
+ *
+ * @catchphrase
+ * Tell if struct
+ */
+Struct.isStruct = isStruct
+
+/**
+ * @synopsis
+ * <T>objectEntriesGenerator(x Object<T>) -> Iterator<[key string, T]>
+ */
+const objectEntriesGenerator = function*(x) {
+  for (const k in x) {
+    yield [k, x[k]]
+  }
+}
+
+/**
+ * @name Struct.entries
+ *
+ * @synopsis
+ * <T any>Struct.entries(x Array<T>) -> Iterator<[index number, T]>
+ *
+ * <T any>Struct.entries(x Object<T>) -> Iterator<[key string, T]>
+ *
+ * <T any>Struct.entries(x Set<T>) -> Iterator<[T, T]>
+ *
+ * <A any, B any>Struct.entries(x Map<A, B>) -> Iterator<[A, B]>
+ *
+ * @catchphrase
+ * Get an iterator of key value pairs
+ */
+Struct.entries = x => isObject(x) ? objectEntriesGenerator(x) : x.entries()
+
+/**
+ * @synopsis
+ * <T>objectValuesGenerator(x Object<T>) -> Iterator<T>
+ */
+const objectValuesGenerator = function*(x) {
+  for (const k in x) {
+    yield x[k]
+  }
+}
+
+/**
+ * @name Struct.values
+ *
+ * @synopsis
+ * <T any>Struct.values(
+ *   x Array<T>|Object<T>|Set<T>|Map<any, T>
+ * ) -> Iterator<T>
+ *
+ * @catchphrase
+ * Get an iterator of values
+ */
+Struct.values = x => isObject(x) ? objectValuesGenerator(x) : x.values()
+
+/**
+ * @name Struct.get
+ *
+ * @synopsis
+ * <T any>Struct.get(x Array<T>, index number) -> T|undefined
+ *
+ * <T any>Struct.get(x Object<T>, index string) -> T|undefined
+ *
+ * <T any>Struct.get(x Set<T>, index T) -> T|undefined
+ *
+ * <A any, B any>Struct.get(x Map<A, B>, index A) -> B|undefined
+ *
+ * @catchphrase
+ * Get an item by index
+ */
+Struct.get = (x, index) => {
+  if (typeof x.get == 'function') return x.get(index)
+  if (typeof x.has == 'function') return x.has(index) ? index : undefined
+  return x[index]
+}
+
+/*
+Struct.get.ternary = (x, index) => (typeof x.get == 'function'
+  ? x.get(index) : typeof x.has == 'function'
+  ? x.has(index) ? index : undefined : x[index])
+*/
+
+/**
+ * @name Struct.set
+ *
+ * @synopsis
+ * Struct.set(x Array, value any, index number) -> mutated Array
+ *
+ * Struct.set(x Object, value any, index string) -> mutated Object
+ *
+ * Struct.set(x Set, value any) -> mutated Set
+ *
+ * Struct.set(x Map, value any, index any) -> mutated Map
+ *
+ * @catchphrase
+ * Set a value
+ */
+Struct.set = (x, value, index) => {
+  if (typeof x.set == 'function') return x.set(index, value)
+  if (typeof x.add == 'function') return x.add(value)
+  x[index] = value
+  return x
+}
+
+/**
+ * @synopsis
+ * objectKeysCount(obj object) -> ct number
+ */
+const objectKeysCount = obj => {
+  let ct = 0
+  for (const _ in obj) ct += 1
+  return ct
+}
+
+/**
+ * @name Struct.size
+ *
+ * @synopsis
+ * Struct.size(x Array|Object|Set|Map) -> number
+ *
+ * @catchphrase
+ * Count values
+ */
+Struct.size = x => {
+  if (isObject(x)) return objectKeysCount(x)
+  return 'size' in x ? x.size : x.length
+}
+
+/*
+Struct.size.objectKeys = x => {
+  if (isObject(x)) return Object.keys(x).length
+  return 'size' in x ? x.size : x.length
+}
+*/
+
+/**
+ * @synopsis
+ * copySet(x Set) -> y Set
+ */
+const copySet = x => {
+  const y = new Set()
+  for (const item of x) y.add(item)
+  return y
+}
+
+
+/**
+ * @synopsis
+ * copyMap(x Map) -> y Map
+ */
+const copyMap = x => {
+  const y = new Map()
+  for (const entry of x) y.set(...entry)
+  return y
+}
+
+/**
+ * @name Struct.copy
+ *
+ * @synopsis
+ * Struct.copy(x Array) -> copied Array
+ *
+ * Struct.copy(x Object) -> copied Object
+ *
+ * Struct.copy(x Set) -> copied Set
+ *
+ * Struct.copy(x Map) -> copied Map
+ *
+ * @catchphrase
+ * Shallow copy a struct
+ */
+Struct.copy = x => {
+  if (isArray(x)) return x.slice()
+  if (isObject(x)) return { ...x }
+  return isSet(x) ? copySet(x) : copyMap(x)
+}
+
+const { entries: structEntries, set: structSet } = Struct
+
+/**
+ * @name Struct.copyDeep
+ *
+ * @synopsis
+ * Struct.copyDeep(x Array) -> deeplyCopied Array
+ *
+ * Struct.copyDeep(x Object) -> deeplyCopied Object
+ *
+ * Struct.copyDeep(x Set) -> deeplyCopied Set
+ *
+ * Struct.copyDeep(x Map) -> deeplyCopied Map
+ *
+ * @catchphrase
+ * Deep copy a struct
+ */
+const structCopyDeep = x => {
+  const y = new x.constructor()
+  for (const [index, value] of structEntries(x)) {
+    structSet(
+      y,
+      isStruct(value) ? structCopyDeep(value) : value,
+      index,
+    )
+  }
+  return y
+}
+
+Struct.copyDeep = structCopyDeep
+
+module.exports = Struct

package/monad/Struct.test.js

@@ -0,0 +1,237 @@
+const assert = require('assert')
+const Struct = require('./Struct')
+
+describe('Struct', () => {
+  describe('new Struct(x Array|Object|Set|Map) -> Struct', () => {
+    it('x Array; Struct', async () => {
+      assert.equal(new Struct([1, 2, 3]).constructor, Struct)
+    })
+    it('x Object; Struct', async () => {
+      assert.equal(new Struct({ a: 1, b: 2, c: 3 }).constructor, Struct)
+    })
+    it('x Set; Struct', async () => {
+      assert.equal(new Struct(new Set([1, 2, 3])).constructor, Struct)
+    })
+    it('x Map; Struct', async () => {
+      assert.equal(new Struct(new Map([['a', 1], ['b', 2], ['c', 3]])).constructor, Struct)
+    })
+    it('x string; TypeError', async () => {
+      assert.throws(
+        () => new Struct('hey'),
+        new TypeError('cannot convert hey to Struct')
+      )
+    })
+    it('x null; TypeError', async () => {
+      assert.throws(
+        () => new Struct(null),
+        new TypeError('cannot convert null to Struct')
+      )
+    })
+    it('x undefined; TypeError', async () => {
+      assert.throws(
+        () => new Struct(undefined),
+        new TypeError('cannot convert undefined to Struct')
+      )
+    })
+  })
+
+  describe('Struct.isStruct(x any) -> boolean', () => {
+    it('x Array; true', async () => {
+      assert.equal(Struct.isStruct([]), true)
+    })
+    it('x Object; true', async () => {
+      assert.equal(Struct.isStruct({}), true)
+    })
+    it('x Set; true', async () => {
+      assert.equal(Struct.isStruct(new Set()), true)
+    })
+    it('x Map; true', async () => {
+      assert.equal(Struct.isStruct(new Map()), true)
+    })
+    it('x ArrayBuffer; false', async () => {
+      assert.equal(Struct.isStruct(new ArrayBuffer()), false)
+    })
+    it('x Number; false', async () => {
+      assert.equal(Struct.isStruct(1), false)
+    })
+    it('x String; false', async () => {
+      assert.equal(Struct.isStruct('hey'), false)
+    })
+  })
+
+  const nativeObjectToString = Object.prototype.toString
+
+  const objectToString = x => nativeObjectToString.call(x)
+
+  it('<T any>Struct.entries(x Array<T>) -> Iterator<[index number, T]>', async () => {
+    assert.equal(objectToString(Struct.entries([1, 2, 3])), '[object Array Iterator]')
+    assert.deepEqual([...Struct.entries([1, 2, 3])], [[0, 1], [1, 2], [2, 3]])
+  })
+
+  it('<T any>Struct.entries(x Object<T>) -> Iterator<[key string, T]>', async () => {
+    assert.equal(objectToString(Struct.entries({ a: 1, b: 2, c: 3 })), '[object Generator]')
+    assert.deepEqual([...Struct.entries({ a: 1, b: 2, c: 3 })], [['a', 1], ['b', 2], ['c', 3]])
+  })
+
+  it('<T any>Struct.entries(x Set<T>) -> Iterator<[T, T]>', async () => {
+    assert.equal(objectToString(Struct.entries(new Set([1, 2, 3]))), '[object Set Iterator]')
+    assert.deepEqual([...Struct.entries(new Set([1, 2, 3]))], [[1, 1], [2, 2], [3, 3]])
+  })
+
+  it('<A any, B any>Struct.entries(x Map<A, B>) -> Iterator<[A, B]>', async () => {
+    assert.equal(objectToString(Struct.entries(new Map([[1, 'a'], [2, 'b'], [3, 'c']]))), '[object Map Iterator]')
+    assert.deepEqual([...Struct.entries(new Map([[1, 'a'], [2, 'b'], [3, 'c']]))], [[1, 'a'], [2, 'b'], [3, 'c']])
+  })
+
+  describe('<T any>Struct.values(x Array<T>|Object<T>|Set<T>|Map<any, T>) -> Iterator<T>', () => {
+    it('x Array<T>; Iterator<T>', async () => {
+      assert.equal(objectToString(Struct.values([1, 2, 3])), '[object Array Iterator]')
+      assert.deepEqual([...Struct.values([1, 2, 3])], [1, 2, 3])
+    })
+    it('x Object<T>; Iterator<T>', async () => {
+      assert.equal(objectToString(Struct.values({ a: 1, b: 2, c: 3 })), '[object Generator]')
+      assert.deepEqual([...Struct.values({ a: 1, b: 2, c: 3 })], [1, 2, 3])
+    })
+    it('x Set<T>; Iterator<T>', async () => {
+      assert.equal(objectToString(Struct.values(new Set([1, 2, 3]))), '[object Set Iterator]')
+      assert.deepEqual([...Struct.values(new Set([1, 2, 3]))], [1, 2, 3])
+    })
+    it('x Map<T>; Iterator<T>', async () => {
+      assert.equal(objectToString(Struct.values(new Map([[1, 'a'], [2, 'b'], [3, 'c']]))), '[object Map Iterator]')
+      assert.deepEqual([...Struct.values(new Map([[1, 'a'], [2, 'b'], [3, 'c']]))], ['a', 'b', 'c'])
+    })
+  })
+
+  it('<T any>Struct.get(x Array<T>, index number) -> T|undefined', async () => {
+    assert.equal(Struct.get([1, 2, 3], 0), 1)
+    assert.strictEqual(Struct.get([1, 2, 3], 4), undefined)
+  })
+
+  it('<T any>Struct.get(x Object<T>, index string) -> T|undefined', async () => {
+    assert.equal(Struct.get({ a: 1, b: 2, c: 3 }, 'a'), 1)
+    assert.strictEqual(Struct.get({ a: 1, b: 2, c: 3 }, 'e'), undefined)
+  })
+
+  it('<T any>Struct.get(x Set<T>, index T) -> T|undefined', async () => {
+    assert.equal(Struct.get(new Set([1, 2, 3]), 1), 1)
+    assert.strictEqual(Struct.get(new Set([1, 2, 3]), 5), undefined)
+  })
+
+  it('<A any, B any>Struct.get(x Map<A, B>, index A) -> B|undefined', async () => {
+    const m = new Map([[1, 'a'], [2, 'b'], [3, 'c']])
+    assert.equal(Struct.get(m, 1), 'a')
+    assert.strictEqual(Struct.get(m, 5), undefined)
+  })
+
+  it('Struct.set(x Array, value any, index number) -> mutated Array', async () => {
+    const arr = [1, 2]
+    assert.deepEqual(Struct.set(arr, 3, 2), [1, 2, 3])
+  })
+
+  it('Struct.set(x Object, value any, index string) -> mutated Object', async () => {
+    const obj = { a: 1, b: 2 }
+    assert.deepEqual(Struct.set(obj, 3, 'c'), { a: 1, b: 2, c: 3 })
+  })
+
+  it('Struct.set(x Set, value any) -> mutated Set', async () => {
+    const set = new Set([1, 2])
+    assert.deepEqual(Struct.set(set, 3), new Set([1, 2, 3]))
+  })
+
+  it('Struct.set(x Map, value any, index any) -> mutated Map', async () => {
+    const map = new Map([['a', 1], ['b', 2]])
+    assert.deepEqual(Struct.set(map, 3, 'c'), new Map([['a', 1], ['b', 2], ['c', 3]]))
+  })
+
+  describe('Struct.size(x Array|Object|Set|Map) -> y number', () => {
+    it('x [1, 2, 3]; y 3', async () => {
+      assert.strictEqual(Struct.size([1, 2, 3]), 3)
+    })
+    it('x []; y 0', async () => {
+      assert.strictEqual(Struct.size([]), 0)
+    })
+    it('x { a: 1, b: 2, c: 3 }; y 3', async () => {
+      assert.strictEqual(Struct.size({ a: 1, b: 2, c: 3 }), 3)
+    })
+    it('x {}; y 0', async () => {
+      assert.strictEqual(Struct.size({}), 0)
+    })
+    it('x Set<[1, 2, 3]>; y 3', async () => {
+      assert.strictEqual(Struct.size(new Set([1, 2, 3])), 3)
+    })
+    it('x Set<[]>; y 0', async () => {
+      assert.strictEqual(Struct.size(new Set()), 0)
+    })
+    it('x Map<[[\'a\', 1], [\'b\', 2], [\'c\', 3]]>; y 3', async () => {
+      assert.strictEqual(Struct.size(new Map([['a', 1], ['b', 2], ['c', 3]])), 3)
+    })
+    it('x Map<[]>; y 0', async () => {
+      assert.strictEqual(Struct.size(new Map()), 0)
+    })
+  })
+
+  it('Struct.copy(x Array) -> copied Array', async () => {
+    const arr = [1, 2, 3]
+    const copied = Struct.copy(arr)
+    assert(copied !== arr)
+    assert.deepEqual(arr, copied)
+  })
+
+  it('Struct.copy(x Object) -> copied Object', async () => {
+    const obj = { a: 1, b: 2, c: 3 }
+    const copied = Struct.copy(obj)
+    assert(copied !== obj)
+    assert.deepEqual(obj, copied)
+  })
+
+  it('Struct.copy(x Set) -> copied Set', async () => {
+    const set = new Set([1, 2, 3])
+    const copied = Struct.copy(set)
+    assert(copied !== set)
+    assert.deepEqual(set, copied)
+  })
+
+  it('Struct.copy(x Map) -> copied Map', async () => {
+    const map = new Map([['a', 1], ['b', 2], ['c', 3]])
+    const copied = Struct.copy(map)
+    assert(copied !== map)
+    assert.deepEqual(map, copied)
+  })
+
+  it('Struct.copyDeep(x Array) -> deeplyCopied Array', async () => {
+    const arr = [1, [2], [[3], 'hey', new Uint8Array([1, 2, 3])]]
+    const copied = Struct.copyDeep(arr)
+    assert(copied !== arr)
+    assert.deepEqual(arr, copied)
+  })
+
+  it('Struct.copyDeep(x Object) -> deeplyCopied Object', async () => {
+    const obj = { a: 1, b: [2], c: [[3]], d: new Set([NaN, 'hey', { a: null }]) }
+    const copied = Struct.copy(obj)
+    assert(copied !== obj)
+    assert.deepEqual(obj, copied)
+  })
+
+  it('Struct.copyDeep(x Set) -> deeplyCopied Set', async () => {
+    const set = new Set([1, [2], [[[[3]]]], {}, [], undefined])
+    const copied = Struct.copy(set)
+    assert(copied !== set)
+    assert.deepEqual(set, copied)
+  })
+
+  it('Struct.copyDeep(x Map) -> deeplyCopied Map', async () => {
+    const map = new Map([
+      ['a', 1], ['b', 2], ['c', 3],
+      [Symbol.for('ayo'), {}], ['hey', {
+        a: [1, [2], [[3]]],
+        b: new Set([undefined, null, {}, [], new RegExp()]),
+        c: { d: { e: new BigInt64Array([1n, 2n, 3n]) } },
+      }],
+    ])
+    const copied = Struct.copy(map)
+    assert(copied !== map)
+    assert.deepEqual(map, copied)
+    assert.strictEqual(map.get('hey').c.d.e, copied.get('hey').c.d.e)
+    // anything not a struct is a reference. This is good for performance but could be dangerous
+  })
+})

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rubico",
-  "version": "2.2.0",
+  "version": "2.2.2",
   "description": "[a]synchronous functional programming",
   "author": "Richard Tong",
   "license": "MIT",
@@ -14,6 +14,7 @@
     "_internal",
     "dist",
     "x",
+    "monad",
     "index.js",
     "es.js",
     "global.js",

package/reduce.js

@@ -22,6 +22,7 @@ const _reduce = function (collection, reducer, initialValue) {
  * @synopsis
  * ```coffeescript [specscript]
  * type Foldable = Array|Object|Map|Iterator|AsyncIterator
+ *
  * type Reducer = (
  *   accumulator any,
  *   value any,

package/set.js

@@ -39,7 +39,7 @@ const _set = function (obj, path, value) {
  * @synopsis
  * ```coffeescript [specscript]
  * set(
- *   object Object,
+ *   object Promise|Object,
  *   path string|Array<string|number>,
  *   value function|any,
  * ) -> result Promise|Object
@@ -60,15 +60,15 @@ const _set = function (obj, path, value) {
  *  * an array of keys or indices - `['a', 0, 'value']`
  *
  * ```javascript [playground]
- * console.log(set('a', 1)({ b: 2 })) // { a: 1, b: 2 }
+ * console.log(set({ b: 2 }, 'a', 1)) // { a: 1, b: 2 }
  *
  * const nestedAC2 = { a: { c: 2 } }
  *
- * console.log(set('a.b', 1)(nestedAC2)) // { a : { b: 1, c: 2 }}
+ * console.log(set(nestedAC2, 'a.b', 1)) // { a : { b: 1, c: 2 }}
  *
  * const nestedA0BC3 = { a: [{ b: { c: 3 } }] }
  *
- * console.log(set('a[0].b.c', 4)(nestedA0BC3)) // { a: [{ b: { c: 4 } }] }
+ * console.log(set(nestedA0BC3, 'a[0].b.c', 4)) // { a: [{ b: { c: 4 } }] }
  * ```
  *
  * The property value may be a function, in which case it is treated as a resolver and provided the argument object to resolve the value to set.
@@ -81,6 +81,15 @@ const _set = function (obj, path, value) {
  * console.log(myNewObj) // { a: 1, b: 3 }
  * ```
  *
+ * `set` supports a tacit API for composability.
+ *
+ * ```javascript [playground]
+ * pipe({ a: 1 }, [
+ *   set('b', 2),
+ *   console.log, // { a: 1, b: 2 }
+ * ])
+ * ```
+ *
  * @since 1.7.0
  */
 

package/some.js

@@ -75,10 +75,21 @@ const _some = function (collection, predicate) {
  *   yield 1; yield 2; yield 3; yield 4; yield 5
  * }
  *
- * some(pipe([
- *   fetchTodo,
- *   todo => todo.title.startsWith('fugiat'),
- * ]))(todoIDsGenerator()).then(console.log) // true
+ * const promise = some(todoIDsGenerator(), async id => {
+ *   const todo = await fetchTodo(id)
+ *   return todo.title.startsWith('fugiat')
+ * })
+ *
+ * promise.then(console.log) // true
+ * ```
+ *
+ * `some` supports a tacit API for composability.
+ *
+ * ```javascript [playground]
+ * pipe([1, 2, 3], [
+ *   some(number => number < 5),
+ *   console.log, // true
+ * ])
  * ```
  *
  * @execution concurrent

package/switchCase.js

@@ -15,12 +15,31 @@ const curryArgs3 = require('./_internal/curryArgs3')
  * switchCase(conditionalValues Array<boolean|any>) -> Promise|any
  *
  * switchCase(
+ *   ...args,
+ *   conditionalFuncsOrValues Array<function|boolean|any>
+ * ) -> Promise|any
+ *
+ * switchCase(
  *   conditionalFuncsOrValues Array<function|boolean|any>
  * )(...args) -> Promise|any
  * ```
  *
  * @description
- * Functional equivalent to the [Conditional (ternary) operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Conditional_Operator). Accepts an array of conditional functions that specifies cases as pairings of `predicate` and `resolver` functions with the exception of the last, default resolver. All functions are provided with the same arguments and executed in series. The result of a `switchCase` execution is either the result of the execution the last default resolver, or the result of the execution of the first resolver where the associated predicate tested truthy.
+ * Functional equivalent to the [Conditional (ternary) operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Conditional_Operator). Accepts an array of conditional functions that specifies cases as pairings of `predicate` and `resolver` functions with the exception of the last, default resolver. All functions are provided with the same arguments and executed in series. The result of a `switchCase` operation is either the result of the execution the last default resolver, or the result of the execution of the first resolver where the associated predicate tested true.
+ *
+ * ```javascript [playground]
+ * const fruitIsYellow = fruit => fruit.color == 'yellow'
+ *
+ * console.log(
+ *   switchCase({ name: 'plantain', color: 'yellow' }, [
+ *     fruitIsYellow,
+ *     fruit => fruit.name + ' is possibly a banana',
+ *     fruit => fruit.name + ' is probably not a banana',
+ *   ])
+ * ) // plantain is possibly a banana
+ * ```
+ *
+ * For composability `switchCase` supports a tacit API.
  *
  * ```javascript [playground]
  * const fruitIsYellow = fruit => fruit.color == 'yellow'
@@ -38,7 +57,7 @@ const curryArgs3 = require('./_internal/curryArgs3')
  * // apple is probably not a banana
  * ```
  *
- * Any function can be replaced with a nonfunction (object or primitive) value so that the value is treated as an already resolved value.
+ * Any function can be replaced with a nonfunction (object or primitive) value to be used directly in the operation.
  *
  * ```javascript [playground]
  * switchCase([

package/transform.js

@@ -26,8 +26,6 @@ const _transform = function (collection, transducer, initialValue) {
  * type Transformable = Array|String|Set|TypedArray|{ concat: function }|{ write: function }|Object
  * type Foldable = Iterable|AsyncIterable|Object<value any>
  *
- * initialValue Transformable|((foldable Foldable)=>Promise|Transformable)
- *
  * transform(
  *   foldable Foldable,
  *   transducer Transducer,
@@ -58,9 +56,9 @@ const _transform = function (collection, transducer, initialValue) {
  *
  * const isOdd = number => number % 2 == 1
  *
- * const squaredOdds = pipe([
- *   filter(isOdd),
- *   map(square),
+ * const squaredOdds = compose([
+ *   Transducer.filter(isOdd),
+ *   Transducer.map(square),
  * ])
  *
  * // transform arrays into arrays
@@ -96,7 +94,7 @@ const _transform = function (collection, transducer, initialValue) {
  *   },
  * }
  *
- * transform(map(square), Stdout)([1, 2, 3, 4, 5])
+ * transform(Transducer.map(square), Stdout)([1, 2, 3, 4, 5])
  * // 1
  * // 4
  * // 9
@@ -124,8 +122,10 @@ const _transform = function (collection, transducer, initialValue) {
  * }
  *
  * transform(
- *   map(pipe([square, toString])), process.stdout,
- * )(streamRandomInts()) // 9216576529289484980147613249169774446246768649...
+ *   streamRandomInts(),
+ *   Transducer.map(pipe([square, toString])),
+ *   process.stdout,
+ * ) // 9216576529289484980147613249169774446246768649...
  * ```
  *
  * @execution series