rubico 1.9.7 → 2.0.1

package/_internal/curryArgs2.js

@@ -0,0 +1,43 @@
+const __ = require('./placeholder')
+
+// argument resolver for curryArgs2
+const curryArgs2ResolveArgs0 = (
+  baseFunc, arg1, arg2,
+) => function args0Resolver(...args) {
+  return baseFunc(args, arg1)
+}
+
+// argument resolver for curryArgs2
+const curryArgs2ResolveArgs1 = (
+  baseFunc, arg0, arg2,
+) => function arg1Resolver(...args) {
+  return baseFunc(arg0, args)
+}
+
+/**
+ * @name curryArgs2
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * type __ = Symbol('placeholder')
+ *
+ * curryArgs2(
+ *   baseFunc function,
+ *   arg0 __|any,
+ *   arg1 __|any,
+ * ) -> function
+ * ```
+ *
+ * @description
+ * Curry arguments for a 2-ary function. Arguments are supplied in placeholder position as an array.
+ *
+ * Note: at least one argument must be the placeholder
+ */
+const curryArgs2 = function (baseFunc, arg0, arg1) {
+  if (arg0 == __) {
+    return curryArgs2ResolveArgs0(baseFunc, arg1)
+  }
+  return curryArgs2ResolveArgs1(baseFunc, arg0)
+}
+
+module.exports = curryArgs2

package/_internal/curryArgs3.test.js

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

package/_internal/curryArgs4.js

@@ -0,0 +1,65 @@
+const __ = require('./placeholder')
+
+// argument resolver for curryArgs4
+const curryArgs4ResolveArgs0 = (
+  baseFunc, arg1, arg2, arg3,
+) => function args0Resolver(...args) {
+  return baseFunc(args, arg1, arg2, arg3)
+}
+
+// argument resolver for curryArgs4
+const curryArgs4ResolveArgs1 = (
+  baseFunc, arg0, arg2, arg3,
+) => function args1Resolver(...args) {
+  return baseFunc(arg0, args, arg2, arg3)
+}
+
+// argument resolver for curryArgs4
+const curryArgs4ResolveArgs2 = (
+  baseFunc, arg0, arg1, arg3,
+) => function args2Resolver(...args) {
+  return baseFunc(arg0, arg1, args, arg3)
+}
+
+// argument resolver for curryArgs4
+const curryArgs4ResolveArgs3 = (
+  baseFunc, arg0, arg1, arg2,
+) => function args3Resolver(...args) {
+  return baseFunc(arg0, arg1, arg2, args)
+}
+
+/**
+ * @name curryArgs4
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * __ = Symbol('placeholder')
+ *
+ * curryArgs4(
+ *   baseFunc function,
+ *   arg0 __|any,
+ *   arg1 __|any,
+ *   arg2 __|any
+ *   arg3 __|any,
+ * ) -> function
+ * ```
+ *
+ * @description
+ * Curry arguments for a 4-ary function. Arguments are supplied in placeholder position as an array.
+ *
+ * Note: at least one argument must be the placeholder
+ */
+const curryArgs4 = function (baseFunc, arg0, arg1, arg2, arg3) {
+  if (arg0 == __) {
+    return curryArgs4ResolveArgs0(baseFunc, arg1, arg2, arg3)
+  }
+  if (arg1 == __) {
+    return curryArgs4ResolveArgs1(baseFunc, arg0, arg2, arg3)
+  }
+  if (arg2 == __) {
+    return curryArgs4ResolveArgs2(baseFunc, arg0, arg1, arg3)
+  }
+  return curryArgs4ResolveArgs3(baseFunc, arg0, arg1, arg2)
+}
+
+module.exports = curryArgs4

package/_internal/curryArgs4.test.js

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

package/_internal/equals.js

@@ -0,0 +1,13 @@
+/**
+ * @name equals
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * equals(left any, right any) -> boolean
+ * ```
+ */
+const equals = function (left, right) {
+  return left == right
+}
+
+module.exports = equals

