rubico 2.11.0 → 2.13.0

package/forEach.js

@@ -47,19 +47,27 @@ const _forEach = function (collection, callback) {
  * ```coffeescript [specscript]
  * type Iterable = Array|Set|Map|Generator|AsyncGenerator|{ forEach: function }|Object
  *
- * type SyncOrAsyncCallback = (
+ * type Callback = (
  *   item any,
  *   indexOrKey number|string|any,
  *   iterable Iterable
  * )=>Promise|undefined
  *
- * forEach(iterable Promise|Iterable, callback SyncOrAsyncCallback) -> iterable Promise|Iterable
- * forEach(callback SyncOrAsyncCallback)(iterable Iterable) -> iterable Promise|Iterable
+ * forEach(iterable Promise|Iterable, callback Callback) -> iterable Promise|Iterable
+ * forEach(callback Callback)(iterable Iterable) -> iterable Promise|Iterable
  * ```
  *
  * @description
  * Executes a callback function for each item of an iterable, returning the original iterable unmodified.
  *
+ * ```javascript [playground]
+ * console.log('array')
+ * forEach([1, 2, 3, 4, 5], num => console.log(num))
+ *
+ * console.log('object')
+ * forEach({ a: 1, b: 2, c: 3 }, num => console.log(num))
+ * ```
+ *
  * The following data types are considered to be iterable:
  *  * `array`
  *  * `set`
@@ -101,14 +109,6 @@ const _forEach = function (collection, callback) {
  * callback(item any, key string, iterable Object) -> Promise|undefined
  * ```
  *
- * ```javascript [playground]
- * console.log('array')
- * forEach([1, 2, 3, 4, 5], num => console.log(num))
- *
- * console.log('object')
- * forEach({ a: 1, b: 2, c: 3 }, num => console.log(num))
- * ```
- *
  * If the iterable is an object with a `.forEach` method, the callback function signature is defined externally.
  *
  * If the callback function is asynchronous, it is executed concurrently.
@@ -190,14 +190,14 @@ const _forEachSeries = function (collection, callback) {
  * ```coffeescript [specscript]
  * type Iterable = Array|Set|Map|Generator|AsyncGenerator|{ forEach: function }|Object
  *
- * type SyncOrAsyncCallback = (
+ * type Callback = (
  *   item any,
  *   indexOrKey number|string|any,
  *   iter Iterable
  * )=>Promise|undefined
  *
- * forEach.series(iterable Promise|Iterable, callback SyncOrAsyncCallback) -> iterable Promise|Iterable
- * forEach.series(callback SyncOrAsyncCallback)(iterable Iterable) -> iterable Promise|Iterable
+ * forEach.series(iterable Promise|Iterable, callback Callback) -> iterable Promise|Iterable
+ * forEach.series(callback Callback)(iterable Iterable) -> iterable Promise|Iterable
  * ```
  *
  * @description

package/get.js

@@ -74,9 +74,9 @@ const _get = function (object, path, defaultValue) {
  * ```javascript [playground]
  * const asyncDefaultResolver = async object => object.a
  *
- * const promise = get({ a: 1 }, 'notfound', asyncDefaultResolver)
+ * const result = await get({ a: 1 }, 'notfound', asyncDefaultResolver)
  *
- * promise.then(console.log)
+ * console.log(result)
  * ```
  *
  * `get` supports three types of path patterns for nested property access.
@@ -96,7 +96,7 @@ const _get = function (object, path, defaultValue) {
  * const get00000BracketNotation = get('[0][0][0][0][0]')
  * const get00000ArrayNotation = get([0, 0, 0, 0, 0])
  *
- * const nested = [[[[['foo']]]]]
+ * const nested = [[[[[1]]]]]
  *
  * console.log(get00000DotNotation(nested))
  * console.log(get00000BracketNotation(nested))

package/gt.js

@@ -6,44 +6,37 @@ const greaterThan = require('./_internal/greaterThan')
  *
  * @synopsis
  * ```coffeescript [specscript]
- * args Array<any>
- * argsOrPromises Array<Promise|any>
- *
- * type SyncOrAsyncResolver = (...args)=>Promise|any
- *
- * leftValue Promise|any
- * rightValue Promise|any
- * leftResolver SyncOrAsyncResolver
- * rightResolver SyncOrAsyncResolver
- *
- * gt(leftValue, rightValue) -> Promise|boolean
- * gt(...argsOrPromises, leftResolver, rightValue) -> Promise|boolean
- * gt(...argsOrPromises, leftValue, rightResolver) -> Promise|boolean
- * gt(...argsOrPromises, leftResolver, rightResolver) -> Promise|boolean
- * gt(leftResolver, rightValue)(...args) -> Promise|boolean
- * gt(leftValue, rightResolver)(...args) -> Promise|boolean
- * gt(leftResolver, rightResolver)(...args) -> Promise|boolean
+ * type Resolver = (...arguments)=>Promise|any
+ *
+ * gt(leftValue Promise|any, rightValue Promise|any) -> Promise|boolean
+ * gt(...arguments, leftResolver Resolver, rightValue Promise|any) -> Promise|boolean
+ * gt(...arguments, leftValue Promise|any, rightResolver Resolver) -> Promise|boolean
+ * gt(...arguments, leftResolver Resolver, rightResolver Resolver) -> Promise|boolean
+ *
+ * gt(leftResolver Resolver, rightValue Promise|any)(...arguments) -> Promise|boolean
+ * gt(leftValue Promise|any, rightResolver Resolver)(...arguments) -> Promise|boolean
+ * gt(leftResolver Resolver, rightResolver Resolver)(...arguments) -> Promise|boolean
  * ```
  *
  * @description
- * Functional equivalent of the [Greater than (>)](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Greater_than) operator. Tests if a value is greater than (`>`) another value.
+ * Comparison operator. Tests if a value is greater than (`>`) another value.
  *
  * ```javascript [playground]
  * const age = 40
  *
  * const isAgeGreaterThan21 = gt(age, 21)
  *
- * console.log(isAgeGreaterThan21) // true
+ * console.log(isAgeGreaterThan21)
  * ```
  *
- * If either of the two values are resolver functions, `gt` returns a function that resolves the value(s) to compare.
+ * If either of the two values are resolver functions, `gt` returns a function that resolves the values to compare.
  *
  * ```javascript [playground]
  * const isOfLegalAge = gt(get('age'), 21)
  *
  * const juvenile = { age: 16 }
  *
- * console.log(isOfLegalAge(juvenile)) // false
+ * console.log(isOfLegalAge(juvenile))
  * ```
  *
  * If either of the resolver functions is asynchronous, `gt` returns an asynchronous function.
@@ -53,7 +46,7 @@ const greaterThan = require('./_internal/greaterThan')
  *
  * const juvenile = { age: 16 }
  *
- * asyncIsOfLegalAge(juvenile).then(console.log) // false
+ * asyncIsOfLegalAge(juvenile).then(console.log)
  * ```
  *
  * `gt` supports a lazy interface for composability.
@@ -61,14 +54,14 @@ const greaterThan = require('./_internal/greaterThan')
  * ```javascript [playground]
  * pipe({ value: 1 }, [
  *   gt(5, get('value')),
- *   console.log, // true
+ *   console.log,
  * ])
  * ```
  *
- * Any promises passed in data argument position are resolved for their values before further execution.
+ * Any promises in `arguments` are resolved for their values before further execution for the eager interface only.
  *
  * ```javascript [playground]
- * gt(Promise.resolve({ a: 2, b: 1 }), get('a'), get('b')).then(console.log) // true
+ * gt(Promise.resolve({ a: 2, b: 1 }), get('a'), get('b')).then(console.log)
  * ```
  *
  * See also:

package/gte.js

@@ -6,46 +6,39 @@ const greaterThanOrEqual = require('./_internal/greaterThanOrEqual')
  *
  * @synopsis
  * ```coffeescript [specscript]
- * args Array<any>
- * argsOrPromises Array<Promise|any>
- *
- * type SyncOrAsyncResolver = (...args)=>Promise|any
- *
- * leftValue Promise|any
- * rightValue Promise|any
- * leftResolver SyncOrAsyncResolver
- * rightResolver SyncOrAsyncResolver
- *
- * gte(leftValue, rightValue) -> Promise|boolean
- * gte(...argsOrPromises, leftResolver, rightValue) -> Promise|boolean
- * gte(...argsOrPromises, leftValue, rightResolver) -> Promise|boolean
- * gte(...argsOrPromises, leftResolver, rightResolver) -> Promise|boolean
- * gte(leftResolver, rightValue)(...args) -> Promise|boolean
- * gte(leftValue, rightResolver)(...args) -> Promise|boolean
- * gte(leftResolver, rightResolver)(...args) -> Promise|boolean
+ * type Resolver = (...arguments)=>Promise|any
+ *
+ * gte(leftValue Promise|any, rightValue Promise|any) -> Promise|boolean
+ * gte(...arguments, leftResolver Resolver, rightValue Promise|any) -> Promise|boolean
+ * gte(...arguments, leftValue Promise|any, rightResolver Resolver) -> Promise|boolean
+ * gte(...arguments, leftResolver Resolver, rightResolver Resolver) -> Promise|boolean
+ *
+ * gte(leftResolver Resolver, rightValue Promise|any)(...arguments) -> Promise|boolean
+ * gte(leftValue Promise|any, rightResolver Resolver)(...arguments) -> Promise|boolean
+ * gte(leftResolver Resolver, rightResolver Resolver)(...arguments) -> Promise|boolean
  * ```
  *
  * @description
- * Functional equivalent of the [Greater than or equal (>=)](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Greater_than_or_equal) operator. Tests if a value is greater than or equal (`>=`) to another value.
+ * Comparison operator. Tests if a value is greater than or equal (`>=`) to another value.
  *
  * ```javascript [playground]
  * const age = 20
  *
  * const isAdultAge = gte(age, 18)
  *
- * console.log(isAdultAge) // true
+ * console.log(isAdultAge)
  * ```
  *
- * If either of the two values are resolver functions, `gte` returns a function that resolves the value(s) to compare.
+ * If either of the two values are resolver functions, `gte` returns a function that resolves the values to compare.
  *
  * ```javascript [playground]
  * const identity = value => value
  *
  * const isAtLeast100 = gte(identity, 100)
  *
- * console.log(isAtLeast100(99)) // false
- * console.log(isAtLeast100(100)) // true
- * console.log(isAtLeast100(101)) // true
+ * console.log(isAtLeast100(99))
+ * console.log(isAtLeast100(100))
+ * console.log(isAtLeast100(101))
  * ```
  *
  * If either of the two resolver functions is asynchronous, `gte` returns an asynchronous function.
@@ -55,9 +48,9 @@ const greaterThanOrEqual = require('./_internal/greaterThanOrEqual')
  *
  * const asyncIsAtLeast100 = gte(asyncIdentity, 100)
  *
- * asyncIsAtLeast100(99).then(console.log) // false
- * asyncIsAtLeast100(100).then(console.log) // true
- * asyncIsAtLeast100(101).then(console.log) // true
+ * asyncIsAtLeast100(99).then(console.log)
+ * asyncIsAtLeast100(100).then(console.log)
+ * asyncIsAtLeast100(101).then(console.log)
  * ```
  *
  * `gte` supports a lazy interface for composability.
@@ -65,14 +58,14 @@ const greaterThanOrEqual = require('./_internal/greaterThanOrEqual')
  * ```javascript [playground]
  * pipe({ value: 1 }, [
  *   gte(1, get('value')),
- *   console.log, // true
+ *   console.log,
  * ])
  * ```
  *
- * Any promises passed in data argument position are resolved for their values before further execution.
+ * Any promises in `arguments` are resolved for their values before further execution for the eager interface only.
  *
  * ```javascript [playground]
- * gte(Promise.resolve({ a: 1, b: 1 }), get('a'), get('b')).then(console.log) // true
+ * gte(Promise.resolve({ a: 1, b: 1 }), get('a'), get('b')).then(console.log)
  * ```
  *
  * See also:

package/index.js

@@ -1,5 +1,5 @@
 /**
- * Rubico v2.10.0
+ * Rubico v2.13.0
  * https://rubico.land/
  *
  * © Richard Yufei Tong, King of Software
@@ -374,7 +374,8 @@ 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, __),
@@ -385,6 +386,90 @@ const functionArrayAllSeries = function (funcs, args) {
   return result
 }
 
+// argument resolver for curry5
+const curry5ResolveArg0 = (
+  baseFunc, arg1, arg2, arg3, arg4,
+) => function arg0Resolver(arg0) {
+  return baseFunc(arg0, arg1, arg2, arg3, arg4)
+}
+
+// argument resolver for curry5
+const curry5ResolveArg1 = (
+  baseFunc, arg0, arg2, arg3, arg4,
+) => function arg1Resolver(arg1) {
+  return baseFunc(arg0, arg1, arg2, arg3, arg4)
+}
+
+// argument resolver for curry5
+const curry5ResolveArg2 = (
+  baseFunc, arg0, arg1, arg3, arg4,
+) => function arg2Resolver(arg2) {
+  return baseFunc(arg0, arg1, arg2, arg3, arg4)
+}
+
+// argument resolver for curry5
+const curry5ResolveArg3 = (
+  baseFunc, arg0, arg1, arg2, arg4,
+) => function arg3Resolver(arg3) {
+  return baseFunc(arg0, arg1, arg2, arg3, arg4)
+}
+
+// argument resolver for curry5
+const curry5ResolveArg4 = (
+  baseFunc, arg0, arg1, arg2, arg3,
+) => function arg3Resolver(arg4) {
+  return baseFunc(arg0, arg1, arg2, arg3, arg4)
+}
+
+const curry5 = function (baseFunc, arg0, arg1, arg2, arg3, arg4) {
+  if (arg0 == __) {
+    return curry5ResolveArg0(baseFunc, arg1, arg2, arg3, arg4)
+  }
+  if (arg1 == __) {
+    return curry5ResolveArg1(baseFunc, arg0, arg2, arg3, arg4)
+  }
+  if (arg2 == __) {
+    return curry5ResolveArg2(baseFunc, arg0, arg1, arg3, arg4)
+  }
+  if (arg3 == __) {
+    return curry5ResolveArg3(baseFunc, arg0, arg1, arg2, arg4)
+  }
+  return curry5ResolveArg4(baseFunc, arg0, arg1, arg2, arg3)
+}
+
+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
+}
+
+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
+}
+
 const functionObjectAll = function (funcs, args) {
   const result = {}, promises = []
   for (const key in funcs) {
@@ -441,14 +526,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)
 }
 
 const objectAssign = Object.assign
@@ -1480,26 +1584,64 @@ const FilteringIterator = (iterator, predicate) => ({
   },
 })
 
-const FilteringAsyncIterator = (asyncIterator, predicate) => ({
-  isAsyncIteratorDone: false,
-  [symbolAsyncIterator]() {
-    return this
-  },
-  async next() {
-    while (!this.isAsyncIteratorDone) {
-      const { value, done } = await asyncIterator.next()
-      if (done) {
-        this.isAsyncIteratorDone = true
-      } else {
-        const predication = predicate(value)
-        if (isPromise(predication) ? await predication : predication) {
-          return { value, done: false }
+const FilteringAsyncIterator = (asyncIterator, predicate) => {
+  const buffer = new LinkedList()
+
+  let index = -1
+  let consumingAsyncIterator = false
+  let isAsyncIteratorDone = false
+
+  return {
+    [symbolAsyncIterator]() {
+      return this
+    },
+
+    // _consumeAsyncIterator() -> Promise<>
+    async _consumeAsyncIterator() {
+      for await (const item of asyncIterator) {
+        index += 1
+        const booleanResult = predicate(item)
+        buffer.append([booleanResult, item])
+      }
+      isAsyncIteratorDone = true
+    },
+
+    
+    async next() {
+      if (!consumingAsyncIterator) {
+        this._consumeAsyncIterator()
+        consumingAsyncIterator = true
+      }
+
+      while (!isAsyncIteratorDone) {
+        if (buffer.length > 0) {
+          let [booleanResult, item] = buffer.popFirst()
+          if (isPromise(booleanResult)) {
+            booleanResult = await booleanResult
+          }
+          if (booleanResult) {
+            return { value: item, done: false }
+          }
+          continue
         }
+        await sleep(10)
       }
-    }
-    return { value: undefined, done: true }
-  },
-})
+
+      while (buffer.length > 0) {
+        let [booleanResult, item] = buffer.popFirst()
+        if (isPromise(booleanResult)) {
+          booleanResult = await booleanResult
+        }
+        if (booleanResult) {
+          return { value: item, done: false }
+        }
+      }
+
+      return { value: undefined, done: true }
+    },
+
+  }
+}
 
 const arrayExtendMap = function (
   array, values, valuesMapper, valuesIndex,
@@ -1759,57 +1901,6 @@ const arrayReduce = function (array, reducer, result) {
   return result
 }
 
-// argument resolver for curry5
-const curry5ResolveArg0 = (
-  baseFunc, arg1, arg2, arg3, arg4,
-) => function arg0Resolver(arg0) {
-  return baseFunc(arg0, arg1, arg2, arg3, arg4)
-}
-
-// argument resolver for curry5
-const curry5ResolveArg1 = (
-  baseFunc, arg0, arg2, arg3, arg4,
-) => function arg1Resolver(arg1) {
-  return baseFunc(arg0, arg1, arg2, arg3, arg4)
-}
-
-// argument resolver for curry5
-const curry5ResolveArg2 = (
-  baseFunc, arg0, arg1, arg3, arg4,
-) => function arg2Resolver(arg2) {
-  return baseFunc(arg0, arg1, arg2, arg3, arg4)
-}
-
-// argument resolver for curry5
-const curry5ResolveArg3 = (
-  baseFunc, arg0, arg1, arg2, arg4,
-) => function arg3Resolver(arg3) {
-  return baseFunc(arg0, arg1, arg2, arg3, arg4)
-}
-
-// argument resolver for curry5
-const curry5ResolveArg4 = (
-  baseFunc, arg0, arg1, arg2, arg3,
-) => function arg3Resolver(arg4) {
-  return baseFunc(arg0, arg1, arg2, arg3, arg4)
-}
-
-const curry5 = function (baseFunc, arg0, arg1, arg2, arg3, arg4) {
-  if (arg0 == __) {
-    return curry5ResolveArg0(baseFunc, arg1, arg2, arg3, arg4)
-  }
-  if (arg1 == __) {
-    return curry5ResolveArg1(baseFunc, arg0, arg2, arg3, arg4)
-  }
-  if (arg2 == __) {
-    return curry5ResolveArg2(baseFunc, arg0, arg1, arg3, arg4)
-  }
-  if (arg3 == __) {
-    return curry5ResolveArg3(baseFunc, arg0, arg1, arg2, arg4)
-  }
-  return curry5ResolveArg4(baseFunc, arg0, arg1, arg2, arg3)
-}
-
 const objectKeys = Object.keys
 
 const objectReduceAsync = async function (object, reducer, result, keys, index) {
@@ -1944,8 +2035,6 @@ const reduce = function (...args) {
 
 const isBinary = ArrayBuffer.isView
 
-const add = (a, b) => a + b
-
 const _arrayExtend = function (array, values) {
   const arrayLength = array.length,
     valuesLength = values.length

package/lt.js

@@ -6,44 +6,37 @@ const lessThan = require('./_internal/lessThan')
  *
  * @synopsis
  * ```coffeescript [specscript]
- * args Array<any>
- * argsOrPromises Array<Promise|any>
- *
- * type SyncOrAsyncResolver = (...args)=>Promise|any
- *
- * leftValue Promise|any
- * rightValue Promise|any
- * leftResolver SyncOrAsyncResolver
- * rightResolver SyncOrAsyncResolver
- *
- * lt(leftValue, rightValue) -> Promise|boolean
- * lt(...argsOrPromises, leftResolver, rightValue) -> Promise|boolean
- * lt(...argsOrPromises, leftValue, rightResolver) -> Promise|boolean
- * lt(...argsOrPromises, leftResolver, rightResolver) -> Promise|boolean
- * lt(leftResolver, rightValue)(...args) -> Promise|boolean
- * lt(leftValue, rightResolver)(...args) -> Promise|boolean
- * lt(leftResolver, rightResolver)(...args) -> Promise|boolean
+ * type Resolver = (...arguments)=>Promise|any
+ *
+ * lt(leftValue Promise|any, rightValue Promise|any) -> Promise|boolean
+ * lt(...arguments, leftResolver Resolver, rightValue Promise|any) -> Promise|boolean
+ * lt(...arguments, leftValue Promise|any, rightResolver Resolver) -> Promise|boolean
+ * lt(...arguments, leftResolver Resolver, rightResolver Resolver) -> Promise|boolean
+ *
+ * lt(leftResolver Resolver, rightValue Promise|any)(...arguments) -> Promise|boolean
+ * lt(leftValue Promise|any, rightResolver Resolver)(...arguments) -> Promise|boolean
+ * lt(leftResolver Resolver, rightResolver Resolver)(...arguments) -> Promise|boolean
  * ```
  *
  * @description
- * Functional equivalent of the [Less than (<)](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Less_than) operator. Tests if a value is less than (`<`) another value.
+ * Comparison operator. Tests if a value is less than (`<`) another value.
  *
  * ```javascript [playground]
- * console.log(lt(1, 3)) // true
- * console.log(lt(3, 3)) // false
- * console.log(lt(4, 3)) // false
+ * console.log(lt(1, 3))
+ * console.log(lt(3, 3))
+ * console.log(lt(4, 3))
  * ```
  *
- * If either of the two values are resolver functions, `lt` returns a function that resolves the value(s) to compare.
+ * If either of the two values are resolver functions, `lt` returns a function that resolves the values to compare.
  *
  * ```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))
+ * console.log(isLessThan3(3))
+ * console.log(isLessThan3(5))
  * ```
  *
  * If either of the resolver functions is asynchronous, `lt` returns an asynchronous function.
@@ -53,9 +46,9 @@ const lessThan = require('./_internal/lessThan')
  *
  * const asyncIsLessThan3 = lt(asyncIdentity, 3)
  *
- * asyncIsLessThan3(1).then(console.log) // true
- * asyncIsLessThan3(3).then(console.log) // false
- * asyncIsLessThan3(5).then(console.log) // false
+ * asyncIsLessThan3(1).then(console.log)
+ * asyncIsLessThan3(3).then(console.log)
+ * asyncIsLessThan3(5).then(console.log)
  * ```
  *
  * `lt` supports a lazy interface for composability.
@@ -63,15 +56,24 @@ const lessThan = require('./_internal/lessThan')
  * ```javascript [playground]
  * pipe({ value: 1 }, [
  *   lt(0, get('value')),
- *   console.log, // true
+ *   console.log,
  * ])
  * ```
  *
- * Any promises passed in data argument position are resolved for their values before further execution.
+ * Any promises in `arguments` are resolved for their values before further execution for the eager interface only.
  *
  * ```javascript [playground]
- * lt(Promise.resolve({ a: 1, b: 2 }), get('a'), get('b')).then(console.log) // true
+ * lt(Promise.resolve({ a: 1, b: 2 }), get('a'), get('b')).then(console.log)
  * ```
+ *
+ * See also:
+ *  * [and](/docs/and)
+ *  * [eq](/docs/eq)
+ *  * [gt](/docs/lt)
+ *  * [gte](/docs/gte)
+ *  * [lte](/docs/lte)
+ *  * [thunkify](/docs/thunkify)
+ *
  */
 const lt = ComparisonOperator(lessThan)