rubico 1.9.6 → 2.0.0

package/flatMap.js

@@ -1,80 +1,105 @@
+const isPromise = require('./_internal/isPromise')
 const FlatMappingIterator = require('./_internal/FlatMappingIterator')
 const FlatMappingAsyncIterator = require('./_internal/FlatMappingAsyncIterator')
 const isArray = require('./_internal/isArray')
-const isGeneratorFunction = require('./_internal/isGeneratorFunction')
-const isAsyncGeneratorFunction = require('./_internal/isAsyncGeneratorFunction')
-const isBinary = require('./_internal/isBinary')
 const arrayFlatMap = require('./_internal/arrayFlatMap')
 const objectFlatMap = require('./_internal/objectFlatMap')
 const setFlatMap = require('./_internal/setFlatMap')
 const stringFlatMap = require('./_internal/stringFlatMap')
-const streamFlatMap = require('./_internal/streamFlatMap')
-const binaryFlatMap = require('./_internal/binaryFlatMap')
-const reducerFlatMap = require('./_internal/reducerFlatMap')
-const generatorFunctionFlatMap = require('./_internal/generatorFunctionFlatMap')
-const asyncGeneratorFunctionFlatMap = require('./_internal/asyncGeneratorFunctionFlatMap')
 const symbolIterator = require('./_internal/symbolIterator')
