rubico 1.9.6 → 2.0.0

package/reduce.js

@@ -1,173 +1,172 @@
 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]
- * reduce(
- *   arrayReducer (result any, value any, index number, array Array)=>Promise|any,
- *   initialValue? (array=>Promise|any)|any,
- * )(array) -> Promise|result
- *
- * reduce(
- *   objectReducer (result any, value any, key string, object Object)=>Promise|any,
- *   initialValue? (object=>Promise|any)|any,
- * )(object) -> Promise|result
- *
- * reduce(
- *   mapReducer (result any, value any, key any, map Map)=>Promise|any,
- *   initialValue? (map=>Promise|any)|any,
- * )(map) -> Promise|result
- *
- * Foldable = Iterable|AsyncIterable|{ reduce: (reducer, result?)=>any }
- *
- * reduce(
- *   reducer (result any, value any)=>Promise|any,
- *   initialValue? ((foldable Foldable)=>Promise|any)|any,
- * )(foldable) -> Promise|result
+ * type Foldable = Array|Object|Map|Iterator|AsyncIterator
+ * type Reducer = (
+ *   accumulator any,
+ *   value any,
+ *   indexOrKey? number|string,
+ *   collection? Foldable,
+ * )=>(nextAccumulator Promise|any)
  *
  * reduce(
- *   reducer (result any, value any)=>Promise|any,
- *   initialValue? (()=>Promise|any)|any,
- * )(generatorFunction) -> reducingGeneratorValuesFunction (...generatorFunctionArgs)=>Promise|any
+ *   collection Foldable,
+ *   reducer Reducer,
+ *   initialValue? function|any
+ * ) -> result Promise|any
  *
  * reduce(
- *   reducer (result any, value any)=>Promise|any,
- *   initialValue? (()=>Promise|any)|any,
- * )(asyncGeneratorFunction) -> reducingAsyncGeneratorValuesFunction (...asyncGeneratorFunctionArgs)=>Promise|any
- *
- * reduce(reducer, initialValue?)(...moreReducers) -> ...args=>Promise|any
+ *   reducer Reducer,
+ *   initialValue? function|any
+ * )(collection Foldable) -> result Promise|any
  * ```
  *
  * @description
- * Execute a reducer for each item of a collection, returning a single output value.
+ * Transforms a collection based on a reducer function and optional initial value. In a reducing operation, the result is defined in the beginning as either the initial value if supplied or the first item of the collection. The reducing operation then iterates through the remaining items in the collection, executing the reducer at each iteration to return the result to be used in the next iteration. The final result is the result of the execution of the reducer at the last item of the iteration. `reduce` accepts the following collections:
+ *
+ *  * `Array`
+ *  * `Object`
+ *  * `Set`
+ *  * `Map`
+ *  * `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. 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
  *
  * console.log(
- *   reduce(max)([1, 3, 5, 4, 2]),
+ *   reduce([1, 3, 5, 4, 2], max)
+ * ) // 5
+ *
+ * console.log(
+ *   reduce(max)([1, 3, 5, 4, 2])
  * ) // 5
  * ```
  *
- * If an optional initialization parameter is supplied, the result starts as that parameter rather than the first item of the collection. For memory and performance, this library makes no assumptions about immutability. Handle references for this initial value with care, as they could be mutated.
+ * If an optional initial value is provided, the result starts as the provided initial value rather than the first item of the collection.
  *
  * ```javascript [playground]
  * const add = (a, b) => a + b
  *
- * console.log(
- *   reduce(add)([1, 2, 3, 4, 5], 0),
- * ) // 15
+ * console.log(reduce([1, 2, 3, 4, 5], add, 0)) // 15
+ * console.log(reduce(add, 0)([1, 2, 3, 4, 5])) // 15
  * ```
  *
- * If the initialization parameter is a function, it is treated as a resolver and called with the input arguments to resolve an initial value for the accumulator at execution time.
+ * If the initialization parameter is a function, it is treated as a resolver and called with the arguments to resolve the initial value.
  *
  * ```javascript [playground]
  * const concatSquares = (array, value) => array.concat(value ** 2)
  *
