rubico 2.7.3 → 2.7.5

package/every.d.ts

@@ -12,7 +12,7 @@ export = every;
  * ```
  *
  * @description
- * Test a predicate concurrently across all items of a collection, returning true if all predications are truthy.
+ * Test a predicate concurrently across all elements of a collection, returning true if all predications are truthy.
  *
  * ```javascript [playground]
  * const isOdd = number => number % 2 == 1

package/every.js

@@ -42,13 +42,16 @@ const _every = function (collection, predicate) {
  * @synopsis
  * ```coffeescript [specscript]
  * type Foldable = Array|Set|Map|Generator|AsyncGenerator|{ reduce: function }|Object
+ * type UnarySyncOrAsyncPredicate = any=>Promise|boolean
  *
- * every(foldable Foldable, predicate function) -> result Promise|boolean
- * every(predicate function)(foldable Foldable) -> result Promise|boolean
+ * predicate UnarySyncOrAsyncPredicate
+ *
+ * every(foldable Foldable, predicate) -> result Promise|boolean
+ * every(predicate)(foldable Foldable) -> result Promise|boolean
  * ```
  *
  * @description
- * Test a predicate concurrently across all items of a foldable, returning true if all executions return true.
+ * Test a predicate concurrently across all elements of a foldable, returning true if all executions return true.
  *
  * ```javascript [playground]
  * const isOdd = number => number % 2 == 1

package/filter.d.ts

@@ -17,7 +17,7 @@ export = filter;
  * ```
  *
  * @description
- * Filter out items from a collection based on the results of their concurrent executions with a synchronous or asynchronous predicate function. `filter` accepts the following collections:
+ * Filter out elements from a collection based on the results of their concurrent executions with a synchronous or asynchronous predicate function. `filter` accepts the following collections:
  *
  *  * `Array`
  *  * `Object`
@@ -26,7 +26,7 @@ export = filter;
  *  * `Iterator`/`Generator`
  *  * `AsyncIterator`/`AsyncGenerator`
  *
- * For arrays (type `Array`), `filter` applies the predicate function to each item of the array, returning a new array containing only the items that tested truthy by the predicate. The order of the items is preserved. On each iteration, the predicate is passed the item, the index of the item, and a reference to the array.
+ * For arrays (type `Array`), `filter` applies the predicate function to each element of the array, returning a new array containing only the elements that tested truthy by the predicate. The order of the elements is preserved. On each iteration, the predicate is passed the element, the index of the element, and a reference to the array.
  *
  * ```javascript [playground]
  * const isOdd = number => number % 2 == 1
@@ -48,7 +48,7 @@ export = filter;
  * console.log(filter(obj, isOdd)) // { a: 1, c: 3, e: 5 }
  * ```
  *
- * For sets (type `Set`), `filter` applies the predicate function to each item in the set, returning a new set containing only the items that tested truthy by the predicate. On each iteration, the predicate is passed the item, the same item as the key argument, and a reference to the set.
+ * For sets (type `Set`), `filter` applies the predicate function to each element in the set, returning a new set containing only the elements that tested truthy by the predicate. On each iteration, the predicate is passed the element, the same element as the key argument, and a reference to the set.
  *
  * ```javascript [playground]
  * const isOdd = number => number % 2 == 1

package/filter.js

@@ -92,18 +92,18 @@ const _filter = function (value, predicate) {
  * ```coffeescript [specscript]
  * type Filterable = Array|Set|Map|Generator|AsyncGenerator|{ filter: function }|Object
  *
- * type Predicate = (
+ * type SyncOrAsyncPredicate = (
  *   value any,
  *   indexOrKey number|string|any,
  *   filterable Filterable,
- * )=>boolean
+ * )=>(condition Promise|boolean)
  *
- * filter(filterable Promise|Filterable, predicate Predicate) -> result Promise|Filterable
- * filter(predicate Predicate)(filterable Filterable) -> result Promise|Filterable
+ * filter(filterable Promise|Filterable, predicate SyncOrAsyncPredicate) -> result Promise|Filterable
+ * filter(predicate SyncOrAsyncPredicate)(filterable Filterable) -> result Promise|Filterable
  * ```
  *
  * @description
- * Filters out items from a filterable. Returns a filterable of the same type. The order of the items in the filterable is preserved.
+ * Filters out elements from a filterable. Returns a filterable of the same type. The order of the elements in the filterable is preserved.
  *
  * The following data types are considered to be filterables:
  *  * `array`
@@ -114,11 +114,11 @@ const _filter = function (value, predicate) {
  *  * `object with .filter method`
  *  * `object`
  *
- * The filtering operation is defined by a given predicate function. The predicate function dictates whether a given item from the filterable should be included in the returned filterable.
+ * The filtering operation is defined by a given predicate function. The predicate function dictates whether a given element from the filterable should be included in the returned filterable.
  *
  * ```javascript
- * const predicate = function (item) {
- *   // condition is the boolean result of the predicate test on item
+ * const predicate = function (element) {
+ *   // condition is the boolean result of the predicate test on element
  *   return condition
  * }
  * ```
@@ -127,34 +127,34 @@ const _filter = function (value, predicate) {
  *
  * If the filterable is an array:
  * ```coffeescript [specscript]
- * predicate(item any, index number, filt Array) -> condition Promise|boolean|any
+ * predicate(element any, index number, filt Array) -> condition Promise|boolean|any
  * ```
  *
  * If the filterable is a set:
  * ```coffeescript [specscript]
- * predicate(item any, item any, filt Set) -> condition Promise|boolean|any
+ * predicate(element any, element any, filt Set) -> condition Promise|boolean|any
  * ```
  *
  * If the filterable is a map:
  * ```coffeescript [specscript]
- * predicate(item any, key any, filt Map) -> condition Promise|boolean|any
+ * predicate(element any, key any, filt Map) -> condition Promise|boolean|any
  * ```
  *
  * If the filterable is a generator:
  * ```coffeescript [specscript]
- * predicate(item any) -> condition Promise|boolean|any
+ * predicate(element any) -> condition Promise|boolean|any
  * ```
  *
  * If the filterable is an async generator:
  * ```coffeescript [specscript]
- * predicate(item any) -> condition Promise|boolean|any
+ * predicate(element any) -> condition Promise|boolean|any
  * ```
  *
  * If the filterable is an object with a `.filter` method, the predicate function signature is defined externally.
  *
  * If the filterable is a plain object:
  * ```coffeescript [specscript]
- * predicate(item any, key string, filt Object) -> condition Promise|boolean|any
+ * predicate(element any, key string, filt Object) -> condition Promise|boolean|any
  * ```
  *
  * `filter` works for arrays.

package/flatMap.d.ts

@@ -9,7 +9,7 @@ export = flatMap;
  * type Iterable = Iterable|AsyncIterable|Object<value any>
  *
  * type FlatMapper = (
- *   item any,
+ *   element any,
  *   indexOrKey string,
  *   collection FlatMappable
  * )=>Promise|FlatMappable
@@ -19,10 +19,10 @@ export = flatMap;
  * ```
  *
  * @description
- * Applies a flatMapper function concurrently to each item of a collection, creating a new collection of the same type. A flatMapping operation iterates through each item of a collection and applies the flatMapper function to each item, flattening the result of the execution into the result collection. The result of an individual execution can be any iterable, async iterable, or object values iterable collection. The flatMapper function may be asynchronous.
+ * Applies a flatMapper function concurrently to each element of a collection, creating a new collection of the same type. A flatMapping operation iterates through each element of a collection and applies the flatMapper function to each element, flattening the result of the execution into the result collection. The result of an individual execution can be any iterable, async iterable, or object values iterable collection. The flatMapper function may be asynchronous.
  *
- *  * `Iterable` - the execution result is iterated and each item is added to the result collection
- *  * `AsyncIterable` - the execution result is asynchronously iterated and each item is added to the result collection
+ *  * `Iterable` - the execution result is iterated and each element is added to the result collection
+ *  * `AsyncIterable` - the execution result is asynchronously iterated and each element is added to the result collection
  *  * `Object` - the execution result values are added to the result collection
  *
  * The following example demonstrates various execution results being flattened into the same array.
@@ -41,7 +41,7 @@ export = flatMap;
  * // [1, 1, 2, 3, 3, 5, 5, 8, 7, 7]
  * ```
  *
- * A flatMapping operation concatenates onto the resulting collection synchronous values and muxes any asynchronous values. Muxing, or asynchronously "mixing", is the process of combining multiple asynchronous sources into one source, with order determined by the asynchronous resolution of the individual items.
+ * A flatMapping operation concatenates onto the resulting collection synchronous values and muxes any asynchronous values. Muxing, or asynchronously "mixing", is the process of combining multiple asynchronous sources into one source, with order determined by the asynchronous resolution of the individual elements.
  *
  * ```javascript [playground]
  * const sleep = ms => new Promise(resolve => setTimeout(resolve, ms))
@@ -67,7 +67,7 @@ export = flatMap;
  * // ['foo', 'bar', 'baz', 'foo', 'bar', 'baz', 'foo', 'bar', 'baz']
  * ```
  *
- * For arrays (type `Array`), `flatMap` applies the flatMapper function to each item, pushing (`.push`) the items of each execution into a new array.
+ * For arrays (type `Array`), `flatMap` applies the flatMapper function to each element, pushing (`.push`) the elements of each execution into a new array.
  *
  * ```javascript [playground]
  * const duplicate = value => [value, value]
@@ -77,7 +77,7 @@ export = flatMap;
  * ) // [1, 1, 2, 2, 3, 3, 4, 4, 5, 5]
  * ```
  *
- * For strings (type `String`), `flatMap` applies the flatMapper function to each character, adding (`+`) the items of each execution into a new string
+ * For strings (type `String`), `flatMap` applies the flatMapper function to each character, adding (`+`) the elements of each execution into a new string
  *
  * ```javascript [playground]
  * const duplicate = value => [value, value]
@@ -87,7 +87,7 @@ export = flatMap;
  * ) // 1122334455
  * ```
  *
- * For sets (type `Set`), `flatMap` applies the flatMapper function to each item, adding (`.add`) the items of each execution into a new set
+ * For sets (type `Set`), `flatMap` applies the flatMapper function to each element, adding (`.add`) the elements of each execution into a new set
  *
  * ```javascript [playground]
  * const pairPlus100 = value => [value, value + 100]
