rubico 1.9.7 → 2.0.1

package/Transducer.test.js

@@ -0,0 +1,117 @@
+const assert = require('assert')
+const Transducer = require('./Transducer')
+const compose = require('./compose')
+const reduce = require('./reduce')
+const transform = require('./transform')
+
+describe('Transducer', () => {
+  const ade = assert.deepEqual
+  const ase = assert.strictEqual
+  const aok = assert.ok
+
+  describe('integration: transducers from Transducer.map, Transducer.filter, Transducer.flatMap', () => {
+    const concat = (y, xi) => y.concat(xi)
+    const add = (y, xi) => y + xi
+    const isOdd = number => number % 2 == 1
+
+    it('reduce with sync transduced reducers', async () => {
+      const squareOdds = compose([
+        Transducer.filter(isOdd),
+        Transducer.map(x => x ** 2),
+      ])
+      ade(
+        reduce(squareOdds(concat), [])([1, 2, 3, 4, 5]),
+        [1, 9, 25],
+      )
+      ade(
+        reduce(squareOdds((y, xi) => y.add(xi)), new Set())([1, 2, 3, 4, 5]),
+        new Set([1, 9, 25]),
+      )
+      const appendAlphas = compose([
+        Transducer.map(x => `${x}a`),
+        Transducer.map(x => `${x}b`),
+        Transducer.map(x => `${x}c`),
+      ])
+      ase(
+        reduce(appendAlphas(add), '')('123'),
+        '1abc2abc3abc',
+      )
+      ade(
+        reduce(appendAlphas(concat), [])('123'),
+        ['1abc', '2abc', '3abc'],
+      )
+    })
+
+    it('reduce with an async transduced reducer', async () => {
+      const hosWithHey = compose([
+        Transducer.filter(async x => x === 'ho'),
+        Transducer.map(x => Promise.resolve(`${x}hey`)),
+      ])
+      const hihos = { a: 'hi', b: 'ho', c: 'hi', d: 'ho', e: 'hi', f: 'ho' }
+      aok(reduce(hosWithHey(add), '')(hihos) instanceof Promise),
+      aok(reduce(hosWithHey(concat), [])(hihos) instanceof Promise),
+      ase(
+        await reduce(hosWithHey(add), '')(hihos),
+        'hoheyhoheyhohey',
+      )
+      ade(
+        await reduce(hosWithHey(concat), [])(hihos),
+        ['hohey', 'hohey', 'hohey'],
+      )
+    })
+
+    it('flatMapping transducer', async () => {
+      const createOddMultiplesSync = compose([
+        Transducer.filter(isOdd),
+        Transducer.flatMap(number => [number * 2, number * 3]),
+      ])
+
+      ase(
+        reduce([1, 2, 3], createOddMultiplesSync(add), 0),
+        2 + 3 + 6 + 9,
+      )
+      ade(
+        reduce([1, 2, 3], createOddMultiplesSync(concat), []),
+        [2, 3, 6, 9],
+      )
+
+      const createOddMultiplesAsync = compose([
+        Transducer.filter(isOdd),
+        Transducer.flatMap(async number => [number * 2, number * 3]),
+      ])
+
+      const p1 = reduce([1, 2, 3], createOddMultiplesAsync(add), 0)
+      aok(p1 instanceof Promise)
+      const p2 = reduce([1, 2, 3], createOddMultiplesAsync(concat), [])
+      aok(p2 instanceof Promise)
+      await p1.then(result => {
+        ase(result, 2 + 3 + 6 + 9)
+      })
+      await p2.then(result => {
+        ade(result, [2, 3, 6, 9])
+      })
+    })
+
+    it('forEach transducer', async () => {
+      let sum1 = 0
+      reduce([1, 2, 3, 4, 5], Transducer.forEach(number => {
+        sum1 += number
+      })(() => {}), null)
+      assert.equal(sum1, 15)
+
+      let sum2 = 0
+      await reduce([1, 2, 3, 4, 5], Transducer.forEach(async number => {
+        sum2 += number
+      })(() => {}), null)
+      assert.equal(sum2, 15)
+    })
+
+    it('passthrough transducer', async () => {
+      assert.deepEqual(
+        transform({ a: 1, b: 2, c: 3 }, Transducer.passthrough, []),
+        [1, 2, 3],
+      )
+    })
+  })
+
+})

package/_internal/ComparisonOperator.js