-const symbolAsyncIterator = require('./_internal/symbolAsyncIterator')
+const curry2 = require('./_internal/curry2')
+const __ = require('./_internal/placeholder')
 
 /**
- * @name flatMap
+ * @name _flatMap
  *
  * @synopsis
  * ```coffeescript [specscript]
- * Stream<T> = { read: ()=>T, write: T=>() }
- * Monad<T> = Array<T>|String<T>|Set<T>
- *   |TypedArray<T>|Stream<T>|Iterator<T>|AsyncIterator<T>
- *   |{ chain: T=>Monad<T> }|{ flatMap: T=>Monad<T> }|Object<T>
- * Reducer<T> = (any, T)=>Promise|any
- * Foldable<T> = Iterable<T>|AsyncIterable<T>|{ reduce: Reducer<T>=>any }|Object<T>
- *
- * var T any,
- *   flatMapper T=>Promise|Monad<T>|Foldable<T>|T,
- *   monad Monad<T>,
- *   args ...any,
- *   generatorFunction ...args=>Generator<Promise|T>,
- *   asyncGeneratorFunction ...args=>AsyncGenerator<T>,
- *   reducer Reducer<T>
+ * type FlatMappable = Array|String|Set|Iterator|AsyncIterator
+ * type Iterable = Iterable|AsyncIterable|Object<value any>
  *
- * flatMap(flatMapper)(monad) -> Monad<T>
+ * _flatMap(
+ *   value FlatMappable,
+ *   flatMapper (item any)=>Promise|Iterable,
+ * ) -> result Promise|FlatMappable
+ * ```
+ */
+const _flatMap = function (value, flatMapper) {
+  if (isArray(value)) {
+    return arrayFlatMap(value, flatMapper)
+  }
+  if (value == null) {
+    return flatMapper(value)
+  }
+
+  if (typeof value.then == 'function') {
+    return value.then(flatMapper)
+  }
+  if (typeof value.next == 'function') {
+    return symbolIterator in value
+      ? FlatMappingIterator(value, flatMapper)
+      : FlatMappingAsyncIterator(value, flatMapper)
+  }
+  if (typeof value.chain == 'function') {
+    return value.chain(flatMapper)
+  }
+  if (typeof value.flatMap == 'function') {
+    return value.flatMap(flatMapper)
+  }
+  const valueConstructor = value.constructor
+  if (valueConstructor == Object) {
+    return objectFlatMap(value, flatMapper)
+  }
+  if (valueConstructor == Set) {
+    return setFlatMap(value, flatMapper)
+  }
+  if (typeof value == 'string' || valueConstructor == String) {
+    return stringFlatMap(value, flatMapper)
+  }
+  return flatMapper(value)
+}
+
+/**
+ * @name flatMap
  *
- * flatMap(flatMapper)(generatorFunction) -> ...args=>Generator<T>
+ * @synopsis
+ * ```coffeescript [specscript]
+ * type FlatMappable = Array|String|Set|Iterator|AsyncIterator
+ * type Iterable = Iterable|AsyncIterable|Object<value any>
  *
- * flatMap(flatMapper)(asyncGeneratorFunction) -> ...args=>AsyncGenerator<T>
+ * flatMap(
+ *   collection FlatMappable,
+ *   flatMapper (item any)=>Promise|Iterable,
+ * ) -> result Promise|FlatMappable
  *
- * flatMap(flatMapper)(reducer) -> Reducer<T>
+ * flatMap(flatMapper (item any)=>Promise|Iterable)(collection FlatMappable)
+ *   -> result Promise|FlatMappable
  * ```
  *
  * @description
- * Apply a flatMapper concurrently to each item of a monad, flattening the items of each execution into a new monad that is the same type as the original.
+ * 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.
  *
- * The following list outlines high level behavior for various input monads.
+ *  * `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
+ *  * `Object` - the execution result values are added to the result collection
  *
- *  * `Array` - Apply a flatMapper to each item, pushing (`.push`) the items of each execution into a new array
- *  * `String` - Apply a flatMapper to each character, adding (`+`) the items of each execution into a new string
- *  * `Set` - Apply a flatMapper to each item, adding (`.add`) the items of each execution into a new set
- *  * `TypedArray` - Apply a flatMapper to each byte, setting (`.set`) the items of each execution into a new typed array
- *  * `Buffer (Node.js)` - Apply a flatMapper to each byte, setting (`.set`) the items of each execution into a new Node.js Buffer
- *  * `stream.Duplex (Node.js)` - Apply a flatMapper to each item, writing (`.write`) the items of each execution into a new duplex stream
- *  * `Object` - Apply a flatMapper to each value, assigning (`Object.assign`) the items of each execution into a new object
- *  * `Reducer` - Apply a flatMapper to each item of a reducer's reducing operation, calling each item of each execution with the reducer.
- *  * `{ chain: function }` - Call `.chain` directly with flatMapper
- *  * `{ flatMap: function }` - Call `.flatMap` directly with flatMapper
+ * The following example demonstrates various execution results being flattened into the same array.
  *
  * ```javascript [playground]
- * const duplicate = number => [number, number]
- *
- * console.log(
- *   flatMap(duplicate)([1, 2, 3, 4, 5]),
- * ) // [1, 1, 2, 2, 3, 3, 4, 4, 5, 5]
- *
- * const asyncDuplicate = async number => [number, number]
+ * const identity = value => value
  *
- * flatMap(asyncDuplicate)( // concurrent execution
- *   [1, 2, 3, 4, 5]).then(console.log) // [1, 1, 2, 2, 3, 3, 4, 4, 5, 5]
+ * flatMap(identity)([
+ *   [1, 1], // array
+ *   new Set([2, 2]), // set
+ *   (function* () { yield 3; yield 3 })(), // generator
+ *   (async function* () { yield 7; yield 7 })(), // asyncGenerator
+ *   { a: 5, b: 5 }, // object
+ *   new Uint8Array([8]), // typedArray
+ * ]).then(console.log)
+ * // [1, 1, 2, 3, 3, 5, 5, 8, 7, 7]
  * ```
  *
- * A flatMapping operation concatenates onto the result 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 items.
  *
  * ```javascript [playground]
  * const sleep = ms => new Promise(resolve => setTimeout(resolve, ms))
@@ -84,7 +109,7 @@ const symbolAsyncIterator = require('./_internal/symbolAsyncIterator')
  * }
  *
  * console.log( // sync is concatenated
- *   flatMap(repeat3)(['foo', 'bar', 'baz']),
+ *   flatMap(['foo', 'bar', 'baz'], repeat3),
  * ) // ['foo', 'foo', 'foo', 'bar', 'bar', 'bar', 'baz', 'baz', 'baz']
  *
  * const asyncRepeat3 = async function* (message) {
@@ -95,133 +120,59 @@ const symbolAsyncIterator = require('./_internal/symbolAsyncIterator')
  *   yield message
  * }
  *
- * flatMap(asyncRepeat3)( // async is muxed
- *   ['foo', 'bar', 'baz']).then(console.log)
+ * // async is muxed
+ * flatMap(['foo', 'bar', 'baz'], asyncRepeat3).then(console.log)
  * // ['foo', 'bar', 'baz', 'foo', 'bar', 'baz', 'foo', 'bar', 'baz']
  * ```
  *
- * In general, flattening is by order of concatenation with the exception of async iterables, which are muxed. Below, the two `4`s are asynchronous and are pushed onto the result after all the synchronous values have been flattened.
+ * For arrays (type `Array`), `flatMap` applies the flatMapper function to each item, pushing (`.push`) the items of each execution into a new array.
  *
  * ```javascript [playground]
- * const identity = value => value
+ * const duplicate = value => [value, value]
  *
- * flatMap(identity)([
- *   [1, 1],
- *   new Set([2, 2]),
- *   (function* () { yield 3; yield 3 })(),
- *   (async function* () { yield 4; yield 4 })(),
- *   { a: 5, b: 5 },
- *   6,
- *   Promise.resolve(7),
- *   new Uint8Array([8]),
- * ]).then(console.log)
- * // [1, 1, 2, 3, 3, 5, 5, 6, 7, 8, 4, 4]
+ * console.log(
+ *   flatMap([1, 2, 3, 4, 5], duplicate)
+ * ) // [1, 1, 2, 2, 3, 3, 4, 4, 5, 5]
  * ```
  *
- * Purer functional programming is possible with `flatMap` and explicit monads. An explicit monad is any object that defines a method `.chain` or `.flatMap`.
+ * For strings (type `String`), `flatMap` applies the flatMapper function to each character, adding (`+`) the items of each execution into a new string
  *
  * ```javascript [playground]
- * const Maybe = value => ({
- *   chain(flatMapper) {
- *     return value == null ? value : flatMapper(value)
- *   },
- * })
- *
- * const userbase = new Map([
- *   ['1', { _id: '1', name: 'George' }],
- *   ['2', { _id: '2', name: 'Jane' }],
- *   ['3', { _id: '3', name: 'Jim' }],
- * ])
- *
- * const getUserByID = async userID => userbase.get(userID)
- *
- * const logUserByID = pipe([
- *   getUserByID,
- *   Maybe,
- *   flatMap(console.log),
- * ])
+ * const duplicate = value => [value, value]
  *
- * logUserByID('5')
- *
- * logUserByID('1') // { _id: '1', name: 'George' }
+ * console.log(
+ *   flatMap('12345', duplicate)
+ * ) // 1122334455
  * ```
  *
- * Additionally, `flatMap` is a powerful option when working with transducers. A flatMapping transducer applies a flatMapper to each item of a reducer's reducing operation, calling each item of each execution with the reducer.
+ * For sets (type `Set`), `flatMap` applies the flatMapper function to each item, adding (`.add`) the items of each execution into a new set
  *
  * ```javascript [playground]
- * const isOdd = number => number % 2 == 1
- *
- * const powers = number => [number, number ** 2, number ** 3]
- *
- * const oddPowers = pipe([
- *   filter(isOdd),
- *   flatMap(powers),
- * ])
- *
- * const arrayConcat = (array, value) => array.concat(value)
+ * const pairPlus100 = value => [value, value + 100]
  *
  * console.log(
- *   reduce(oddPowers(arrayConcat), [])([1, 2, 3, 4, 5]),
- * ) // [1, 1, 1, 3, 9, 27, 5, 25, 125]
+ *   flatMap(new Set([1, 2, 3, 4, 5]), pairPlus100)
+ * ) // Set(10) { 1, 101, 2, 102, 3, 103, 4, 104, 5, 105 }
  * ```
  *
- * In the case above, each item of the array of numbers returned by `powers` is called with the reducer `arrayConcat` for flattening into the final result.
- *
  * @execution concurrent
  *
  * @transducing
+ *
+ * @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
  */