@@ -104,6 +104,6 @@ export = flatMap;
  * @archive
  *  * For typed arrays (type [`TypedArray`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray#typedarray_objects)) and Node.js buffers (type [`Buffer`](https://nodejs.org/api/buffer.html)), `flatMap` applies a flatMapper function to each value of the typed array/buffer, joining the result of each execution with `.set` into the resulting typed array
  *
- *  * For Node.js duplex streams (type [Stream](https://nodejs.org/api/stream.html#class-streamduplex)), `flatMap` applies a flatMapper function to each item of the stream, writing (`.write`) each item of each execution into the duplex stream
+ *  * For Node.js duplex streams (type [Stream](https://nodejs.org/api/stream.html#class-streamduplex)), `flatMap` applies a flatMapper function to each element of the stream, writing (`.write`) each element of each execution into the duplex stream
  */
 declare function flatMap(...args: any[]): any;

package/flatMap.js

@@ -20,7 +20,7 @@ const __ = require('./_internal/placeholder')
  *
  * _flatMap(
  *   m Monad,
- *   flatMapper (item any)=>Promise|Iterable,
+ *   flatMapper (element any)=>Promise|Iterable,
  * ) -> result Promise|Monad
  * ```
  */
@@ -66,22 +66,22 @@ const _flatMap = function (value, flatMapper) {
  * ```coffeescript [specscript]
  * type Monad = Array|String|Set|Generator|AsyncGenerator|{ flatMap: string }|{ chain: string }|Object
  *
- * type FlatMapper = (
- *   item any,
+ * type SyncOrAsyncFlatMapper = (
+ *   element any,
  *   indexOrKey number|string|any,
  *   monad Monad
  * )=>Promise|Monad|any
  *
- * flatMapper FlatMapper
+ * flatMapper SyncOrAsyncFlatMapper
  *
  * flatMap(monad Promise|Monad, flatMapper) -> result Promise|Monad
  * flatMap(flatMapper)(monad Monad) -> result Promise|Monad
  * ```
  *
  * @description
- * Applies a flatMapper function to each item of a monad, returning a monad of the same type.
+ * Applies a flatMapper function to each element of a monad, returning a monad of the same type.
  *
- * A flatMapping operation iterates through each item of a monad and applies the flatMapper function to each item, flattening the result of the execution into the returned monad.
+ * A flatMapping operation iterates through each element of a monad and applies the flatMapper function to each element, flattening the result of the execution into the returned monad.
  *
  * If the flatMapper is asynchronous, it is executed concurrently. The execution result may be asynchronously iterable, in which case it is muxed into the returned monad.
  *
@@ -111,7 +111,7 @@ const _flatMap = function (value, flatMapper) {
  * // [1, 1, 2, 3, 3, 5, 5, 8, 7, 7]
  * ```
  *
- * Values from async generators are muxed. Muxing, or asynchronously "mixing", is the process of combining multiple asynchronous sources into one source, with order determined by the asynchronous resolution of the individual items.
+ * Values from async generators are muxed. Muxing, or asynchronously "mixing", is the process of combining multiple asynchronous sources into one source, with order determined by the asynchronous resolution of the individual elements.
  *
  * ```javascript [playground]
  * const sleep = ms => new Promise(resolve => setTimeout(resolve, ms))
@@ -137,7 +137,7 @@ const _flatMap = function (value, flatMapper) {
  * // ['foo', 'bar', 'baz', 'foo', 'bar', 'baz', 'foo', 'bar', 'baz']
  * ```
  *
- * `flatMap` applies the flatMapper function to each item of an array, flattening the results into a new array.
+ * `flatMap` applies the flatMapper function to each element of an array, flattening the results into a new array.
  *
  * ```javascript [playground]
  * const duplicate = value => [value, value]
@@ -179,7 +179,7 @@ const _flatMap = function (value, flatMapper) {
  * @archive
  *  * For typed arrays (type [`TypedArray`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray#typedarray_objects)) and Node.js buffers (type [`Buffer`](https://nodejs.org/api/buffer.html)), `flatMap` applies a flatMapper function to each value of the typed array/buffer, joining the result of each execution with `.set` into the resulting typed array
  *
- *  * For Node.js duplex streams (type [Stream](https://nodejs.org/api/stream.html#class-streamduplex)), `flatMap` applies a flatMapper function to each item of the stream, writing (`.write`) each item of each execution into the duplex stream
+ *  * For Node.js duplex streams (type [Stream](https://nodejs.org/api/stream.html#class-streamduplex)), `flatMap` applies a flatMapper function to each element of the stream, writing (`.write`) each element of each execution into the duplex stream
  */
 const flatMap = (arg0, arg1) => {
   if (typeof arg0 == 'function') {

package/forEach.d.ts

@@ -12,7 +12,7 @@ export = forEach;
  * ```
  *
  * @description
- * Execute a callback for each item of a collection, returning a Promise if the execution is asynchronous.
+ * Execute a callback for each element of a collection, returning a Promise if the execution is asynchronous.
  *
  * ```javascript [playground]
  * forEach([1, 2, 3, 4, 5l], console.log) // 1 2 3 4 5

package/forEach.js

@@ -47,19 +47,21 @@ const _forEach = function (collection, callback) {
  * ```coffeescript [specscript]
  * type Iterable = Array|Set|Map|Generator|AsyncGenerator|{ forEach: function }|Object
  *
- * type Callback = (
- *   item any,
+ * type SyncOrAsyncCallback = (
+ *   element any,
  *   indexOrKey number|string|any,
  *   iter Iterable
  * )=>Promise|undefined
  *
- * forEach(iter Iterable, cb Callback) -> iter Promise|Iterable
+ * iterable Iterable
+ * cb SyncOrAsyncCallback
  *
- * forEach(cb Callback)(iter Iterable) -> iter Promise|Iterable
+ * forEach(iterable, cb) -> unmodifiedIterable Promise|Iterable
+ * forEach(cb)(iterable) -> unmodifiedIterable Promise|Iterable
  * ```
  *
  * @description
- * Execute a callback function for each item of an iterable, returning the original iterable unmodified.
+ * Execute a callback function for each element of an iterable, returning the original iterable unmodified.
  *
  * The following data types are considered to be iterables:
  *  * `array`
@@ -74,34 +76,34 @@ const _forEach = function (collection, callback) {
  *
  * If the iterable is an array:
  * ```coffeescript [specscript]
- * callback(item any, index number, iter Array) -> Promise|undefined
+ * callback(element any, index number, iter Array) -> Promise|undefined
  * ```
  *
  * If the iterable is a set:
  * ```coffeescript [specscript]
- * callback(item any, key any, iter Set) -> Promise|undefined
+ * callback(element any, key any, iter Set) -> Promise|undefined
  * ```
  *
  * If the iterable is a map:
  * ```coffeescript [specscript]
- * callback(item any, key any, filt Map) -> Promise|undefined
+ * callback(element any, key any, filt Map) -> Promise|undefined
  * ```
  *
  * If the iterable is a generator:
  * ```coffeescript [specscript]
- * callback(item any) -> Promise|undefined
+ * callback(element any) -> Promise|undefined
  * ```
  *
  * If the iterable is an async generator:
  * ```coffeescript [specscript]
- * callback(item any) -> Promise|undefined
+ * callback(element any) -> Promise|undefined
  * ```
  *
  * If the iterable is an object with a `.forEach` method, the callback function signature is defined externally.
  *
  * If the iterable is a plain object:
  * ```coffeescript [specscript]
- * callback(item any, key string, iter Object) -> Promise|undefined
+ * callback(element any, key string, iter Object) -> Promise|undefined
  * ```
  *
  * If the callback function is asynchronous, it is executed concurrently.
@@ -200,15 +202,17 @@ const _forEachSeries = function (collection, callback) {
  * ```coffeescript [specscript]
  * type Iterable = Array|Set|Map|Generator|AsyncGenerator|{ forEach: function }|Object
  *
- * type Callback = (
- *   item any,
+ * type SyncOrAsyncCallback = (
+ *   element any,
  *   indexOrKey number|string|any,
  *   iter Iterable
  * )=>Promise|undefined
  *
- * forEach(iter Iterable, cb Callback) -> iter Promise|Iterable
+ * iterable Iterable
+ * cb SyncOrAsyncCallback
  *
- * forEach(cb Callback)(iter Iterable) -> iter Promise|Iterable
+ * forEach(iterable, cb) -> unmodifiedIterable Promise|Iterable
+ * forEach(cb)(iterable) -> unmodifiedIterable Promise|Iterable
  * ```
  *
  * @description

package/global.js

@@ -29,3 +29,4 @@ globalThis.thunkify = require('./thunkify')
 globalThis.always = require('./always')
 globalThis.curry = require('./curry')
 globalThis.__ = require('./__')
+globalThis.Transducer = require('./Transducer')

package/gt.js

@@ -6,20 +6,27 @@ const greaterThan = require('./_internal/greaterThan')
  *
  * @synopsis
  * ```coffeescript [specscript]
- * gt(leftValue Promise|any, rightValue Promise|any) -> boolean
- *
- * gt(leftValue Promise|any, right function)(...args) -> Promise|boolean
- * gt(...args, leftValue Promise|any, right function) -> Promise|boolean
- *
- * gt(left function, rightValue Promise|any)(...args) -> Promise|boolean
- * gt(...args, left function, rightValue Promise|any) -> Promise|boolean
- *
- * gt(left function, right function)(...args) -> Promise|boolean
- * gt(...args, left function, right function) -> Promise|boolean
+ * 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
  * ```
  *
  * @description
- * Test if a value is greater than (`>`) another value.
+ * 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.
  *
  * ```javascript [playground]
  * const age = 40
@@ -29,16 +36,26 @@ const greaterThan = require('./_internal/greaterThan')
  * console.log(isAgeGreaterThan21) // true
  * ```
  *
- * If either of the two values are resolver functions, `gt` returns a function that resolves the values to compare from its arguments.
+ * If either of the two values are resolver functions, `gt` returns a function that resolves the value(s) to compare.
  *
  * ```javascript [playground]
- * const isOfLegalAge = gt(21, get('age'))
+ * const isOfLegalAge = gt(get('age'), 21)
  *
  * const juvenile = { age: 16 }
  *
  * console.log(isOfLegalAge(juvenile)) // false
  * ```
  *
+ * If either of the resolver functions is asynchronous, `gt` returns an asynchronous function.
+ *
+ * ```javascript [playground]
+ * const asyncIsOfLegalAge = gt(async person => person.age, 21)
+ *
+ * const juvenile = { age: 16 }
+ *
+ * asyncIsOfLegalAge(juvenile).then(console.log) // false
+ * ```
+ *
  * `gt` supports a lazy API for composability.
  *
  * ```javascript [playground]

package/gte.js

@@ -6,20 +6,27 @@ const greaterThanOrEqual = require('./_internal/greaterThanOrEqual')
  *
  * @synopsis
  * ```coffeescript [specscript]
- * gte(leftValue Promise|any, rightValue Promise|any) -> boolean
- *
- * gte(leftValue Promise|any, right function)(...args) -> Promise|boolean
- * gte(...args, leftValue Promise|any, right function) -> Promise|boolean
- *
- * gte(left function, rightValue Promise|any)(...args) -> Promise|boolean
- * gte(...args, left function, rightValue Promise|any) -> Promise|boolean
- *
- * gte(left function, right function)(...args) -> Promise|boolean
- * gte(...args, left function, right function) -> Promise|boolean
+ * 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
  * ```
  *
  * @description
- * Test if a value is greater than or equal (`>=`) to another value.
+ * 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.
  *
  * ```javascript [playground]
  * const age = 20
@@ -29,7 +36,7 @@ const greaterThanOrEqual = require('./_internal/greaterThanOrEqual')
  * console.log(isAdultAge) // true
  * ```
  *
- * If either of the two values are resolver functions, `gte` returns a function that resolves the values to compare from its arguments.
+ * If either of the two values are resolver functions, `gte` returns a function that resolves the value(s) to compare.
  *
  * ```javascript [playground]
  * const identity = value => value
@@ -41,6 +48,18 @@ const greaterThanOrEqual = require('./_internal/greaterThanOrEqual')
  * console.log(isAtLeast100(101)) // true
  * ```
  *
+ * If either of the two resolver functions is asynchronous, `gte` returns an asynchronous function.
+ *
+ * ```javascript [playground]
+ * const asyncIdentity = async value => value
+ *
+ * const asyncIsAtLeast100 = gte(asyncIdentity, 100)
+ *
+ * asyncIsAtLeast100(99).then(console.log) // false
+ * asyncIsAtLeast100(100).then(console.log) // true
+ * asyncIsAtLeast100(101).then(console.log) // true
+ * ```
+ *
  * `gte` supports a lazy API for composability.
  *
  * ```javascript [playground]