@@ -0,0 +1,68 @@
+const isPromise = require('./isPromise')
+const areAnyValuesPromises = require('./areAnyValuesPromises')
+const __ = require('./placeholder')
+const curry4 = require('./curry4')
+const curryArgs4 = require('./curryArgs4')
+const spread2 = require('./spread2')
+const promiseAll = require('./promiseAll')
+const leftResolverRightResolverCompare = require('./leftResolverRightResolverCompare')
+const leftResolverRightValueCompare = require('./leftResolverRightValueCompare')
+const leftValueRightResolverCompare = require('./leftValueRightResolverCompare')
+
+// ComparisonOperator(comparator function) -> operator function
+const ComparisonOperator = comparator => function operator(...args) {
+  const right = args.pop()
+  const left = args.pop()
+  const isLeftResolver = typeof left == 'function',
+    isRightResolver = typeof right == 'function'
+
+  if (isLeftResolver && isRightResolver) {
+    if (args.length == 0) {
+      return curryArgs4(
+        leftResolverRightResolverCompare, __, comparator, left, right,
+      )
+    }
+    if (areAnyValuesPromises(args)) {
+      return promiseAll(args).then(curry4(
+        leftResolverRightResolverCompare, __, comparator, left, right,
+      ))
+    }
+    return leftResolverRightResolverCompare(args, comparator, left, right)
+  }
+
+  if (isLeftResolver) {
+    if (args.length == 0) {
+      return curryArgs4(
+        leftResolverRightValueCompare, __, comparator, left, right,
+      )
+    }
+    if (areAnyValuesPromises(args)) {
+      return promiseAll(args).then(curry4(
+        leftResolverRightValueCompare, __, comparator, left, right,
+      ))
+    }
+    return leftResolverRightValueCompare(args, comparator, left, right)
+  }
+
+  if (isRightResolver) {
+    if (args.length == 0) {
+      return curryArgs4(
+        leftValueRightResolverCompare, __, comparator, left, right,
+      )
+    }
+    if (areAnyValuesPromises(args)) {
+      return promiseAll(args).then(curry4(
+        leftValueRightResolverCompare, __, comparator, left, right,
+      ))
+    }
+    return leftValueRightResolverCompare(args, comparator, left, right)
+  }
+
+  if (isPromise(left) || isPromise(right)) {
+    return promiseAll([left, right]).then(spread2(comparator))
+  }
+  return comparator(left, right)
+}
+
+
+module.exports = ComparisonOperator

package/_internal/File.js

@@ -0,0 +1,41 @@
+const fs = require('fs')
+
+/**
+ * @name File
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * new File(path string) -> File
+ * ```
+ */
+const File = function (path) {
+  this.path = path
+  this.writeStream = fs.createWriteStream(path)
+  return this
+}
+
+/**
+ * @name File.prototype.write
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * new File(...).write(str string) -> ()
+ * ```
+ */
+File.prototype.write = function (str) {
+  this.writeStream.write(str)
+}
+
+/**
+ * @name File.prototype.rm
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * new File(...).rm() -> Promise<>
+ * ```
+ */
+File.prototype.rm = async function () {
+  await fs.promises.rm(this.path)
+}
+
+module.exports = File

package/_internal/FlatMappingAsyncIterator.js

@@ -2,7 +2,7 @@ const isPromise = require('./isPromise')
 const genericReduce = require('./genericReduce')
 const symbolAsyncIterator = require('./symbolAsyncIterator')
 const arrayPush = require('./arrayPush')
-const curryArgs3 = require('./curryArgs3')
+const curry3 = require('./curry3')
 const __ = require('./placeholder')
 const promiseRace = require('./promiseRace')
 const sleep = require('./sleep')