-const flatMap = flatMapper => function flatMapping(value) {
-  if (isArray(value)) {
-    return arrayFlatMap(value, flatMapper)
-  }
-  if (typeof value == 'function') {
-    if (isGeneratorFunction(value)) {
-      return generatorFunctionFlatMap(value, flatMapper)
-    }
-    if (isAsyncGeneratorFunction(value)) {
-      return asyncGeneratorFunctionFlatMap(value, flatMapper)
-    }
-    return reducerFlatMap(value, flatMapper)
-  }
-  if (isBinary(value)) {
-    return binaryFlatMap(value, flatMapper)
+const flatMap = (...args) => {
+  const flatMapper = args.pop()
+  if (args.length == 0) {
+    return curry2(_flatMap, __, flatMapper)
   }
-  if (value == null) {
-    return flatMapper(value)
-  }
-
-  if (typeof value.then == 'function') {
-    return value.then(flatMapper)
-  }
-  if (typeof value.next == 'function') {
-    return symbolIterator in value
-      ? FlatMappingIterator(value, flatMapper)
-      : FlatMappingAsyncIterator(value, flatMapper)
-  }
-  if (typeof value.chain == 'function') {
-    return value.chain(flatMapper)
-  }
-  if (typeof value.flatMap == 'function') {
-    return value.flatMap(flatMapper)
-  }
-  if (
-    typeof value[symbolAsyncIterator] == 'function'
-      && typeof value.write == 'function'
-  ) {
-    return streamFlatMap(value, flatMapper)
-  }
-  const valueConstructor = value.constructor
-  if (valueConstructor == Object) {
-    return objectFlatMap(value, flatMapper)
-  }
-  if (valueConstructor == Set) {
-    return setFlatMap(value, flatMapper)
-  }
-  if (typeof value == 'string' || valueConstructor == String) {
-    return stringFlatMap(value, flatMapper)
-  }
-  return flatMapper(value)
+  const collection = args[0]
+  return isPromise(collection)
+    ? collection.then(curry2(_flatMap, __, flatMapper))
+    : _flatMap(args[0], flatMapper)
 }
 
 module.exports = flatMap

package/forEach.js

@@ -0,0 +1,82 @@
+const isPromise = require('./_internal/isPromise')
+const __ = require('./_internal/placeholder')
+const curry2 = require('./_internal/curry2')
+const isArray = require('./_internal/isArray')
+const isGeneratorFunction = require('./_internal/isGeneratorFunction')
+const isAsyncGeneratorFunction = require('./_internal/isAsyncGeneratorFunction')
+const arrayForEach = require('./_internal/arrayForEach')
+const objectForEach = require('./_internal/objectForEach')
+const iteratorForEach = require('./_internal/iteratorForEach')
+const asyncIteratorForEach = require('./_internal/asyncIteratorForEach')
+const symbolIterator = require('./_internal/symbolIterator')
+const symbolAsyncIterator = require('./_internal/symbolAsyncIterator')
+
+// type Collection = Array|Iterable|AsyncIterable|{ forEach: function }|Object
+// _forEach(collection Collection, callback function) -> collection Collection
+const _forEach = function (collection, callback) {
+  if (isArray(collection)) {
+    return arrayForEach(collection, callback)
+  }
+  if (collection == null) {
+    return collection
+  }
+  if (typeof collection.forEach == 'function') {
+    return collection.forEach(callback)
+  }
+  if (typeof collection[symbolIterator] == 'function') {
+    return iteratorForEach(collection[symbolIterator](), callback)
+  }
+  if (typeof collection[symbolAsyncIterator] == 'function') {
+    return asyncIteratorForEach(collection[symbolAsyncIterator](), callback)
+  }
+  if (collection.constructor == Object) {
+    return objectForEach(collection, callback)
+  }
+  return collection
+}
+
+/**
+ * @name forEach
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * type Collection = Array|Iterable|AsyncIterable|{ forEach: function }|Object
+ *
+ * forEach(collection Collection, callback function) -> collection Collection
+ *
+ * forEach(callback function)(collection Collection) -> collection Collection
+ * ```
+ *
+ * @description
+ * Execute a callback for each item 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
+ *
+ * forEach({ a: 1, b: 2, c: 3 }, console.log) // 1 2 3
+ * ```
+ *
+ * Omit the data argument for a composable API
+ *
+ * ```javascript [playground]
+ * pipe([1, 2, 3, 4, 5], [
+ *   filter(number => number % 2 == 1),
+ *   map(number => number ** 2),
+ *   forEach(console.log), // 1
+ *                         // 9
+ *                         // 25
+ * ])
+ * ```
+ */
+const forEach = function (...args) {
+  const callback = args.pop()
+  if (args.length == 0) {
+    return curry2(_forEach, __, callback)
+  }
+  const collection = args[0]
+  return isPromise(collection)
+    ? collection.then(curry2(_forEach, __, callback))
+    : _forEach(collection, callback)
+}
+
+module.exports = forEach

package/get.js

@@ -1,36 +1,48 @@
+const isPromise = require('./_internal/isPromise')
+const __ = require('./_internal/placeholder')
+const curry3 = require('./_internal/curry3')
+const isArray = require('./_internal/isArray')
+const isObject = require('./_internal/isObject')
 const getByPath = require('./_internal/getByPath')
 
+// _get(object Object, path string, defaultValue function|any)
+const _get = function (object, path, defaultValue) {
+  const result = object == null ? undefined : getByPath(object, path)
+  return result === undefined
+    ? typeof defaultValue == 'function' ? defaultValue(object) : defaultValue
+    : result
+}
+
 /**
  * @name get
  *
  * @synopsis
  * ```coffeescript [specscript]
- * var value any,
+ * get(
  *   path string|number|Array<string|number>,
- *   defaultValue (value=>any)|any
- *
- * get(path, defaultValue?) -> getter value=>any
+ *   defaultValue? function|any
+ * )(object Object) -> result Promise|Object
  * ```
  *
  * @description
- * Create a getter that accesses a property on a value denoted by path.
+ * Accesses a property of an object given a path denoted by a string, number, or an array of string or numbers.
  *
  * ```javascript [playground]
- * console.log(
- *   get('hello')({ hello: 'world' }),
- * ) // world
+ * const getHello = get('hello')
+ *
+ * console.log(getHello({ hello: 'world' })) // world
  * ```
  *
- * It is possible to return a default value on not found by supplying the value or resolver of such value as the second parameter.
+ * If the value at the end of the path is not found on the object, returns an optional default value. The default value can be a function resolver that takes the object as an argument. If no default value is provided, returns `undefined`. The function resolver may be asynchronous (returns a promise).
  *
  * ```javascript [playground]
- * console.log(
- *   get('hello', 'default')({ foo: 'bar' }),
- * ) // default
+ * const getHelloWithDefaultValue = get('hello', 'default')
+ *
+ * console.log(getHelloWithDefaultValue({ foo: 'bar' })) // default
  *
- * console.log(
- *   get('hello', object => object.foo)({ foo: 'bar' }),
- * ) // bar
+ * const getHelloWithDefaultResolver = get('hello', object => object.foo)
+ *
+ * console.log(getHelloWithDefaultResolver({ foo: 'bar' })) // bar
  * ```
  *
  * `get` supports three types of path patterns for nested property access.
@@ -40,32 +52,28 @@ const getByPath = require('./_internal/getByPath')
  *  * an array of keys or indices - `['a', 0, 'value']`
  *
  * ```javascript [playground]
- * const nestedABC0 = { a: { b: { c: ['hello'] } } }
- *
- * console.log(
- *   get('a.b.c[0]')(nestedABC0),
- * ) // hello
- *
- * const nested00000 = [[[[['foo']]]]]
+ * const getABC0 = get('a.b.c[0]')
  *
- * console.log(
- *   get('0.0.0.0.0')(nested00000),
- * ) // foo
+ * console.log(getABC0({ a: { b: { c: ['hello'] } } })) // hello
  *
- * console.log(
- *   get('[0][0][0][0][0]')(nested00000),
- * ) // foo
+ * const get00000DotNotation = get('0.0.0.0.0')
+ * const get00000BracketNotation = get('[0][0][0][0][0]')
+ * const get00000ArrayNotation = get([0, 0, 0, 0, 0])
  *
- * console.log(
- *   get([0, 0, 0, 0, 0])(nested00000),
- * ) // foo
+ * console.log(get00000DotNotation([[[[['foo']]]]])) // foo
+ * console.log(get00000BracketNotation([[[[['foo']]]]])) // foo
+ * console.log(get00000ArrayNotation([[[[['foo']]]]])) // foo
  * ```
  */
-const get = (path, defaultValue) => function getter(value) {
-  const result = value == null ? undefined : getByPath(value, path)
-  return result === undefined
-    ? typeof defaultValue == 'function' ? defaultValue(value) : defaultValue
-    : result
+
+const get = function (arg0, arg1, arg2) {
+  if (isPromise(arg0)) {
+    return arg0.then(curry3(_get, __, arg1, arg2))
+  }
+  if (isObject(arg0) && !isArray(arg0)) {
+    return _get(arg0, arg1, arg2)
+  }
+  return curry3(_get, __, arg0, arg1)
 }
 
 module.exports = get

package/global.js

@@ -1,7 +1,8 @@
 globalThis.pipe = require('./pipe')
-globalThis.fork = require('./fork')
-globalThis.assign = require('./assign')
+globalThis.compose = require('./compose')
 globalThis.tap = require('./tap')
+globalThis.all = require('./all')
+globalThis.assign = require('./assign')
 globalThis.tryCatch = require('./tryCatch')
 globalThis.switchCase = require('./switchCase')
 globalThis.map = require('./map')
@@ -9,8 +10,9 @@ globalThis.filter = require('./filter')
 globalThis.reduce = require('./reduce')
 globalThis.transform = require('./transform')
 globalThis.flatMap = require('./flatMap')
-globalThis.any = require('./any')
-globalThis.all = require('./all')
+globalThis.forEach = require('./forEach')
+globalThis.some = require('./some')
+globalThis.every = require('./every')
 globalThis.and = require('./and')
 globalThis.or = require('./or')
 globalThis.not = require('./not')

package/gt.js

@@ -1,26 +1,25 @@
-const spread2 = require('./_internal/spread2')
-const isPromise = require('./_internal/isPromise')
-const promiseAll = require('./_internal/promiseAll')
+const ComparisonOperator = require('./_internal/ComparisonOperator')
 const greaterThan = require('./_internal/greaterThan')
-const curry2 = require('./_internal/curry2')
-const always = require('./_internal/always')
-const __ = require('./_internal/placeholder')
 
 /**
  * @name gt
  *
  * @synopsis
  * ```coffeescript [specscript]
- * gt(leftValue any, rightValue any) -> boolean
- * gt(leftValue any, right function)(value any) -> Promise|boolean
- * gt(left function, rightValue any)(value any) -> Promise|boolean
- * gt(left function, right function)(value any) -> Promise|boolean
+ * 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
  * ```
  *
  * @description
- * Test if a left value is greater than (`>`) a right value. Either parameter may be an actual value.
- *
- * If both arguments are values, `gt` eagerly computes and returns a boolean value.
+ * Test if a value is greater than (`>`) another value.
  *
  * ```javascript [playground]
  * const age = 40
@@ -30,58 +29,16 @@ const __ = require('./_internal/placeholder')
  * console.log(isAgeGreaterThan21) // true
  * ```
  *
- * If both arguments are functions, `gt` treats those functions as argument resolvers and returns a function that first resolves its arguments by the argument resolvers before making the comparison.
- *
- * If only one argument is a function, `gt` still returns a function that resolves its arguments by the argument resolver, treating the value (non function) argument as an already resolved value for comparison.
+ * If either of the two values are resolver functions, `gt` returns a function that resolves the values to compare from its arguments.
  *
  * ```javascript [playground]
- * const isOfLegalAge = gt(21, person => person.age)
+ * const isOfLegalAge = gt(21, get('age'))
  *
  * const juvenile = { age: 16 }
  *
  * console.log(isOfLegalAge(juvenile)) // false
  * ```
  */
-const gt = function (left, right) {
-  const isLeftResolver = typeof left == 'function',
-    isRightResolver = typeof right == 'function'
-
-  if (isLeftResolver && isRightResolver) {
-    return function greaterThanBy(value) {
-      const leftResolve = left(value),
-        rightResolve = right(value)
-      const isLeftPromise = isPromise(leftResolve),
-        isRightPromise = isPromise(rightResolve)
-      if (isLeftPromise && isRightPromise) {
-        return promiseAll(
-          [leftResolve, rightResolve]).then(spread2(greaterThan))
-      } else if (isLeftPromise) {
-        return leftResolve.then(curry2(greaterThan, __, rightResolve))
-      } else if (isRightPromise) {
-        return rightResolve.then(curry2(greaterThan, leftResolve, __))
-      }
-      return leftResolve > rightResolve
-    }
-  }
-
-  if (isLeftResolver) {
-    return function greaterThanBy(value) {
-      const leftResolve = left(value)
-      return isPromise(leftResolve)
-        ? leftResolve.then(curry2(greaterThan, __, right))
-        : leftResolve > right
-    }
-  }
-  if (isRightResolver) {
-    return function strictEqualBy(value) {
-      const rightResolve = right(value)
-      return isPromise(rightResolve)
-        ? rightResolve.then(curry2(greaterThan, left, __))
-        : left > rightResolve
-    }
-  }
-
-  return left > right
-}
+const gt = ComparisonOperator(greaterThan)
 
 module.exports = gt