rubico 1.9.7 → 2.0.0

package/every.js

@@ -0,0 +1,94 @@
+const isPromise = require('./_internal/isPromise')
+const __ = require('./_internal/placeholder')
+const curry2 = require('./_internal/curry2')
+const isArray = require('./_internal/isArray')
+const arrayEvery = require('./_internal/arrayEvery')
+const iteratorEvery = require('./_internal/iteratorEvery')
+const asyncIteratorEvery = require('./_internal/asyncIteratorEvery')
+const objectValues = require('./_internal/objectValues')
+const reducerEvery = require('./_internal/reducerEvery')
+const symbolIterator = require('./_internal/symbolIterator')
+const symbolAsyncIterator = require('./_internal/symbolAsyncIterator')
+
+// _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 (collection == null) {
+    return predicate(collection)
+  }
+
+  if (typeof collection[symbolIterator] == 'function') {
+    return iteratorEvery(collection[symbolIterator](), predicate)
+  }
+  if (typeof collection[symbolAsyncIterator] == 'function') {
+    return asyncIteratorEvery(
+      collection[symbolAsyncIterator](), predicate, new Set()
+    )
+  }
+  if (typeof collection.reduce == 'function') {
+    return collection.reduce(reducerEvery(predicate), true)
+  }
+  if (collection.constructor == Object) {
+    return arrayEvery(objectValues(collection), predicate)
+  }
+  return predicate(collection)
+}
+
+/**
+ * @name every
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * type Foldable = Array|Iterable|AsyncIterable|{ reduce: function }|Object
+ *
+ * every(collection Foldable, predicate function) -> result Promise|boolean
+ *
+ * every(predicate function)(collection Foldable) -> result Promise|boolean
+ * ```
+ *
+ * @description
+ * Test a predicate concurrently across all items of a collection, returning true if all predications are truthy.
+ *
+ * ```javascript [playground]
+ * const isOdd = number => number % 2 == 1
+ *
+ * console.log(
+ *   every(isOdd)([1, 2, 3, 4, 5]),
+ * ) // false
+ *
+ * console.log(
+ *   every(isOdd)([1, 3, 5]),
+ * ) // true
+ * ```
+ *
+ * The collection can be any iterable, async iterable, or object values iterable collection. Below is an example of `every` accepting an async generator as the collection.
+ *
+ * ```javascript [playground]
+ * const asyncNumbers = async function* () {
+ *   yield 1; yield 2; yield 3; yield 4; yield 5
+ * }
+ *
+ * every(async number => number < 6)(asyncNumbers()).then(console.log) // true
+ * ```
+ *
+ * @execution concurrent
+ *
+ * @muxing
+ */
+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 _every(collection, predicate)
+}
+
+module.exports = every

package/filter.js

@@ -3,17 +3,11 @@ const curry2 = require('./_internal/curry2')
 const FilteringIterator = require('./_internal/FilteringIterator')
 const FilteringAsyncIterator = require('./_internal/FilteringAsyncIterator')
 const isArray = require('./_internal/isArray')
-const isGeneratorFunction = require('./_internal/isGeneratorFunction')
-const isAsyncGeneratorFunction = require('./_internal/isAsyncGeneratorFunction')
 const arrayFilter = require('./_internal/arrayFilter')
-const generatorFunctionFilter = require('./_internal/generatorFunctionFilter')
-const asyncGeneratorFunctionFilter = require('./_internal/asyncGeneratorFunctionFilter')
-const reducerFilter = require('./_internal/reducerFilter')
 const stringFilter = require('./_internal/stringFilter')
 const setFilter = require('./_internal/setFilter')
 const mapFilter = require('./_internal/mapFilter')
 const objectFilter = require('./_internal/objectFilter')
-const arrayFilterWithIndex = require('./_internal/arrayFilterWithIndex')
 const symbolIterator = require('./_internal/symbolIterator')
 const symbolAsyncIterator = require('./_internal/symbolAsyncIterator')
 
@@ -62,15 +56,6 @@ 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
   }
