rubico 1.9.7 → 2.0.1

package/pipe.js

@@ -1,8 +1,9 @@
-const noop = require('./_internal/noop')
+const areAnyValuesPromises = require('./_internal/areAnyValuesPromises')
+const promiseAll = require('./_internal/promiseAll')
 const funcConcat = require('./_internal/funcConcat')
-const funcConcatSync = require('./_internal/funcConcatSync')
-const isGeneratorFunction = require('./_internal/isGeneratorFunction')
-const isAsyncGeneratorFunction = require('./_internal/isAsyncGeneratorFunction')
+const funcApply = require('./_internal/funcApply')
+const curry2 = require('./_internal/curry2')
+const __ = require('./_internal/placeholder')
 
 /**
  * @name pipe
@@ -15,7 +16,7 @@ const isAsyncGeneratorFunction = require('./_internal/isAsyncGeneratorFunction')
  * ```
  *
  * @description
- * Creates a function pipeline with an array of functions where each function passes its return value as a single argument to the next function until all functions have executed. The result of a pipeline execution is the return of its last function. If any function of the pipeline is asynchronous, the result of the execution is a Promise.
+ * Creates a function pipeline from an array of functions, where each function passes its return value as a single argument to the next function until all functions have executed. The first function is called with the arguments to the pipeline, while the result of the pipeline execution is the return of its last function. If any function of the pipeline is asynchronous, the result of the execution is a Promise.
  *
  * ```javascript [playground]
  * const syncAdd123 = pipe([
@@ -53,55 +54,17 @@ const isAsyncGeneratorFunction = require('./_internal/isAsyncGeneratorFunction')
  */
 const pipe = function (...args) {
   const funcs = args.pop()
+  const pipeline = funcs.reduce(funcConcat)
 
-  if (args.length > 0) {
-    return funcs.reduce(funcConcat)(...args)
+  if (args.length == 0) {
+    return pipeline
   }
 
-  let functionPipeline = noop,
-    functionComposition = noop
-  return function pipeline(...args) {
-    const firstArg = args[0]
-
-    if (
-      typeof firstArg == 'function'
-        && !isGeneratorFunction(firstArg)
-        && !isAsyncGeneratorFunction(firstArg)
-    ) {
-      if (functionComposition == noop) {
-        functionComposition = funcs.reduceRight(funcConcat)
-      }
-      return functionComposition(firstArg)
-    }
-
-    if (functionPipeline == noop) {
-      functionPipeline = funcs.reduce(funcConcat)
-    }
-    return functionPipeline(...args)
+  if (areAnyValuesPromises(args)) {
+    return promiseAll(args).then(curry2(funcApply, pipeline, __))
   }
-}
-
-// funcs Array<function> -> pipeline function
-const pipeSync = funcs => funcs.reduce(funcConcatSync)
 
-/**
- * @name pipe.sync
- *
- * @synopsis
- * ```coffeescript [specscript]
- * pipe.sync(funcs Array<function>)(...args) -> result Promise|any
- * ```
- *
- * @description
- * A synchronous version of `pipe` that does not resolve promises by default.
- *
- * ```javascript [playground]
- * pipe.sync([
- *   value => Promise.resolve(value),
- *   promise => promise.then(console.log)
- * ])('hey') // hey
- * ```
- */
-pipe.sync = pipeSync
+  return pipeline(...args)
+}
 
 module.exports = pipe

package/reduce.js

@@ -1,39 +1,44 @@
 const isPromise = require('./_internal/isPromise')
 const __ = require('./_internal/placeholder')
 const curry3 = require('./_internal/curry3')
-const curryArgs3 = require('./_internal/curryArgs3')
 const genericReduce = require('./_internal/genericReduce')
 
+// _reduce(collection any, reducer function, initialValue function|any) -> Promise
+const _reduce = function (collection, reducer, initialValue) {
+  if (typeof initialValue == 'function') {
+    const actualInitialValue = initialValue(collection)
+    return isPromise(actualInitialValue)
+      ? actualInitialValue.then(curry3(genericReduce, collection, reducer, __))
+      : genericReduce(collection, reducer, actualInitialValue)
+  }
+  return isPromise(initialValue)
+    ? initialValue.then(curry3(genericReduce, collection, reducer, __))
+    : genericReduce(collection, reducer, initialValue)
+}
+
 /**
  * @name reduce
  *
  * @synopsis
  * ```coffeescript [specscript]
- * arrayReducer (result any, value any, index number, array Array)=>(result Promise|any)
- * initialValue function|any
- *
- * reduce(arrayReducer, initialValue?)(array Array) -> result Promise|any
- * reduce(array Array, arrayReducer, initialValue?) -> result Promise|any
- *
- * objectReducer (result any, value any, key string, object Object)=>(result Promise|any)
- *
- * reduce(objectReducer, initialValue?)(object Object) -> result Promise|any
- * reduce(object Object, objectReducer, initialValue?) -> result Promise|any
- *
- * mapReducer (result any, value any, key any, map Map)=>(result Promise|any)
- *
- * reduce(mapReducer, initialValue?)(m Map) -> result Promise|any
- * reduce(m Map, mapReducer, initialValue?) -> result Promise|any
- *
- * reducer (result any, value any)=>(result Promise|any)
- *
- * reduce(reducer, initialValue?)(iterator Iterator) -> result Promise|any
- * reduce(iterator Iterator, reducer, initialValue?) -> result Promise|any
- *
- * reduce(reducer, initialValue?)(asyncIterator AsyncIterator)
- *   -> result Promise|any
- * reduce(asyncIterator AsyncIterator, reducer, initialValue?)
- *   -> result Promise|any
+ * type Foldable = Array|Object|Map|Iterator|AsyncIterator
+ * type Reducer = (
+ *   accumulator any,
+ *   value any,
+ *   indexOrKey? number|string,
+ *   collection? Foldable,
+ * )=>(nextAccumulator Promise|any)
+ *
+ * reduce(
+ *   collection Foldable,
+ *   reducer Reducer,
+ *   initialValue? function|any
+ * ) -> result Promise|any
+ *
+ * reduce(
+ *   reducer Reducer,
+ *   initialValue? function|any
+ * )(collection Foldable) -> result Promise|any
  * ```
  *
  * @description
@@ -46,7 +51,7 @@ const genericReduce = require('./_internal/genericReduce')
  *  * `Iterator`/`Generator`
  *  * `AsyncIterator`/`AsyncGenerator`
  *
- * For arrays (type `Array`), `reduce` executes the reducer function for each item of the array in order, returning a new result at each execution to be used in the next execution.
+ * For arrays (type `Array`), `reduce` executes the reducer function for each item of the array in order, returning a new result at each execution to be used in the next execution. On each iteration, the reducer is passed the accumulator, the item of the iteration, the index of the item in the array, and a reference to the original array.
  *
  * ```javascript [playground]
  * const max = (a, b) => a > b ? a : b
@@ -84,7 +89,7 @@ const genericReduce = require('./_internal/genericReduce')
  * // ['initial length 5', 1, 4, 9, 16, 25]
  * ```
  *
- * For objects (type `Object`), `reduce` executes the reducer function for each value of the object.
+ * For objects (type `Object`), `reduce` executes the reducer function for each value of the object. On each iteration, the reducer is passed the accumulator, the object value, the key of the object value, and a reference to the original object.
  *
  * ```javascript [playground]
  * const add = (a, b) => a + b
@@ -100,7 +105,7 @@ const genericReduce = require('./_internal/genericReduce')
  * ) // 15
  * ```
  *
- * For sets (type `Set`), `reduce` executes the reducer function for each item of the set.
+ * For sets (type `Set`), `reduce` executes the reducer function for each item of the set. On each iteration, the reducer is passed the accumulator and item of the set.
  *
  * ```javascript [playground]
  * const add = (a, b) => a + b
@@ -116,7 +121,7 @@ const genericReduce = require('./_internal/genericReduce')
  * ) // 15
  * ```
  *
- * For maps (type `Map`), `reduce` executes the reducer function for each value of each entry of the map.
+ * For maps (type `Map`), `reduce` executes the reducer function for each value of each entry of the map. On each iteration, the reducer is passed the accumulator, the map item, the key of the map item, and a reference to the original map.
  *
  * ```javascript [playground]
  * const add = (a, b) => a + b
@@ -132,7 +137,7 @@ const genericReduce = require('./_internal/genericReduce')
  * ) // 15
  * ```
  *
- * For iterators (type `Iterator`) and generators (type `Generator`), `reduce` executes the reducer function for each value of the iterator/generator. The iterator/generator is consumed in the process.
+ * For iterators (type `Iterator`) and generators (type `Generator`), `reduce` executes the reducer function for each value of the iterator/generator. On each iteration, the reducer is passed the accumulator and the item of the iteration. The iterator/generator is consumed in the process.
  *
  * ```javascript [playground]
  * const add = (a, b) => a + b
@@ -150,7 +155,7 @@ const genericReduce = require('./_internal/genericReduce')
  * ) // 15
  * ```
  *
- * For asyncIterators (type `AsyncIterator`) and asyncGenerators (type `AsyncGenerator`), `reduce` executes the reducer function for each value of the asyncIterator/asyncGenerator. The asyncIterator/asyncGenerator is consumed in the process.
+ * For asyncIterators (type `AsyncIterator`) and asyncGenerators (type `AsyncGenerator`), `reduce` executes the reducer function for each value of the asyncIterator/asyncGenerator. On each iteration, the reducer is passed the accumulator and the item of the async iteration. The asyncIterator/asyncGenerator is consumed in the process.
  *
  * ```javascript [playground]
  * const asyncAdd = async (a, b) => a + b
@@ -174,27 +179,13 @@ const genericReduce = require('./_internal/genericReduce')
  */
 
 const reduce = function (...args) {
-  if (typeof args[0] != 'function') {
-    const reducer = args[1]
-    const initialValue = args[2]
-    if (typeof initialValue == 'function') {
-      return genericReduce([args[0]], reducer, initialValue(args[0]))
-    }
-    return genericReduce([args[0]], reducer, initialValue)
+  if (typeof args[0] == 'function') {
+    return curry3(_reduce, __, args[0], args[1])
   }
-
-  const reducer = args[0]
-  const initialValue = args[1]
-
-  if (typeof initialValue == 'function') {
-    return function reducing(...args) {
-      const result = initialValue(...args)
-      return isPromise(result)
-        ? result.then(curry3(genericReduce, args, reducer, __))
-        : genericReduce(args, reducer, result)
-    }
+  if (isPromise(args[0])) {
+    return args[0].then(curry3(_reduce, __, args[1], args[2]))
   }
-  return curryArgs3(genericReduce, __, reducer, initialValue)
+  return _reduce(args[0], args[1], args[2])
 }
 
 module.exports = reduce

package/rubico.js

@@ -1,7 +1,8 @@
 const pipe = require('./pipe')
-const fork = require('./fork')
-const assign = require('./assign')
+const compose = require('./compose')
 const tap = require('./tap')
+const all = require('./all')
+const assign = require('./assign')
 const tryCatch = require('./tryCatch')
 const switchCase = require('./switchCase')
 const map = require('./map')
@@ -9,8 +10,9 @@ const filter = require('./filter')
 const reduce = require('./reduce')
 const transform = require('./transform')
 const flatMap = require('./flatMap')
-const any = require('./any')
-const all = require('./all')
+const forEach = require('./forEach')
+const some = require('./some')
+const every = require('./every')
 const and = require('./and')
 const or = require('./or')
 const not = require('./not')
@@ -42,14 +44,23 @@ const __ = require('./__')
  */
 
 const rubico = {
-  pipe, tap,
-  switchCase, tryCatch,
-  fork, assign, get, set, pick, omit,
-  map, filter, reduce, transform, flatMap,
-  and, or, not, any, all,
+  pipe, compose,
+
+  tap, forEach,
+
+  switchCase,
+
+  tryCatch,
+
+  all, assign, get, set, pick, omit,
+
+  map, filter, flatMap, reduce, transform,
+
+  and, or, not, some, every,
+
   eq, gt, lt, gte, lte,
-  thunkify, always,
-  curry, __,
+
+  thunkify, always, curry, __,
 }
 
 module.exports = rubico

package/set.js

@@ -3,12 +3,48 @@ const setByPath = require('./_internal/setByPath')
 const curry3 = require('./_internal/curry3')
 const __ = require('./_internal/placeholder')
 
+/**
+ * @name _set
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * _set(
+ *   obj Object,
+ *   path string|Array<string|number>,
+ *   value function|any,
+ * ) -> result Promise|Object
+ * ```
+ */
+const _set = function (obj, path, value) {
+  if (typeof value == 'function') {
+    const actualValue = value(obj)
+    if (isPromise(actualValue)) {
+      return actualValue.then(
+        curry3(setByPath, obj, __, path)
+      )
+    }
+    return setByPath(obj, actualValue, path)
+  }
+  if (isPromise(value)) {
+    return value.then(
+      curry3(setByPath, obj, __, path)
+    )
+  }
+  return setByPath(obj, value, path)
+}
+
 /**
  * @name set
  *
  * @synopsis
  * ```coffeescript [specscript]
  * set(
+ *   object Object,
+ *   path string|Array<string|number>,
+ *   value function|any,
+ * ) -> result Promise|Object
+ *
+ * set(
  *   path string|Array<string|number>,
  *   value function|any,
  * )(object Object) -> result Promise|Object
@@ -48,17 +84,14 @@ const __ = require('./_internal/placeholder')
  * @since 1.7.0
  */
 
-const set = (path, value) => function setter(obj) {
-  if (typeof value == 'function') {
-    const actualValue = value(obj)
-    if (isPromise(actualValue)) {
-      return actualValue.then(
-        curry3(setByPath, obj, __, path)
-      )
-    }
-    return setByPath(obj, actualValue, path)
+const set = function (arg0, arg1, arg2) {
+  if (arg2 == null) {
+    return curry3(_set, __, arg0, arg1)
   }
-  return setByPath(obj, value, path)
+  if (isPromise(arg0)) {
+    return arg0.then(curry3(_set, __, arg1, arg2))
+  }
+  return _set(arg0, arg1, arg2)
 }
 
 module.exports = set

package/some.js

@@ -0,0 +1,105 @@
+const isPromise = require('./_internal/isPromise')
+const __ = require('./_internal/placeholder')
+const curry2 = require('./_internal/curry2')
+const isArray = require('./_internal/isArray')
+const objectValues = require('./_internal/objectValues')
+const arraySome = require('./_internal/arraySome')
+const iteratorSome = require('./_internal/iteratorSome')
+const asyncIteratorSome = require('./_internal/asyncIteratorSome')
+const reducerSome = require('./_internal/reducerSome')
+const symbolIterator = require('./_internal/symbolIterator')
+const symbolAsyncIterator = require('./_internal/symbolAsyncIterator')
+
+// _some(collection Array|Iterable|AsyncIterable|{ reduce: function }|Object, predicate function) -> Promise|boolean
+const _some = function (collection, predicate) {
+  if (isArray(collection)) {
+    return arraySome(collection, predicate)
+  }
+  if (collection == null) {
+    return predicate(collection)
+  }
+  if (typeof collection[symbolIterator] == 'function') {
+    return iteratorSome(collection[symbolIterator](), predicate)
+  }
+  if (typeof collection[symbolAsyncIterator] == 'function') {
+    return asyncIteratorSome(
+      collection[symbolAsyncIterator](), predicate, new Set()
+    )
+  }
+  if (typeof collection.reduce == 'function') {
+    return collection.reduce(reducerSome(predicate), false)
+  }
+  if (collection.constructor == Object) {
+    return arraySome(objectValues(collection), predicate)
+  }
+  return predicate(collection)
+}
+
+/**
+ * @name some
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * type Foldable = Array|Iterable|AsyncIterable|{ reduce: function }|Object
+ *
+ * some(collection Foldable, predicate function) -> Promise|boolean
+ *
+ * some(predicate function)(collection Foldable) -> Promise|boolean
+ * ```
+ *
+ * @description
+ * Test a predicate concurrently across all items of a collection, returning true if any executions return truthy.
+ *
+ * ```javascript [playground]
+ * const isOdd = number => number % 2 == 1
+ *
+ * console.log(
+ *   some([1, 2, 3, 4, 5], isOdd),
+ * ) // true
+ * ```
+ *
+ * The collection can be any iterable, async iterable, or object values iterable collection. Below is an example of `some` accepting an async generator as the collection.
+ *
+ * ```javascript [playground]
+ * const toTodosUrl = id => 'https://jsonplaceholder.typicode.com/todos/' + id
+ *
+ * const fetchedToJson = fetched => fetched.json()
+ *
+ * const fetchTodo = pipe([
+ *   toTodosUrl,
+ *   fetch,
+ *   fetchedToJson,
+ * ])
+ *
+ * const todoIDsGenerator = async function* () {
+ *   yield 1; yield 2; yield 3; yield 4; yield 5
+ * }
+ *
+ * some(pipe([
+ *   fetchTodo,
+ *   todo => todo.title.startsWith('fugiat'),
+ * ]))(todoIDsGenerator()).then(console.log) // true
+ * ```
+ *
+ * @execution concurrent
+ *
+ * @muxing
+ *
+ * @related or
+ */
+
+const some = function (...args) {
+  const predicate = args.pop()
+  if (args.length == 0) {
+    return curry2(_some, __, predicate)
+  }
+
+  const collection = args[0]
+  if (isPromise(collection)) {
+    return collection.then(curry2(_some, __, predicate))
+  }
+
+  return _some(collection, predicate)
+}
+
+module.exports = some

package/switchCase.js

@@ -1,6 +1,11 @@
+const promiseAll = require('./_internal/promiseAll')
+const areAnyValuesPromises = require('./_internal/areAnyValuesPromises')
 const arrayConditional = require('./_internal/arrayConditional')
 const areAllValuesNonfunctions = require('./_internal/areAllValuesNonfunctions')
 const nonfunctionsConditional = require('./_internal/nonfunctionsConditional')
+const __ = require('./_internal/placeholder')
+const curry3 = require('./_internal/curry3')
+const curryArgs3 = require('./_internal/curryArgs3')
 
 /**
  * @name switchCase
@@ -57,13 +62,18 @@ const nonfunctionsConditional = require('./_internal/nonfunctionsConditional')
  *
  * @execution series
  */
-const switchCase = values => {
+const switchCase = (...args) => {
+  const values = args.pop()
   if (areAllValuesNonfunctions(values)) {
     return nonfunctionsConditional(values, -2)
   }
-  return function switchingCases(...args) {
-    return arrayConditional(values, args, -2)
+  if (args.length == 0) {
+    return curryArgs3(arrayConditional, values, __, -2)
   }
+  if (areAnyValuesPromises(args)) {
+    return promiseAll(args).then(curry3(arrayConditional, values, __, -2))
+  }
+  return arrayConditional(values, args, -2)
 }
 
 module.exports = switchCase

package/tap.js

@@ -1,6 +1,5 @@
 const isPromise = require('./_internal/isPromise')
 const always = require('./_internal/always')
-const tapSync = require('./_internal/tapSync')
 const thunkifyArgs = require('./_internal/thunkifyArgs')
 const thunkConditional = require('./_internal/thunkConditional')
 const curry3 = require('./_internal/curry3')
@@ -35,29 +34,6 @@ const tap = func => function tapping(...args) {
   return isPromise(call) ? call.then(always(result)) : result
 }
 
-/**
- * @name tap.sync
- *
- * @synopsis
- * ```coffeescript [specscript]
- * tap.sync(func function)(...args) -> args[0]
- * ```
- *
- * @description
- * Synchronous `tap`
- *
- * ```javascript [playground]
- * const pipeline = pipe([
- *   tap.sync(number => console.log('square', number ** 2)),
- *   tap.sync(number => console.log('cube', number ** 3)),
- * ])
- *
- * pipeline(3) // 9
- *             // 27
- * ```
- */
-tap.sync = tapSync
-
 /**
  * @name tap.if
  *