rubico 2.11.0 → 2.12.1

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 SyncOrAsyncResolver = (...arguments)=>Promise|any
+ *
+ * gt(leftValue Promise|any, rightValue Promise|any) -> Promise|boolean
+ * gt(...arguments, leftResolver SyncOrAsyncResolver, rightValue Promise|any) -> Promise|boolean
+ * gt(...arguments, leftValue Promise|any, rightResolver SyncOrAsyncResolver) -> Promise|boolean
+ * gt(...arguments, leftResolver SyncOrAsyncResolver, rightResolver SyncOrAsyncResolver) -> Promise|boolean
+ *
+ * gt(leftResolver SyncOrAsyncResolver, rightValue Promise|any)(...arguments) -> Promise|boolean
+ * gt(leftValue Promise|any, rightResolver SyncOrAsyncResolver)(...arguments) -> Promise|boolean
+ * gt(leftResolver SyncOrAsyncResolver, rightResolver SyncOrAsyncResolver)(...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 SyncOrAsyncResolver = (...arguments)=>Promise|any
+ *
+ * gte(leftValue Promise|any, rightValue Promise|any) -> Promise|boolean
+ * gte(...arguments, leftResolver SyncOrAsyncResolver, rightValue Promise|any) -> Promise|boolean
+ * gte(...arguments, leftValue Promise|any, rightResolver SyncOrAsyncResolver) -> Promise|boolean
+ * gte(...arguments, leftResolver SyncOrAsyncResolver, rightResolver SyncOrAsyncResolver) -> Promise|boolean
+ *
+ * gte(leftResolver SyncOrAsyncResolver, rightValue Promise|any)(...arguments) -> Promise|boolean
+ * gte(leftValue Promise|any, rightResolver SyncOrAsyncResolver)(...arguments) -> Promise|boolean
+ * gte(leftResolver SyncOrAsyncResolver, rightResolver SyncOrAsyncResolver)(...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.12.1
  * https://rubico.land/
  *
  * © Richard Yufei Tong, King of Software
@@ -1480,26 +1480,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,

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 SyncOrAsyncResolver = (...arguments)=>Promise|any
+ *
+ * lt(leftValue Promise|any, rightValue Promise|any) -> Promise|boolean
+ * lt(...arguments, leftResolver SyncOrAsyncResolver, rightValue Promise|any) -> Promise|boolean
+ * lt(...arguments, leftValue Promise|any, rightResolver SyncOrAsyncResolver) -> Promise|boolean
+ * lt(...arguments, leftResolver SyncOrAsyncResolver, rightResolver SyncOrAsyncResolver) -> Promise|boolean
+ *
+ * lt(leftResolver SyncOrAsyncResolver, rightValue Promise|any)(...arguments) -> Promise|boolean
+ * lt(leftValue Promise|any, rightResolver SyncOrAsyncResolver)(...arguments) -> Promise|boolean
+ * lt(leftResolver SyncOrAsyncResolver, rightResolver SyncOrAsyncResolver)(...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)
 

package/lte.js

@@ -6,44 +6,37 @@ const lessThanOrEqual = require('./_internal/lessThanOrEqual')
  *
  * @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
- *
- * lte(leftValue, rightValue) -> Promise|boolean
- * lte(...argsOrPromises, leftResolver, rightValue) -> Promise|boolean
- * lte(...argsOrPromises, leftValue, rightResolver) -> Promise|boolean
- * lte(...argsOrPromises, leftResolver, rightResolver) -> Promise|boolean
- * lte(leftResolver, rightValue)(...args) -> Promise|boolean
- * lte(leftValue, rightResolver)(...args) -> Promise|boolean
- * lte(leftResolver, rightResolver)(...args) -> Promise|boolean
+ * type SyncOrAsyncResolver = (...arguments)=>Promise|any
+ *
+ * lte(leftValue Promise|any, rightValue Promise|any) -> Promise|boolean
+ * lte(...arguments, leftResolver SyncOrAsyncResolver, rightValue Promise|any) -> Promise|boolean
+ * lte(...arguments, leftValue Promise|any, rightResolver SyncOrAsyncResolver) -> Promise|boolean
+ * lte(...arguments, leftResolver SyncOrAsyncResolver, rightResolver SyncOrAsyncResolver) -> Promise|boolean
+ *
+ * lte(leftResolver SyncOrAsyncResolver, rightValue Promise|any)(...arguments) -> Promise|boolean
+ * lte(leftValue Promise|any, rightResolver SyncOrAsyncResolver)(...arguments) -> Promise|boolean
+ * lte(leftResolver SyncOrAsyncResolver, rightResolver SyncOrAsyncResolver)(...arguments) -> Promise|boolean
  * ```
  *
  * @description
- * Functional equivalent of the [Less than or equal (>=)](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Less_than_or_equal) operator. Tests if a value is less than or equal (`<=`) to another value.
+ * Comparison operator. Tests if a value is less than or equal (`<=`) to another value.
  *
  * ```javascript [playground]
- * console.log(lte(1, 3)) // true
- * console.log(lte(3, 3)) // true
- * console.log(lte(4, 3)) // false
+ * console.log(lte(1, 3))
+ * console.log(lte(3, 3))
+ * console.log(lte(4, 3))
  * ```
  *
- * If either of the two values are resolver functions, `lte` returns a function that resolves the value(s) to compare.
+ * If either of the two values are resolver functions, `lte` returns a function that resolves the values to compare.
  *
  * ```javascript [playground]
  * const identity = value => value
  *
  * const isLessThanOrEqualTo3 = lte(identity, 3)
  *
- * console.log(isLessThanOrEqualTo3(1)) // true
- * console.log(isLessThanOrEqualTo3(3)) // true
- * console.log(isLessThanOrEqualTo3(5)) // false
+ * console.log(isLessThanOrEqualTo3(1))
+ * console.log(isLessThanOrEqualTo3(3))
+ * console.log(isLessThanOrEqualTo3(5))
  * ```
  *
  * If either of the two resolver functions is asynchronous, `lte` returns an asynchronous function.
@@ -53,9 +46,9 @@ const lessThanOrEqual = require('./_internal/lessThanOrEqual')
  *
  * const asyncIsLessThanOrEqualTo3 = lte(asyncIdentity, 3)
  *
- * asyncIsLessThanOrEqualTo3(1).then(console.log) // true
- * asyncIsLessThanOrEqualTo3(3).then(console.log) // true
- * asyncIsLessThanOrEqualTo3(5).then(console.log) // false
+ * asyncIsLessThanOrEqualTo3(1).then(console.log)
+ * asyncIsLessThanOrEqualTo3(3).then(console.log)
+ * asyncIsLessThanOrEqualTo3(5).then(console.log)
  * ```
  *
  * `lte` supports a lazy interface for composability.
@@ -63,14 +56,14 @@ const lessThanOrEqual = require('./_internal/lessThanOrEqual')
  * ```javascript [playground]
  * pipe({ value: 1 }, [
  *   lte(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]
- * lte(Promise.resolve({ a: 1, b: 1 }), get('a'), get('b')).then(console.log) // true
+ * lte(Promise.resolve({ a: 1, b: 1 }), get('a'), get('b')).then(console.log)
  * ```
  *
  * See also:

package/map.js

@@ -109,6 +109,19 @@ const _map = function (value, f) {
  * @description
  * Applies a mapper function to each item of a functor, returning a mapped functor of the same type with the mapped items. The order of the items of the functor is preserved.
  *
+ * ```javascript [playground]
+ * const square = number => number ** 2
+ *
+ * const array = [1, 2, 3, 4, 5]
+ * const object = { a: 1, b: 2, c: 3 }
+ *
+ * const mappedArray = map(array, square)
+ * const mappedObject = map(object, square)
+ *
+ * console.log(mappedArray)
+ * console.log(mappedObject)
+ * ```
+ *
  * The following data types are considered to be functors:
  *  * `array`
  *  * `set`
@@ -160,36 +173,23 @@ const _map = function (value, f) {
  * mapper(item any, key string, functor Object) -> mappedItem Promise|any
  * ```
  *
- * ```javascript [playground]
- * const square = number => number ** 2
- *
- * const array = [1, 2, 3, 4, 5]
- * const object = { a: 1, b: 2, c: 3 }
- *
- * const mappedArray = map(array, square)
- * const mappedObject = map(object, square)
- *
- * console.log(mappedArray)
- * console.log(mappedObject)
- * ```
- *
  * If the functor is an object with a `.map` method, the mapper function signature is defined externally.
  *
- * If the mapper function is asynchronous, it is executed concurrently.
- *
  * If the functor is a generator, the mapper function must be synchronous.
  *
+ * If the mapper function is asynchronous, it is executed concurrently.
+ *
  * ```javascript [playground]
  * const asyncSquare = async number => number ** 2
  *
  * const array = [1, 2, 3, 4, 5]
  *
- * const promise = map(array, asyncSquare)
+ * const result = await map(array, asyncSquare)
  *
- * promise.then(console.log)
+ * console.log(result)
  * ```
  *
- * `map` applies the mapper function to just the values of objects and maps.
+ * `map` iterates over just the values of objects and maps.
  *
  * ```javascript [playground]
  * const square = number => number ** 2
@@ -298,6 +298,19 @@ const _mapEntries = (value, f) => {
  * @description
  * [map](/docs/map) that applies the mapper function to the entries of a functor as opposed to the values.
  *
+ * ```javascript [playground]
+ * const upperCaseKeysAndSquareValues =
+ *   map.entries(([key, value]) => [key.toUpperCase(), value ** 2])
+ *
+ * const object = { a: 1, b: 2, c: 3 }
+ *
+ * console.log(upperCaseKeysAndSquareValues(object))
+ *
+ * const m = new Map([['a', 1], ['b', 2], ['c', 3]])
+ *
+ * console.log(upperCaseKeysAndSquareValues(m))
+ * ```
+ *
  * The following data types are considered to be functors with entries:
  *   * `map`
  *   * `object`
@@ -316,19 +329,6 @@ const _mapEntries = (value, f) => {
  *   mappedEntry Promise|[mappedKey string, mappedValue any]
  * ```
  *
- * ```javascript [playground]
- * const upperCaseKeysAndSquareValues =
- *   map.entries(([key, value]) => [key.toUpperCase(), value ** 2])
- *
- * const object = { a: 1, b: 2, c: 3 }
- *
- * console.log(upperCaseKeysAndSquareValues(object))
- *
- * const m = new Map([['a', 1], ['b', 2], ['c', 3]])
- *
- * console.log(upperCaseKeysAndSquareValues(m))
- * ```
- *
  * If the functor with entries is a promise, it is resolved for its value before further execution for the eager interface only.
  *
  * ```javascript [playground]
@@ -552,10 +552,7 @@ const _mapPool = function (f, concurrency, mapper) {
  *   return value
  * }
  *
- * map.pool(2, pipe([
- *   delayedIdentity,
- *   console.log,
- * ]))(ids)
+ * map.pool(ids, 2, pipe(delayedIdentity, console.log))
  * ```
  *
  * If the functor is a promise, it is resolved for its value before further execution for the eager interface only.

package/not.js

@@ -19,36 +19,31 @@ const _not = function (args, predicate) {
  *
  * @synopsis
  * ```coffeescript [specscript]
- * args Array<any>
- * argsOrPromises Array<Promise|any>
+ * type SyncOrAsyncPredicate = (...arguments)=>Promise|boolean
  *
- * type SyncOrAsyncPredicate = (...args)=>Promise|boolean
- *
- * predicate SyncOrAsyncPredicate
- *
- * not(value Promise|boolean|any) -> negated Promise|boolean
- * not(...argsOrPromises, predicate) -> negated Promise|boolean
- * not(predicate)(...args) -> negated Promise|boolean
+ * not(value Promise|boolean|any) -> negatedResult Promise|boolean
+ * not(...arguments, predicate SyncOrAsyncPredicate) -> negatedResult Promise|boolean
+ * not(predicate SyncOrAsyncPredicate)(...arguments) -> negatedResult Promise|boolean
  * ```
  *
  * @description
- * Function equivalent to the [Logical NOT (`!`)](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Logical_NOT) operator. Negates a value.
+ * Logical operator. Negates a predicate or value.
  *
  * ```javascript [playground]
- * const myObj = { a: 1 }
+ * const object = { a: 1 }
  *
- * console.log(not('a' in myObj)) // false
- * console.log(not('b' in myObj)) // true
+ * console.log(not('a' in object))
+ * console.log(not('b' in object))
  * ```
  *
- * If provided a predicate function, `not` returns a logically inverted predicate that returns true everywhere the original predicate would have returned false.
+ * If provided a predicate function, `not` returns a logically inverted predicate.
  *
  * ```javascript [playground]
  * const isOdd = number => number % 2 == 1
  *
  * const isNotOdd = not(isOdd)
  *
- * console.log(isNotOdd(3)) // false
+ * console.log(isNotOdd(3))
  * ```
  *
  * `not` negates the resolved value of a promise.
@@ -56,10 +51,10 @@ const _not = function (args, predicate) {
  * ```javascript [playground]
  * const promise = Promise.resolve(false)
  *
- * not(promise).then(console.log) // true
+ * not(promise).then(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]
  * const isOdd = number => number % 2 == 1