rubico 1.9.6 → 2.0.0

package/lt.js

@@ -1,26 +1,25 @@
-const spread2 = require('./_internal/spread2')
-const isPromise = require('./_internal/isPromise')
-const promiseAll = require('./_internal/promiseAll')
+const ComparisonOperator = require('./_internal/ComparisonOperator')
 const lessThan = require('./_internal/lessThan')
-const curry2 = require('./_internal/curry2')
-const always = require('./_internal/always')
-const __ = require('./_internal/placeholder')
 
 /**
  * @name lt
  *
  * @synopsis
  * ```coffeescript [specscript]
- * lt(leftValue any, rightValue any) -> boolean
- * lt(leftValue any, right function)(value any) -> Promise|boolean
- * lt(left function, rightValue any)(value any) -> Promise|boolean
- * lt(left function, right function)(value any) -> Promise|boolean
+ * lt(leftValue Promise|any, rightValue Promise|any) -> boolean
+ *
+ * lt(leftValue Promise|any, right function)(...args) -> Promise|boolean
+ * lt(...args, leftValue Promise|any, right function) -> Promise|boolean
+ *
+ * lt(left function, rightValue Promise|any)(...args) -> Promise|boolean
+ * lt(...args, left function, rightValue Promise|any) -> Promise|boolean
+ *
+ * lt(left function, right function)(...args) -> Promise|boolean
+ * lt(...args, left function, right function) -> Promise|boolean
  * ```
  *
  * @description
- * Test if a left value is less than (`<`) a right value. Either parameter may be an actual value.
- *
- * If both arguments are values, `lt` eagerly computes and returns a boolean value.
+ * Test if a value is less than (`<`) another value.
  *
  * ```javascript [playground]
  * console.log(lt(1, 3)) // true
@@ -28,60 +27,18 @@ const __ = require('./_internal/placeholder')
  * console.log(lt(4, 3)) // false
  * ```
  *
- * If both arguments are functions, `lt` treats those functions as argument resolvers and returns a function that first resolves its arguments by the argument resolvers before making the comparison.
- *
- * If only one argument is a function, `lt` still returns a function that resolves its arguments by the argument resolver, treating the value (non function) argument as an already resolved value for comparison.
+ * If either of the two values are resolver functions, `lt` returns a function that resolves the values to compare from its arguments.
  *
  * ```javascript [playground]
  * const identity = value => value
  *
  * const isLessThan3 = lt(identity, 3)
  *
- * console.log(isLessThan3(1), true)
- * console.log(isLessThan3(3), false)
- * console.log(isLessThan3(5), false)
+ * console.log(isLessThan3(1)) // true
+ * console.log(isLessThan3(3)) // false
+ * console.log(isLessThan3(5)) // false
  * ```
  */
-const lt = function (left, right) {
-  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 (isLeftResolver) {
-    return function lessThanBy(value) {
-      const leftResolve = left(value)
-      return isPromise(leftResolve)
-        ? leftResolve.then(curry2(lessThan, __, right))
-        : leftResolve < right
-    }
-  }
-  if (isRightResolver) {
-    return function lessThanBy(value) {
-      const rightResolve = right(value)
-      return isPromise(rightResolve)
-        ? rightResolve.then(curry2(lessThan, left, __))
-        : left < rightResolve
-    }
-  }
-
-  return left < right
-}
+const lt = ComparisonOperator(lessThan)
 
 module.exports = lt

package/lte.js

@@ -1,26 +1,25 @@
-const spread2 = require('./_internal/spread2')
-const isPromise = require('./_internal/isPromise')
-const promiseAll = require('./_internal/promiseAll')
+const ComparisonOperator = require('./_internal/ComparisonOperator')
 const lessThanOrEqual = require('./_internal/lessThanOrEqual')