- * const initEmptyArray = () => []
+ * const contrivedInitializer = array => [`initial length ${array.length}`]
+ *
+ * const array = [1, 2, 3, 4, 5]
+ *
+ * console.log(reduce(concatSquares, contrivedInitializer)(array))
+ * // ['initial length 5', 1, 4, 9, 16, 25]
+ * console.log(reduce(array, concatSquares, contrivedInitializer))
+ * // ['initial length 5', 1, 4, 9, 16, 25]
+ * ```
+ *
+ * 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
+ *
+ * const obj = { a: 1, b: 2, c: 3, d: 4, e: 5 }
+ *
+ * console.log(
+ *   reduce(obj, add)
+ * ) // 15
  *
  * console.log(
- *   reduce(concatSquares, initEmptyArray)([1, 2, 3, 4, 5]),
- * ) // [1, 4, 9, 16, 25]
+ *   reduce(add)(obj)
+ * ) // 15
  * ```
  *
- * Fully asynchronous reducing operations are possible with asynchronous reducers and asynchronous data streams.
+ * 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 sleep = ms => new Promise(resolve => setTimeout(resolve, ms))
- *
- * // asyncAppReducer(
- * //   state { todos: Array },
- * //   action { type: string, todoID: string },
- * // ) -> state
- * const asyncAppReducer = async function (state, action) {
- *   if (action.type == 'FETCH_TODO') {
- *     const todo = await fetch(
- *       'https://jsonplaceholder.typicode.com/todos/' + action.todoID,
- *     ).then(response => response.json())
- *     console.log('fetched', todo)
- *     state.todos.push(todo)
- *     return state
- *   }
- *   return state
- * }
+ * const add = (a, b) => a + b
  *
- * const asyncFetchActions = async function* (count) {
- *   let idCount = 0
- *   while (++idCount <= count) {
- *     await sleep(1000)
- *     yield { type: 'FETCH_TODO', todoID: idCount }
- *   }
- * }
+ * const set = new Set([1, 2, 3, 4, 5])
  *
- * const state = { todos: [] }
- *
- * reduce(asyncAppReducer, state)(asyncFetchActions(5))
- *   .then(reducedState => console.log('finalState', reducedState))
- *
- * // fetched { userId: 1, id: 1, title: 'delectus aut autem', completed: false }
- * // fetched { userId: 1, id: 2, title: 'quis ut nam facilis...', completed: false }
- * // fetched { userId: 1, id: 3, title: 'fugiat veniam minus', completed: false }
- * // fetched { userId: 1, id: 4, title: 'et porro tempora', completed: true }
- * // fetched { userId: 1, id: 5, title: 'laboriosam mollitia...', completed: false }
- * // finalState {
- * //   todos: [
- * //     { userId: 1, id: 1, title: 'delectus aut autem', completed: false },
- * //     { userId: 1, id: 2, title: 'quis ut nam facilis...', completed: false },
- * //     { userId: 1, id: 3, title: 'fugiat veniam minus', completed: false },
- * //     { userId: 1, id: 4, title: 'et porro tempora', completed: true },
- * //     { userId: 1, id: 5, title: 'laboriosam mollitia...', completed: false },
- * //   ],
- * // }
+ * console.log(
+ *   reduce(set, add)
+ * ) // 15
+ *
+ * console.log(
+ *   reduce(add)(set)
+ * ) // 15
  * ```
  *
- * If the first argument to a reducing function is a reducer, `reduce` concatenates any reducers in argument position onto the initial reducer, producing a combined reducer that performs a chained operation per each item in a reducing operation.
+ * 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 reducerA = (state, action) => {
- *   if (action.type == 'A') return { ...state, A: true }
- *   return state
- * }
+ * const add = (a, b) => a + b
  *
- * const reducerB = (state, action) => {
- *   if (action.type == 'B') return { ...state, B: true }
- *   return state
- * }
+ * const m = new Map([['a', 1], ['b', 2], ['c', 3], ['d', 4], ['e', 5]])
  *
- * const reducerC = (state, action) => {
- *   if (action.type == 'C') return { ...state, C: true }
- *   return state
- * }
+ * console.log(
+ *   reduce(m, add)
+ * ) // 15
  *
- * // state => state
- * const traceMiddleware = tap(
- *   (state, action) => console.log('state, action', state, action))
+ * console.log(
+ *   reduce(add)(m)
+ * ) // 15
+ * ```
  *
