rubico 1.9.7 → 2.0.0

package/_internal/functionObjectAll.js

@@ -0,0 +1,32 @@
+const always = require('./always')
+const isPromise = require('./isPromise')
+const promiseAll = require('./promiseAll')
+const __ = require('./placeholder')
+const curry3 = require('./curry3')
+const objectSet = require('./objectSet')
+
+/**
+ * @name functionObjectAll
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * functionObjectAll(funcs Array<function>, args Array) -> Promise|Object
+ * ```
+ *
+ * @description
+ * Concurrently execute the same arguments for each function of an object of functions, returning an object of results.
+ */
+const functionObjectAll = function (funcs, args) {
+  const result = {}, promises = []
+  for (const key in funcs) {
+    const resultItem = funcs[key](...args)
+    if (isPromise(resultItem)) {
+      promises.push(resultItem.then(curry3(objectSet, result, key, __)))
+    } else {
+      result[key] = resultItem
+    }
+  }
+  return promises.length == 0 ? result : promiseAll(promises).then(always(result))
+}
+
+module.exports = functionObjectAll

package/_internal/genericReduce.js

@@ -12,8 +12,6 @@ const curryArgs3 = require('./curryArgs3')
 const arrayReduce = require('./arrayReduce')
 const objectReduce = require('./objectReduce')
 const mapReduce = require('./mapReduce')
-const generatorFunctionReduce = require('./generatorFunctionReduce')
-const asyncGeneratorFunctionReduce = require('./asyncGeneratorFunctionReduce')
 const reducerConcat = require('./reducerConcat')
 
 /**
@@ -25,7 +23,7 @@ const reducerConcat = require('./reducerConcat')
  *   |{ reduce: (any, T)=>any }|Object<T>
  *
  * genericReduce<T>(
- *   args [collection Foldable<T>, ...any],
+ *   collection Foldable<T>,
  *   reducer (any, T)=>any,
  *   result any?,
  * ) -> result
@@ -33,33 +31,17 @@ const reducerConcat = require('./reducerConcat')
  *
  * @related genericReduceConcurrent
  *
- * @TODO genericReduceSync(args, reducer, init) - performance optimization for some of these genericReduces that we know are synchronous
+ * @TODO genericReduceSync(collection, reducer, init) - performance optimization for some of these genericReduces that we know are synchronous
  *
- * @TODO genericReducePool(poolSize, args, reducer, init) - for some of these genericReduces that we want to race - result should not care about order of concatenations
+ * @TODO genericReducePool(poolSize, collection, reducer, init) - for some of these genericReduces that we want to race - result should not care about order of concatenations
  * reduce.pool
  * transform.pool
  * flatMap.pool
  */
