rubico 2.11.0 → 2.13.0

package/README.md

@@ -23,7 +23,7 @@ const numbers = [1, 2, 3, 4, 5]
 pipe(numbers, [
   filter(isOdd),
   map(asyncSquare),
-  console.log, // [1, 9, 25]
+  console.log,
 ])
 ```
 
@@ -94,32 +94,37 @@ Rubico is a library for [A]synchronous Functional Programming in JavaScript. The
 
 ```javascript
 const {
-  // compose functions
+
+  // function composition
   pipe, compose, tap,
 
-  // control flow
+  // conditional operators
   switchCase,
 
-  // handle errors
+  // error handling
   tryCatch,
 
-  // compose data
+  // data construction
   all, assign, get, set, pick, omit,
 
-  // iterate
+  // iteration
   forEach,
 
-  // transform data
+  // transformation
   map, filter, reduce, transform, flatMap,
 
-  // compose predicates
-  and, or, not, some, every,
+  // data testing
+  some, every,
+
+  // logical operators
+  and, or, not,
 
   // comparison operators
   eq, gt, lt, gte, lte,
 
   // partial application
   thunkify, always, curry, __,
+
 } = rubico
 ```
 
@@ -133,7 +138,7 @@ pipe(helloPromise, [ // helloPromise is resolved for 'hello'
   // the Promise returned from the async function is resolved
   // and the resolved value is passed to console.log
 
-  console.log, // hello world
+  console.log,
 ])
 ```
 
@@ -151,7 +156,6 @@ const myDuplicatedSquaredObject = map(myObj, pipe([
 ]))
 
 console.log(myDuplicatedSquaredObject)
-// { a: [1, 1], b: [4, 4], c: [9, 9] }
 ```
 
 The Rubico operators are versatile and act on a wide range of vanilla JavaScript types to create declarative, extensible, and async-enabled function compositions. The same operator `map` can act on an array and also a `Map` data structure.
@@ -172,11 +176,6 @@ pipe(todoIDs, [
     response => response.json(),
 
     tap(console.log),
-    // { userId: 1, id: 4, title: 'et porro tempora', completed: true }
-    // { userId: 1, id: 1, title: 'delectus aut autem', completed: false }
-    // { userId: 1, id: 3, title: 'fugiat veniam minus', completed: false }
-    // { userId: 1, id: 2, title: 'quis ut nam facilis...', completed: false }
-    // { userId: 1, id: 5, title: 'laboriosam mollitia...', completed: false }
   ])),
 
   // group the todos by userId in a new Map
@@ -201,9 +200,6 @@ pipe(todoIDs, [
   })),
 
   tap(console.log),
-  // Map(1) {
-  //   1 => [ { userId: 1, id: 4, title: 'et porro tempora', completed: true } ]
-  // }
 ])
 ```
 
@@ -227,7 +223,7 @@ pipe(generateNumbers(), [
     Transducer.filter(isOdd),
     Transducer.map(asyncSquare),
   ), []),
-  console.log, // [1, 9, 25]
+  console.log,
 ])
 ```
 

package/Transducer.js

@@ -11,8 +11,44 @@ const __ = require('./_internal/placeholder')
 /**
  * @name Transducer
  *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * type Reducer = (accumulator any, value any)=>(nextAccumulator Promise|any)
+ *
+ * type Transducer = Reducer=>Reducer
+ * ```
+ *
  * @description