-const curry2 = require('./_internal/curry2')
-const always = require('./_internal/always')
-const __ = require('./_internal/placeholder')
 
 /**
  * @name lte
  *
  * @synopsis
  * ```coffeescript [specscript]
- * lte(leftValue any, rightValue any) -> boolean
- * lte(leftValue any, right function)(value any) -> Promise|boolean
- * lte(left function, rightValue any)(value any) -> Promise|boolean
- * lte(left function, right function)(value any) -> Promise|boolean
+ * lte(leftValue Promise|any, rightValue Promise|any) -> boolean
+ *
+ * lte(leftValue Promise|any, right function)(...args) -> Promise|boolean
+ * lte(...args, leftValue Promise|any, right function) -> Promise|boolean
+ *
+ * lte(left function, rightValue Promise|any)(...args) -> Promise|boolean
+ * lte(...args, left function, rightValue Promise|any) -> Promise|boolean
+ *
+ * lte(left function, right function)(...args) -> Promise|boolean
+ * lte(...args, left function, right function) -> Promise|boolean
  * ```
  *
  * @description
- * Test if a left value is less than or equal (`<=`) to a right value. Either parameter may be an actual value.
- *
- * If both arguments are values, `lte` eagerly computes and returns a boolean value.
+ * Test if a value is less than or equal (`<=`) to another value.
  *
  * ```javascript [playground]
  * console.log(lte(1, 3)) // true
@@ -28,9 +27,7 @@ const __ = require('./_internal/placeholder')
  * console.log(lte(4, 3)) // false
  * ```
  *
- * If both arguments are functions, `lte` treats those functions as argument resolvers and returns a function that first resolves its arguments by the argument resolvers before making the comparison.
- *
- * If only one argument is a function, `lte` still returns a function that resolves its arguments by the argument resolver, treating the value (non function) argument as an already resolved value for comparison.
+ * If either of the two values are resolver functions, `lte` returns a function that resolves the values to compare from its arguments.
  *
  * ```javascript [playground]
  * const identity = value => value
@@ -42,46 +39,6 @@ const __ = require('./_internal/placeholder')
  * console.log(isLessThanOrEqualTo3(5), false)
  * ```
  */
-const lte = function (left, right) {
-  const isLeftResolver = typeof left == 'function',
-    isRightResolver = typeof right == 'function'
-
-  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
-    }
-  }
-
-  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
-    }
-  }
-
-  return left <= right
-}
+const lte = ComparisonOperator(lessThanOrEqual)
 
 module.exports = lte

package/map.js

@@ -1,23 +1,17 @@
+const isPromise = require('./_internal/isPromise')
 const MappingIterator = require('./_internal/MappingIterator')
 const MappingAsyncIterator = require('./_internal/MappingAsyncIterator')
 const __ = require('./_internal/placeholder')
 const curry2 = require('./_internal/curry2')
 const isArray = require('./_internal/isArray')
 const isObject = require('./_internal/isObject')
-const isGeneratorFunction = require('./_internal/isGeneratorFunction')
-const isAsyncGeneratorFunction = require('./_internal/isAsyncGeneratorFunction')
 const arrayMap = require('./_internal/arrayMap')
-const generatorFunctionMap = require('./_internal/generatorFunctionMap')
-const asyncGeneratorFunctionMap = require('./_internal/asyncGeneratorFunctionMap')
-const reducerMap = require('./_internal/reducerMap')
 const stringMap = require('./_internal/stringMap')
 const setMap = require('./_internal/setMap')
 const mapMap = require('./_internal/mapMap')
 const objectMap = require('./_internal/objectMap')
 const arrayMapSeries = require('./_internal/arrayMapSeries')
 const arrayMapPool = require('./_internal/arrayMapPool')
-const arrayMapWithIndex = require('./_internal/arrayMapWithIndex')
-const objectMapOwn = require('./_internal/objectMapOwn')
 const objectMapEntries = require('./_internal/objectMapEntries')
 const mapMapEntries = require('./_internal/mapMapEntries')
 const symbolIterator = require('./_internal/symbolIterator')
@@ -69,15 +63,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
   }
