rubico 1.9.6 → 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
   }
@@ -102,67 +87,80 @@ const _filter = function (value, predicate) {
 /**
  * @name filter
  *
- * @catchphrase
- * exclude items by predicate
- *
  * @synopsis
  * ```coffeescript [specscript]
- * filter(
- *   arrayPredicate (value any, index number, array Array)=>Promise|boolean
- * )(array Array) -> filteredArray Promise|Array
+ * type Filterable = Array|Object|Set|Map|Iterator|AsyncIterator
+ * type Predicate = (
+ *   value any,
+ *   indexOrKey? number|string,
+ *   collection? Filterable,
+ * )=>boolean
  *
  * filter(
- *   objectPredicate (value any, key string, object Object)=>Promise|boolean
- * )(object Object) -> filteredObject Promise|Object
+ *   collection Filterable,
+ *   predicate Predicate
+ * ) -> result Promise|Filterable
  *
- * filter(
- *   setPredicate (value any, value, set Set)=>Promise|boolean
- * )(set Set) -> filteredSet Promise|Set
+ * filter(predicate Predicate)(collection Filterable)
+ *   -> result Promise|Filterable
+ * ```
  *
- * filter(
- *   mapPredicate (value any, key any, map Map)=>Promise|boolean
- * )(map Map) -> filteredMap Promise|Map
+ * @description
+ * Filter out items from a collection based on the results of their concurrent executions with a synchronous or asynchronous predicate function. `filter` accepts the following collections:
  *
- * filter(
- *   predicate (value any)=>Promise|boolean
- * )(generatorFunction GeneratorFunction) -> filteringGeneratorFunction GeneratorFunction
+ *  * `Array`
+ *  * `Object`
+ *  * `Set`
+ *  * `Map`
+ *  * `Iterator`/`Generator`
+ *  * `AsyncIterator`/`AsyncGenerator`
  *
- * filter(
- *   predicate (value any)=>Promise|boolean
- * )(asyncGeneratorFunction AsyncGeneratorFunction) -> filteringAsyncGeneratorFunction AsyncGeneratorFunction
+ * 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.
  *
- * filter(
- *   predicate (value any)=>Promise|boolean
- * )(reducer Reducer) -> filteringReducer Reducer
+ * ```javascript [playground]
+ * const isOdd = number => number % 2 == 1
+ *
+ * const array = [1, 2, 3, 4, 5]
+ *
+ * console.log(filter(isOdd)(array)) // [1, 3, 5]
+ * console.log(filter(array, isOdd)) // [1, 3, 5]
  * ```
  *
- * @description
- * Filter out items from a filterable based on the results of their concurrent executions with a predicate. `filter` recognizes several vanilla JavaScript types as filterables.
+ * 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
  *
- *  * `Array` - filter array items by predicate
- *  * `Object` - filter object values by predicate
- *  * `Set` - filter Set values by predicate
- *  * `Map` - filter Map values by predicate (not entries)
- *  * `Iterator` - skip iterations by predicate
- *  * `AsyncIterator` - skip async iterations by predicate
+ * const obj = { a: 1, b: 2, c: 3, d: 4, e: 5 }
+ *
+ * console.log(filter(isOdd)(obj)) // { a: 1, c: 3, e: 5 }
+ * console.log(filter(obj, isOdd)) // { a: 1, c: 3, e: 5 }
+ * ```
+ *
+ * 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
  *
- * console.log(
- *   filter(isOdd)([1, 2, 3, 4, 5]),
- * ) // [1, 3, 5]
+ * const set = new Set([1, 2, 3, 4, 5])
+ *
+ * console.log(filter(isOdd)(set)) // Set { 1, 3, 5 }
+ * console.log(filter(set, isOdd)) // Set { 1, 3, 5 }
+ * ```
+ *
+ * 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.
  *
- * console.log(
- *   filter(isOdd)({ a: 1, b: 2, c: 3, d: 4, e: 5 }),
- * ) // { a: 1, c: 3, e: 5 }
+ * ```javascript [playground]
+ * const isOdd = number => number % 2 == 1
  *
- * console.log(
- *   filter(isOdd)(new Set([1, 2, 3, 4, 5])),
- * ) // Set { 1, 3, 5 }
+ * const obj = { a: 1, b: 2, c: 3, d: 4, e: 5 }
+ * const m = new Map([['a', 1], ['b', 2], ['c', 3], ['d', 4], ['e', 5]])
+ *
+ * console.log(filter(isOdd)(m)) // Map(3) { 'a' => 1, 'c' => 3, 'e' => 5 }
+ * console.log(filter(m, isOdd)) // Map(3) { 'a' => 1, 'c' => 3, 'e' => 5 }
  * ```
  *
- * Passing a generator function to `filter` in filterable position returns a generator function that produces filtering generators; all values that are normally yielded by a generator that test falsy by the predicate are skipped by a filtering 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
@@ -171,24 +169,32 @@ const _filter = function (value, predicate) {
  *   yield 1; yield 2; yield 3; yield 4; yield 5
  * }
  *
- * const oddNumbersGeneratorFunction = filter(isOdd)(numbersGeneratorFunction)
+ * const numbersGenerator = numbersGeneratorFunction()
+ * const oddNumbersGenerator = filter(numbersGeneratorFunction(), isOdd)
+ * const oddNumbersGenerator2 = filter(isOdd)(numbersGeneratorFunction())
  *
- * for (const number of oddNumbersGeneratorFunction()) {
+ * for (const number of numbersGenerator) {
  *   console.log(number) // 1
+ *                       // 2
  *                       // 3
+ *                       // 4
  *                       // 5
  * }
  *
- * const oddNumbersGenerator = filter(isOdd)(numbersGeneratorFunction())
- *
  * for (const number of oddNumbersGenerator) {
  *   console.log(number) // 1
  *                       // 3
  *                       // 5
  * }
+ *
+ * for (const number of oddNumbersGenerator2) {
+ *   console.log(number) // 1
+ *                       // 3
+ *                       // 5
+ * }
  * ```
  *
- * In a similar vein to generator functions, passing an async generator function in filterable position creates an async generator function of filtered async generators. Each filtered async generator skips async iterations with values that test falsy by the 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. On each iteration, the predicate is passed the iteration value only.
  *
  * ```javascript [playground]
  * const asyncIsOdd = async number => number % 2 == 1
@@ -197,45 +203,31 @@ const _filter = function (value, predicate) {
  *   yield 1; yield 2; yield 3; yield 4; yield 5
  * }
  *
- * const asyncOddNumbersGeneratorFunction = filter(asyncIsOdd)(asyncNumbersGeneratorFunction)
+ * const asyncNumbersGenerator = asyncNumbersGeneratorFunction()
  *
- * for await (const number of asyncOddNumbersGeneratorFunction()) {
+ * const asyncOddNumbersGenerator = filter(asyncNumbersGeneratorFunction(), asyncIsOdd)
+ *
+ * const asyncOddNumbersGenerator2 = filter(asyncIsOdd)(asyncNumbersGeneratorFunction())
+ *
+ * for await (const number of asyncNumbersGenerator) {
  *   console.log(number) // 1
+ *                       // 2
  *                       // 3
+ *                       // 4
  *                       // 5
  * }
  *
- * const asyncOddNumbersGenerator = filter(asyncIsOdd)(asyncNumbersGeneratorFunction())
- *
  * for await (const number of asyncOddNumbersGenerator) {
  *   console.log(number) // 1
  *                       // 3
  *                       // 5
  * }
- * ```
- *
- * A reducer in filterable position creates a filtering reducer - one that skips items of the reducer's reducing operation if they test falsy by the predicate. It is possible to use an asynchronous predicate when filtering a reducer, however the implementation of `reduce` must support asynchronous operations. This library provides such an implementation as `reduce`.
- *
- * ```javascript [playground]
- * const isOdd = number => number % 2 == 1
- *
- * const concat = (array, item) => array.concat(item)
- *
- * const concatOddNumbers = filter(isOdd)(concat)
  *
- * console.log(
- *   [1, 2, 3, 4, 5].reduce(concatOddNumbers, []),
- * ) // [1, 3, 5]
- * ```
- *
- * `filter`, when passed a single argument before the predicate function, treats that argument as the value to be filtered.
- *
- * ```javascript [playground]
- * const numbers = [1, 2, 3]
- *
- * const odds = filter(numbers, number => number % 2 == 1)
- *
- * console.log(odds) // [1, 3]
+ * for await (const number of asyncOddNumbersGenerator2) {
+ *   console.log(number) // 1
+ *                       // 3
+ *                       // 5
+ * }
  * ```
  *
  * @execution concurrent
@@ -245,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]
- * var T any,
- *   index number,
- *   array Array<T>,
- *   indexedPredicate (T, index, array)=>Promise|boolean
- *
- * filter.withIndex(indexedPredicate)(array) -> Array<T>
- * ```
- *
- * @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]
- * ```
- *
- * @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