- * Temporary repository of transducer functionality throughout rubico v1
+ * A transducer is a function that takes a `Reducer` and returns another `Reducer`. Transducers enable function chains with reducers - pass a reducer to a transducer to create a reducer with chained functionality. A `Reducer` is a function that defines a relationship between an accumulator and an item in a transformation, and can be used in a reducing operation, such as with Rubico's [reduce](/docs/reduce) or vanilla JavaScript [Array.prototype.reduce](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce).
+ *
+ * ```javascript [playground]
+ * const isOdd = number => number % 2 == 1
+ *
+ * const asyncSquare = async number => number ** 2
+ *
+ * const numbers = [1, 2, 3, 4, 5]
+ *
+ * const transducer = compose(
+ *   Transducer.filter(isOdd),
+ *   Transducer.map(asyncSquare)
+ * )
+ *
+ * const transformed = await transform(numbers, transducer, [])
+ *
+ * console.log(transformed)
+ * ```
+ *
+ * The following are the core building blocks for creating transducers with Rubico, and are offered through this [Transducer](/docs/Transducer) module.
+ *
+ * * [Transducer.map](/docs/Transducer.map)
+ * * [Transducer.filter](/docs/Transducer.filter)
+ * * [Transducer.flatMap](/docs/Transducer.flatMap)
+ * * [Transducer.forEach](/docs/Transducer.forEach)
+ * * [Transducer.passthrough](/docs/Transducer.passthrough)
+ * * [Transducer.tryCatch](/docs/Transducer.tryCatch)
+ *
+ * See also:
+ *   * [Transducers Crash Course](/blog/transducers-crash-course)
  */
 const Transducer = {}
 
@@ -21,22 +57,20 @@ const Transducer = {}
  *
  * @synopsis
  * ```coffeescript [specscript]
- * type SyncOrAsyncReducer = (accumulator any, value any)=>(nextAccumulator Promise|any)
- * type Transducer = SyncOrAsyncReducer=>SyncOrAsyncReducer
- * type UnarySyncOrAsyncMapper = (element any)=>(resultElement Promise|any)
- *
- * mapper UnarySyncOrAsyncMapper
+ * type Reducer = (accumulator any, value any)=>(nextAccumulator Promise|any)
+ * type Transducer = Reducer=>Reducer
+ * type Mapper = (item any)=>(mappedItem Promise|any)
  *
- * Transducer.map(mapper) -> mappingTransducer Transducer
+ * Transducer.map(mapper Mapper) -> mappingTransducer Transducer
  * ```
  *
  * @description
- * Creates a mapping transducer. Elements of the transducer's reducing operation are transformed by the mapper function. It is possible to use an asynchronous mapper, however the reducing operation must support asynchronous execution. This library provides such implementations as [reduce](/docs/reduce) and [transform](/docs/transform).
+ * Creates a mapping [transducer](/blog/transducers-crash-course). Items of the transducer's reducing operation are transformed by the mapper function. It is possible to use an asynchronous mapper, however the reducing operation must support asynchronous execution. This library provides such implementations as [reduce](/docs/reduce) and [transform](/docs/transform).
  *
  * ```javascript [playground]
  * const square = number => number ** 2
  *
- * const concat = (array, element) => array.concat(element)
+ * const concat = (array, item) => array.concat(item)
  *
  * const mapSquare = Transducer.map(square)
  * // mapSquare is a transducer
@@ -45,23 +79,18 @@ const Transducer = {}
  * // now mapSquare is passed the reducer function concat; squareConcatReducer
  * // is a reducer with chained functionality square and concat
  *
- * console.log(
- *   reduce([1, 2, 3, 4, 5], squareConcatReducer, [])
- * ) // [1, 4, 9, 16, 25]
+ * const squaredNumbersRubicoReduce = reduce([1, 2, 3, 4, 5], squareConcatReducer, [])
+ * console.log(squaredNumbersRubicoReduce)
  *
  * // the same squareConcatReducer is consumable with vanilla JavaScript
- * console.log(
- *   [1, 2, 3, 4, 5].reduce(squareConcatReducer, [])
- * ) // [1, 4, 9, 16, 25]
+ * const squaredNumbersVanillaReduce = [1, 2, 3, 4, 5].reduce(squareConcatReducer, [])
+ * console.log(squaredNumbersVanillaReduce)
  *
  * // concat is implicit when transforming into arrays
- * console.log(
- *   transform([1, 2, 3, 4, 5], Transducer.map(square), [])
- * ) // [1, 4, 9, 16, 25]
+ * const squaredNumbersTransform = transform([1, 2, 3, 4, 5], Transducer.map(square), [])
+ * console.log(squaredNumbersTransform)
  * ```
  *