@@ -114,150 +99,186 @@ const _map = function (value, mapper) {
  *
  * @synopsis
  * ```coffeescript [specscript]
- * map(
- *   arrayMapper (value any, index number, array Array)=>Promise|any
- * )(array Array) -> mappedArray Promise|Array
+ * arrayMapperFunc (value any, index number, array Array)=>Promise|any
  *
- * map(
- *   objectMapper (value any, key string, object Object)=>Promise|any
- * )(object Object) -> mappedObject Promise|Array
+ * map(arrayMapperFunc)(value Array) -> result Promise|Array
+ * map(value Array, arrayMapperFunc) -> result Promise|Array
  *
- * map(
- *   setMapper (value any, value, set Set)=>Promise|any,
- * )(set Set) -> mappedSet Promise|Set
+ * objectMapperFunc (value any, key string, object Object)=>Promise|any
  *
- * map(
- *   mapMapper (value any, key any, originalMap Map)=>Promise|any,
- * )(originalMap Map) -> mappedMap Promise|Map
+ * map(objectMapperFunc)(value Object) -> result Promise|Array
+ * map(value Object, objectMapperFunc) -> result Promise|Array
  *
- * map(
- *   syncMapper (value any)=>any
- * )(generatorFunction GeneratorFunction)
- *   -> mappingGeneratorFunction ...args=>Generator
+ * setMapperFunc (value any, value, set Set)=>Promise|any
  *
- * map(
- *   mapper (value any)=>Promise|any
- * )(asyncGeneratorFunction AsyncGeneratorFunction)
- *   -> mappingAsyncGeneratorFunction ...args=>AsyncGenerator
+ * map(setMapperFunc)(value Set) -> result Promise|Set
+ * map(value Set, setMapperFunc) -> result Promise|Set
  *
- * map(
- *   mapper (value any)=>Promise|any
- * )(originalReducer Reducer) -> mappingReducer Reducer
+ * mapMapperFunc (value any, key any, originalMap Map)=>Promise|any
+ *
+ * map(mapMapperFunc)(value Map) -> result Promise|Map
+ * map(value Map, mapMapperFunc) -> result Promise|Map
+ *
+ * iteratorMapperFunc (value any)=>any
+ *
+ * map(iteratorMapperFunc)(value Iterator|Generator) -> result Iterator
+ * map(value Iterator|Generator, iteratorMapperFunc) -> result Iterator
+ *
+ * asyncIteratorMapperFunc (value any)=>Promise|any
+ *
+ * map(asyncIteratorMapperFunc)(value AsyncIterator|AsyncGenerator)
+ *   -> result AsyncIterator
+ * map(value AsyncIterator|AsyncGenerator, asyncIteratorMapperFunc)
+ *   -> result AsyncIterator
  * ```
  *
  * @description
- * Apply a mapper concurrently to each item of a functor, returning the results in a functor of the same type. If order is implied by the collection, it is maintained in the result. The following list describes `map` behavior with vanilla JavaScript functors.
+ * Applies a synchronous or asynchronous mapper function concurrently to each item of a collection, returning the results in a new collection of the same type. If order is implied by the collection, it is maintained in the result. `map` accepts the following collections:
  *
- *  * `Array` - apply a mapper to items, returning a new array of results
- *  * `Object` - apply a mapper to object values, returning a new object of results
- *  * `Set` - apply a mapper to Set items, returning a new `Set` of results
- *  * `Map` - apply a mapper to Map values (not entries), returning a new `Map` of results
- *  * `Iterator`/`Generator` - return an iterator that applies a mapper to each iteration's value, yielding mapped iterations
- *  * `AsyncIterator`/`AsyncGenerator` - return an async iterator that applies a mapper to each async iteration's value, yielding Promises of a mapped iterations
- *  * `{ map: function }` - call `.map` directly with mapper
+ *  * `Array`
+ *  * `Object`
+ *  * `Set`
+ *  * `Map`
+ *  * `Iterator`/`Generator`
+ *  * `AsyncIterator`/`AsyncGenerator`
+ *
+ * With arrays (type `Array`), `map` applies the mapper function to each item of the array, returning the transformed results in a new array ordered the same as the original array.
  *
  * ```javascript [playground]
  * const square = number => number ** 2
  *
- * console.log(
- *   map(square)([1, 2, 3, 4, 5]),
- * ) // [1, 4, 9, 16, 25]
+ * const array = [1, 2, 3, 4, 5]
  *
  * console.log(
- *   map(square)(new Map([['a', 1], ['b', 2], ['c', 3], ['d', 4], ['e', 5]])),
- * ) // Map { 'a' => 1, 'b' => 4, 'c' => 9, 'd' => 16, 'e' => 25 }
+ *   map(array, square)
+ * ) // [1, 4, 9, 16, 25]
  *
  * console.log(
- *   map(square)({ a: 1, b: 2, c: 3, d: 4, e: 5 }),
- * ) // { a: 1, b: 4, c: 9, d: 16, e: 25 }
+ *   map(square)(array)
+ * ) // [1, 4, 9, 16, 25]
  * ```
  *
- * `map` recognizes three types of functions in functor position:
- *
- *  * Generator Functions `function* () {}` - `map(mapper)(generatorFunction)` creates a generator function that generates generators of mapped values. Async mappers are yielded synchronously and may lead to unexpected results.
- *  * Async Generator Functions `async function* () {}` - `map(mapper)(asyncGeneratorFunction)` creates an async generator function that generates async generators of mapped values. Promises produced by async mappers are resolved.
- *  * Reducers `(accumulator, item)=>accumulator` - `map(mapper)(reducer)` creates a transducer that, when called with another reducer, creates a mapping step for each item of the reducer's reducing operation. Promises produced by async mappers are resolved.
- *
- * Use mapping generator functions to create lazy computations executed at iteration time.
+ * With objects (type `Object`), `map` applies the mapper function to each value of the object, returning the transformed results as values in a new object ordered by the keys of the original object
  *
  * ```javascript [playground]
- * const capitalize = string => string.toUpperCase()
- *
- * const abc = function* () {
- *   yield 'a'; yield 'b'; yield 'c'
- * }
+ * const square = number => number ** 2
  *
- * const ABC = map(capitalize)(abc)
+ * const obj = { a: 1, b: 2, c: 3, d: 4, e: 5 }
  *
- * const abcIter = abc()
+ * console.log(
+ *   map(square)(obj)
+ * ) // { a: 1, b: 4, c: 9, d: 16, e: 25 }
  *
- * const ABCIter = ABC()
+ * console.log(
+ *   map(obj, square)
+ * ) // { a: 1, b: 4, c: 9, d: 16, e: 25 }
+ * ```
  *
- * console.log([...abcIter]) // ['a', 'b', 'c']
+ * With sets (type `Set`), `map` applies the mapper function to each value of the set, returning the transformed results unordered in a new set.
  *
- * console.log([...ABCIter]) // ['A', 'B', 'C']
- * ```
+ * ```javascript [playground]
+ * const square = number => number ** 2
  *
- * Create a mapping transducer by supplying `map` with a reducer. A reducer is a variadic function that depicts a relationship between an accumulator and any number of arguments. A transducer is a function that accepts a reducer as an argument and returns another reducer.
+ * const set = new Set([1, 2, 3, 4, 5])
  *
- * ```coffeescript [specscript]
- * Reducer<T> = (any, T)=>Promise|any
+ * console.log(
+ *   map(set, square)
+ * ) // [1, 4, 9, 16, 25]
  *
- * Transducer = Reducer=>Reducer
+ * console.log(
+ *   map(square)(set)
+ * ) // [1, 4, 9, 16, 25]
  * ```
  *
- * The transducer signature enables chaining functionality for reducers. `map` is core to this mechanism, and provides a way via transducers to transform items of reducers. To `map`, reducers are just another category.
+ * With maps (type `Map`), `map` applies the mapper function to each value of the map, returning the results at the same keys in a new map. The entries of the resulting map are in the same order as those of the original map
  *
  * ```javascript [playground]
  * const square = number => number ** 2
  *
- * const concat = (array, item) => array.concat(item)
+ * const m = new Map([['a', 1], ['b', 2], ['c', 3], ['d', 4], ['e', 5]])
  *
- * const mapSquare = map(square)
- * // mapSquare could potentially be a transducer, but at this point, it is
- * // undifferentiated and not necessarily locked in to transducer behavior.
+ * console.log(
+ *   map(square)(m)
+ * ) // Map { 'a' => 1, 'b' => 4, 'c' => 9, 'd' => 16, 'e' => 25 }
  *
  * console.log(
- *   mapSquare([1, 2, 3, 4, 5]),
- * ) // [1, 4, 9, 16, 25]
+ *   map(m, square)
+ * ) // Map { 'a' => 1, 'b' => 4, 'c' => 9, 'd' => 16, 'e' => 25 }
+ * ```
  *
- * const squareConcatReducer = mapSquare(concat)
- * // now mapSquare is passed the function concat, so it assumes transducer
- * // position. squareConcatReducer is a reducer with chained functionality
- * // square and concat.
+ * With iterators (type `Iterator`) or generators (type `Generator`), `map` applies the mapper function lazily to each value of the iterator/generator, creating a new iterator with transformed iterations.
  *
- * console.log(
- *   [1, 2, 3, 4, 5].reduce(squareConcatReducer, []),
- * ) // [1, 4, 9, 16, 25]
+ * ```javascript [playground]
+ * const capitalize = string => string.toUpperCase()
  *
- * console.log(
- *   [1, 2, 3, 4, 5].reduce(squareConcatReducer, ''),
- * ) // '1491625'
+ * const abcGeneratorFunc = function* () {
+ *   yield 'a'; yield 'b'; yield 'c'
+ * }
+ *
+ * const abcGenerator = abcGeneratorFunc()
+ * const ABCGenerator = map(abcGeneratorFunc(), capitalize)
+ * const ABCGenerator2 = map(capitalize)(abcGeneratorFunc())
+ *
+ * console.log([...abcGenerator]) // ['a', 'b', 'c']
+ *
+ * console.log([...ABCGenerator]) // ['A', 'B', 'C']
+ *
+ * console.log([...ABCGenerator2]) // ['A', 'B', 'C']
  * ```
  *
- * `map`, when passed a single argument before the mapper function, treats that argument as the value to be mapped.
+ * With asyncIterators (type `AsyncIterator`, or `AsyncGenerator`), `map` applies the mapper function lazily to each value of the asyncIterator, creating a new asyncIterator with transformed iterations
  *
  * ```javascript [playground]
- * const myArray = [1, 2, 3]
+ * const capitalize = string => string.toUpperCase()
  *
- * const mappedArray = map(myArray, number => number ** 2)
+ * const abcAsyncGeneratorFunc = async function* () {
+ *   yield 'a'; yield 'b'; yield 'c'
+ * }
  *
- * console.log(mappedArray) // [1, 4, 9]
+ * const abcAsyncGenerator = abcAsyncGeneratorFunc()
+ * const ABCGenerator = map(abcAsyncGeneratorFunc(), capitalize)
+ * const ABCGenerator2 = map(capitalize)(abcAsyncGeneratorFunc())
+ *
+ * ;(async function () {
+ *   for await (const letter of abcAsyncGenerator) {
+ *     console.log(letter)
+ *     // a
+ *     // b
+ *     // c
+ *   }
+ *
+ *   for await (const letter of ABCGenerator) {
+ *     console.log(letter)
+ *     // A
+ *     // B
+ *     // C
+ *   }
+ *
+ *   for await (const letter of ABCGenerator2) {
+ *     console.log(letter)
+ *     // A
+ *     // B
+ *     // C
+ *   }
+ * })()
  * ```
  *
  * @execution concurrent
  *
- * @transducing
- *
  * @TODO streamMap
  */
 
 const map = (...args) => {
   const mapper = args.pop()
-  if (args.length > 0) {
-    return _map(args[0], mapper)
+  if (args.length == 0) {
+    return curry2(_map, __, mapper)
   }
-  return curry2(_map, __, mapper)
+
+  const collection = args[0]
+  if (isPromise(collection)) {
+    return collection.then(curry2(_map, __, mapper))
+  }
+  return _map(collection, mapper)
 }
 
 /**
@@ -271,13 +292,17 @@ const map = (...args) => {
  * ```
  *
  * @description
- * `map` over the entries of a `Map` or `Object`.
+ * `map` over the entries rather than the values of a collection. Accepts collections of type `Map` or `Object`.
+ *
  * ```javascript [playground]
- * console.log(
- *   map.entries(
- *     ([key, value]) => [key.toUpperCase(), value ** 2],
- *   )({ a: 1, b: 2, c: 3 })
- * ) // { A: 1, B: 4, C: 9 }
+ * const upperCaseKeysAndSquareValues =
+ *   map.entries(([key, value]) => [key.toUpperCase(), value ** 2])
+ *
+ * console.log(upperCaseKeysAndSquareValues({ a: 1, b: 2, c: 3 }))
+ * // { A: 1, B: 4, C: 9 }
+ *
+ * console.log(upperCaseKeysAndSquareValues(new Map([['a', 1], ['b', 2], ['c', 3]])))
+ * // Map(3) { 'A' => 1, 'B' => 4, 'C' => 9 }
  * ```
  *
  * @since v1.7.0
@@ -302,11 +327,9 @@ map.entries = function mapEntries(mapper) {
  *
  * @synopsis
  * ```coffeescript [specscript]
- * var T any,
- *   mapper T=>Promise|any,
- *   array Array<T>
- *
- * map.series(mapper)(array) -> Promise|Array
+ * map.series(
+ *   mapperFunc (value any)=>Promise|any,
+ * )(array Array) -> Promise|Array
  * ```
  *
  * @description
@@ -338,27 +361,29 @@ map.series = mapper => function mappingInSeries(value) {
  *
  * @synopsis
  * ```coffeescript [specscript]
- * var maxConcurrency number,
- *   T any,
- *   mapper T=>Promise|any,
- *   array Array<T>
- *
- * map.pool(maxConcurrency, mapper)(array) -> Promise|Array
+ * map.pool(
+ *   maxConcurrency number,
+ *   mapper (value any)=>Promise|any,
+ * )(array Array) -> result Promise|Array
  * ```
  *
  * @description
- * `map` with limited concurrency.
+ * `map` that specifies the maximum concurrency (number of ongoing promises at any time) of the execution. Only works for arrays.
  *
  * ```javascript [playground]
- * const delayedLog = x => new Promise(function (resolve) {
- *   setTimeout(function () {
- *     console.log(x)
- *     resolve()
- *   }, 1000)
- * })
+ * const ids = [1, 2, 3, 4, 5]
  *
- * console.log('start')
- * map.pool(2, delayedLog)([1, 2, 3, 4, 5])
+ * const sleep = ms => new Promise(resolve => setTimeout(resolve, ms))
+ *
+ * const delayedIdentity = async value => {
+ *   await sleep(1000)
+ *   return value
+ * }
+ *
+ * map.pool(2, pipe([
+ *   delayedIdentity,
+ *   console.log,
+ * ]))(ids)
  * ```
  *
  * @TODO objectMapPool
@@ -372,79 +397,4 @@ map.pool = (concurrencyLimit, mapper) => function concurrentPoolMapping(value) {
   throw new TypeError(`${value} is not an Array`)
 }
 
-/**
- * @name map.withIndex
- *
- * @synopsis
- * ```coffeescript [specscript]
- * var T any,
- *   index number,
- *   array Array<T>,
- *   indexedMapper (T, index, array)=>Promise|any
- *
- * map.withIndex(indexedMapper)(array) -> Promise|Array
- * ```
- *
- * @description
- * `map` with an indexed mapper.
- *
- * ```javascript [playground]
- * const range = length => map.withIndex(
- *   (_, index) => index + 1)(Array(length))
- *
- * console.log(range(5)) // [1, 2, 3, 4, 5]
- * ```
- *
- * @execution concurrent
- *
- * @related
- * map, filter.withIndex
- */
-map.withIndex = mapper => function mappingWithIndex(value) {
-  if (isArray(value)) {
-    return arrayMapWithIndex(value, mapper)
-  }
-  throw new TypeError(`${value} is not an Array`)
-}
-
-/**
- * @name map.own
- *
- * @synopsis
- * ```coffeescript [specscript]
- * var T any,
- *   object Object<T>,
- *   mapper T=>Promise|any
- *
- * map.own(mapper)(object) -> Promise|Object
- * ```
- *
- * @description
- * `map` over an object's own properties.
- *
- * ```javascript [playground]
- * const Person = function (name) {
- *   this.name = name
- * }
- *
- * Person.prototype.greet = function () {}
- *
- * const david = new Person('david')
- * david.a = 1
- * david.b = 2
- * david.c = 3
- *
- * const square = number => number ** 2
- * console.log(
- *   map.own(square)(david)
- * ) // { name: NaN, a: 1, b: 4, c: 9 }
- * ```
- */
-map.own = mapper => function mappingOwnProperties(value) {
-  if (isObject(value) && !isArray(value)) {
-    return objectMapOwn(value, mapper)
-  }
-  throw new TypeError(`${value} is not an Object`)
-}
-
 module.exports = map