@@ -104,39 +89,20 @@ const _filter = function (value, predicate) {
  *
  * @synopsis
  * ```coffeescript [specscript]
- * arrayPredicate (value any, index number, array Array)=>Promise|boolean
- *
- * filter(arrayPredicate)(array Array) -> filteredArray Promise|Array
- * filter(array Array, arrayPredicate) -> filteredArray Promise|Array
- *
- * objectPredicate (value any, key string, object Object)=>Promise|boolean
- *
- * filter(objectPredicate)(object Object) -> filteredObject Promise|Object
- * filter(object Object, objectPredicate) -> filteredObject Promise|Object
- *
- * setPredicate (value any, value, set Set)=>Promise|boolean
- *
- * filter(setPredicate)(set Set) -> filteredSet Promise|Set
- * filter(set Set, setPredicate) -> filteredSet Promise|Set
- *
- * mapPredicate (value any, key any, map Map)=>Promise|boolean
- *
- * filter(mapPredicate)(map Map) -> filteredMap Promise|Map
- * filter(map Map, mapPredicate) -> filteredMap Promise|Map
- *
- * iteratorPredicate (value any)=>any
- *
- * filter(iteratorPredicate)(iterator Iterator|Generator)
- *   -> filteredIterator Iterator|Generator
- * filter(iterator Iterator|Generator, iteratorPredicate)
- *   -> filteredIterator Iterator|Generator
- *
- * asyncIteratorPredicate (value any)=>Promise|any
- *
- * filter(asyncIteratorPredicate)(asyncIterator AsyncIterator|AsyncGenerator)
- *   -> filteredAsyncIterator AsyncIterator|AsyncGenerator
- * filter(asyncIterator AsyncIterator|AsyncGenerator, asyncIteratorPredicate)
- *   -> filteredAsyncIterator AsyncIterator|AsyncGenerator
+ * type Filterable = Array|Object|Set|Map|Iterator|AsyncIterator
+ * type Predicate = (
+ *   value any,
+ *   indexOrKey? number|string,
+ *   collection? Filterable,
+ * )=>boolean
+ *
+ * filter(
+ *   collection Filterable,
+ *   predicate Predicate
+ * ) -> result Promise|Filterable
+ *
+ * filter(predicate Predicate)(collection Filterable)
+ *   -> result Promise|Filterable
  * ```
  *
  * @description
@@ -149,7 +115,7 @@ const _filter = function (value, predicate) {
  *  * `Iterator`/`Generator`
  *  * `AsyncIterator`/`AsyncGenerator`
  *
- * With arrays (type `Array`), `filter` applies the predicate function to each item of the array, returning a new array containing only the items that tested truthy by the predicate. The order of the items is preserved.
+ * For arrays (type `Array`), `filter` applies the predicate function to each item of the array, returning a new array containing only the items that tested truthy by the predicate. The order of the items is preserved. On each iteration, the predicate is passed the item, the index of the item, and a reference to the array.
  *
  * ```javascript [playground]
  * const isOdd = number => number % 2 == 1
@@ -160,7 +126,7 @@ const _filter = function (value, predicate) {
  * console.log(filter(array, isOdd)) // [1, 3, 5]
  * ```
  *
- * With objects (type `Object`), `filter` applies the predicate function to each value of the object, returning a new object containing only the values that tested truthy by the predicate.
+ * For objects (type `Object`), `filter` applies the predicate function to each value of the object, returning a new object containing only the values that tested truthy by the predicate. On each iteration, the predicate is passed the object value, the key of the object value, and a reference to the object.
  *
  * ```javascript [playground]
  * const isOdd = number => number % 2 == 1
@@ -171,7 +137,7 @@ const _filter = function (value, predicate) {
  * console.log(filter(obj, isOdd)) // { a: 1, c: 3, e: 5 }
  * ```
  *
- * With sets (type `Set`), `filter` applies the predicate function to each item in the set, returning a new set containing only the items that tested truthy by the predicate.
+ * For sets (type `Set`), `filter` applies the predicate function to each item in the set, returning a new set containing only the items that tested truthy by the predicate. On each iteration, the predicate is passed the item, the same item as the key argument, and a reference to the set.
  *
  * ```javascript [playground]
  * const isOdd = number => number % 2 == 1
@@ -182,7 +148,7 @@ const _filter = function (value, predicate) {
  * console.log(filter(set, isOdd)) // Set { 1, 3, 5 }
  * ```
  *
- * With maps (type `Map`), `filter` applies the predicate function to the value of each entry of the map, returning a new map containing only the entries where the values tested truthy by the predicate. The order of the entries are preserved.
+ * For maps (type `Map`), `filter` applies the predicate function to the value of each entry of the map, returning a new map containing only the entries where the values tested truthy by the predicate. The order of the entries are preserved. On each iteration, the predicate is passed the map value, the key of the value, and a reference to the map.
  *
  * ```javascript [playground]
  * const isOdd = number => number % 2 == 1
@@ -194,7 +160,7 @@ const _filter = function (value, predicate) {
  * console.log(filter(m, isOdd)) // Map(3) { 'a' => 1, 'c' => 3, 'e' => 5 }
  * ```
  *
- * With iterators (type `Iterator`) or generators (type `Generator`), `filter` returns a lazily filtered iterator/generator; all values that are normally yielded by the iterator/generator that test falsy by the predicate function are skipped by the lazily filtered iterator/generator.
+ * For iterators (type `Iterator`) or generators (type `Generator`), `filter` returns a lazily filtered iterator/generator; all values that are normally yielded by the iterator/generator that test falsy by the predicate function are skipped by the lazily filtered iterator/generator. On each iteration, the predicate is passed the iteration value only.
  *
  * ```javascript [playground]
  * const isOdd = number => number % 2 == 1
@@ -228,7 +194,7 @@ const _filter = function (value, predicate) {
  * }
  * ```
  *
- * With asyncIterators (type `AsyncIterator`) or asyncGenerators (type `AsyncGenerator`), `filter` returns a lazily filtered asyncIterator/asyncGenerator; all values that are normally yielded by the asyncIterator/asyncGenerator that test falsy by the predicate function are skipped by the lazily filtered asyncIterator/asyncGenerator.
+ * With asyncIterators (type `AsyncIterator`) or asyncGenerators (type `AsyncGenerator`), `filter` returns a lazily filtered asyncIterator/asyncGenerator; all values that are normally yielded by the asyncIterator/asyncGenerator that test falsy by the predicate function are skipped by the lazily filtered asyncIterator/asyncGenerator. On each iteration, the predicate is passed the iteration value only.
  *
  * ```javascript [playground]
  * const asyncIsOdd = async number => number % 2 == 1
@@ -271,44 +237,10 @@ const _filter = function (value, predicate) {
 
 const filter = function (...args) {
   const predicate = args.pop()
-  if (args.length > 0) {
-    return _filter(args[0], predicate)
-  }
-  return curry2(_filter, __, predicate)
-}
-
-/**
- * @name filter.withIndex
- *
- * @synopsis
- * ```coffeescript [specscript]
- * filter.withIndex(
- *   indexedPredicate (item any, index number, array Array)=>Promise|boolean
- * )(array Array) -> result Array
- * ```
- *
- * @description
- * `filter` with each predicate call supplemented by index and reference to original collection.
- *
- * ```javascript [playground]
- * const uniq = filter.withIndex(
- *   (item, index, array) => item !== array[index + 1]
- * )
- *
- * console.log(
- *   uniq([1, 1, 1, 2, 2, 2, 3, 3, 3]),
- * ) // [1, 2, 3]
- * ```
- *
- * @DEPRECATED
- *
- * @execution concurrent
- */
-filter.withIndex = predicate => function filteringWithIndex(value) {
-  if (isArray(value)) {
-    return arrayFilterWithIndex(value, predicate)
+  if (args.length == 0) {
+    return curry2(_filter, __, predicate)
   }
-  throw new TypeError(`${value} is not an Array`)
+  return _filter(args[0], predicate)
 }
 
 module.exports = filter

package/flatMap.js

@@ -1,36 +1,83 @@
+const isPromise = require('./_internal/isPromise')
 const FlatMappingIterator = require('./_internal/FlatMappingIterator')
 const FlatMappingAsyncIterator = require('./_internal/FlatMappingAsyncIterator')
 const isArray = require('./_internal/isArray')
-const isGeneratorFunction = require('./_internal/isGeneratorFunction')
-const isAsyncGeneratorFunction = require('./_internal/isAsyncGeneratorFunction')
-const isBinary = require('./_internal/isBinary')
 const arrayFlatMap = require('./_internal/arrayFlatMap')
 const objectFlatMap = require('./_internal/objectFlatMap')
 const setFlatMap = require('./_internal/setFlatMap')
 const stringFlatMap = require('./_internal/stringFlatMap')
-const streamFlatMap = require('./_internal/streamFlatMap')
-const binaryFlatMap = require('./_internal/binaryFlatMap')
-const reducerFlatMap = require('./_internal/reducerFlatMap')
-const generatorFunctionFlatMap = require('./_internal/generatorFunctionFlatMap')
-const asyncGeneratorFunctionFlatMap = require('./_internal/asyncGeneratorFunctionFlatMap')
 const symbolIterator = require('./_internal/symbolIterator')
-const symbolAsyncIterator = require('./_internal/symbolAsyncIterator')
+const curry2 = require('./_internal/curry2')
+const __ = require('./_internal/placeholder')
+
+/**
+ * @name _flatMap
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * type FlatMappable = Array|String|Set|Iterator|AsyncIterator
+ * type Iterable = Iterable|AsyncIterable|Object<value any>
+ *
+ * _flatMap(
+ *   value FlatMappable,
+ *   flatMapper (item any)=>Promise|Iterable,
+ * ) -> result Promise|FlatMappable
+ * ```
+ */
+const _flatMap = function (value, flatMapper) {
+  if (isArray(value)) {
+    return arrayFlatMap(value, flatMapper)
+  }
+  if (value == null) {
+    return flatMapper(value)
+  }
+
+  if (typeof value.then == 'function') {
+    return value.then(flatMapper)
+  }
+  if (typeof value.next == 'function') {
+    return symbolIterator in value
+      ? FlatMappingIterator(value, flatMapper)
+      : FlatMappingAsyncIterator(value, flatMapper)
+  }
+  if (typeof value.chain == 'function') {
+    return value.chain(flatMapper)
+  }
+  if (typeof value.flatMap == 'function') {
+    return value.flatMap(flatMapper)
+  }
+  const valueConstructor = value.constructor
+  if (valueConstructor == Object) {
+    return objectFlatMap(value, flatMapper)
+  }
+  if (valueConstructor == Set) {
+    return setFlatMap(value, flatMapper)
+  }
+  if (typeof value == 'string' || valueConstructor == String) {
+    return stringFlatMap(value, flatMapper)
+  }
+  return flatMapper(value)
+}
 
 /**
  * @name flatMap
  *
  * @synopsis
  * ```coffeescript [specscript]
- * type Monad = Array|String|Set|Iterator|AsyncIterator
- * type Foldable = Iterable|AsyncIterable|Object
+ * type FlatMappable = Array|String|Set|Iterator|AsyncIterator
+ * type Iterable = Iterable|AsyncIterable|Object<value any>
  *
  * flatMap(
- *   flatMapper (item any)=>Promise|Foldable,
- * )(value Monad) -> result Promise|Monad
+ *   collection FlatMappable,
+ *   flatMapper (item any)=>Promise|Iterable,
+ * ) -> result Promise|FlatMappable
+ *
+ * flatMap(flatMapper (item any)=>Promise|Iterable)(collection FlatMappable)
+ *   -> result Promise|FlatMappable
  * ```
  *
  * @description
- * Applies a synchronous or asynchronous flatMapper function concurrently to each item of a collection, creating a new collection of the same type. A flatMapping operation iterates through each item of a collection and applies the flatMapper function to each item, flattening the result of the execution into the result collection. The result of an individual execution can be any iterable, async iterable, or object values iterable collection.
+ * Applies a flatMapper function concurrently to each item of a collection, creating a new collection of the same type. A flatMapping operation iterates through each item of a collection and applies the flatMapper function to each item, flattening the result of the execution into the result collection. The result of an individual execution can be any iterable, async iterable, or object values iterable collection. The flatMapper function may be asynchronous.
  *
  *  * `Iterable` - the execution result is iterated and each item is added to the result collection
  *  * `AsyncIterable` - the execution result is asynchronously iterated and each item is added to the result collection
@@ -52,7 +99,7 @@ const symbolAsyncIterator = require('./_internal/symbolAsyncIterator')
  * // [1, 1, 2, 3, 3, 5, 5, 8, 7, 7]
  * ```
  *
- * A flatMapping operation concatenates onto the result collection synchronous values and muxes any asynchronous values. Muxing, or asynchronously "mixing", is the process of combining multiple asynchronous sources into one source, with order determined by the asynchronous resolution of the individual items.
+ * A flatMapping operation concatenates onto the resulting collection synchronous values and muxes any asynchronous values. Muxing, or asynchronously "mixing", is the process of combining multiple asynchronous sources into one source, with order determined by the asynchronous resolution of the individual items.
  *
  * ```javascript [playground]
  * const sleep = ms => new Promise(resolve => setTimeout(resolve, ms))
@@ -62,7 +109,7 @@ const symbolAsyncIterator = require('./_internal/symbolAsyncIterator')
  * }
  *
  * console.log( // sync is concatenated
- *   flatMap(repeat3)(['foo', 'bar', 'baz']),
+ *   flatMap(['foo', 'bar', 'baz'], repeat3),
  * ) // ['foo', 'foo', 'foo', 'bar', 'bar', 'bar', 'baz', 'baz', 'baz']
  *
  * const asyncRepeat3 = async function* (message) {
@@ -74,7 +121,7 @@ const symbolAsyncIterator = require('./_internal/symbolAsyncIterator')
  * }
  *
  * // async is muxed
- * flatMap(asyncRepeat3)(['foo', 'bar', 'baz']).then(console.log)
+ * flatMap(['foo', 'bar', 'baz'], asyncRepeat3).then(console.log)
  * // ['foo', 'bar', 'baz', 'foo', 'bar', 'baz', 'foo', 'bar', 'baz']
  * ```
  *
@@ -84,7 +131,7 @@ const symbolAsyncIterator = require('./_internal/symbolAsyncIterator')
  * const duplicate = value => [value, value]
  *
  * console.log(
- *   flatMap(duplicate)([1, 2, 3, 4, 5])
+ *   flatMap([1, 2, 3, 4, 5], duplicate)
  * ) // [1, 1, 2, 2, 3, 3, 4, 4, 5, 5]
  * ```
  *
@@ -94,7 +141,7 @@ const symbolAsyncIterator = require('./_internal/symbolAsyncIterator')
  * const duplicate = value => [value, value]
  *
  * console.log(
- *   flatMap(duplicate)('12345')
+ *   flatMap('12345', duplicate)
  * ) // 1122334455
  * ```
  *
@@ -104,7 +151,7 @@ const symbolAsyncIterator = require('./_internal/symbolAsyncIterator')
  * const pairPlus100 = value => [value, value + 100]
  *
  * console.log(
- *   flatMap(pairPlus100)(new Set([1, 2, 3, 4, 5]))
+ *   flatMap(new Set([1, 2, 3, 4, 5]), pairPlus100)
  * ) // Set(10) { 1, 101, 2, 102, 3, 103, 4, 104, 5, 105 }
  * ```
  *
@@ -117,57 +164,15 @@ const symbolAsyncIterator = require('./_internal/symbolAsyncIterator')
  *
  *  * For Node.js duplex streams (type [Stream](https://nodejs.org/api/stream.html#class-streamduplex)), `flatMap` applies a flatMapper function to each item of the stream, writing (`.write`) each item of each execution into the duplex stream
  */
-const flatMap = flatMapper => function flatMapping(value) {
-  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)
-  }
-
-  if (typeof value.then == 'function') {
-    return value.then(flatMapper)
-  }
-  if (typeof value.next == 'function') {
-    return symbolIterator in value
-      ? FlatMappingIterator(value, flatMapper)
-      : FlatMappingAsyncIterator(value, flatMapper)
-  }
-  if (typeof value.chain == 'function') {
-    return value.chain(flatMapper)
-  }
-  if (typeof value.flatMap == 'function') {
-    return value.flatMap(flatMapper)
-  }
-  if (
-    typeof value[symbolAsyncIterator] == 'function'
-      && typeof value.write == 'function'
-  ) {
-    return streamFlatMap(value, flatMapper)
+const flatMap = (...args) => {
+  const flatMapper = args.pop()
+  if (args.length == 0) {
+    return curry2(_flatMap, __, flatMapper)
   }
-  const valueConstructor = value.constructor
-  if (valueConstructor == Object) {
-    return objectFlatMap(value, flatMapper)
-  }
-  if (valueConstructor == Set) {
-    return setFlatMap(value, flatMapper)
-  }
-  if (typeof value == 'string' || valueConstructor == String) {
-    return stringFlatMap(value, flatMapper)
-  }
-  return flatMapper(value)
+  const collection = args[0]
+  return isPromise(collection)
+    ? collection.then(curry2(_flatMap, __, flatMapper))
+    : _flatMap(args[0], flatMapper)
 }
 
 module.exports = flatMap

package/forEach.js

@@ -0,0 +1,82 @@
+const isPromise = require('./_internal/isPromise')
+const __ = require('./_internal/placeholder')
+const curry2 = require('./_internal/curry2')
+const isArray = require('./_internal/isArray')
+const isGeneratorFunction = require('./_internal/isGeneratorFunction')
+const isAsyncGeneratorFunction = require('./_internal/isAsyncGeneratorFunction')
+const arrayForEach = require('./_internal/arrayForEach')
+const objectForEach = require('./_internal/objectForEach')
+const iteratorForEach = require('./_internal/iteratorForEach')
+const asyncIteratorForEach = require('./_internal/asyncIteratorForEach')
+const symbolIterator = require('./_internal/symbolIterator')
+const symbolAsyncIterator = require('./_internal/symbolAsyncIterator')
+
+// 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
+}
+
+/**
+ * @name forEach
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * type Collection = Array|Iterable|AsyncIterable|{ forEach: function }|Object
+ *
+ * forEach(collection Collection, callback function) -> collection Collection
+ *
+ * forEach(callback function)(collection Collection) -> collection Collection
+ * ```
+ *
+ * @description
+ * Execute a callback for each item of a collection, returning a Promise if the execution is asynchronous.
+ *
+ * ```javascript [playground]
+ * forEach([1, 2, 3, 4, 5l], console.log) // 1 2 3 4 5
+ *
+ * forEach({ a: 1, b: 2, c: 3 }, console.log) // 1 2 3
+ * ```
+ *
+ * Omit the data argument for a composable API
+ *
+ * ```javascript [playground]
+ * pipe([1, 2, 3, 4, 5], [
+ *   filter(number => number % 2 == 1),
+ *   map(number => number ** 2),
+ *   forEach(console.log), // 1
+ *                         // 9
+ *                         // 25
+ * ])
+ * ```
+ */
+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)
+}
+
+module.exports = forEach