- * const reducingABC = reduce(
- *   traceMiddleware, () => ({}))(reducerA, reducerB, reducerC)
+ * 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
  *
- * const actions = [{ type: 'A' }, { type: 'B' }, { type: 'C' }]
+ * const generate12345 = function* () {
+ *   yield 1; yield 2; yield 3; yield 4; yield 5
+ * }
  *
  * console.log(
- *   'final state:',
- *   reducingABC(actions),
- * ) // { A: true, B: true, C: true }
+ *   reduce(generate12345(), add)
+ * ) // 15
+ *
+ * console.log(
+ *   reduce(add)(generate12345())
+ * ) // 15
  * ```
  *
- * `reduce`, when passed a single non-function argument before the reducer function, treats that argument as the value to be reduced.
+ * 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 numbers = [1, 2, 3, 4, 5]
+ * const asyncAdd = async (a, b) => a + b
+ *
+ * const asyncGenerate12345 = async function* () {
+ *   yield 1; yield 2; yield 3; yield 4; yield 5
+ * }
  *
- * const sum = reduce(numbers, (a, b) => a + b)
+ * reduce(asyncGenerate12345(), asyncAdd).then(console.log) // 15
  *
- * assert.equal(sum, 15)
+ * reduce(asyncAdd)(asyncGenerate12345()).then(console.log) // 15
  * ```
  *
  * @execution series
@@ -180,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,11 +44,11 @@ const __ = require('./__')
  */
 
 const rubico = {
-  pipe, tap,
+  pipe, compose, tap,
   switchCase, tryCatch,
-  fork, assign, get, set, pick, omit,
-  map, filter, reduce, transform, flatMap,
-  and, or, not, any, all,
+  all, assign, get, set, pick, omit,
+  map, filter, flatMap, forEach, reduce, transform,
+  and, or, not, some, every,
   eq, gt, lt, gte, lte,
   thunkify, always,
   curry, __,

package/set.js

@@ -3,36 +3,75 @@ 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]
- * var value any,
+ * set(
+ *   object Object,
  *   path string|Array<string|number>,
- *   value (value=>any)|any
+ *   value function|any,
+ * ) -> result Promise|Object
  *
- * set(path, value) -> setter  object=>object
+ * set(
+ *   path string|Array<string|number>,
+ *   value function|any,
+ * )(object Object) -> result Promise|Object
  * ```
  *
  * @description
- * Create a setter that sets a property on an object denoted by path.
+ * Sets a property on a new object shallow cloned from the argument object given a path denoted by a string, number, or an array of string or numbers.
+ *
+ * `set` supports three types of path patterns for nested property access.
+ *
+ *  * dot delimited - `'a.b.c'`
+ *  * bracket notation - `'a[0].value'`
+ *  * an array of keys or indices - `['a', 0, 'value']`
  *
  * ```javascript [playground]
- * console.log(
- *   set('a', 1)({ b: 2 })
- * ) // { a: 1, b: 2 }
+ * console.log(set('a', 1)({ b: 2 })) // { a: 1, b: 2 }
  *
- * console.log(
- *   set('a.b', 1)({ a: { c: 2 } }),
- * ) // { a : { b: 1, c: 2 }}
+ * const nestedAC2 = { a: { c: 2 } }
  *
