rubico 1.9.6 → 2.0.0

package/all.js

@@ -1,78 +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]
- * Reducer<T> = (any, T)=>Promise|any
- * Foldable<T> = Iterable<T>|AsyncIterable<T>
- *   |{ reduce: Reducer<T>=>any }|Object<T>
+ * all(...args, funcsArray Array<function>) -> result Promise|Array
  *
- * var T any,
- *   predicate T=>Promise|boolean,
- *   foldable Foldable<T>
+ * all(funcsArray Array<function>)(...args) -> result Promise|Array
  *
- * all(predicate)(foldable) -> Promise|boolean
+ * 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']
+ *
+ * const createObjectOfGreetingsFor = all({
+ *   hi: name => `Hi ${name}`,
+ *   hey: name => `Hey ${name}`,
+ *   hello: name => `Hello ${name}`,
+ * })
  *
- * console.log(
- *   all(isOdd)([1, 2, 3, 4, 5]),
- * ) // false
+ * const objectOfGreetingsForJane = createObjectOfGreetingsFor('Jane')
  *
- * console.log(
- *   all(isOdd)([1, 3, 5]),
- * ) // true
+ * console.log(objectOfGreetingsForJane)
+ * // { hi: 'Hi Jane', hey: 'Hey Jane', hello: 'Hello Jane' }
  * ```
  *
- * The value may be an asynchronous stream.
+ * `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
  *
- * all(async number => number < 6)(asyncNumbers()).then(console.log) // true
+ * 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}`)
+ *   }),
+ * ])
+ *
+ * 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/always.js

@@ -9,20 +9,14 @@ const always = require('./_internal/always')
  * ```
  *
  * @description
- * Create a function that always returns a value.
+ * Creates a function from a value that always returns the provided value.
  *
  * ```javascript [playground]
  * const always5 = always(5)
  *
  * console.log(always5()) // 5
- *
- * console.log(
- *   fork({
- *     a: always(1),
- *     b: always(2),
- *     c: always(3),
- *   })(),
- * ) // { a: 1, b: 2, c: 3 }
+ * console.log(always5()) // 5
+ * console.log(always5()) // 5
  * ```
  */
 

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,36 +67,67 @@ 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
  *
  * @synopsis
  * ```coffeescript [specscript]
- * and(
- *   predicates Array<predicate function|nonfunction>
- * )(point any) -> Promise|boolean
+ * and(values Array<boolean>) -> result boolean
+ *
+ * and(...args, predicatesOrValues Array<function|boolean>) -> Promise|boolean
+ *
+ * and(predicatesOrValues Array<function|boolean>)(...args) -> Promise|boolean
  * ```
  *
  * @description
- * Test an array of predicates or nonfunction values concurrently against a single input, returning true if all test truthy.
+ * Tests an array of boolean values, returning true if all boolean values are truthy.
  *
  * ```javascript [playground]
- * const isOdd = number => number % 2 == 1
- *
- * const isPositive = number => number > 0
- *
- * const isLessThan3 = number => number < 3
+ * const oneIsLessThanThree = 1 < 3
+ * const twoIsGreaterThanOne = 2 > 1
+ * const threeIsEqualToThree = 3 === 3
  *
  * console.log(
- *   and([isOdd, isPositive, isLessThan3])(1),
+ *   and([oneIsLessThanThree, twoIsGreaterThanOne, threeIsEqualToThree]),
  * ) // true
  * ```
  *
- * `and` behaves eagerly if provided only nonfunction values
+ * If any values in the array are synchronous or asynchronous predicate functions, `and` takes another argument to test concurrently against the predicate functions, returning true if all array values and resolved values from the predicates are truthy.
  *
  * ```javascript [playground]
+ * const isOdd = number => number % 2 == 1
+ *
+ * const isPositive = number => number > 0
+ *
+ * const isLessThan3 = number => number < 3
+ *
  * console.log(
- *   and([true, true, true]),
+ *   and([isOdd, isPositive, isLessThan3])(1),
  * ) // true
  * ```
  *
@@ -100,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))
+}