rubico 1.9.7 → 2.0.0

package/all.js

@@ -1,72 +1,138 @@
+const areAnyValuesPromises = require('./_internal/areAnyValuesPromises')
+const promiseAll = require('./_internal/promiseAll')
 const isArray = require('./_internal/isArray')
-const arrayAll = require('./_internal/arrayAll')
-const iteratorAll = require('./_internal/iteratorAll')
-const asyncIteratorAll = require('./_internal/asyncIteratorAll')
-const objectValues = require('./_internal/objectValues')
-const reducerAll = require('./_internal/reducerAll')
-const symbolIterator = require('./_internal/symbolIterator')
-const symbolAsyncIterator = require('./_internal/symbolAsyncIterator')
+const __ = require('./_internal/placeholder')
+const curry2 = require('./_internal/curry2')
+const curryArgs2 = require('./_internal/curryArgs2')
+const functionArrayAll = require('./_internal/functionArrayAll')
+const functionArrayAllSeries = require('./_internal/functionArrayAllSeries')
+const functionObjectAll = require('./_internal/functionObjectAll')
 
 /**
  * @name all
  *
  * @synopsis
  * ```coffeescript [specscript]
- * type Foldable = Iterable|AsyncIterable|Object
+ * all(...args, funcsArray Array<function>) -> result Promise|Array
  *
- * all(predicate function)(collection Foldable) -> result Promise|boolean
+ * all(funcsArray Array<function>)(...args) -> result Promise|Array
+ *
+ * all(...args, funcsObject Object<function>) -> result Promise|Object
+ *
+ * all(funcsObject Object<function>)(...args) -> result Promise|Object
  * ```
  *
  * @description
- * Test a predicate concurrently across all items of a collection, returning true if all predications are truthy.
+ * Function executor and composer. Accepts either an array of functions or an object of functions as the values. Calls each function of the provided array or object in parallel with the provided arguments. Returns either an array or object of the results of the function executions.
  *
  * ```javascript [playground]
- * const isOdd = number => number % 2 == 1
+ * const createArrayOfGreetingsFor = all([
+ *   name => `Hi ${name}`,
+ *   name => `Hey ${name}`,
+ *   name => `Hello ${name}`,
+ * ])
+ *
+ * const arrayOfGreetingsForFred = createArrayOfGreetingsFor('Fred')
+ *
+ * console.log(arrayOfGreetingsForFred)
+ * // ['Hi Fred', 'Hey Fred', 'Hello Fred']
  *
- * console.log(
- *   all(isOdd)([1, 2, 3, 4, 5]),
- * ) // false
+ * const createObjectOfGreetingsFor = all({
+ *   hi: name => `Hi ${name}`,
+ *   hey: name => `Hey ${name}`,
+ *   hello: name => `Hello ${name}`,
+ * })
  *
- * console.log(
- *   all(isOdd)([1, 3, 5]),
- * ) // true
+ * const objectOfGreetingsForJane = createObjectOfGreetingsFor('Jane')
+ *
+ * console.log(objectOfGreetingsForJane)
+ * // { hi: 'Hi Jane', hey: 'Hey Jane', hello: 'Hello Jane' }
  * ```
  *
- * The collection can be any iterable, async iterable, or object values iterable collection. Below is an example of `all` accepting an async generator as the collection.
+ * `all` can simultaneously compose objects and handle promises.
  *
  * ```javascript [playground]
- * const asyncNumbers = async function* () {
- *   yield 1; yield 2; yield 3; yield 4; yield 5
- * }
+ * const identity = value => value
+ *
+ * const userbase = new Map()
+ * userbase.set('1', { _id: 1, name: 'George' })
+ *
+ * const getUserByID = async id => userbase.get(id)
+ *
+ * const getAndLogUserById = pipe([
+ *   all({
+ *     id: identity,
+ *     user: getUserByID,
+ *   }),
+ *   tap(({ id, user }) => {
+ *     console.log(`Got user ${JSON.stringify(user)} by id ${id}`)
+ *   }),
+ * ])
  *
- * all(async number => number < 6)(asyncNumbers()).then(console.log) // true
+ * getAndLogUserById('1') // Got user {"_id":1,"name":"George"} by id 1
  * ```
  *
  * @execution concurrent
- *
- * @muxing
  */