- * Read more on [transducers](/blog/transducers-crash-course-rubico-v2).
- *
  * See also:
  *  * [thunkify](/docs/thunkify)
  *  * [Transducer.filter](/docs/Transducer.filter)
@@ -80,35 +109,31 @@ Transducer.map = function transducerMap(mapper) {
  *
  * @synopsis
  * ```coffeescript [specscript]
- * type SyncOrAsyncReducer = (accumulator any, value any)=>(nextAccumulator Promise|any)
- * type Transducer = SyncOrAsyncReducer=>SyncOrAsyncReducer
- * type UnarySyncOrAsyncPredicate = any=>Promise|boolean|any
+ * type Reducer = (accumulator any, value any)=>(nextAccumulator Promise|any)
+ * type Transducer = Reducer=>Reducer
+ * type Predicate = any=>Promise|boolean|any
  *
- * predicate UnarySyncOrAsyncPredicate
- *
- * Transducer.filter(predicate) -> filteringTransducer Transducer
+ * Transducer.filter(predicate Predicate) -> filteringTransducer Transducer
  * ```
  *
  * @description
- * Creates a filtering transducer. A filtering transducer filters out elements of its reducing operation if they test false by the predicate. It is possible to use an asynchronous predicate, however the reducing operation must support asynchronous execution. This library provides such implementations as [reduce](/docs/reduce) and [transform](/docs/transform).
+ * Creates a filtering [transducer](/blog/transducers-crash-course). A filtering transducer filters out items of its reducing operation if they test false by the predicate. It is possible to use an asynchronous predicate, however the reducing operation must support asynchronous execution. This library provides such implementations as [reduce](/docs/reduce) and [transform](/docs/transform).
  *
  * ```javascript [playground]
  * const isOdd = number => number % 2 == 1
  *
- * const concat = (array, element) => array.concat(element)
+ * const concat = (array, item) => array.concat(item)
  *
  * const concatOddNumbers = Transducer.filter(isOdd)(concat)
  *
  * const array = [1, 2, 3, 4, 5]
  *
  * const oddNumbers1 = array.reduce(concatOddNumbers, [])
- * console.log(oddNumbers1) // [1, 3, 5]
- *
  * const oddNumbers2 = transform(array, Transducer.filter(isOdd), [])
- * console.log(oddNumbers2) // [1, 3, 5]
- * ```
  *
- * Read more on [transducers](/blog/transducers-crash-course-rubico-v2).
+ * console.log(oddNumbers1)
+ * console.log(oddNumbers2)
+ * ```
  *
  * See also:
  *  * [thunkify](/docs/thunkify)
@@ -128,30 +153,26 @@ Transducer.filter = function transducerFilter(predicate) {
  *
  * @synopsis
  * ```coffeescript [specscript]
- * type SyncOrAsyncReducer = (accumulator any, value any)=>(nextAccumulator Promise|any)
- * type Transducer = SyncOrAsyncReducer=>SyncOrAsyncReducer
+ * type Reducer = (accumulator any, value any)=>(nextAccumulator Promise|any)
+ * type Transducer = Reducer=>Reducer
  * type Monad = Array|String|Set|Generator|AsyncGenerator|{ flatMap: string }|{ chain: string }|Object
- * type UnarySyncOrAsyncFlatMapper = (element any)=>(monad Promise|Monad|any)
+ * type FlatMapper = (item any)=>(monad Promise|Monad|any)
  *
- * flatMapper UnarySyncOrAsyncFlatMapper
- *
- * Transducer.flatMap(flatMapper) -> flatMappingTransducer Transducer
+ * Transducer.flatMap(flatMapper FlatMapper) -> flatMappingTransducer Transducer
  * ```
  *
  * @description
- * Creates a flatMapping transducer. A flatMapping transducer applies the flatMapper function to each element of its reducing operation, concatenating the results of the flatMapper execution onto the accumulator. It is possible to use an asynchronous flatMapper, however the reducing operation must support asynchronous execution. This library provides such implementations as [reduce](/docs/reduce) and [transform](/docs/transform).
+ * Creates a flatMapping [transducer](/blog/transducers-crash-course). A flatMapping transducer applies the flatMapper function to each item of its reducing operation, concatenating the results of the flatMapper execution onto the accumulator. It is possible to use an asynchronous flatMapper, however the reducing operation must support asynchronous execution. This library provides such implementations as [reduce](/docs/reduce) and [transform](/docs/transform).
  *
  * ```javascript [playground]
  * const powers = number => [number, number ** 2, number ** 3]
  *
  * const numbers = [1, 2, 3, 4, 5]
  *
- * console.log(
- *   transform(numbers, Transducer.flatMap(powers), [])
- * ) // [1, 1, 1, 2, 4, 8, 3, 9, 27, 4, 16, 64, 5, 25, 125]
- * ```
+ * const result = transform(numbers, Transducer.flatMap(powers), [])
  *
- * Read more on [transducers](/blog/transducers-crash-course-rubico-v2).
+ * console.log(result)
+ * ```
  *
  * See also:
  *  * [thunkify](/docs/thunkify)
@@ -171,28 +192,25 @@ Transducer.flatMap = function transducerFlatMap(flatMapper) {
  *
  * @synopsis
  * ```coffeescript [specscript]
- * type SyncOrAsyncReducer = (accumulator any, value any)=>(nextAccumulator Promise|any)
- * type Transducer = SyncOrAsyncReducer=>SyncOrAsyncReducer
- * type UnarySyncOrAsyncCallback = (element any)=>Promise|undefined
- *
- * callback UnarySyncOrAsyncCallback
+ * type Reducer = (accumulator any, value any)=>(nextAccumulator Promise|any)
+ * type Transducer = Reducer=>Reducer
+ * type Callback = (item any)=>Promise|undefined
  *
- * Transducer.forEach(callback) -> forEachTransducer Transducer
+ * Transducer.forEach(callback Callback) -> forEachTransducer Transducer
  * ```
  *
  * @description
- * Executes a callback function for each element of a reducing operation, leaving the reducing operation unmodified. It is possible to use an asynchronous callback function, however the reducing operation must support asynchronous execution. This library provides such implementations as [reduce](/docs/reduce) and [transform](/docs/transform).
+ * Creates an iterative [transducer](/blog/transducers-crash-course). Executes a callback function for each item of a reducing operation, leaving each item unmodified. It is possible to use an asynchronous callback function, however the reducing operation must support asynchronous execution. This library provides such implementations as [reduce](/docs/reduce) and [transform](/docs/transform).
  *
  * ```javascript [playground]
  * const numbers = [1, 2, 3, 4, 5]
+ *
  * transform(numbers, compose(
  *   Transducer.map(number => number ** 2),
- *   Transducer.forEach(console.log), // 1 4 9 16 25
+ *   Transducer.forEach(console.log),
  * ), null)
  * ```
  *
- * Read more on [transducers](/blog/transducers-crash-course-rubico-v2).
- *
  * See also:
  *  * [thunkify](/docs/thunkify)
  *  * [Transducer.map](/docs/Transducer.map)
@@ -211,14 +229,14 @@ Transducer.forEach = function transducerForEach(func) {
  *
  * @synopsis
  * ```coffeescript [specscript]
- * type SyncOrAsyncReducer = (accumulator any, value any)=>(nextAccumulator Promise|any)
- * type Transducer = SyncOrAsyncReducer=>SyncOrAsyncReducer
+ * type Reducer = (accumulator any, value any)=>(nextAccumulator Promise|any)
+ * type Transducer = Reducer=>Reducer
  *
- * Transducer.passthrough Transducer
+ * Transducer.passthrough -> Transducer
  * ```
  *
  * @description
- * Creates a pasthrough transducer. The passthrough transducer simply passes each element of the reducing operation through to the next downstream operation, leaving the reducing operation unmodified.
+ * Creates a pasthrough [transducer](/blog/transducers-crash-course). The passthrough transducer simply passes each item of the reducing operation through to the next downstream transducer, leaving each item unmodified.
  *
  * ```javascript [playground]
  * const createAsyncNumbers = async function* () {
@@ -229,11 +247,10 @@ Transducer.forEach = function transducerForEach(func) {
  *   }
  * }
  *
- * transform(createAsyncNumbers(), Transducer.passthrough, [])
- *   .then(console.log) // [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
- * ```
+ * const numbers = await transform(createAsyncNumbers(), Transducer.passthrough, [])
  *
- * Read more on [transducers](/blog/transducers-crash-course-rubico-v2).
+ * console.log(numbers)
+ * ```
  *
  * See also:
  *  * [thunkify](/docs/thunkify)
@@ -253,17 +270,17 @@ Transducer.passthrough = function transducerPassthrough(reducer) {
  *
  * @synopsis
  * ```coffeescript [specscript]
- * type SyncOrAsyncReducer = (accumulator any, value any)=>(nextAccumulator Promise|any)
- * type Transducer = SyncOrAsyncReducer=>SyncOrAsyncReducer
+ * type Reducer = (accumulator any, value any)=>(nextAccumulator Promise|any)
+ * type Transducer = Reducer=>Reducer
  *
- * transducerTryer Transducer
- * catcher (error Error, element any)=>Promise|any
- *
- * Transducer.tryCatch(transducerTryer, catcher) -> tryCatchTransducer Transducer
+ * Transducer.tryCatch(
+ *   transducerTryer Transducer,
+ *   catcher (error Error, item any)=>(Promise|any)
+ * ) -> tryCatchTransducer Transducer
  * ```
  *
  * @description
- * Creates an error handling transducer. The error handling transducer wraps a transducer and catches any errors thrown by the transducer with the catcher function. The catcher function is provided the error as well as the element for which the error was thrown. It is possible for either the transducer or the catcher to be asynchronous, however the reducing operation must support asynchronous execution. This library provides such implementations as [reduce](/docs/reduce) and [transform](/docs/transform).
+ * Creates an error handling [transducer](/blog/transducers-crash-course). The error handling transducer wraps a transducer and catches any errors thrown by the transducer with the catcher function. The catcher function is provided the error and the item for which the error was thrown. It is possible for either the transducer or the catcher to be asynchronous, however the reducing operation must support asynchronous execution. This library provides such implementations as [reduce](/docs/reduce) and [transform](/docs/transform).
  *
  * ```javascript [playground]
  * const db = new Map()
@@ -295,8 +312,6 @@ Transducer.passthrough = function transducerPassthrough(reducer) {
  * ), null)
  * ```
  *
- * Read more on [transducers](/blog/transducers-crash-course-rubico-v2).
- *
  * See also:
  *  * [thunkify](/docs/thunkify)
  *  * [Transducer.map](/docs/Transducer.map)

package/__.js

@@ -12,9 +12,9 @@ const __ = require('./_internal/placeholder')
  * A special placeholder value `__` (two underscores) that denotes the position of an argument in a curried function.
  *
  * ```javascript [playground]
- * console.log(
- *   curry.arity(3, Array.of, __, 2, 3)(1),
- * ) // [1, 2, 3]
+ * const curriedFunction = curry.arity(3, Array.of, __, 2, 3)
+ *
+ * console.log(curriedFunction(1))
  * ```
  *
  * See also:

package/_internal/functionArrayAllSeries.js

@@ -11,7 +11,7 @@ const objectSet = require('./objectSet')
  * @synopsis
  * ```coffeescript [specscript]
  * asyncFunctionArrayAllSeries(
- *   funcs Array<function>,
+ *   funcs Array<function|any>,
  *   args Array,
  *   result Array,
  *   funcsIndex number
@@ -34,14 +34,15 @@ const asyncFunctionArrayAllSeries = async function (funcs, args, result, funcsIn
  *
  * @synopsis
  * ```coffeescript [specscript]
- * functionArrayAllSeries(funcs Array<function>, args Array) -> Promise|Array
+ * functionArrayAllSeries(funcs Array<function|any>, args Array) -> Promise|Array
  * ```
  */
 const functionArrayAllSeries = function (funcs, args) {
   const funcsLength = funcs.length, result = []
   let funcsIndex = -1
   while (++funcsIndex < funcsLength) {
-    const resultElement = funcs[funcsIndex](...args)
+    const f = funcs[funcsIndex]
+    const resultElement = typeof f == 'function' ? f(...args) : f
     if (isPromise(resultElement)) {
       return resultElement.then(funcConcat(
         curry3(objectSet, result, funcsIndex, __),

package/_internal/functionObjectAllSeries.js

@@ -0,0 +1,65 @@
+const funcConcat = require('./funcConcat')
+const isPromise = require('./isPromise')
+const __ = require('./placeholder')
+const curry3 = require('./curry3')
+const curry5 = require('./curry5')
+const objectSet = require('./objectSet')
+
+/**
+ * @name asyncFunctionObjectAllSeries
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * asyncFunctionObjectAllSeries(
+ *   funcs Array<function>,
+ *   args Array,
+ *   result Array,
+ *   keys Array<string>,
+ *   keysIndex number
+ * ) -> Promise|Array
+ * ```
+ *
+ * @TODO benchmark vs regular promise handling
+ */
+const asyncFunctionObjectAllSeries = async function (funcs, args, result, keys, keysIndex) {
+  const keysLength = keys.length
+  while (++keysIndex < keysLength) {
+    const key = keys[keysIndex]
+    const f = funcs[key]
+    let resultElement = typeof f == 'function' ? f(...args) : f
+    if (isPromise(resultElement)) {
+      resultElement = await resultElement
+    }
+    result[key] = resultElement
+  }
+  return result
+}
+
+/**
+ * @name functionObjectAllSeries
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * functionObjectAllSeries(funcs Object<function|any>, args Array) -> Promise|Array
+ * ```
+ */
+const functionObjectAllSeries = function (funcs, args) {
+  const result = {}
+  const keys = Object.keys(funcs)
+  const keysLength = keys.length
+  let keysIndex = -1
+  while (++keysIndex < keysLength) {
+    const key = keys[keysIndex]
+    const f = funcs[key]
+    const resultElement = typeof f == 'function' ? f(...args) : f
+    if (isPromise(resultElement)) {
+      return resultElement.then(funcConcat(
+        curry3(objectSet, result, key, __),
+        curry5(asyncFunctionObjectAllSeries, funcs, args, __, keys, keysIndex)))
+    }
+    result[key] = resultElement
+  }
+  return result
+}
+
+module.exports = functionObjectAllSeries

package/_internal/genericTransform.js

@@ -7,7 +7,6 @@ const curry2 = require('./curry2')
 const curry3 = require('./curry3')
 const always = require('./always')
 const noop = require('./noop')
-const add = require('./add')
 const genericReduce = require('./genericReduce')
 const objectAssign = require('./objectAssign')
 const arrayExtend = require('./arrayExtend')

package/all.js

@@ -9,6 +9,7 @@ const curry2 = require('./_internal/curry2')
 const curryArgs2 = require('./_internal/curryArgs2')
 const functionArrayAll = require('./_internal/functionArrayAll')
 const functionArrayAllSeries = require('./_internal/functionArrayAllSeries')
+const functionObjectAllSeries = require('./_internal/functionObjectAllSeries')
 const functionObjectAll = require('./_internal/functionObjectAll')
 
 /**
@@ -36,16 +37,16 @@ const _allValues = function (values) {
  *
  * @synopsis
  * ```coffeescript [specscript]
- * type SyncOrAsyncResolver = (...arguments)=>Promise|any
- * type ResolverOrValue = SyncOrAsyncResolver|Promise|any
+ * type Resolver = (...arguments)=>Promise|any
+ * type ResolverOrValue = Resolver|Promise|any
  *
- * all(Promise|Array<Promise|any>) -> Promise|Array
- * all(...arguments, Array<ResolverOrValue>) -> Promise|Array
- * all(Array<ResolverOrValue>)(...arguments) -> Promise|Array
+ * all(values Promise|Array<Promise|any>) -> result Promise|Array
+ * all(...arguments, valuesOrFuncs Array<ResolverOrValue>) -> result Promise|Array
+ * all(valuesOrFuncs Array<ResolverOrValue>)(...arguments) -> result Promise|Array
  *
- * all(Promise|Object<Promise|any>) -> Promise|Object
- * all(...arguments, Object<ResolverOrValue>) -> Promise|Object
- * all(Object<ResolverOrValue>)(...arguments) -> Promise|Object
+ * all(values Promise|Object<Promise|any>) -> result Promise|Object
+ * all(...arguments, valuesOrFuncs Object<ResolverOrValue>) -> result Promise|Object
+ * all(valuesOrFuncs Object<ResolverOrValue>)(...arguments) -> result Promise|Object
  * ```
  *
  * @description
@@ -162,9 +163,9 @@ const all = function (...args) {
  *
  * @synopsis
  * ```coffeescript [specscript]
- * all.series(...arguments, Array<function>) -> Promise|Array
+ * all.series(...arguments, funcs Array<function>) -> result Promise|Array
  *
- * all.series(Array<function>)(...arguments) -> Promise|Array
+ * all.series(funcs Array<function>)(...arguments) -> result Promise|Array
  * ```
  *
  * @description
@@ -186,14 +187,33 @@ const all = function (...args) {
  */
 
 all.series = function allSeries(...args) {
-  const funcs = args.pop()
-  if (args.length == 0) {
-    return curryArgs2(functionArrayAllSeries, funcs, __)
+  if (args.length == 1) {
+    const resolversOrValues = args[0]
+    if (isPromise(resolversOrValues)) {
+      return resolversOrValues.then(_allValues)
+    }
+    if (areAllValuesNonfunctions(resolversOrValues)) {
+      return _allValues(resolversOrValues)
+    }
+    return isArray(resolversOrValues)
+      ? curryArgs2(functionArrayAllSeries, resolversOrValues, __)
+      : curryArgs2(functionObjectAllSeries, resolversOrValues, __)
   }
-  if (areAnyValuesPromises(args)) {
-    return promiseAll(args).then(curry2(functionArrayAllSeries, funcs, __))
+
+  const resolversOrValues = args[args.length - 1]
+  const argValues = args.slice(0, -1)
+
+  if (areAnyValuesPromises(argValues)) {
+    return isArray(resolversOrValues)
+      ? promiseAll(argValues)
+        .then(curry2(functionArrayAllSeries, resolversOrValues, __))
+      : promiseAll(argValues)
+        .then(curry2(functionObjectAllSeries, resolversOrValues, __))
   }
-  return functionArrayAllSeries(funcs, args)
+
+  return isArray(resolversOrValues)
+    ? functionArrayAllSeries(resolversOrValues, argValues)
+    : functionObjectAllSeries(resolversOrValues, argValues)
 }
 
 module.exports = all

package/always.js

@@ -9,14 +9,14 @@ const always = require('./_internal/always')
  * ```
  *
  * @description
- * Creates a function from a value that always returns the provided value.
+ * Creates a function that always returns a value.
  *
  * ```javascript [playground]
  * const always5 = always(5)
  *
- * console.log(always5()) // 5
- * console.log(always5()) // 5
- * console.log(always5()) // 5
+ * console.log(always5())
+ * console.log(always5())
+ * console.log(always5())
  * ```
  *
  * See also: