rubico 1.9.7 → 2.0.0

package/dist/rubico.js

@@ -1,7 +1,7 @@
 /**
- * rubico v1.9.7
+ * rubico v2.0.0
  * https://github.com/a-synchronous/rubico
- * (c) 2019-2021 Richard Tong
+ * (c) 2019-2023 Richard Tong
  * rubico may be freely distributed under the MIT license.
  */
 
@@ -11,10 +11,22 @@
   else (root.rubico = rubico) // Browser
 }(typeof globalThis == 'object' ? globalThis : this, (function () { 'use strict'
 
-const noop = function () {}
-
 const isPromise = value => value != null && typeof value.then == 'function'
 
+const areAnyValuesPromises = function (values) {
+  const length = values.length
+  let index = -1
+  while (++index < length) {
+    const value = values[index]
+    if (isPromise(value)) {
+      return true
+    }
+  }
+  return false
+}
+
+const promiseAll = Promise.all.bind(Promise)
+
 const funcConcat = (
   funcA, funcB,
 ) => function pipedFunction(...args) {
@@ -24,82 +36,69 @@ const funcConcat = (
     : funcB(intermediate)
 }
 
-const funcConcatSync = (
-  funcA, funcB,
-) => function pipedFunction(...args) {
-  return funcB(funcA(...args))
-}
-
-const objectProto = Object.prototype
+const funcApply = (func, args) => func(...args)
 
-const nativeObjectToString = objectProto.toString
-
-const objectToString = value => nativeObjectToString.call(value)
-
-const generatorFunctionTag = '[object GeneratorFunction]'
+const __ = Symbol.for('placeholder')
 
-const isGeneratorFunction = value => objectToString(value) == generatorFunctionTag
+// argument resolver for curry2
+const curry2ResolveArg0 = (
+  baseFunc, arg1,
+) => function arg0Resolver(arg0) {
+  return baseFunc(arg0, arg1)
+}
 
-const asyncGeneratorFunctionTag = '[object AsyncGeneratorFunction]'
+// argument resolver for curry2
+const curry2ResolveArg1 = (
+  baseFunc, arg0,
+) => function arg1Resolver(arg1) {
+  return baseFunc(arg0, arg1)
+}
 
-const isAsyncGeneratorFunction = value => objectToString(value) == asyncGeneratorFunctionTag
+const curry2 = function (baseFunc, arg0, arg1) {
+  return arg0 == __
+    ? curry2ResolveArg0(baseFunc, arg1)
+    : curry2ResolveArg1(baseFunc, arg0)
+}
 
 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)
-
-pipe.sync = pipeSync
+  return pipeline(...args)
+}
 
-const isArray = Array.isArray
+const compose = function (...args) {
+  const funcs = args.pop()
+  const composition = funcs.reduceRight(funcConcat)
 
-const promiseAll = Promise.all.bind(Promise)
+  if (args.length == 0) {
+    return composition
+  }
 
-const funcAll = funcs => function allFuncs(...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
+  if (areAnyValuesPromises(args)) {
+    return promiseAll(args).then(curry2(funcApply, composition, __))
   }
-  return isAsync ? promiseAll(result) : result
+
+  return composition(...args)
 }
 
 const always = value => function getter() { return value }
 
-const __ = Symbol.for('placeholder')
+const thunkifyArgs = (func, args) => function thunk() {
+  return func(...args)
+}
+
+const thunkConditional = (
+  conditionalExpression, thunkOnTruthy, thunkOnFalsy,
+) => conditionalExpression ? thunkOnTruthy() : thunkOnFalsy()
 
 // argument resolver for curry3
 const curry3ResolveArg0 = (
@@ -132,22 +131,62 @@ const curry3 = function (baseFunc, arg0, arg1, arg2) {
   return curry3ResolveArg2(baseFunc, arg0, arg1)
 }
 
-const objectSet = function (object, property, value) {
-  object[property] = value
-  return object
+const tap = func => function tapping(...args) {
+  const result = args[0],
+    call = func(...args)
+  return isPromise(call) ? call.then(always(result)) : result
 }
 
-const funcObjectAll = funcs => function objectAllFuncs(...args) {
-  const result = {}, promises = []
-  for (const key in funcs) {
-    const resultItem = funcs[key](...args)
+tap.if = (predicate, func) => function tappingIf(...args) {
+  const predication = predicate(...args)
+  if (isPromise(predication)) {
+    return predication.then(curry3(
+      thunkConditional, __, thunkifyArgs(tap(func), args), always(args[0])))
+  }
+  if (predication) {
+    const execution = func(...args)
+    if (isPromise(execution)) {
+      return execution.then(always(args[0]))
+    }
+  }
+  return args[0]
+}
+
+const isArray = Array.isArray
+
+// 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)
+}
+
+const curryArgs2 = function (baseFunc, arg0, arg1) {
+  if (arg0 == __) {
+    return curryArgs2ResolveArgs0(baseFunc, arg1)
+  }
+  return curryArgs2ResolveArgs1(baseFunc, arg0)
+}
+
+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)) {
-      promises.push(resultItem.then(curry3(objectSet, result, key, __)))
-    } else {
-      result[key] = resultItem
+      isAsync = true
     }
+    result[funcsIndex] = resultItem
   }
-  return promises.length == 0 ? result : promiseAll(promises).then(always(result))
+  return isAsync ? promiseAll(result) : result
 }
 
 // argument resolver for curry4
@@ -191,7 +230,12 @@ const curry4 = function (baseFunc, arg0, arg1, arg2, arg3) {
   return curry4ResolveArg3(baseFunc, arg0, arg1, arg2)
 }
 
-const asyncFuncAllSeries = async function (funcs, args, result, funcsIndex) {
+const objectSet = function (object, property, value) {
+  object[property] = value
+  return object
+}
+
+const asyncFunctionArrayAllSeries = async function (funcs, args, result, funcsIndex) {
   const funcsLength = funcs.length
   while (++funcsIndex < funcsLength) {
     const resultItem = funcs[funcsIndex](...args)
@@ -200,7 +244,7 @@ const asyncFuncAllSeries = async function (funcs, args, result, funcsIndex) {
   return result
 }
 
-const funcAllSeries = funcs => function allFuncsSeries(...args) {
+const functionArrayAllSeries = function (funcs, args) {
   const funcsLength = funcs.length, result = []
   let funcsIndex = -1
   while (++funcsIndex < funcsLength) {
@@ -208,94 +252,106 @@ const funcAllSeries = funcs => function allFuncsSeries(...args) {
     if (isPromise(resultItem)) {
       return resultItem.then(funcConcat(
         curry3(objectSet, result, funcsIndex, __),
-        curry4(asyncFuncAllSeries, funcs, args, __, funcsIndex)))
+        curry4(asyncFunctionArrayAllSeries, funcs, args, __, funcsIndex)))
     }
     result[funcsIndex] = resultItem
   }
   return result
 }
 
-const fork = funcs => isArray(funcs) ? funcAll(funcs) : funcObjectAll(funcs)
-
-fork.series = funcs => isArray(funcs) ? funcAllSeries(funcs) : funcObjectAll(funcs)
+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))
+}
 
-const objectAssign = Object.assign
+const all = function (...args) {
+  const funcs = args.pop()
+  if (args.length == 0) {
+    return isArray(funcs)
+      ? curryArgs2(functionArrayAll, funcs, __)
+      : curryArgs2(functionObjectAll, funcs, __)
+  }
 
-const assign = function (funcs) {
-  const allFuncs = funcObjectAll(funcs)
-  return function assignment(value) {
-    const result = allFuncs(value)
-    return isPromise(result)
-      ? result.then(curry3(objectAssign, {}, value, __))
-      : ({ ...value, ...result })
+  if (areAnyValuesPromises(args)) {
+    return isArray(funcs)
+      ? promiseAll(args).then(curry2(functionArrayAll, funcs, __))
+      : promiseAll(args).then(curry2(functionObjectAll, funcs, __))
   }
-}
 
-const tapSync = func => function tapping(...args) {
-  func(...args)
-  return args[0]
+  return isArray(funcs)
+    ? functionArrayAll(funcs, args)
+    : functionObjectAll(funcs, args)
 }
 
-const thunkifyArgs = (func, args) => function thunk() {
-  return func(...args)
+all.series = function allSeries(...args) {
+  const funcs = args.pop()
+  if (args.length == 0) {
+    return curryArgs2(functionArrayAllSeries, funcs, __)
+  }
+  if (areAnyValuesPromises(args)) {
+    return promiseAll(args).then(curry2(functionArrayAllSeries, funcs, __))
+  }
+  return functionArrayAllSeries(funcs, args)
 }
 
-const thunkConditional = (
-  conditionalExpression, thunkOnTruthy, thunkOnFalsy,
-) => conditionalExpression ? thunkOnTruthy() : thunkOnFalsy()
+const objectAssign = Object.assign
 
-const tap = func => function tapping(...args) {
-  const result = args[0],
-    call = func(...args)
-  return isPromise(call) ? call.then(always(result)) : result
+// _assign(object Object, funcs Object<function>) -> Promise|Object
+const _assign = function (object, funcs) {
+  const result = functionObjectAll(funcs, [object])
+  return isPromise(result)
+    ? result.then(curry3(objectAssign, {}, object, __))
+    : ({ ...object, ...result })
 }
 
-tap.sync = tapSync
-
-tap.if = (predicate, func) => function tappingIf(...args) {
-  const predication = predicate(...args)
-  if (isPromise(predication)) {
-    return predication.then(curry3(
-      thunkConditional, __, thunkifyArgs(tap(func), args), always(args[0])))
-  }
-  if (predication) {
-    const execution = func(...args)
-    if (isPromise(execution)) {
-      return execution.then(always(args[0]))
-    }
+const assign = function (arg0, arg1) {
+  if (arg1 == null) {
+    return curry2(_assign, __, arg0)
   }
-  return args[0]
+  return isPromise(arg0)
+    ? arg0.then(curry2(_assign, __, arg1))
+    : _assign(arg0, arg1)
 }
 
 const catcherApply = function (catcher, err, args) {
   return catcher(err, ...args)
 }
 
+// _tryCatch(tryer function, catcher function, args Array) -> Promise
+const _tryCatch = function (tryer, catcher, args) {
+  try {
+    const result = tryer(...args)
+    return isPromise(result)
+      ? result.catch(curry3(catcherApply, catcher, __, args))
+      : result
+  } catch (error) {
+    return catcher(error, ...args)
+  }
+}
+
 const tryCatch = function (...args) {
   if (args.length > 2) {
     const catcher = args.pop(),
       tryer = args.pop()
-    try {
-      const result = tryer(...args)
-      return isPromise(result)
-        ? result.catch(curry3(catcherApply, catcher, __, args))
-        : result
-    } catch (error) {
-      return catcher(error, ...args)
+    if (areAnyValuesPromises(args)) {
+      return promiseAll(args)
+        .then(curry3(_tryCatch, tryer, catcher, __))
     }
+    return _tryCatch(tryer, catcher, args)
   }
 
   const tryer = args[0],
     catcher = args[1]
   return function tryCatcher(...args) {
-    try {
-      const result = tryer(...args)
-      return isPromise(result)
-        ? result.catch(curry3(catcherApply, catcher, __, args))
-        : result
-    } catch (error) {
-      return catcher(error, ...args)
-    }
+    return _tryCatch(tryer, catcher, args)
   }
 }
 
@@ -383,13 +439,49 @@ const nonfunctionsConditional = function (array, index) {
   return array[index]
 }
 
-const switchCase = values => {
+// argument resolver for curryArgs3
+const curryArgs3ResolveArgs0 = (
+  baseFunc, arg1, arg2,
+) => function args0Resolver(...args) {
+  return baseFunc(args, arg1, arg2)
+}
+
+// argument resolver for curryArgs3
+const curryArgs3ResolveArgs1 = (
+  baseFunc, arg0, arg2,
+) => function arg1Resolver(...args) {
+  return baseFunc(arg0, args, arg2)
+}
+
+// argument resolver for curryArgs3
+const curryArgs3ResolveArgs2 = (
+  baseFunc, arg0, arg1,
+) => function arg2Resolver(...args) {
+  return baseFunc(arg0, arg1, args)
+}
+
+const curryArgs3 = function (baseFunc, arg0, arg1, arg2) {
+  if (arg0 == __) {
+    return curryArgs3ResolveArgs0(baseFunc, arg1, arg2)
+  }
+  if (arg1 == __) {
+    return curryArgs3ResolveArgs1(baseFunc, arg0, arg2)
+  }
+  return curryArgs3ResolveArgs2(baseFunc, arg0, arg1)
+}
+
+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)
 }
 
 const symbolIterator = Symbol.iterator
@@ -428,26 +520,6 @@ const MappingAsyncIterator = (asyncIterator, mapper) => ({
   }
 })
 
-// argument resolver for curry2
-const curry2ResolveArg0 = (
-  baseFunc, arg1,
-) => function arg0Resolver(arg0) {
-  return baseFunc(arg0, arg1)
-}
-
-// argument resolver for curry2
-const curry2ResolveArg1 = (
-  baseFunc, arg0,
-) => function arg1Resolver(arg1) {
-  return baseFunc(arg0, arg1)
-}
-
-const curry2 = function (baseFunc, arg0, arg1) {
-  return arg0 == __
-    ? curry2ResolveArg0(baseFunc, arg1)
-    : curry2ResolveArg1(baseFunc, arg0)
-}
-
 const isObject = value => {
   if (value == null) {
     return false
@@ -473,31 +545,6 @@ const arrayMap = function (array, mapper) {
   return isAsync ? promiseAll(result) : result
 }
 
-const generatorFunctionMap = (
-  generatorFunc, mapper,
-) => function* mappingGeneratorFunc(...args) {
-  for (const item of generatorFunc(...args)) {
-    yield mapper(item)
-  }
-}
-
-const asyncGeneratorFunctionMap = function (asyncGeneratorFunc, mapper) {
-  return async function* mappingAsyncGeneratorFunc(...args) {
-    for await (const item of asyncGeneratorFunc(...args)) {
-      yield mapper(item)
-    }
-  }
-}
-
-const reducerMap = (
-  reducer, mapper,
-) => function mappingReducer(result, reducerItem) {
-  const mappingReducerItem = mapper(reducerItem)
-  return isPromise(mappingReducerItem)
-    ? mappingReducerItem.then(curry2(reducer, result, __))
-    : reducer(result, mappingReducerItem)
-}
-
 const callPropUnary = (value, property, arg0) => value[property](arg0)
 
 const stringMap = function (string, mapper) {
@@ -608,6 +655,11 @@ const arrayMapSeries = function (array, mapper) {
   return result
 }
 
+const tapSync = func => function tapping(...args) {
+  func(...args)
+  return args[0]
+}
+
 const promiseRace = Promise.race.bind(Promise)
 
 const arrayMapPoolAsync = async function (
@@ -653,38 +705,6 @@ const arrayMapPool = function (array, mapper, concurrentLimit) {
   return result
 }
 
-const arrayMapWithIndex = function (array, mapper) {
-  const arrayLength = array.length,
-    result = Array(arrayLength)
-  let index = -1, isAsync = false
-  while (++index < arrayLength) {
-    const resultItem = mapper(array[index], index, array)
-    if (isPromise(resultItem)) {
-      isAsync = true
-    }
-    result[index] = resultItem
-  }
-  return isAsync ? promiseAll(result) : result
-}
-
-const hasOwnProperty = Object.prototype.hasOwnProperty
-const hasOwn = (obj, key) => hasOwnProperty.call(obj, key)
-
-const objectMapOwn = function (object, mapper) {
-  const result = {}
-  let isAsync = false
-  for (const key in object) {
-    if (hasOwn(object, key)) {
-      const resultItem = mapper(object[key])
-      if (isPromise(resultItem)) {
-        isAsync = true
-      }
-      result[key] = resultItem
-    }
-  }
-  return isAsync ? promiseObjectAll(result) : result
-}
-
 const _curryArity = (arity, func, args) => function curried(...curriedArgs) {
   const argsLength = args.length,
     curriedArgsLength = curriedArgs.length,
@@ -792,15 +812,6 @@ const _map = function (value, mapper) {
   if (isArray(value)) {
     return arrayMap(value, mapper)
   }
-  if (typeof value == 'function') {
-    if (isGeneratorFunction(value)) {
-      return generatorFunctionMap(value, mapper)
-    }
-    if (isAsyncGeneratorFunction(value)) {
-      return asyncGeneratorFunctionMap(value, mapper)
-    }
-    return reducerMap(value, mapper)
-  }
   if (value == null) {
     return value
   }
@@ -834,10 +845,15 @@ const _map = function (value, mapper) {
 
 const map = (...args) => {
   const mapper = args.pop()
-  if (args.length > 0) {
-    return _map(args[0], mapper)
+  if (args.length == 0) {
+    return curry2(_map, __, mapper)
+  }
+
+  const collection = args[0]
+  if (isPromise(collection)) {
+    return collection.then(curry2(_map, __, mapper))
   }
-  return curry2(_map, __, mapper)
+  return _map(collection, mapper)
 }
 
 map.entries = function mapEntries(mapper) {
@@ -869,20 +885,6 @@ map.pool = (concurrencyLimit, mapper) => function concurrentPoolMapping(value) {
   throw new TypeError(`${value} is not an Array`)
 }
 
-map.withIndex = mapper => function mappingWithIndex(value) {
-  if (isArray(value)) {
-    return arrayMapWithIndex(value, mapper)
-  }
-  throw new TypeError(`${value} is not an Array`)
-}
-
-map.own = mapper => function mappingOwnProperties(value) {
-  if (isObject(value) && !isArray(value)) {
-    return objectMapOwn(value, mapper)
-  }
-  throw new TypeError(`${value} is not an Object`)
-}
-
 const FilteringIterator = (iterator, predicate) => ({
   [symbolIterator]() {
     return this
@@ -952,12 +954,11 @@ const arrayFilter = function (array, predicate) {
     resultIndex = -1
   while (++index < arrayLength) {
     const item = array[index],
-      shouldIncludeItem = predicate(item)
+      shouldIncludeItem = predicate(item, index, array)
     if (isPromise(shouldIncludeItem)) {
       return promiseAll(
-        arrayExtendMap(
-          [shouldIncludeItem], array, predicate, index)).then(
-            curry4(arrayFilterByConditions, array, result, index - 1, __))
+        arrayExtendMap([shouldIncludeItem], array, predicate, index)
+      ).then(curry4(arrayFilterByConditions, array, result, index - 1, __))
     }
     if (shouldIncludeItem) {
       result[++resultIndex] = item
@@ -966,31 +967,6 @@ const arrayFilter = function (array, predicate) {
   return result
 }
 
-const generatorFunctionFilter = (
-  generatorFunction, predicate,
-) => function* filteringGeneratorFunction(...args) {
-  yield* FilteringIterator(generatorFunction(...args), predicate)
-}
-
-const asyncGeneratorFunctionFilter = (
-  asyncGeneratorFunction, predicate,
-) => async function* filteringAsyncGeneratorFunction(...args) {
-  yield* FilteringAsyncIterator(asyncGeneratorFunction(...args), predicate)
-}
-
-const reducerFilter = (
-  reducer, predicate,
-) => function filteringReducer(result, item) {
-  const shouldInclude = predicate(item)
-  return isPromise(shouldInclude)
-    ? shouldInclude.then(curry3(
-      thunkConditional,
-      __,
-      thunkify2(reducer, result, item),
-      always(result)))
-    : shouldInclude ? reducer(result, item) : result
-}
-
 const stringFilter = function (string, predicate) {
   const filteredCharactersArray = arrayFilter(string, predicate)
   return isPromise(filteredCharactersArray)
@@ -1002,6 +978,8 @@ const thunkify1 = (func, arg0) => function thunk() {
   return func(arg0)
 }
 
+const noop = function () {}
+
 const setFilter = function (value, predicate) {
   const result = new Set(),
     resultAdd = result.add.bind(result),
@@ -1068,53 +1046,10 @@ const objectFilter = function (object, predicate) {
     : promiseAll(promises).then(always(result))
 }
 
-const arrayExtendMapWithIndex = function (
-  array, values, valuesMapper, valuesIndex,
-) {
-  const valuesLength = values.length
-  let arrayIndex = array.length - 1
-
-  while (++valuesIndex < valuesLength) {
-    array[++arrayIndex] = valuesMapper(
-      values[valuesIndex], valuesIndex, values)
-  }
-  return array
-}
-
-const arrayFilterWithIndex = function (array, predicate) {
-  const arrayLength = array.length,
-    result = []
-  let index = -1,
-    resultIndex = -1
-  while (++index < arrayLength) {
-    const item = array[index],
-      shouldIncludeItem = predicate(item, index, array)
-    if (isPromise(shouldIncludeItem)) {
-      return promiseAll(
-        arrayExtendMapWithIndex(
-          [shouldIncludeItem], array, predicate, index)).then(
-            curry4(arrayFilterByConditions, array, result, index - 1, __))
-    }
-    if (shouldIncludeItem) {
-      result[++resultIndex] = item
-    }
-  }
-  return result
-}
-
 const _filter = function (value, predicate) {
   if (isArray(value)) {
     return arrayFilter(value, predicate)
   }
-  if (typeof value == 'function') {
-    if (isGeneratorFunction(value)) {
-      return generatorFunctionFilter(value, predicate)
-    }
-    if (isAsyncGeneratorFunction(value)) {
-      return asyncGeneratorFunctionFilter(value, predicate)
-    }
-    return reducerFilter(value, predicate)
-  }
   if (value == null) {
     return value
   }
@@ -1145,51 +1080,27 @@ const _filter = function (value, predicate) {
 
 const filter = function (...args) {
   const predicate = args.pop()
-  if (args.length > 0) {
-    return _filter(args[0], predicate)
+  if (args.length == 0) {
+    return curry2(_filter, __, predicate)
   }
-  return curry2(_filter, __, predicate)
+  return _filter(args[0], predicate)
 }
 
-filter.withIndex = predicate => function filteringWithIndex(value) {
-  if (isArray(value)) {
-    return arrayFilterWithIndex(value, predicate)
-  }
-  throw new TypeError(`${value} is not an Array`)
-}
+const objectValues = Object.values
 
-// argument resolver for curryArgs3
-const curryArgs3ResolveArgs0 = (
-  baseFunc, arg1, arg2,
-) => function args0Resolver(...args) {
-  return baseFunc(args, arg1, arg2)
-}
+const objectProto = Object.prototype
 
-// argument resolver for curryArgs3
-const curryArgs3ResolveArgs1 = (
-  baseFunc, arg0, arg2,
-) => function arg1Resolver(...args) {
-  return baseFunc(arg0, args, arg2)
-}
+const nativeObjectToString = objectProto.toString
 
-// argument resolver for curryArgs3
-const curryArgs3ResolveArgs2 = (
-  baseFunc, arg0, arg1,
-) => function arg2Resolver(...args) {
-  return baseFunc(arg0, arg1, args)
-}
+const objectToString = value => nativeObjectToString.call(value)
 
-const curryArgs3 = function (baseFunc, arg0, arg1, arg2) {
-  if (arg0 == __) {
-    return curryArgs3ResolveArgs0(baseFunc, arg1, arg2)
-  }
-  if (arg1 == __) {
-    return curryArgs3ResolveArgs1(baseFunc, arg0, arg2)
-  }
-  return curryArgs3ResolveArgs2(baseFunc, arg0, arg1)
-}
+const generatorFunctionTag = '[object GeneratorFunction]'
 
-const objectValues = Object.values
+const isGeneratorFunction = value => objectToString(value) == generatorFunctionTag
+
+const asyncGeneratorFunctionTag = '[object AsyncGeneratorFunction]'
+
+const isAsyncGeneratorFunction = value => objectToString(value) == asyncGeneratorFunctionTag
 
 const iteratorReduceAsync = async function (
   iterator, reducer, result,
@@ -1326,13 +1237,6 @@ const curry5 = function (baseFunc, arg0, arg1, arg2, arg3, arg4) {
 
 const objectKeys = Object.keys
 
-const objectGetFirstKey = function (object) {
-  for (const key in object) {
-    return key
-  }
-  return undefined
-}
-
 const objectReduceAsync = async function (object, reducer, result, keys, index) {
   const keysLength = keys.length
   while (++index < keysLength) {
@@ -1393,18 +1297,6 @@ const mapReduce = function (map, reducer, result) {
   return result
 }
 
-const generatorFunctionReduce = (
-  generatorFunction, reducer, result,
-) => funcConcatSync(
-  generatorFunction,
-  curry3(iteratorReduce, __, reducer, result))
-
-const asyncGeneratorFunctionReduce = (
-  asyncGeneratorFunction, reducer, result,
-) => funcConcatSync(
-  asyncGeneratorFunction,
-  curry3(asyncIteratorReduce, __, reducer, result))
-
 const reducerConcat = (
   reducerA, reducerB,
 ) => function pipedReducer(result, item) {
@@ -1414,26 +1306,10 @@ const reducerConcat = (
     : reducerB(intermediate, item)
 }
 
-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, __)
@@ -1468,38 +1344,33 @@ const genericReduce = function (args, reducer, result) {
     : reducer(result, collection)
 }
 
-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)
+// _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)
+}
 
-  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)
-    }
+const reduce = function (...args) {
+  if (typeof args[0] == 'function') {
+    return curry3(_reduce, __, args[0], args[1])
+  }
+  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])
 }
 
 const isBinary = ArrayBuffer.isView
 
 const add = (a, b) => a + b
 
-const isArrayLike = function (value) {
-  return value != null && value.length > 0
-}
-
 const _arrayExtend = function (array, values) {
   const arrayLength = array.length,
     valuesLength = values.length
@@ -1511,7 +1382,7 @@ const _arrayExtend = function (array, values) {
 }
 
 const arrayExtend = function (array, values) {
-  if (isArrayLike(values)) {
+  if (isArray(values) || isBinary(values)) {
     return _arrayExtend(array, values)
   }
   array.push(values)
@@ -1582,57 +1453,66 @@ const callConcat = function (object, values) {
   return object.concat(values)
 }
 
-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
 }
 
-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)
 }
 
-const transform = function (transducer, init) {
-  if (typeof init == 'function') {
-    return function transforming(...args) {
-      const result = init(...args)
-      return isPromise(result)
-        ? result.then(curry3(genericTransform, args, transducer, __))
-        : genericTransform(args, transducer, result)
-    }
+// _transform(collection any, transducer function, initialValue function|any) -> Promise
+const _transform = function (collection, transducer, initialValue) {
+  if (typeof initialValue == 'function') {
+    const actualInitialValue = initialValue(collection)
+    return isPromise(actualInitialValue)
+      ? actualInitialValue.then(curry3(genericTransform, collection, transducer, __))
+      : genericTransform(collection, transducer, actualInitialValue)
+  }
+  return isPromise(initialValue)
+    ? initialValue.then(curry3(genericTransform, collection, transducer, __))
+    : genericTransform(collection, transducer, initialValue)
+}
+
+const transform = function (...args) {
+  if (typeof args[0] == 'function') {
+    return curry3(_transform, __, args[0], args[1])
   }
-  return function transforming(...args) {
-    return genericTransform(args, transducer, init)
+  if (isPromise(args[0])) {
+    return args[0].then(curry3(_transform, __, args[1], args[2]))
   }
+  return _transform(args[0], args[1], args[2])
 }
 
 const arrayPush = function (array, value) {
@@ -1659,7 +1539,7 @@ const FlatMappingIterator = function (iterator, flatMapper) {
         return iteration
       }
       const monadAsArray = genericReduce(
-        [flatMapper(iteration.value)],
+        flatMapper(iteration.value),
         arrayPush,
         []) // this will always have at least one item
       if (monadAsArray.length > 1) {
@@ -1703,12 +1583,12 @@ const FlatMappingAsyncIterator = function (asyncIterator, flatMapper) {
           } else {
             const monad = flatMapper(value)
             if (isPromise(monad)) {
-              const bufferLoading = monad.then(
-              curryArgs3(genericReduce, __, arrayPush, buffer))
+              const bufferLoading =
+                monad.then(curry3(genericReduce, __, arrayPush, buffer))
               const promise = bufferLoading.then(() => promises.delete(promise))
               promises.add(promise)
             } else {
-              const bufferLoading = genericReduce([monad], arrayPush, buffer)
+              const bufferLoading = genericReduce(monad, arrayPush, buffer)
               if (isPromise(bufferLoading)) {
                 const promise = bufferLoading.then(() => promises.delete(promise))
                 promises.add(promise)
@@ -1732,6 +1612,12 @@ const getArg1 = (arg0, arg1) => arg1
 
 const identity = value => value
 
+const funcConcatSync = (
+  funcA, funcB,
+) => function pipedFunction(...args) {
+  return funcB(funcA(...args))
+}
+
 const asyncIteratorForEach = async function (asyncIterator, callback) {
   const promises = []
   for await (const item of asyncIterator) {
@@ -1911,149 +1797,17 @@ const arrayFlattenToString = funcConcat(
   arrayFlatten,
   curry2(arrayJoin, __, ''))
 
-const stringFlatMap = function (string, flatMapper) {
-  const monadArray = arrayMap(string, flatMapper)
-  return isPromise(monadArray)
-    ? monadArray.then(arrayFlattenToString)
-    : arrayFlattenToString(monadArray)
-}
-
-const streamWrite = function (stream, chunk, encoding, callback) {
-  stream.write(chunk, encoding, callback)
-  return stream
-}
-
-const streamFlatExtend = async function (stream, item) {
-  const resultStreamWrite = curry2(streamWrite, stream, __),
-    // resultStreamWriteReducer = (_, subItem) => stream.write(subItem),
-    resultStreamWriteReducer = funcConcatSync(getArg1, resultStreamWrite),
-    promises = []
-  if (isArray(item)) {
-    const itemLength = item.length
-    let itemIndex = -1
-    while (++itemIndex < itemLength) {
-      stream.write(item[itemIndex])
-    }
-  } else if (item == null) {
-    stream.write(item)
-  } else if (typeof item[symbolIterator] == 'function') {
-    for (const subItem of item) {
-      stream.write(subItem)
-    }
-  } else if (typeof item[symbolAsyncIterator] == 'function') {
-    promises.push(
-      asyncIteratorForEach(item[symbolAsyncIterator](), resultStreamWrite))
-  } else if (typeof item.chain == 'function') {
-    const monadValue = item.chain(identity)
-    isPromise(monadValue)
-      ? promises.push(monadValue.then(resultStreamWrite))
-      : stream.write(monadValue)
-  } else if (typeof item.flatMap == 'function') {
-    const monadValue = item.flatMap(identity)
-    isPromise(monadValue)
-      ? promises.push(monadValue.then(resultStreamWrite))
-      : stream.write(monadValue)
-  } else if (typeof item.reduce == 'function') {
-    const folded = item.reduce(resultStreamWriteReducer, null)
-    isPromise(folded) && promises.push(folded)
-  } else if (item.constructor == Object) {
-    for (const key in item) {
-      stream.write(item[key])
-    }
-  } else {
-    stream.write(item)
-  }
-  return promises.length == 0
-    ? stream
-    : promiseAll(promises).then(always(stream))
-}
-
-const streamFlatMap = async function (stream, flatMapper) {
-  const promises = new Set()
-  for await (const item of stream) {
-    const monad = flatMapper(item)
-    if (isPromise(monad)) {
-      const selfDeletingPromise = monad.then(
-        curry2(streamFlatExtend, stream, __)).then(
-          () => promises.delete(selfDeletingPromise))
-      promises.add(selfDeletingPromise)
-    } else {
-      const streamFlatteningOperation = streamFlatExtend(stream, monad)
-      if (isPromise(streamFlatteningOperation)) {
-        const selfDeletingPromise = streamFlatteningOperation.then(
-          () => promises.delete(selfDeletingPromise))
-        promises.add(selfDeletingPromise)
-      }
-    }
-  }
-  await promiseAll(promises)
-  return stream
-}
-
-const arrayJoinToBinary = function (array, init) {
-  const length = array.length
-  let index = -1,
-    result = init
-  while (++index < length) {
-    result = binaryExtend(result, array[index])
-  }
-  return result
-}
-
-const arrayFlattenToBinary = function (array, result) {
-  const flattened = arrayFlatten(array)
-  return isPromise(flattened)
-    ? flattened.then(curry2(arrayJoinToBinary, __, result))
-    : arrayJoinToBinary(flattened, result)
-}
-
-const binaryFlatMap = function (binary, flatMapper) {
-  const monadArray = arrayMap(binary, flatMapper),
-    result = globalThisHasBuffer && binary.constructor == Buffer
-      ? bufferAlloc(0)
-      : new binary.constructor(0)
-  return isPromise(monadArray)
-    ? monadArray.then(curry2(arrayFlattenToBinary, __, result))
-    : arrayFlattenToBinary(monadArray, result)
-}
-
-const reducerFlatMap = (
-  reducer, flatMapper,
-) => function flatMappingReducer(result, value) {
-  const monad = flatMapper(value)
-  return isPromise(monad)
-    ? monad.then(curryArgs3(genericReduce, __, reducer, result))
-    : genericReduce([monad], reducer, result)
-}
-
-const generatorFunctionFlatMap = (
-  generatorFunction, flatMapper,
-) => function* flatMappingGeneratorFunction(...args) {
-  yield* FlatMappingIterator(generatorFunction(...args), flatMapper)
-}
-
-const asyncGeneratorFunctionFlatMap = (
-  asyncGeneratorFunction, flatMapper,
-) => async function* flatMappingAsyncGeneratorFunction(...args) {
-  yield* FlatMappingAsyncIterator(asyncGeneratorFunction(...args), flatMapper)
+const stringFlatMap = function (string, flatMapper) {
+  const monadArray = arrayMap(string, flatMapper)
+  return isPromise(monadArray)
+    ? monadArray.then(arrayFlattenToString)
+    : arrayFlattenToString(monadArray)
 }
 
-const flatMap = flatMapper => function flatMapping(value) {
+const _flatMap = function (value, flatMapper) {
   if (isArray(value)) {
     return arrayFlatMap(value, flatMapper)
   }
-  if (typeof value == 'function') {
-    if (isGeneratorFunction(value)) {
-      return generatorFunctionFlatMap(value, flatMapper)
-    }
-    if (isAsyncGeneratorFunction(value)) {
-      return asyncGeneratorFunctionFlatMap(value, flatMapper)
-    }
-    return reducerFlatMap(value, flatMapper)
-  }
-  if (isBinary(value)) {
-    return binaryFlatMap(value, flatMapper)
-  }
   if (value == null) {
     return flatMapper(value)
   }
@@ -2072,12 +1826,6 @@ const flatMap = flatMapper => function flatMapping(value) {
   if (typeof value.flatMap == 'function') {
     return value.flatMap(flatMapper)
   }
-  if (
-    typeof value[symbolAsyncIterator] == 'function'
-      && typeof value.write == 'function'
-  ) {
-    return streamFlatMap(value, flatMapper)
-  }
   const valueConstructor = value.constructor
   if (valueConstructor == Object) {
     return objectFlatMap(value, flatMapper)
@@ -2091,12 +1839,93 @@ const flatMap = flatMapper => function flatMapping(value) {
   return flatMapper(value)
 }
 
+const flatMap = (...args) => {
+  const flatMapper = args.pop()
+  if (args.length == 0) {
+    return curry2(_flatMap, __, flatMapper)
+  }
+  const collection = args[0]
+  return isPromise(collection)
+    ? collection.then(curry2(_flatMap, __, flatMapper))
+    : _flatMap(args[0], flatMapper)
+}
+
+const arrayForEach = function (array, callback) {
+  const length = array.length,
+    promises = []
+  let index = -1
+  while (++index < length) {
+    const operation = callback(array[index])
+    if (isPromise(operation)) {
+      promises.push(operation)
+    }
+  }
+  return promises.length == 0 ? array : promiseAll(promises).then(always(array))
+}
+
+const objectForEach = function (object, callback) {
+  const promises = []
+  for (const key in object) {
+    const operation = callback(object[key])
+    if (isPromise(operation)) {
+      promises.push(operation)
+    }
+  }
+  return promises.length == 0 ? object : promiseAll(promises).then(always(object))
+}
+
+const iteratorForEach = function (iterator, callback) {
+  const promises = []
+  for (const item of iterator) {
+    const operation = callback(item)
+    if (isPromise(operation)) {
+      promises.push(operation)
+    }
+  }
+  return promises.length == 0 ? iterator : promiseAll(promises).then(always(iterator))
+}
+
+// type Collection = Array|Iterable|AsyncIterable|{ forEach: function }|Object
+// _forEach(collection Collection, callback function) -> collection Collection
+const _forEach = function (collection, callback) {
+  if (isArray(collection)) {
+    return arrayForEach(collection, callback)
+  }
+  if (collection == null) {
+    return collection
+  }
+  if (typeof collection.forEach == 'function') {
+    return collection.forEach(callback)
+  }
+  if (typeof collection[symbolIterator] == 'function') {
+    return iteratorForEach(collection[symbolIterator](), callback)
+  }
+  if (typeof collection[symbolAsyncIterator] == 'function') {
+    return asyncIteratorForEach(collection[symbolAsyncIterator](), callback)
+  }
+  if (collection.constructor == Object) {
+    return objectForEach(collection, callback)
+  }
+  return collection
+}
+
+const forEach = function (...args) {
+  const callback = args.pop()
+  if (args.length == 0) {
+    return curry2(_forEach, __, callback)
+  }
+  const collection = args[0]
+  return isPromise(collection)
+    ? collection.then(curry2(_forEach, __, callback))
+    : _forEach(collection, callback)
+}
+
 const SelfReferencingPromise = function (basePromise) {
   const promise = basePromise.then(res => [res, promise])
   return promise
 }
 
-const asyncArrayAny = async function (
+const asyncArraySome = async function (
   array, predicate, index, promisesInFlight,
 ) {
   const length = array.length
@@ -2119,13 +1948,13 @@ const asyncArrayAny = async function (
   return false
 }
 
-const arrayAny = function (array, predicate) {
+const arraySome = function (array, predicate) {
   const length = array.length
   let index = -1
   while (++index < length) {
     const predication = predicate(array[index])
     if (isPromise(predication)) {
-      return asyncArrayAny(
+      return asyncArraySome(
         array, predicate, index, new Set([SelfReferencingPromise(predication)]))
     }
     if (predication) {
@@ -2135,7 +1964,7 @@ const arrayAny = function (array, predicate) {
   return false
 }
 
-const asyncIteratorAny = async function (
+const asyncIteratorSome = async function (
   iterator, predicate, promisesInFlight, maxConcurrency = 20,
 ) {
   let iteration = iterator.next()
@@ -2172,11 +2001,11 @@ const asyncIteratorAny = async function (
   return false
 }
 
-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) {
@@ -2190,35 +2019,52 @@ const reducerAnySync = predicate => function anyReducer(result, item) {
   return result ? true : predicate(item)
 }
 
-const reducerAny = predicate => function anyReducer(result, item) {
+const reducerSome = predicate => function anyReducer(result, item) {
   return result === true ? result
     : isPromise(result) ? result.then(curry2(reducerAnySync(predicate), __, item))
     : result ? true : predicate(item)
 }
 
-const any = predicate => function anyTruthy(value) {
-  if (isArray(value)) {
-    return arrayAny(value, predicate)
+// _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 (value == null) {
-    return predicate(value)
+  if (collection == null) {
+    return predicate(collection)
   }
-  if (typeof value[symbolIterator] == 'function') {
-    return iteratorAny(value[symbolIterator](), predicate)
+  if (typeof collection[symbolIterator] == 'function') {
+    return iteratorSome(collection[symbolIterator](), predicate)
   }
-  if (typeof value[symbolAsyncIterator] == 'function') {
-    return asyncIteratorAny(value[symbolAsyncIterator](), predicate, new Set())
+  if (typeof collection[symbolAsyncIterator] == 'function') {
+    return asyncIteratorSome(
+      collection[symbolAsyncIterator](), predicate, new Set()
+    )
+  }
+  if (typeof collection.reduce == 'function') {
+    return collection.reduce(reducerSome(predicate), false)
   }
-  if (typeof value.reduce == 'function') {
-    return value.reduce(reducerAny(predicate), false)
+  if (collection.constructor == Object) {
+    return arraySome(objectValues(collection), predicate)
   }
-  if (value.constructor == Object) {
-    return arrayAny(objectValues(value), predicate)
+  return predicate(collection)
+}
+
+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 predicate(value)
+
+  return _some(collection, predicate)
 }
 
-const arrayAll = function (array, predicate) {
+const arrayEvery = function (array, predicate) {
   const arrayLength = array.length,
     promises = []
   let index = -1
@@ -2235,7 +2081,7 @@ const arrayAll = function (array, predicate) {
     : promiseAll(promises).then(curry3(callPropUnary, __, 'every', Boolean))
 }
 
-const iteratorAll = function (iterator, predicate) {
+const iteratorEvery = function (iterator, predicate) {
   const promises = []
   for (const item of iterator) {
     const predication = predicate(item)
@@ -2250,7 +2096,7 @@ const iteratorAll = function (iterator, predicate) {
     : promiseAll(promises).then(curry3(callPropUnary, __, 'every', Boolean))
 }
 
-const asyncIteratorAll = async function (
+const asyncIteratorEvery = async function (
   asyncIterator, predicate, promisesInFlight, maxConcurrency = 20,
 ) {
   let iteration = await asyncIterator.next()
@@ -2283,45 +2129,62 @@ const asyncIteratorAll = async function (
 
 const reducerAllSync = (predicate, result, item) => result ? predicate(item) : false
 
-const reducerAll = predicate => function allReducer(result, item) {
+const reducerEvery = predicate => function allReducer(result, item) {
   return result === false ? false
     : isPromise(result) ? result.then(
       curry3(reducerAllSync, predicate, __, item))
     : result ? predicate(item) : false
 }
 
-const all = predicate => function allTruthy(value) {
-  if (isArray(value)) {
-    return arrayAll(value, predicate)
+// _every(collection Array|Iterable|AsyncIterable|{ reduce: function }|Object, predicate function) -> Promise|boolean
+const _every = function (collection, predicate) {
+  if (isArray(collection)) {
+    return arrayEvery(collection, predicate)
   }
-  if (value == null) {
-    return predicate(value)
+  if (collection == null) {
+    return predicate(collection)
   }
 
-  if (typeof value[symbolIterator] == 'function') {
-    return iteratorAll(value[symbolIterator](), predicate)
+  if (typeof collection[symbolIterator] == 'function') {
+    return iteratorEvery(collection[symbolIterator](), predicate)
   }
-  if (typeof value[symbolAsyncIterator] == 'function') {
-    return asyncIteratorAll(value[symbolAsyncIterator](), predicate, new Set())
+  if (typeof collection[symbolAsyncIterator] == 'function') {
+    return asyncIteratorEvery(
+      collection[symbolAsyncIterator](), predicate, new Set()
+    )
   }
-  if (typeof value.reduce == 'function') {
-    return value.reduce(reducerAll(predicate), true)
+  if (typeof collection.reduce == 'function') {
+    return collection.reduce(reducerEvery(predicate), true)
   }
-  if (value.constructor == Object) {
-    return arrayAll(objectValues(value), predicate)
+  if (collection.constructor == Object) {
+    return arrayEvery(objectValues(collection), predicate)
+  }
+  return predicate(collection)
+}
+
+const every = function (...args) {
+  const predicate = args.pop()
+  if (args.length == 0) {
+    return curry2(_every, __, predicate)
+  }
+
+  const collection = args[0]
+  if (isPromise(collection)) {
+    return collection.then(curry2(_every, __, predicate))
   }
-  return predicate(value)
+
+  return _every(collection, predicate)
 }
 
-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),
       ))
     }
@@ -2332,12 +2195,12 @@ const areAllNonfunctionsTruthy = function (predicates, index) {
   return true
 }
 
-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
@@ -2349,39 +2212,53 @@ const asyncArePredicatesAllTruthy = async function (predicates, point, index) {
   return true
 }
 
-const and = predicates => {
-  if (areAllValuesNonfunctions(predicates)) {
-    return areAllNonfunctionsTruthy(predicates, -1)
-  }
-  return function arePredicatesAllTruthy(point) {
-    const length = predicates.length
-    let index = -1
+// 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(point)
-      }
-      if (isPromise(predicate)) {
-        return predicate.then(curry3(
-          thunkConditional,
-          __,
-          thunkify3(asyncArePredicatesAllTruthy, predicates, point, index),
-          always(false),
-        ))
-      }
-      if (!predicate) {
-        return false
-      }
+  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
   }
+  return true
+}
+
+const and = function (...args) {
+  const predicatesOrValues = args.pop()
+  if (areAllValuesNonfunctions(predicatesOrValues)) {
+    return areAllValuesTruthy(predicatesOrValues, -1)
+  }
+
+  if (args.length == 0) {
+    return curryArgs2(areAllPredicatesTruthy, __, predicatesOrValues)
+  }
+
+  if (areAnyValuesPromises(args)) {
+    return promiseAll(args)
+      .then(curry2(areAllPredicatesTruthy, __, predicatesOrValues))
+  }
+
+  return areAllPredicatesTruthy(args, predicatesOrValues)
 }
 
 const areAnyNonfunctionsTruthy = 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,
@@ -2397,14 +2274,13 @@ const areAnyNonfunctionsTruthy = function (predicates, index) {
   return false
 }
 
-const asyncAreAnyPredicatesTruthy = async function (predicates, point, index) {
+const asyncAreAnyPredicatesTruthy = 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)
     }
-    console.log('hey - or', predicate)
     if (isPromise(predicate)) {
       predicate = await predicate
     }
@@ -2415,275 +2291,225 @@ const asyncAreAnyPredicatesTruthy = async function (predicates, point, index) {
   return false
 }
 
-const or = predicates => {
-  if (areAllValuesNonfunctions(predicates)) {
-    return areAnyNonfunctionsTruthy(predicates, -1)
-  }
-  return function areAnyPredicatesTruthy(point) {
-    const length = predicates.length
-    let index = -1
+// areAnyPredicatesTruthy(args Array, predicates Array<function>) -> Promise|boolean
+const areAnyPredicatesTruthy = function (args, predicates) {
+  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,
-          __,
-          always(true),
-          thunkify3(asyncAreAnyPredicatesTruthy, predicates, point, index),
-        ))
-      }
-      if (predicate) {
-        return true
-      }
+  while (++index < length) {
+    let predicate = predicates[index]
+    if (typeof predicate == 'function') {
+      predicate = predicate(...args)
+    }
+    if (isPromise(predicate)) {
+      return predicate.then(curry3(
+        thunkConditional,
+        __,
+        always(true),
+        thunkify3(asyncAreAnyPredicatesTruthy, args, predicates, index),
+      ))
+    }
+    if (predicate) {
+      return true
     }
-    return false
   }
+  return false
 }
 
-// true -> false
-const _not = value => !value
-
-const not = function (funcOrValue) {
-  if (typeof funcOrValue == 'function') {
-    return function logicalInverter(value) {
-      const boolean = funcOrValue(value)
-      return isPromise(boolean) ? boolean.then(_not) : !boolean
-    }
+const or = function (...args) {
+  const predicatesOrValues = args.pop()
+  if (areAllValuesNonfunctions(predicatesOrValues)) {
+    return areAnyNonfunctionsTruthy(predicatesOrValues, -1)
   }
-  return !funcOrValue
-}
 
-const notSync = func => function notSync(...args) {
-  return !func(...args)
-}
+  if (args.length == 0) {
+    return curryArgs2(areAnyPredicatesTruthy, __, predicatesOrValues)
+  }
 
-not.sync = notSync
+  if (areAnyValuesPromises(args)) {
+    return promiseAll(args)
+      .then(curry2(areAnyPredicatesTruthy, __, predicatesOrValues))
+  }
 
-const sameValueZero = function (left, right) {
-  return left === right || (left !== left && right !== right)
+  return areAnyPredicatesTruthy(args, predicatesOrValues)
 }
 
-const eq = function (left, right) {
-  const isLeftResolver = typeof left == 'function',
-    isRightResolver = typeof right == 'function'
+// negate(value boolean) -> inverse boolean
+const negate = value => !value
 
-  if (isLeftResolver && isRightResolver) {
-    return function equalBy(value) {
-      const leftResolve = left(value),
-        rightResolve = right(value)
-      const isLeftPromise = isPromise(leftResolve),
-        isRightPromise = isPromise(rightResolve)
-      if (isLeftPromise && isRightPromise) {
-        return promiseAll(
-          [leftResolve, rightResolve]).then(spread2(sameValueZero))
-      } else if (isLeftPromise) {
-        return leftResolve.then(curry2(sameValueZero, __, rightResolve))
-      } else if (isRightPromise) {
-        return rightResolve.then(curry2(sameValueZero, leftResolve, __))
-      }
-      return sameValueZero(leftResolve, rightResolve)
-    }
-  }
+// _not(args Array, predicate function)
+const _not = function (args, predicate) {
+  const boolean = predicate(...args)
+  return isPromise(boolean) ? boolean.then(negate) : !boolean
+}
 
-  if (isLeftResolver) {
-    return function equalBy(value) {
-      const leftResolve = left(value)
-      return isPromise(leftResolve)
-        ? leftResolve.then(curry2(sameValueZero, __, right))
-        : sameValueZero(leftResolve, right)
+const not = function (...args) {
+  const predicateOrValue = args.pop()
+  if (typeof predicateOrValue == 'function') {
+    if (args.length == 0) {
+      return curryArgs2(_not, __, predicateOrValue)
     }
-  }
-  if (isRightResolver) {
-    return function equalBy(value) {
-      const rightResolve = right(value)
-      return isPromise(rightResolve)
-        ? rightResolve.then(curry2(sameValueZero, left, __))
-        : sameValueZero(left, rightResolve)
+    if (areAnyValuesPromises(args)) {
+      return promiseAll(args).then(curry2(_not, __, predicateOrValue))
     }
+    return _not(args, predicateOrValue)
   }
+  return !predicateOrValue
+}
 
-  return sameValueZero(left, right)
+// argument resolver for curryArgs4
+const curryArgs4ResolveArgs0 = (
+  baseFunc, arg1, arg2, arg3,
+) => function args0Resolver(...args) {
+  return baseFunc(args, arg1, arg2, arg3)
 }
 
-const greaterThan = (left, right) => left > right
+// argument resolver for curryArgs4
+const curryArgs4ResolveArgs1 = (
+  baseFunc, arg0, arg2, arg3,
+) => function args1Resolver(...args) {
+  return baseFunc(arg0, args, arg2, arg3)
+}
 
-const gt = function (left, right) {
-  const isLeftResolver = typeof left == 'function',
-    isRightResolver = typeof right == 'function'
+// argument resolver for curryArgs4
+const curryArgs4ResolveArgs2 = (
+  baseFunc, arg0, arg1, arg3,
+) => function args2Resolver(...args) {
+  return baseFunc(arg0, arg1, args, arg3)
+}
 
-  if (isLeftResolver && isRightResolver) {
-    return function greaterThanBy(value) {
-      const leftResolve = left(value),
-        rightResolve = right(value)
-      const isLeftPromise = isPromise(leftResolve),
-        isRightPromise = isPromise(rightResolve)
-      if (isLeftPromise && isRightPromise) {
-        return promiseAll(
-          [leftResolve, rightResolve]).then(spread2(greaterThan))
-      } else if (isLeftPromise) {
-        return leftResolve.then(curry2(greaterThan, __, rightResolve))
-      } else if (isRightPromise) {
-        return rightResolve.then(curry2(greaterThan, leftResolve, __))
-      }
-      return leftResolve > rightResolve
-    }
-  }
+// argument resolver for curryArgs4
+const curryArgs4ResolveArgs3 = (
+  baseFunc, arg0, arg1, arg2,
+) => function args3Resolver(...args) {
+  return baseFunc(arg0, arg1, arg2, args)
+}
 
-  if (isLeftResolver) {
-    return function greaterThanBy(value) {
-      const leftResolve = left(value)
-      return isPromise(leftResolve)
-        ? leftResolve.then(curry2(greaterThan, __, right))
-        : leftResolve > right
-    }
+const curryArgs4 = function (baseFunc, arg0, arg1, arg2, arg3) {
+  if (arg0 == __) {
+    return curryArgs4ResolveArgs0(baseFunc, arg1, arg2, arg3)
   }
-  if (isRightResolver) {
-    return function strictEqualBy(value) {
-      const rightResolve = right(value)
-      return isPromise(rightResolve)
-        ? rightResolve.then(curry2(greaterThan, left, __))
-        : left > rightResolve
-    }
+  if (arg1 == __) {
+    return curryArgs4ResolveArgs1(baseFunc, arg0, arg2, arg3)
+  }
+  if (arg2 == __) {
+    return curryArgs4ResolveArgs2(baseFunc, arg0, arg1, arg3)
+  }
+  return curryArgs4ResolveArgs3(baseFunc, arg0, arg1, arg2)
+}
+
+// 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)
+}
 
-  return left > right
+// 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)
 }
 
-const lessThan = (left, right) => left < right
+// 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)
+}
 
-const lt = function (left, right) {
+// ComparisonOperator(comparator function) -> operator function
+const ComparisonOperator = comparator => function operator(...args) {
+  const right = args.pop()
+  const left = args.pop()
   const isLeftResolver = typeof left == 'function',
     isRightResolver = typeof right == 'function'
 
   if (isLeftResolver && isRightResolver) {
-    return function lessThanBy(value) {
-      const leftResolve = left(value),
-        rightResolve = right(value)
-      const isLeftPromise = isPromise(leftResolve),
-        isRightPromise = isPromise(rightResolve)
-      if (isLeftPromise && isRightPromise) {
-        return promiseAll(
-          [leftResolve, rightResolve]).then(spread2(lessThan))
-      } else if (isLeftPromise) {
-        return leftResolve.then(curry2(lessThan, __, rightResolve))
-      } else if (isRightPromise) {
-        return rightResolve.then(curry2(lessThan, leftResolve, __))
-      }
-      return leftResolve < rightResolve
+    if (args.length == 0) {
+      return curryArgs4(
+        leftResolverRightResolverCompare, __, comparator, left, right,
+      )
+    }
+    if (areAnyValuesPromises(args)) {
+      return promiseAll(args).then(curry4(
+        leftResolverRightResolverCompare, __, comparator, left, right,
+      ))
     }
+    return leftResolverRightResolverCompare(args, comparator, left, right)
   }
 
   if (isLeftResolver) {
-    return function lessThanBy(value) {
-      const leftResolve = left(value)
-      return isPromise(leftResolve)
-        ? leftResolve.then(curry2(lessThan, __, right))
-        : leftResolve < right
+    if (args.length == 0) {
+      return curryArgs4(
+        leftResolverRightValueCompare, __, comparator, left, right,
+      )
     }
+    if (areAnyValuesPromises(args)) {
+      return promiseAll(args).then(curry4(
+        leftResolverRightValueCompare, __, comparator, left, right,
+      ))
+    }
+    return leftResolverRightValueCompare(args, comparator, left, right)
   }
+
   if (isRightResolver) {
-    return function lessThanBy(value) {
-      const rightResolve = right(value)
-      return isPromise(rightResolve)
-        ? rightResolve.then(curry2(lessThan, left, __))
-        : left < rightResolve
+    if (args.length == 0) {
+      return curryArgs4(
+        leftValueRightResolverCompare, __, comparator, left, right,
+      )
     }
+    if (areAnyValuesPromises(args)) {
+      return promiseAll(args).then(curry4(
+        leftValueRightResolverCompare, __, comparator, left, right,
+      ))
+    }
+    return leftValueRightResolverCompare(args, comparator, left, right)
   }
 
-  return left < right
+  if (isPromise(left) || isPromise(right)) {
+    return promiseAll([left, right]).then(spread2(comparator))
+  }
+  return comparator(left, right)
 }
 
-const greaterThanOrEqual = (left, right) => left >= right
+const equals = function (left, right) {
+  return left == right
+}
 
-const gte = function (left, right) {
-  const isLeftResolver = typeof left == 'function',
-    isRightResolver = typeof right == 'function'
+const eq = ComparisonOperator(equals)
 
-  if (isLeftResolver && isRightResolver) {
-    return function greaterThanOrEqualBy(value) {
-      const leftResolve = left(value),
-        rightResolve = right(value)
-      const isLeftPromise = isPromise(leftResolve),
-        isRightPromise = isPromise(rightResolve)
-      if (isLeftPromise && isRightPromise) {
-        return promiseAll(
-          [leftResolve, rightResolve]).then(spread2(greaterThanOrEqual))
-      } else if (isLeftPromise) {
-        return leftResolve.then(curry2(greaterThanOrEqual, __, rightResolve))
-      } else if (isRightPromise) {
-        return rightResolve.then(curry2(greaterThanOrEqual, leftResolve, __))
-      }
-      return leftResolve >= rightResolve
-    }
-  }
+const greaterThan = (left, right) => left > right
 
-  if (isLeftResolver) {
-    return function greaterThanOrEqualBy(value) {
-      const leftResolve = left(value)
-      return isPromise(leftResolve)
-        ? leftResolve.then(curry2(greaterThanOrEqual, __, right))
-        : leftResolve >= right
-    }
-  }
-  if (isRightResolver) {
-    return function greaterThanOrEqualBy(value) {
-      const rightResolve = right(value)
-      return isPromise(rightResolve)
-        ? rightResolve.then(curry2(greaterThanOrEqual, left, __))
-        : left >= rightResolve
-    }
-  }
+const gt = ComparisonOperator(greaterThan)
 
-  return left >= right
-}
+const lessThan = (left, right) => left < right
 
-const lessThanOrEqual = (left, right) => left <= right
+const lt = ComparisonOperator(lessThan)
 
-const lte = function (left, right) {
-  const isLeftResolver = typeof left == 'function',
-    isRightResolver = typeof right == 'function'
+const greaterThanOrEqual = (left, right) => left >= right
 
-  if (isLeftResolver && isRightResolver) {
-    return function lessThanOrEqualBy(value) {
-      const leftResolve = left(value),
-        rightResolve = right(value)
-      const isLeftPromise = isPromise(leftResolve),
-        isRightPromise = isPromise(rightResolve)
-      if (isLeftPromise && isRightPromise) {
-        return promiseAll(
-          [leftResolve, rightResolve]).then(spread2(lessThanOrEqual))
-      } else if (isLeftPromise) {
-        return leftResolve.then(curry2(lessThanOrEqual, __, rightResolve))
-      } else if (isRightPromise) {
-        return rightResolve.then(curry2(lessThanOrEqual, leftResolve, __))
-      }
-      return leftResolve <= rightResolve
-    }
-  }
+const gte = ComparisonOperator(greaterThanOrEqual)
 
-  if (isLeftResolver) {
-    return function lessThanOrEqualBy(value) {
-      const leftResolve = left(value)
-      return isPromise(leftResolve)
-        ? leftResolve.then(curry2(lessThanOrEqual, __, right))
-        : leftResolve <= right
-    }
-  }
-  if (isRightResolver) {
-    return function lessThanOrEqualBy(value) {
-      const rightResolve = right(value)
-      return isPromise(rightResolve)
-        ? rightResolve.then(curry2(lessThanOrEqual, left, __))
-        : left <= rightResolve
-    }
-  }
+const lessThanOrEqual = (left, right) => left <= right
 
-  return left <= right
-}
+const lte = ComparisonOperator(lessThanOrEqual)
 
 const memoizeCappedUnary = function (func, cap) {
   const cache = new Map(),
@@ -2743,13 +2569,24 @@ const getByPath = function (value, path) {
   return result
 }
 
-const get = (path, defaultValue) => function getter(value) {
-  const result = value == null ? undefined : getByPath(value, path)
+// _get(object Object, path string, defaultValue function|any)
+const _get = function (object, path, defaultValue) {
+  const result = object == null ? undefined : getByPath(object, path)
   return result === undefined
-    ? typeof defaultValue == 'function' ? defaultValue(value) : defaultValue
+    ? typeof defaultValue == 'function' ? defaultValue(object) : defaultValue
     : result
 }
 
+const get = function (arg0, arg1, arg2) {
+  if (isPromise(arg0)) {
+    return arg0.then(curry3(_get, __, arg1, arg2))
+  }
+  if (isObject(arg0) && !isArray(arg0)) {
+    return _get(arg0, arg1, arg2)
+  }
+  return curry3(_get, __, arg0, arg1)
+}
+
 const setByPath = function (obj, value, path) {
   if (!isObject(obj)){
     return obj
@@ -2775,7 +2612,7 @@ const setByPath = function (obj, value, path) {
   return result
 }
 
-const set = (path, value) => function setter(obj) {
+const _set = function (obj, path, value) {
   if (typeof value == 'function') {
     const actualValue = value(obj)
     if (isPromise(actualValue)) {
@@ -2785,9 +2622,24 @@ const set = (path, value) => function setter(obj) {
     }
     return setByPath(obj, actualValue, path)
   }
+  if (isPromise(value)) {
+    return value.then(
+      curry3(setByPath, obj, __, path)
+    )
+  }
   return setByPath(obj, value, path)
 }
 
+const set = function (arg0, arg1, arg2) {
+  if (arg2 == null) {
+    return curry3(_set, __, arg0, arg1)
+  }
+  if (isPromise(arg0)) {
+    return arg0.then(curry3(_set, __, arg1, arg2))
+  }
+  return _set(arg0, arg1, arg2)
+}
+
 // _pick(source Object, keys Array<string>) -> result Object
 const _pick = function (source, keys) {
   if (source == null) {
@@ -2806,10 +2658,13 @@ const _pick = function (source, keys) {
   return result
 }
 
-const pick = (arg0, arg1) => {
+const pick = function (arg0, arg1) {
   if (arg1 == null) {
     return curry2(_pick, __, arg0)
   }
+  if (isPromise(arg0)) {
+    return arg0.then(curry2(_pick, __, arg1))
+  }
   return _pick(arg0, arg1)
 }
 
@@ -2896,10 +2751,16 @@ const omit = function (arg0, arg1) {
   if (arg1 == null) {
     return curry2(_omit, __, arg0)
   }
+  if (isPromise(arg0)) {
+    return arg0.then(curry2(_omit, __, arg1))
+  }
   return _omit(arg0, arg1)
 }
 
 const thunkify = (func, ...args) => function thunk() {
+  if (areAnyValuesPromises(args)) {
+    return promiseAll(args).then(curry2(funcApply, func, __))
+  }
   return func(...args)
 }
 
@@ -2910,11 +2771,11 @@ curry.arity = function curryArity_(arity, func, ...args) {
 }
 
 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, __,