-const all = predicate => function allTruthy(value) {
-  if (isArray(value)) {
-    return arrayAll(value, predicate)
-  }
-  if (value == null) {
-    return predicate(value)
-  }
 
-  if (typeof value[symbolIterator] == 'function') {
-    return iteratorAll(value[symbolIterator](), predicate)
+const all = function (...args) {
+  const funcs = args.pop()
+  if (args.length == 0) {
+    return isArray(funcs)
+      ? curryArgs2(functionArrayAll, funcs, __)
+      : curryArgs2(functionObjectAll, funcs, __)
   }
-  if (typeof value[symbolAsyncIterator] == 'function') {
-    return asyncIteratorAll(value[symbolAsyncIterator](), predicate, new Set())
+
+  if (areAnyValuesPromises(args)) {
+    return isArray(funcs)
+      ? promiseAll(args).then(curry2(functionArrayAll, funcs, __))
+      : promiseAll(args).then(curry2(functionObjectAll, funcs, __))
   }
-  if (typeof value.reduce == 'function') {
-    return value.reduce(reducerAll(predicate), true)
+
+  return isArray(funcs)
+    ? functionArrayAll(funcs, args)
+    : functionObjectAll(funcs, args)
+}
+
+/**
+ * @name all.series
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * all.series(...args, funcsArray Array<function>) -> result Promise|Array
+ *
+ * all.series(funcsArray Array<function>)(...args) -> result Promise|Array
+ * ```
+ *
+ * @description
+ * `all` with serial execution.
+ *
+ * ```javascript [playground]
+ * const sleep = ms => () => new Promise(resolve => setTimeout(resolve, ms))
+ *
+ * all.series([
+ *   greeting => console.log(greeting + ' world'),
+ *   sleep(1000),
+ *   greeting => console.log(greeting + ' mom'),
+ *   sleep(1000),
+ *   greeting => console.log(greeting + ' goodbye'),
+ * ])('hello') // hello world
+ *             // hello mom
+ *             // hello goodbye
+ * ```
+ *
+ * @execution series
+ */
+
+all.series = function allSeries(...args) {
+  const funcs = args.pop()
+  if (args.length == 0) {
+    return curryArgs2(functionArrayAllSeries, funcs, __)
   }
-  if (value.constructor == Object) {
-    return arrayAll(objectValues(value), predicate)
+  if (areAnyValuesPromises(args)) {
+    return promiseAll(args).then(curry2(functionArrayAllSeries, funcs, __))
   }
-  return predicate(value)
+  return functionArrayAllSeries(funcs, args)
 }
 
 module.exports = all

package/and.js

@@ -1,6 +1,10 @@
+const promiseAll = require('./_internal/promiseAll')
 const isPromise = require('./_internal/isPromise')
-const curry3 = require('./_internal/curry3')
+const areAnyValuesPromises = require('./_internal/areAnyValuesPromises')
 const __ = require('./_internal/placeholder')
+const curry2 = require('./_internal/curry2')
+const curry3 = require('./_internal/curry3')
+const curryArgs2 = require('./_internal/curryArgs2')
 const thunkConditional = require('./_internal/thunkConditional')
 const areAllValuesNonfunctions = require('./_internal/areAllValuesNonfunctions')
 const thunkify2 = require('./_internal/thunkify2')
@@ -8,22 +12,22 @@ const thunkify3 = require('./_internal/thunkify3')
 const always = require('./_internal/always')
 
 /**
- * @name areAllNonfunctionsTruthy
+ * @name areAllValuesTruthy
  *
  * @synopsis
  * ```coffeescript [specscript]
- * areAllNonfunctionsTruthy(predicates Array<value>) -> Promise|boolean
+ * areAllValuesTruthy(predicates Array<value>) -> Promise|boolean
  * ```
  */
-const areAllNonfunctionsTruthy = function (predicates, index) {
+const areAllValuesTruthy = function (predicates, index) {
   const length = predicates.length
   while (++index < length) {
-    let predicate = predicates[index]
+    const predicate = predicates[index]
     if (isPromise(predicate)) {
       return predicate.then(curry3(
         thunkConditional,
         __,
-        thunkify2(areAllNonfunctionsTruthy, predicates, index),
+        thunkify2(areAllValuesTruthy, predicates, index),
         always(false),
       ))
     }
@@ -41,17 +45,17 @@ const areAllNonfunctionsTruthy = function (predicates, index) {
  * ```coffeescript [specscript]
  * asyncArePredicatesAllTruthy(
  *   predicates Array<value=>Promise|boolean>
- *   point any,
+ *   args Array,
  *   index number,
  * ) -> allTruthy boolean
  * ```
  */
-const asyncArePredicatesAllTruthy = async function (predicates, point, index) {
+const asyncArePredicatesAllTruthy = async function (args, predicates, index) {
   const length = predicates.length
   while (++index < length) {
     let predicate = predicates[index]
     if (typeof predicate == 'function') {
-      predicate = predicate(point)
+      predicate = predicate(...args)
     }
     if (isPromise(predicate)) {
       predicate = await predicate
@@ -63,6 +67,31 @@ const asyncArePredicatesAllTruthy = async function (predicates, point, index) {
   return true
 }
 
+// areAllPredicatesTruthy(args Array, predicates Array<function>) -> Promise|boolean
+const areAllPredicatesTruthy = function (args, predicates) {
+  const length = predicates.length
+  let index = -1
+
+  while (++index < length) {
+    let predicate = predicates[index]
+    if (typeof predicate == 'function') {
+      predicate = predicate(...args)
+    }
+    if (isPromise(predicate)) {
+      return predicate.then(curry3(
+        thunkConditional,
+        __,
+        thunkify3(asyncArePredicatesAllTruthy, args, predicates, index),
+        always(false),
+      ))
+    }
+    if (!predicate) {
+      return false
+    }
+  }
+  return true
+}
+
 /**
  * @name and
  *
@@ -70,9 +99,9 @@ const asyncArePredicatesAllTruthy = async function (predicates, point, index) {
  * ```coffeescript [specscript]
  * and(values Array<boolean>) -> result boolean
  *
- * and(
- *   predicatesOrValues Array<function|boolean>
- * )(value any) -> result Promise|boolean
+ * and(...args, predicatesOrValues Array<function|boolean>) -> Promise|boolean
+ *
+ * and(predicatesOrValues Array<function|boolean>)(...args) -> Promise|boolean
  * ```
  *
  * @description
@@ -106,33 +135,22 @@ const asyncArePredicatesAllTruthy = async function (predicates, point, index) {
  *
  * @note ...args slows down here by an order of magnitude
  */
-const and = predicates => {
-  if (areAllValuesNonfunctions(predicates)) {
-    return areAllNonfunctionsTruthy(predicates, -1)
+const and = function (...args) {
+  const predicatesOrValues = args.pop()
+  if (areAllValuesNonfunctions(predicatesOrValues)) {
+    return areAllValuesTruthy(predicatesOrValues, -1)
   }
-  return function arePredicatesAllTruthy(point) {
-    const length = predicates.length
-    let index = -1
 
-    while (++index < length) {
-      let predicate = predicates[index]
-      if (typeof predicate == 'function') {
-        predicate = predicate(point)
-      }
-      if (isPromise(predicate)) {
-        return predicate.then(curry3(
-          thunkConditional,
-          __,
-          thunkify3(asyncArePredicatesAllTruthy, predicates, point, index),
-          always(false),
-        ))
-      }
-      if (!predicate) {
-        return false
-      }
-    }
-    return true
+  if (args.length == 0) {
+    return curryArgs2(areAllPredicatesTruthy, __, predicatesOrValues)
   }
+
+  if (areAnyValuesPromises(args)) {
+    return promiseAll(args)
+      .then(curry2(areAllPredicatesTruthy, __, predicatesOrValues))
+  }
+
+  return areAllPredicatesTruthy(args, predicatesOrValues)
 }
 
 module.exports = and

package/archive/{FlatMappingIteratorCool.js → FlatMappingIterator-2020-09-28.js}

@@ -21,7 +21,7 @@ const FlatMappingIterator = function (iterator, flatMapper) {
   const buffer = [], promises = [],
     bufferPush = curry3(callPropUnary, buffer, 'push', __),
     bufferPushReducer = funcConcatSync(getArg1, bufferPush),
-    flattenIntoBuffer = curryArgs3(genericReduce, __, bufferPushReducer, null),
+    flattenIntoBuffer = curry3(genericReduce, __, bufferPushReducer, null),
     loadIntoBuffer = funcConcatSync(flattenIntoBuffer, tapSync(bufferLoading => {
       if (isPromise(bufferLoading)) {
         const promise = bufferLoading.then(() => promises.delete(promise))

package/archive/_Promise-2023-05-29.js

@@ -0,0 +1,93 @@
+const isPromise = require('./isPromise')
+
+/**
+ * @name _Promise
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * new _Promise() -> _Promise
+ * ```
+ *
+ * @description
+ * Internal _Promise. Does not conform to spec.
+ */
+const _Promise = function () {
+  this.onFulfilledCallbacks = []
+  this.onRejectedCallbacks = []
+  this.value = null
+  this.error = null
+  this.status = 'pending'
+}
+
+_Promise.prototype._fulfill = function (value) {
+  if (this.status == 'pending') {
+    this.status = 'fulfilled'
+    this.value = value
+    this.onFulfilledCallbacks.forEach(cb => cb(value)) // TODO optimize
+  }
+}
+
+_Promise.prototype._reject = function (error) {
+  if (this.status == 'pending') {
+    this.status = 'rejected'
+    this.error = error
+    this.onRejectedCallbacks.forEach(cb => cb(error)) // TODO optimize
+  }
+}
+
+_Promise.prototype.then = function (onFulfilled, onRejected) {
+  return new Promise((resolve, reject) => {
+    if (this.status == 'pending') {
+      this.onFulfilledCallbacks.push(() => {
+        try {
+          const ret = onFulfilled(this.value)
+          if (isPromise(ret)) {
+            ret.then(resolve, reject)
+          } else {
+            resolve(ret)
+          }
+        } catch (error) {
+          reject(error)
+        }
+      })
+      this.onRejectedCallbacks.push(() => {
+        try {
+          const ret = onRejected(this.error)
+          if (isPromise(ret)) {
+            ret.then(resolve, reject)
+          } else {
+            reject(ret)
+          }
+        } catch (error) {
+          reject(error)
+        }
+      })
+    }
+    else if (this.status == 'fulfilled') {
+      try {
+        const ret = onFulfilled(this.value)
+        if (isPromise(ret)) {
+          ret.then(resolve, reject)
+        } else {
+          resolve(ret)
+        }
+      } catch (error) {
+        reject(error)
+      }
+    }
+    else {
+      try {
+        const ret = onRejected(this.error)
+        if (isPromise(ret)) {
+          ret.then(resolve, reject)
+        } else {
+          reject(ret)
+        }
+      } catch (error) {
+        reject(error)
+      }
+    }
+  })
+}
+
+module.exports = _Promise

package/archive/arrayMap2-2023-05-29.js

@@ -0,0 +1,73 @@
+const funcCall = require('./funcCall')
+const thunkify4 = require('./thunkify4')
+const __ = require('./placeholder')
+const curry2 = require('./curry2')
+const curry3 = require('./curry3')
+const curry4 = require('./curry4')
+const isPromise = require('./isPromise')
+const promiseAll = require('./promiseAll')
+const _Promise = require('./_Promise')
+
+/**
+ * @name arrayMap
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * arrayMap(
+ *   array Array,
+ *   mapper (item any, index number, array Array)=>Promise|any,
+ * ) -> Promise|Array
+ * ```
+ *
+ * @description
+ * Apply a mapper to each item of an array, returning an array. Mapper may be asynchronous.
+ */
+
+const arrayMapHandlePromise = function (
+  result, promise, index, promiseCounts, _promise
+) {
+  promiseCounts.pending += 1
+  promise.then(value => {
+    result[index] = value
+    promiseCounts.resolved += 1
+    if (promiseCounts.resolved == promiseCounts.pending) {
+      _promise._fulfill(result)
+    }
+  }, error => {
+    _promise.reject(error)
+  })
+}
+
+const arrayMap2 = function (array, mapper) {
+  const length = array.length
+  const result = Array(length)
+  const promiseCounts = { pending: 0, resolved: 0 }
+
+  let index = -1
+  let _promise = new _Promise()
+
+  while (++index < length) {
+    const ret = mapper(array[index], index, array)
+    if (isPromise(ret)) {
+      arrayMapHandlePromise(result, ret, index, promiseCounts, _promise)
+    } else {
+      result[index] = ret
+    }
+  }
+
+  if (promiseCounts.pending == 0) {
+    return result
+  }
+
+  return _promise
+}
+
+if (process.argv[1] == __filename) {
+  const timeInLoopAsync = require('./timeInLoopAsync')
+
+  timeInLoopAsync('arrayMap2', 1e6, async () => {
+    await arrayMap2([1, 2, 3, 4, 5], async value => value + 1)
+  })
+}
+
+module.exports = arrayMap2

package/archive/benchmarks-v1.9.7/all.js

@@ -0,0 +1,34 @@
+const timeInLoop = require('../x/timeInLoop')
+const rubico = require('..')
+const _ = require('lodash')
+const R = require('ramda')
+
+const isOdd = number => number % 2 == 1
+
+const isEven = number => number % 2 == 0
+
+/**
+ * @name allRace
+ *
+ * @benchmark
+ * _.every: 1e+6: 20.984ms
+ * R.all: 1e+6: 368.142ms
+ * rubico.all: 1e+6: 24.772ms
+ *
+ * @remarks
+ * promise check
+ */
+
+{
+  const evenNumbers = [2, 4, 6, 8, 10]
+
+  // console.log(_.every(evenNumbers, isEven))
+  // console.log(R.all(isEven)(evenNumbers))
+  // console.log(rubico.all(isEven)(evenNumbers))
+
+  // timeInLoop('_.every', 1e6, () => _.every(evenNumbers, isEven))
+
+  // timeInLoop('R.all', 1e6, () => R.all(isEven)(evenNumbers))
+
+  // timeInLoop('rubico.all', 1e6, () => rubico.all(isEven)(evenNumbers))
+}

package/archive/benchmarks-v1.9.7/and.js

@@ -0,0 +1,24 @@
+const timeInLoop = require('../x/timeInLoop')
+const rubico = require('..')
+
+const { and } = rubico
+
+const isOdd = x => x % 2 == 1
+
+const threeOddChecks = number => isOdd(number) && isOdd(number) && isOdd(number)
+
+const threeIsOdd = and([isOdd, isOdd, isOdd])
+
+/**
+ * @name or
+ *
+ * @benchmark
+ * isOdd(value) && isOdd(value) && isOdd(value): 1e+6: 6.664ms
+ * and([isOdd, isOdd, isOdd]): 1e+6: 16.842ms
+ */
+
+{
+  // timeInLoop('isOdd(value) && isOdd(value) && isOdd(value)', 1e6, () => threeOddChecks(1))
+
+  // timeInLoop('and([isOdd, isOdd, isOdd])', 1e6, () => threeIsOdd(1))
+}