package/_internal/findAllFilePaths.js

@@ -0,0 +1,22 @@
+const fs = require('fs')
+const pathResolve = require('./pathResolve')
+
+// findAllFilePaths(path string) -> filePaths Promise<Array<string>>
+const findAllFilePaths = async function (path) {
+  const files = await fs.promises.readdir(path, {
+    withFileTypes: true,
+    recursive: true,
+  })
+  const result = []
+  for (const file of files) {
+    if (file.isDirectory()) {
+      const filePaths = await findAllFilePaths(pathResolve(path, file.name))
+      result.push(...filePaths)
+    } else {
+      result.push(pathResolve(path, file.name))
+    }
+  }
+  return result
+}
+
+module.exports = findAllFilePaths

package/_internal/funcApply.js

@@ -13,3 +13,5 @@
  * Apply arguments to a function.
  */
 const funcApply = (func, args) => func(...args)
+
+module.exports = funcApply

package/_internal/funcCall.js

@@ -0,0 +1,14 @@
+/**
+ * @name funcCall
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * funcCall(func function, context Object, ...args) -> any
+ * ```
+ *
+ * @description
+ * Apply arguments to a function.
+ */
+const funcCall = (func, context, ...args) => func.call(context, ...args)
+
+module.exports = funcCall

package/_internal/functionArrayAll.js

@@ -0,0 +1,26 @@
+const isPromise = require('./isPromise')
+const promiseAll = require('./promiseAll')
+
+/**
+ * @name functionArrayAll
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * functionArrayAll(funcs Array<function>, args Array) -> Promise|Array
+ * ```
+ */
+const functionArrayAll = function (funcs, args) {
+  const funcsLength = funcs.length,
+    result = Array(funcsLength)
+  let funcsIndex = -1, isAsync = false
+  while (++funcsIndex < funcsLength) {
+    const resultItem = funcs[funcsIndex](...args)
+    if (isPromise(resultItem)) {
+      isAsync = true
+    }
+    result[funcsIndex] = resultItem
+  }
+  return isAsync ? promiseAll(result) : result
+}
+
+module.exports = functionArrayAll

package/_internal/functionArrayAllSeries.js

@@ -0,0 +1,55 @@
+const funcConcat = require('./funcConcat')
+const isPromise = require('./isPromise')
+const __ = require('./placeholder')
+const curry3 = require('./curry3')
+const curry4 = require('./curry4')
+const objectSet = require('./objectSet')
+
+/**
+ * @name asyncFunctionArrayAllSeries
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * asyncFunctionArrayAllSeries(
+ *   funcs Array<function>,
+ *   args Array,
+ *   result Array,
+ *   funcsIndex number
+ * ) -> Promise|Array
+ * ```
+ *
+ * @TODO benchmark vs regular promise handling
+ */
+const asyncFunctionArrayAllSeries = async function (funcs, args, result, funcsIndex) {
+  const funcsLength = funcs.length
+  while (++funcsIndex < funcsLength) {
+    const resultItem = funcs[funcsIndex](...args)
+    result[funcsIndex] = isPromise(resultItem) ? await resultItem : resultItem
+  }
+  return result
+}
+
+/**
+ * @name functionArrayAllSeries
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * functionArrayAllSeries(funcs Array<function>, args Array) -> Promise|Array
+ * ```
+ */
+const functionArrayAllSeries = function (funcs, args) {
+  const funcsLength = funcs.length, result = []
+  let funcsIndex = -1
+  while (++funcsIndex < funcsLength) {
+    const resultItem = funcs[funcsIndex](...args)
+    if (isPromise(resultItem)) {
+      return resultItem.then(funcConcat(
+        curry3(objectSet, result, funcsIndex, __),
+        curry4(asyncFunctionArrayAllSeries, funcs, args, __, funcsIndex)))
+    }
+    result[funcsIndex] = resultItem
+  }
+  return result
+}
+
+module.exports = functionArrayAllSeries

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