@@ -55,12 +55,12 @@ const FlatMappingAsyncIterator = function (asyncIterator, flatMapper) {
           } else {
             const monad = flatMapper(value)
             if (isPromise(monad)) {
-              const bufferLoading = monad.then(
-              curryArgs3(genericReduce, __, arrayPush, buffer))
+              const bufferLoading =
+                monad.then(curry3(genericReduce, __, arrayPush, buffer))
               const promise = bufferLoading.then(() => promises.delete(promise))
               promises.add(promise)
             } else {
-              const bufferLoading = genericReduce([monad], arrayPush, buffer)
+              const bufferLoading = genericReduce(monad, arrayPush, buffer)
               if (isPromise(bufferLoading)) {
                 const promise = bufferLoading.then(() => promises.delete(promise))
                 promises.add(promise)

package/_internal/FlatMappingIterator.js

@@ -31,7 +31,7 @@ const FlatMappingIterator = function (iterator, flatMapper) {
         return iteration
       }
       const monadAsArray = genericReduce(
-        [flatMapper(iteration.value)],
+        flatMapper(iteration.value),
         arrayPush,
         []) // this will always have at least one item
       if (monadAsArray.length > 1) {

package/_internal/TimeInLoopSuite.js

@@ -0,0 +1,138 @@
+const timeInLoop = require('./timeInLoop')
+const timeInLoopAsync = require('./timeInLoopAsync')
+
+/**
+ * @name formatRunOutput
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * formatRunOutput(
+ *   description string,
+ *   loopCount number,
+ *   duration number
+ * ) -> formatted string
+ * ```
+ */
+const formatRunOutput = function (description, loopCount, duration) {
+  const formattedDuration = duration < 1e3
+    ? `${duration.toFixed(3)}ms`
+    : `${(duration / 1e3).toFixed(3)}s`
+  return `
+${description}: ${loopCount.toExponential()}: ${formattedDuration}
+  `.trim()
+}
+
+/**
+ * @name TimeInLoopSuite
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * new TimeInLoopSuite(options? {
+ *   loopCount?: number,
+ *   runs?: number,
+ *   async?: boolean,
+ * }) -> TimeInLoopSuite
+ * ```
+ */
+const TimeInLoopSuite = function (options = {}) {
+  this.loopCount = options.loopCount ?? 1e6
+  this.runs = options.runs ?? 5
+  this.isAsync = options.async ?? false
+  this.benchmarkCases = []
+  this.handlerMap = new Map()
+}
+
+
+/**
+ * @name TimeInLoopSuite.prototype.emit
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * new TimeInLoopSuite(...).emit(eventName string, event Object) -> ()
+ * ```
+ */
+TimeInLoopSuite.prototype.emit = function (eventName, event) {
+  const handlerMap = this.handlerMap
+  if (handlerMap.has(eventName)) {
+    handlerMap.get(eventName).forEach(handler => handler(event))
+  }
+}
+
+/**
+ * @name TimeInLoopSuite.prototype.on
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * new TimeInLoopSuite(...).on(eventName string, handler function) -> ()
+ * ```
+ */
+TimeInLoopSuite.prototype.on = function (eventName, handler) {
+  const handlerMap = this.handlerMap
+  if (handlerMap.has(eventName)) {
+    handlerMap.get(eventName).add(handler)
+  } else {
+    handlerMap.set(eventName, new Set([handler]))
+  }
+}
+
+/**
+ * @name TimeInLoopSuite.prototype.add
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * new TimeInLoopSuite(...).add(description string, func function) -> ()
+ * ```
+ */
+TimeInLoopSuite.prototype.add = function (description, func) {
+  const { loopCount, isAsync } = this
+  this.benchmarkCases.push({
+    description,
+    loopCount,
+    benchmark: isAsync
+      ? () => timeInLoopAsync(description, loopCount, func, { silent: true })
+      : () => timeInLoop(description, loopCount, func, { silent: true }),
+  })
+}
+
+/**
+ * @name TimeInLoopSuite.prototype.run
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * new TimeInLoopSuite(...).run() -> Promise<>
+ * ```
+ */
+TimeInLoopSuite.prototype.run = async function () {
+  const caseBestRuns = []
+  for (const { description, loopCount, benchmark } of this.benchmarkCases) {
+    const durations = []
+    let runCount = 0
+    while (runCount < this.runs) {
+      const { duration } = await benchmark()
+      durations.push(duration)
+      runCount += 1
+      this.emit('run', { description, duration, loopCount })
+    }
+
+    const caseBestDuration = Math.min(...durations)
+
+    const caseBestRun = {
+      description,
+      duration: caseBestDuration,
+      loopCount,
+      output: formatRunOutput(description, loopCount, caseBestDuration),
+    }
+
+    caseBestRuns.push(caseBestRun)
+
+    this.emit('caseBestRun', caseBestRun)
+  }
+
+  const suiteBestRun = caseBestRuns.reduce(
+    (suiteBest, run) => run.duration < suiteBest.duration ? run : suiteBest
+  )
+
+  this.emit('suiteBestRun', suiteBestRun)
+}
+
+module.exports = TimeInLoopSuite

package/_internal/areAnyValuesPromises.js

@@ -0,0 +1,23 @@
+const isPromise = require('./isPromise')
+
+/**
+ * @name areAnyValuesPromises
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * areAnyValuesPromises(values Array) -> boolean
+ * ```
+ */
+const areAnyValuesPromises = function (values) {
+  const length = values.length
+  let index = -1
+  while (++index < length) {
+    const value = values[index]
+    if (isPromise(value)) {
+      return true
+    }
+  }
+  return false
+}
+
+module.exports = areAnyValuesPromises

package/_internal/{arrayAll.js → arrayEvery.js}

@@ -5,14 +5,14 @@ const promiseAll = require('./promiseAll')
 const callPropUnary = require('./callPropUnary')
 
 /**
- * @name arrayAll
+ * @name arrayEvery
  *
  * @synopsis
  * ```coffeescript [specscript]
- * arrayAll(array Array, predicate ...any=>boolean) -> boolean
+ * arrayEvery(array Array, predicate ...any=>boolean) -> boolean
  * ```
  */
-const arrayAll = function (array, predicate) {
+const arrayEvery = function (array, predicate) {
   const arrayLength = array.length,
     promises = []
   let index = -1
@@ -29,4 +29,4 @@ const arrayAll = function (array, predicate) {
     : promiseAll(promises).then(curry3(callPropUnary, __, 'every', Boolean))
 }
 
-module.exports = arrayAll
+module.exports = arrayEvery

package/_internal/arrayExtend.js

@@ -1,4 +1,5 @@
-const isArrayLike = require('./isArrayLike')
+const isArray = require('./isArray')
+const isBinary = require('./isBinary')
 
 /**
  * @name _arrayExtend
@@ -30,7 +31,7 @@ const _arrayExtend = function (array, values) {
  * Extend an array with values.
  */
 const arrayExtend = function (array, values) {
-  if (isArrayLike(values)) {
+  if (isArray(values) || isBinary(values)) {
     return _arrayExtend(array, values)
   }
   array.push(values)

package/_internal/arrayFilter.js

@@ -26,12 +26,11 @@ const arrayFilter = function (array, predicate) {
     resultIndex = -1
   while (++index < arrayLength) {
     const item = array[index],
-      shouldIncludeItem = predicate(item)
+      shouldIncludeItem = predicate(item, index, array)
     if (isPromise(shouldIncludeItem)) {
       return promiseAll(
-        arrayExtendMap(
-          [shouldIncludeItem], array, predicate, index)).then(
-            curry4(arrayFilterByConditions, array, result, index - 1, __))
+        arrayExtendMap([shouldIncludeItem], array, predicate, index)
+      ).then(curry4(arrayFilterByConditions, array, result, index - 1, __))
     }
     if (shouldIncludeItem) {
       result[++resultIndex] = item

package/_internal/{arrayAny.js → arraySome.js}

@@ -3,11 +3,11 @@ const isPromise = require('./isPromise')
 const promiseRace = require('./promiseRace')
 
 /**
- * @name asyncArrayAny
+ * @name asyncArraySome
  *
  * @synopsis
  * ```coffeescript [specscript]
- * asyncArrayAny(
+ * asyncArraySome(
  *   array Array,
  *   predicate any=>Promise|boolean,
  *   index number,
@@ -15,7 +15,7 @@ const promiseRace = require('./promiseRace')
  * ) -> boolean
  * ```
  */
-const asyncArrayAny = async function (
+const asyncArraySome = async function (
   array, predicate, index, promisesInFlight,
 ) {
   const length = array.length
@@ -39,23 +39,23 @@ const asyncArrayAny = async function (
 }
 
 /**
- * @name arrayAny
+ * @name arraySome
  *
  * @synopsis
  * ```coffeescript [specscript]
- * arrayAny(
+ * arraySome(
  *   array Array,
  *   predicate any=>Promise|boolean,
  * ) -> boolean
  * ```
  */
-const arrayAny = function (array, predicate) {
+const arraySome = function (array, predicate) {
   const length = array.length
   let index = -1
   while (++index < length) {
     const predication = predicate(array[index])
     if (isPromise(predication)) {
-      return asyncArrayAny(
+      return asyncArraySome(
         array, predicate, index, new Set([SelfReferencingPromise(predication)]))
     }
     if (predication) {
@@ -65,4 +65,4 @@ const arrayAny = function (array, predicate) {
   return false
 }
 
-module.exports = arrayAny
+module.exports = arraySome

package/_internal/{asyncIteratorAll.js → asyncIteratorEvery.js}

@@ -3,7 +3,7 @@ const isPromise = require('./isPromise')
 const promiseRace = require('./promiseRace')
 
 /**
- * @name asyncIteratorAll
+ * @name asyncIteratorEvery
  *
  * @synopsis
  * var T any,
@@ -12,11 +12,11 @@ const promiseRace = require('./promiseRace')
  *   promisesInFlight Set<Promise<[T, Promise]>>,
  *   maxConcurrency number
  *
- * asyncIteratorAll(
+ * asyncIteratorEvery(
  *   asyncIterator, predicate, promisesInFlight, maxConcurrency,
  * ) -> Promise<boolean>
  */
-const asyncIteratorAll = async function (
+const asyncIteratorEvery = async function (
   asyncIterator, predicate, promisesInFlight, maxConcurrency = 20,
 ) {
   let iteration = await asyncIterator.next()
@@ -47,4 +47,4 @@ const asyncIteratorAll = async function (
   return true
 }
 
-module.exports = asyncIteratorAll
+module.exports = asyncIteratorEvery

package/_internal/{asyncIteratorAny.js → asyncIteratorSome.js}

@@ -3,11 +3,11 @@ const isPromise = require('./isPromise')
 const promiseRace = require('./promiseRace')
 
 /**
- * @name asyncIteratorAny
+ * @name asyncIteratorSome
  *
  * @synopsis
  * ```coffeescript [specscript]
- * asyncIteratorAny(
+ * asyncIteratorSome(
  *   iterator Iterator|AsyncIterator,
  *   predicate any=>Promise|boolean,
  *   index number,
@@ -16,7 +16,7 @@ const promiseRace = require('./promiseRace')
  * ) -> boolean
  * ```
  */
-const asyncIteratorAny = async function (
+const asyncIteratorSome = async function (
   iterator, predicate, promisesInFlight, maxConcurrency = 20,
 ) {
   let iteration = iterator.next()
@@ -53,4 +53,4 @@ const asyncIteratorAny = async function (
   return false
 }
 
-module.exports = asyncIteratorAny
+module.exports = asyncIteratorSome

package/_internal/curry4.test.js

@@ -0,0 +1,25 @@
+const assert = require('assert')
+const curry4 = require('./curry4')
+const __ = require('./placeholder')
+
+describe('curry4', () => {
+  const func = function (a, b, c, d) {
+    return [a, b, c, d]
+  }
+  it('resolves arguments in __ position for arg0', async () => {
+    const curried = curry4(func, __, 1, 2, 3)
+    assert.deepEqual(curried(4), [4, 1, 2, 3])
+  })
+  it('resolves arguments in __ position for arg1', async () => {
+    const curried = curry4(func, 1, __, 2, 3)
+    assert.deepEqual(curried(4), [1, 4, 2, 3])
+  })
+  it('resolves arguments in __ position for arg2', async () => {
+    const curried = curry4(func, 1, 2, __, 3)
+    assert.deepEqual(curried(4), [1, 2, 4, 3])
+  })
+  it('resolves arguments in __ position for arg3', async () => {
+    const curried = curry4(func, 1, 2, 3, __)
+    assert.deepEqual(curried(4), [1, 2, 3, 4])
+  })
+})

package/_internal/curry5.test.js

@@ -0,0 +1,29 @@
+const assert = require('assert')
+const curry5 = require('./curry5')
+const __ = require('./placeholder')
+
+describe('curry5', () => {
+  const func = function (a, b, c, d, e) {
+    return [a, b, c, d, e]
+  }
+  it('resolves arguments in __ position for arg0', async () => {
+    const curried = curry5(func, __, 1, 2, 3, 4)
+    assert.deepEqual(curried(5), [5, 1, 2, 3, 4])
+  })
+  it('resolves arguments in __ position for arg1', async () => {
+    const curried = curry5(func, 1, __, 2, 3, 4)
+    assert.deepEqual(curried(5), [1, 5, 2, 3, 4])
+  })
+  it('resolves arguments in __ position for arg2', async () => {
+    const curried = curry5(func, 1, 2, __, 3, 4)
+    assert.deepEqual(curried(5), [1, 2, 5, 3, 4])
+  })
+  it('resolves arguments in __ position for arg3', async () => {
+    const curried = curry5(func, 1, 2, 3, __, 4)
+    assert.deepEqual(curried(5), [1, 2, 3, 5, 4])
+  })
+  it('resolves arguments in __ position for arg4', async () => {
+    const curried = curry5(func, 1, 2, 3, 4, __)
+    assert.deepEqual(curried(5), [1, 2, 3, 4, 5])
+  })
+})