package/get.js

@@ -1,5 +1,18 @@
+const isPromise = require('./_internal/isPromise')
+const __ = require('./_internal/placeholder')
+const curry3 = require('./_internal/curry3')
+const isArray = require('./_internal/isArray')
+const isObject = require('./_internal/isObject')
 const getByPath = require('./_internal/getByPath')
 
+// _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(object) : defaultValue
+    : result
+}
+
 /**
  * @name get
  *
@@ -7,7 +20,7 @@ const getByPath = require('./_internal/getByPath')
  * ```coffeescript [specscript]
  * get(
  *   path string|number|Array<string|number>,
- *   defaultValue function|any
+ *   defaultValue? function|any
  * )(object Object) -> result Promise|Object
  * ```
  *
@@ -52,11 +65,15 @@ const getByPath = require('./_internal/getByPath')
  * console.log(get00000ArrayNotation([[[[['foo']]]]])) // foo
  * ```
  */
-const get = (path, defaultValue) => function getter(value) {
-  const result = value == null ? undefined : getByPath(value, path)
-  return result === undefined
-    ? typeof defaultValue == 'function' ? defaultValue(value) : 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)
 }
 
 module.exports = get

package/global.js

@@ -1,7 +1,8 @@
 globalThis.pipe = require('./pipe')
-globalThis.fork = require('./fork')
-globalThis.assign = require('./assign')
+globalThis.compose = require('./compose')
 globalThis.tap = require('./tap')
+globalThis.all = require('./all')
+globalThis.assign = require('./assign')
 globalThis.tryCatch = require('./tryCatch')
 globalThis.switchCase = require('./switchCase')
 globalThis.map = require('./map')
@@ -9,8 +10,9 @@ globalThis.filter = require('./filter')
 globalThis.reduce = require('./reduce')
 globalThis.transform = require('./transform')
 globalThis.flatMap = require('./flatMap')
-globalThis.any = require('./any')
-globalThis.all = require('./all')
+globalThis.forEach = require('./forEach')
+globalThis.some = require('./some')
+globalThis.every = require('./every')
 globalThis.and = require('./and')
 globalThis.or = require('./or')
 globalThis.not = require('./not')