-const genericReduce = function (args, reducer, result) {
-  const collection = args[0]
+const genericReduce = function (collection, reducer, result) {
   if (isArray(collection)) {
     return arrayReduce(collection, reducer, result)
   }
-  if (typeof collection == 'function') {
-    if (isGeneratorFunction(collection)) {
-      return generatorFunctionReduce(collection, reducer, result)
-    }
-    if (isAsyncGeneratorFunction(collection)) {
-      return asyncGeneratorFunctionReduce(collection, reducer, result)
-    }
-    return curryArgs3(
-      genericReduce,
-      __,
-      args.length == 1
-        ? reducerConcat(reducer, collection)
-        : args.reduce(reducerConcat, reducer),
-      result)
-  }
   if (collection == null) {
     return result === undefined
       ? curry2(reducer, collection, __)

package/_internal/genericTransform.js

@@ -24,7 +24,7 @@ const callConcat = require('./callConcat')
  * Reducer = (any, any)=>Promise|any
  *
  * identityTransform<
- *   args Array,
+ *   collection any,
  *   transducer Reducer=>Reducer,
  *   result undefined|null,
  * >(args, transducer, result) -> Promise|result
@@ -33,8 +33,8 @@ const callConcat = require('./callConcat')
  * @description
  * Reduce a value, always returning the initial result
  */
-const identityTransform = function (args, transducer, result) {
-  const nil = genericReduce(args, transducer(noop), null)
+const identityTransform = function (collection, transducer, result) {
+  const nil = genericReduce(collection, transducer(noop), null)
   return isPromise(nil) ? nil.then(always(result)) : result
 }
 
@@ -48,44 +48,44 @@ const identityTransform = function (args, transducer, result) {
  *   |{ concat: function }|{ write: function }|Object
  *
  * genericTransform<
- *   args ...any,
+ *   collection any,
  *   transducer Reducer=>Reducer,
  *   result Semigroup|any,
- * >(args, transducer, result) -> result
+ * >(collection, transducer, result) -> result
  * ```
  */
-const genericTransform = function (args, transducer, result) {
+const genericTransform = function (collection, transducer, result) {
   if (isArray(result)) {
-    return genericReduce(args, transducer(arrayExtend), result)
+    return genericReduce(collection, transducer(arrayExtend), result)
   }
   if (isBinary(result)) {
-    const intermediateArray = genericReduce(args, transducer(arrayExtend), [])
+    const intermediateArray = genericReduce(collection, transducer(arrayExtend), [])
     return isPromise(intermediateArray)
       ? intermediateArray.then(curry2(binaryExtend, result, __))
       : binaryExtend(result, intermediateArray)
   }
   if (result == null) {
-    return identityTransform(args, transducer, result)
+    return identityTransform(collection, transducer, result)
   }
 
   const resultConstructor = result.constructor
   if (typeof result == 'string' || resultConstructor == String) {
     // TODO: use array + join over adding
-    return genericReduce(args, transducer(add), result)
+    return genericReduce(collection, transducer(add), result)
   }
   if (typeof result.concat == 'function') {
-    return genericReduce(args, transducer(callConcat), result)
+    return genericReduce(collection, transducer(callConcat), result)
   }
   if (typeof result.write == 'function') {
-    return genericReduce(args, transducer(streamExtend), result)
+    return genericReduce(collection, transducer(streamExtend), result)
   }
   if (resultConstructor == Set) {
-    return genericReduce(args, transducer(setExtend), result)
+    return genericReduce(collection, transducer(setExtend), result)
   }
   if (resultConstructor == Object) {
-    return genericReduce(args, transducer(objectAssign), result)
+    return genericReduce(collection, transducer(objectAssign), result)
   }
-  return identityTransform(args, transducer, result)
+  return identityTransform(collection, transducer, result)
 }
 
 module.exports = genericTransform

package/_internal/improvedGenericTransform.js

@@ -0,0 +1,93 @@
+const isPromise = require('./isPromise')
+const isArray = require('./isArray')
+const isBinary = require('./isBinary')
+const callPropUnary = require('./callPropUnary')
+const __ = require('./placeholder')
+const curry2 = require('./curry2')
+const curry3 = require('./curry3')
+const always = require('./always')
+const noop = require('./noop')
+const add = require('./add')
+const genericReduce = require('./genericReduce')
+const objectAssign = require('./objectAssign')
+const arrayExtend = require('./arrayExtend')
+const binaryExtend = require('./binaryExtend')
+const streamExtend = require('./streamExtend')
+const setExtend = require('./setExtend')
+const callConcat = require('./callConcat')
+
+/**
+ * @name identityTransform
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * Reducer = (any, any)=>Promise|any
+ *
+ * identityTransform<
+ *   collection any,
+ *   transducer Reducer=>Reducer,
+ *   accum undefined|null,
+ * >(args, transducer, accum) -> Promise|accum
+ * ```
+ *
+ * @description
+ * Reduce a value, always returning the initial accum
+ */
+const identityTransform = function (collection, transducer, accum) {
+  const nil = genericReduce(collection, transducer(noop), null)
+  return isPromise(nil) ? nil.then(always(accum)) : accum
+}
+
+/**
+ * @name genericTransform
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * Reducer = (any, any)=>Promise|any
+ * Semigroup = Array|string|Set|TypedArray
+ *   |{ concat: function }|{ write: function }|Object
+ *
+ * genericTransform<
+ *   collection any,
+ *   transducer Reducer=>Reducer,
+ *   accum Semigroup|any,
+ * >(collection, transducer, accum) -> accum
+ * ```
+ */
+const genericTransform = function (collection, transducer, accum) {
+  if (isArray(accum)) {
+    return genericReduce(collection, transducer(arrayExtend), accum)
+  }
+  if (isBinary(accum)) {
+    const intermediateArray = genericReduce(collection, transducer(arrayExtend), [])
+    return isPromise(intermediateArray)
+      ? intermediateArray.then(curry2(binaryExtend, accum, __))
+      : binaryExtend(accum, intermediateArray)
+  }
+  if (accum == null) {
+    return identityTransform(collection, transducer, accum)
+  }
+
+  const constructor = accum.constructor
+  if (typeof accum == 'string' || constructor == String) {
+    const result = genericReduce(collection, transducer(arrayExtend), [accum])
+    return isPromise(result)
+      ? result.then(curry3(callPropUnary, __, 'join', ''))
+      : result.join('')
+  }
+  if (typeof accum.concat == 'function') {
+    return genericReduce(collection, transducer(callConcat), accum)
+  }
+  if (typeof accum.write == 'function') {
+    return genericReduce(collection, transducer(streamExtend), accum)
+  }
+  if (constructor == Set) {
+    return genericReduce(collection, transducer(setExtend), accum)
+  }
+  if (constructor == Object) {
+    return genericReduce(collection, transducer(objectAssign), accum)
+  }
+  return identityTransform(collection, transducer, accum)
+}
+
+module.exports = genericTransform

package/_internal/{iteratorAll.js → iteratorEvery.js}

@@ -5,16 +5,16 @@ const curry3 = require('./curry3')
 const callPropUnary = require('./callPropUnary')
 
 /**
- * @name iteratorAll
+ * @name iteratorEvery
  *
  * @synopsis
  * ```coffeescript [specscript]
- * iteratorAll(iterator Iterator, predicate ...any=>boolean) -> boolean
+ * iteratorEvery(iterator Iterator, predicate ...any=>boolean) -> boolean
  * ```
  *
  * @TODO use .next() calls
  */
-const iteratorAll = function (iterator, predicate) {
+const iteratorEvery = function (iterator, predicate) {
   const promises = []
   for (const item of iterator) {
     const predication = predicate(item)
@@ -29,4 +29,4 @@ const iteratorAll = function (iterator, predicate) {
     : promiseAll(promises).then(curry3(callPropUnary, __, 'every', Boolean))
 }
 
-module.exports = iteratorAll
+module.exports = iteratorEvery

package/_internal/{iteratorAny.js → iteratorSome.js}

@@ -1,23 +1,23 @@
 const SelfReferencingPromise = require('./SelfReferencingPromise')
-const asyncIteratorAny = require('./asyncIteratorAny')
+const asyncIteratorSome = require('./asyncIteratorSome')
 const isPromise = require('./isPromise')
 
 /**
- * @name iteratorAny
+ * @name iteratorSome
  *
  * @synopsis
  * ```coffeescript [specscript]
- * iteratorAny(
+ * iteratorSome(
  *   iterator Iterator,
  *   predicate any=>Promise|boolean,
  * ) -> boolean
  * ```
  */
-const iteratorAny = function (iterator, predicate) {
+const iteratorSome = function (iterator, predicate) {
   for (const item of iterator) {
     const predication = predicate(item)
     if (isPromise(predication)) {
-      return asyncIteratorAny(
+      return asyncIteratorSome(
         iterator, predicate, new Set([SelfReferencingPromise(predication)]))
     }
     if (predication) {
@@ -27,4 +27,4 @@ const iteratorAny = function (iterator, predicate) {
   return false
 }
 
-module.exports = iteratorAny
+module.exports = iteratorSome

package/_internal/leftResolverRightResolverCompare.js

@@ -0,0 +1,19 @@
+const spread2 = require('./spread2')
+const isPromise = require('./isPromise')
+const promiseAll = require('./promiseAll')
+
+// leftResolverRightResolverCompare(
+//   args Array, comparator function, left function, right function,
+// ) -> Promise|boolean
+const leftResolverRightResolverCompare = function (
+  args, comparator, left, right,
+) {
+  const leftResult = left(...args),
+    rightResult = right(...args)
+  if (isPromise(leftResult) || isPromise(rightResult)) {
+    return promiseAll([leftResult, rightResult]).then(spread2(comparator))
+  }
+  return comparator(leftResult, rightResult)
+}
+
+module.exports = leftResolverRightResolverCompare

package/_internal/leftResolverRightValueCompare.js

@@ -0,0 +1,16 @@
+const spread2 = require('./spread2')
+const isPromise = require('./isPromise')
+const promiseAll = require('./promiseAll')
+
+// leftResolverRightValueCompare(
+//   args Array, comparator function, left function, right any
+// ) -> Promise|boolean
+const leftResolverRightValueCompare = function (args, comparator, left, right) {
+  const leftResult = left(...args)
+  if (isPromise(leftResult) || isPromise(right)) {
+    return promiseAll([leftResult, right]).then(spread2(comparator))
+  }
+  return comparator(leftResult, right)
+}
+
+module.exports = leftResolverRightValueCompare

package/_internal/leftValueRightResolverCompare.js

@@ -0,0 +1,16 @@
+const spread2 = require('./spread2')
+const isPromise = require('./isPromise')
+const promiseAll = require('./promiseAll')
+
+// leftValueRightResolverCompare(
+//   args Array, comparator function, left any, right any,
+// ) -> Promise|boolean
+const leftValueRightResolverCompare = function (args, comparator, left, right) {
+  const rightResult = right(...args)
+  if (isPromise(left) || isPromise(rightResult)) {
+    return promiseAll([left, rightResult]).then(spread2(comparator))
+  }
+  return comparator(left, rightResult)
+}
+
+module.exports = leftValueRightResolverCompare

package/_internal/objectReduce.js

@@ -2,7 +2,6 @@ const isPromise = require('./isPromise')
 const __ = require('./placeholder')
 const curry5 = require('./curry5')
 const objectKeys = require('./objectKeys')
-const objectGetFirstKey = require('./objectGetFirstKey')
 
 /**
  * @name objectReduceAsync

package/_internal/pathResolve.js

@@ -0,0 +1,6 @@
+const path = require('path')
+
+// pathResolve(...args) -> resolvedPath string
+const pathResolve = (...args) => path.resolve(...args)
+
+module.exports = pathResolve

package/_internal/{reducerAll.js → reducerEvery.js}

@@ -4,20 +4,20 @@ const curry3 = require('./curry3')
 const reducerAllSync = require('./reducerAllSync')
 
 /**
- * @name reducerAll
+ * @name reducerEvery
  *
  * @synopsis
  * ```coffeescript [specscript]
- * reducerAll(
+ * reducerEvery(
  *   predicate any=>boolean,
  * ) -> reducer(result boolean, item any)=>boolean
  * ```
  */
-const reducerAll = predicate => function allReducer(result, item) {
+const reducerEvery = predicate => function allReducer(result, item) {
   return result === false ? false
     : isPromise(result) ? result.then(
       curry3(reducerAllSync, predicate, __, item))
     : result ? predicate(item) : false
 }
 
-module.exports = reducerAll
+module.exports = reducerEvery

package/_internal/reducerFlatMap.js

@@ -1,7 +1,7 @@
-const curryArgs3 = require('./curryArgs3')
-const genericReduce = require('./genericReduce')
+const curry3 = require('./curry3')
 const __ = require('./placeholder')
 const isPromise = require('./isPromise')
+const genericReduce = require('./genericReduce')
 
 /**
  * @name reducerFlatMap
@@ -26,8 +26,8 @@ const reducerFlatMap = (
 ) => function flatMappingReducer(result, value) {
   const monad = flatMapper(value)
   return isPromise(monad)
-    ? monad.then(curryArgs3(genericReduce, __, reducer, result))
-    : genericReduce([monad], reducer, result)
+    ? monad.then(curry3(genericReduce, __, reducer, result))
+    : genericReduce(monad, reducer, result)
 }
 
 module.exports = reducerFlatMap

package/_internal/reducerFlatten.js

@@ -26,7 +26,7 @@ const genericReduce = require('./genericReduce')
 const reducerFlatten = reducer => function flatteningReducer(
   result, reducerItem,
 ) {
-  return genericReduce([reducerItem], reducer, result)
+  return genericReduce(reducerItem, reducer, result)
 }
 
 module.exports = reducerFlatten

package/_internal/{reducerAny.js → reducerSome.js}

@@ -4,11 +4,11 @@ const __ = require('./placeholder')
 const isPromise = require('./isPromise')
 
 /**
- * @name reducerAny
+ * @name reducerSome
  *
  * @synopsis
  * ```coffeescript [specscript]
- * reducerAny(
+ * reducerSome(
  *   predicate any=>boolean,
  * ) -> anyReducer (result boolean, item any)=>boolean
  * ```
@@ -17,10 +17,10 @@ const isPromise = require('./isPromise')
  *
  * @TODO throw to break early?
  */
-const reducerAny = predicate => function anyReducer(result, item) {
+const reducerSome = predicate => function anyReducer(result, item) {
   return result === true ? result
     : isPromise(result) ? result.then(curry2(reducerAnySync(predicate), __, item))
     : result ? true : predicate(item)
 }
 
-module.exports = reducerAny
+module.exports = reducerSome

package/_internal/timeInLoop.js

@@ -0,0 +1,37 @@
+/**
+ * @name timeInLoop
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * timeInLoop(description string, loopCount number, fn function, options? {
+ *   silent?: boolean,
+ * }) -> undefined
+ * ```
+ *
+ * @description
+ * Logs the amount of time required for a function to run a certain number of times
+ *
+ * ```js
+ * timeInLoop('hello', 1e6, () => 'hello') // hello: 1e+6: 3.474ms
+ * ```
+ *
+ * Reference: https://gist.github.com/funfunction/91b5876a5f562e1e352aed0fcabc3858
+ */
+const timeInLoop = (description, loopCount, fn, options = {}) => {
+  const d = `${description}: ${loopCount.toExponential()}`
+  const start = performance.now()
+  for (let i = 0; i < loopCount; i++) {
+    fn()
+  }
+  const end = performance.now()
+  const duration = end - start
+
+  if (options.silent) {
+    return { description, loopCount, duration }
+  }
+
+  console.log(`${d}: ${duration}`)
+  return { description, loopCount, duration }
+}
+
+module.exports = timeInLoop

package/_internal/timeInLoop.test.js

@@ -0,0 +1,18 @@
+const assert = require('assert')
+const timeInLoop = require('./timeInLoop')
+
+describe('timeInLoop', () => {
+  it('times a function in a loop', async () => {
+    const result = timeInLoop('hey', 1e5, () => 'hey')
+    assert.equal(result.description, 'hey')
+    assert.equal(result.loopCount, 1e5)
+    assert.equal(typeof result.duration, 'number')
+  })
+
+  it('can be silent', async () => {
+    const result = timeInLoop('hey', 1e5, () => 'hey', { silent: true })
+    assert.equal(result.description, 'hey')
+    assert.equal(result.loopCount, 1e5)
+    assert.equal(typeof result.duration, 'number')
+  })
+})

package/_internal/timeInLoopAsync.js

@@ -0,0 +1,35 @@
+/**
+ * @name timeInLoopAsync
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * timeInLoop.async(description string, loopCount number, fn function, options? {
+ *   silent?: boolean,
+ * }) -> undefined
+ * ```
+ *
+ * @description
+ * Like timeInLoop, but every call is awaited
+ *
+ * ```js
+ * timeInLoop.async('async hello', 1e6, async () => 'hello') // async hello: 1e+6: 116.006ms
+ * ```
+ */
+const timeInLoopAsync = async (description, loopCount, fn, options = {}) => {
+  const d = `${description}: ${loopCount.toExponential()}`
+  const start = performance.now()
+  for (let i = 0; i < loopCount; i++) {
+    await fn()
+  }
+  const end = performance.now()
+  const duration = end - start
+
+  if (options.silent) {
+    return { description, loopCount, duration }
+  }
+
+  console.log(`${d}: ${duration}`)
+  return { description, loopCount, duration }
+}
+
+module.exports = timeInLoopAsync

package/_internal/timeInLoopAsync.test.js

@@ -0,0 +1,22 @@
+const assert = require('assert')
+const timeInLoopAsync = require('./timeInLoopAsync')
+
+describe('timeInLoopAsync', () => {
+  it('times an async function in a loop', async () => {
+    const p = timeInLoopAsync('asyncHey', 1e5, async () => 'asyncHey')
+    assert(p instanceof Promise)
+    const result = await p
+    assert.equal(result.description, 'asyncHey')
+    assert.equal(result.loopCount, 1e5)
+    assert.equal(typeof result.duration, 'number')
+  })
+
+  it('can be silent', async () => {
+    const p = timeInLoopAsync('asyncHey', 1e5, async () => 'asyncHey', { silent: true })
+    assert(p instanceof Promise)
+    const result = await p
+    assert.equal(result.description, 'asyncHey')
+    assert.equal(result.loopCount, 1e5)
+    assert.equal(typeof result.duration, 'number')
+  })
+})