- * console.log(
- *   set('a[0].b.c', 4)({ a: [{ b: { c: 3 } }] }),
- * ) // { a: [{ b: { c: 4 } }] }
+ * console.log(set('a.b', 1)(nestedAC2)) // { a : { b: 1, c: 2 }}
+ *
+ * const nestedA0BC3 = { a: [{ b: { c: 3 } }] }
+ *
+ * console.log(set('a[0].b.c', 4)(nestedA0BC3)) // { a: [{ b: { c: 4 } }] }
  * ```
  *
- * The property value may be a function, in which case it is treated as a resolver and passed the argument object to resolve the value to set.
+ * The property value may be a function, in which case it is treated as a resolver and provided the argument object to resolve the value to set.
  *
  * ```javascript [playground]
  * const myObj = { a: 1 }
@@ -45,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,27 +1,26 @@
+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
  *
  * @synopsis
  * ```coffeescript [specscript]
- * var args ...any,
- *   result any,
- *   predicate ...args=>Promise|boolean,
- *   resolver ...args=>Promise|result,
- *   defaultResolver ...args=>Promise|result,
- *   conditionalFunctions [
- *     ...Array<predicate|resolver>,
- *     defaultResolver,
- *   ]
+ * switchCase(conditionalValues Array<boolean|any>) -> Promise|any
  *
- * switchCase(conditionalFunctions)(...args) -> Promise|result
+ * switchCase(
+ *   conditionalFuncsOrValues Array<function|boolean|any>
+ * )(...args) -> Promise|any
  * ```
  *
  * @description
- * Conditional operator with cases specified as pairings of `predicate` and `value`, with the exception of the last, default value. Any `predicate` or `value` can be a function, in which case it is evaluated against the point.
+ * Functional equivalent to the [Conditional (ternary) operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Conditional_Operator). Accepts an array of conditional functions that specifies cases as pairings of `predicate` and `resolver` functions with the exception of the last, default resolver. All functions are provided with the same arguments and executed in series. The result of a `switchCase` execution is either the result of the execution the last default resolver, or the result of the execution of the first resolver where the associated predicate tested truthy.
  *
  * ```javascript [playground]
  * const fruitIsYellow = fruit => fruit.color == 'yellow'
@@ -32,12 +31,14 @@ const nonfunctionsConditional = require('./_internal/nonfunctionsConditional')
  *   fruit => fruit.name + ' is probably not a banana',
  * ])
  *
- * console.log(
- *   fruitsGuesser({ name: 'plantain', color: 'yellow' }),
- * ) // plantain is possibly a banana
+ * console.log(fruitsGuesser({ name: 'plantain', color: 'yellow' }))
+ * // plantain is possibly a banana
+ *
+ * console.log(fruitsGuesser({ name: 'apple', color: 'red' }))
+ * // apple is probably not a banana
  * ```
  *
- * A mixture of functions and nonfunctions can be supplied as any of the array items. Any Promises are resolved in series.
+ * Any function can be replaced with a nonfunction (object or primitive) value so that the value is treated as an already resolved value.
  *
  * ```javascript [playground]
  * switchCase([
@@ -49,27 +50,30 @@ const nonfunctionsConditional = require('./_internal/nonfunctionsConditional')
  * ])(false).then(console.log) // default
  * ```
  *
- * If every item in the argument array to switchCase is a value, switchCase should behave as the ternary ? : operator.
+ * If every item in the conditional array is a nonfunction value, `switchCase` executes eagerly.
  *
  * ```javascript [playground]
- * const a = 1
+ * const age = 26
  *
- * switchCase([
- *   a == 1,
- *   Promise.resolve('hello world'),
- *   'default',
- * ]).then(console.log) // hello world
+ * const myDrink = switchCase([age >= 21, 'Beer', 'Juice'])
+ *
+ * console.log(myDrink) // Beer
  * ```
  *
  * @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