rubico 2.2.3 → 2.3.1

package/gt.d.ts

@@ -0,0 +1,49 @@
+export = gt;
+/**
+ * @name gt
+ *
+ * @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
+ * ```
+ *
+ * @description
+ * Test if a value is greater than (`>`) another value.
+ *
+ * ```javascript [playground]
+ * const age = 40
+ *
+ * const isAgeGreaterThan21 = gt(age, 21)
+ *
+ * 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.
+ *
+ * ```javascript [playground]
+ * const isOfLegalAge = gt(21, get('age'))
+ *
+ * const juvenile = { age: 16 }
+ *
+ * console.log(isOfLegalAge(juvenile)) // false
+ * ```
+ *
+ * `gt` supports a tacit API for composability.
+ *
+ * ```javascript [playground]
+ * pipe({ value: 1 }, [
+ *   gt(5, get('value')),
+ *   console.log, // true
+ * ])
+ * ```
+ */
+declare const gt: (...args: any[]) => any;

package/gte.d.ts

@@ -0,0 +1,51 @@
+export = gte;
+/**
+ * @name gte
+ *
+ * @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
+ * ```
+ *
+ * @description
+ * Test 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
+ * ```
+ *
+ * If either of the two values are resolver functions, `gte` returns a function that resolves the values to compare from its arguments.
+ *
+ * ```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
+ * ```
+ *
+ * `gte` supports a tacit API for composability.
+ *
+ * ```javascript [playground]
+ * pipe({ value: 1 }, [
+ *   gte(1, get('value')),
+ *   console.log, // true
+ * ])
+ * ```
+ */
+declare const gte: (...args: any[]) => any;

package/index.d.ts

@@ -0,0 +1 @@
+export = rubico;

package/index.js

@@ -1,5 +1,5 @@
 /**
- * rubico v2.2.3
+ * rubico v2.3.1
  * https://github.com/a-synchronous/rubico
  * (c) 2019-2023 Richard Tong
  * rubico may be freely distributed under the MIT license.

package/lt.d.ts

@@ -0,0 +1,49 @@
+export = lt;
+/**
+ * @name lt
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * lt(leftValue Promise|any, rightValue Promise|any) -> boolean
+ *
+ * lt(leftValue Promise|any, right function)(...args) -> Promise|boolean
+ * lt(...args, leftValue Promise|any, right function) -> Promise|boolean
+ *
+ * lt(left function, rightValue Promise|any)(...args) -> Promise|boolean
+ * lt(...args, left function, rightValue Promise|any) -> Promise|boolean
+ *
+ * lt(left function, right function)(...args) -> Promise|boolean
+ * lt(...args, left function, right function) -> Promise|boolean
+ * ```
+ *
+ * @description
+ * Test 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
+ * ```
+ *
+ * If either of the two values are resolver functions, `lt` returns a function that resolves the values to compare from its arguments.
+ *
+ * ```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
+ * ```
+ *
+ * `lt` supports a tacit API for composability.
+ *
+ * ```javascript [playground]
+ * pipe({ value: 1 }, [
+ *   lt(0, get('value')),
+ *   console.log, // true
+ * ])
+ * ```
+ */
+declare const lt: (...args: any[]) => any;

package/lte.d.ts

@@ -0,0 +1,49 @@
+export = lte;
+/**
+ * @name lte
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * lte(leftValue Promise|any, rightValue Promise|any) -> boolean
+ *
+ * lte(leftValue Promise|any, right function)(...args) -> Promise|boolean
+ * lte(...args, leftValue Promise|any, right function) -> Promise|boolean
+ *
+ * lte(left function, rightValue Promise|any)(...args) -> Promise|boolean
+ * lte(...args, left function, rightValue Promise|any) -> Promise|boolean
+ *
+ * lte(left function, right function)(...args) -> Promise|boolean
+ * lte(...args, left function, right function) -> Promise|boolean
+ * ```
+ *
+ * @description
+ * Test 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
+ * ```
+ *
+ * If either of the two values are resolver functions, `lte` returns a function that resolves the values to compare from its arguments.
+ *
+ * ```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)
+ * ```
+ *
+ * `lte` supports a tacit API for composability.
+ *
+ * ```javascript [playground]
+ * pipe({ value: 1 }, [
+ *   lte(1, get('value')),
+ *   console.log, // true
+ * ])
+ * ```
+ */
+declare const lte: (...args: any[]) => any;

package/map.d.ts

@@ -0,0 +1,246 @@
+export = map;
+/**
+ * @name map
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * type Mappable = Array|Object|Set|Map|Iterator|AsyncIterator
+ *
+ * type Mapper = (
+ *   value any,
+ *   indexOrKey number|string,
+ *   collection Mappable
+ * )=>(mappedItem Promise|any)
+ *
+ * map(value Mappable, mapper Mapper) -> result Promise|Mappable
+ * map(mapper Mapper)(value Mappable) -> result Promise|Mappable
+ * ```
+ *
+ * @description
+ * Applies a synchronous or asynchronous mapper function concurrently to each item of a collection, returning the results in a new collection of the same type. If order is implied by the collection, it is maintained in the result. `map` accepts the following collections:
+ *
+ *  * `Array`
+ *  * `Object`
+ *  * `Set`
+ *  * `Map`
+ *  * `Iterator`/`Generator`
+ *  * `AsyncIterator`/`AsyncGenerator`
+ *
+ * With arrays (type `Array`), `map` applies the mapper function to each item of the array, returning the transformed results in a new array ordered the same as the original array.
+ *
+ * ```javascript [playground]
+ * const square = number => number ** 2
+ *
+ * const array = [1, 2, 3, 4, 5]
+ *
+ * console.log(
+ *   map(array, square)
+ * ) // [1, 4, 9, 16, 25]
+ *
+ * console.log(
+ *   map(square)(array)
+ * ) // [1, 4, 9, 16, 25]
+ * ```
+ *
+ * With objects (type `Object`), `map` applies the mapper function to each value of the object, returning the transformed results as values in a new object ordered by the keys of the original object
+ *
+ * ```javascript [playground]
+ * const square = number => number ** 2
+ *
+ * const obj = { a: 1, b: 2, c: 3, d: 4, e: 5 }
+ *
+ * console.log(
+ *   map(square)(obj)
+ * ) // { a: 1, b: 4, c: 9, d: 16, e: 25 }
+ *
+ * console.log(
+ *   map(obj, square)
+ * ) // { a: 1, b: 4, c: 9, d: 16, e: 25 }
+ * ```
+ *
+ * With sets (type `Set`), `map` applies the mapper function to each value of the set, returning the transformed results unordered in a new set.
+ *
+ * ```javascript [playground]
+ * const square = number => number ** 2
+ *
+ * const set = new Set([1, 2, 3, 4, 5])
+ *
+ * console.log(
+ *   map(set, square)
+ * ) // [1, 4, 9, 16, 25]
+ *
+ * console.log(
+ *   map(square)(set)
+ * ) // [1, 4, 9, 16, 25]
+ * ```
+ *
+ * With maps (type `Map`), `map` applies the mapper function to each value of the map, returning the results at the same keys in a new map. The entries of the resulting map are in the same order as those of the original map
+ *
+ * ```javascript [playground]
+ * const square = number => number ** 2
+ *
+ * const m = new Map([['a', 1], ['b', 2], ['c', 3], ['d', 4], ['e', 5]])
+ *
+ * console.log(
+ *   map(square)(m)
+ * ) // Map { 'a' => 1, 'b' => 4, 'c' => 9, 'd' => 16, 'e' => 25 }
+ *
+ * console.log(
+ *   map(m, square)
+ * ) // Map { 'a' => 1, 'b' => 4, 'c' => 9, 'd' => 16, 'e' => 25 }
+ * ```
+ *
+ * With iterators (type `Iterator`) or generators (type `Generator`), `map` applies the mapper function lazily to each value of the iterator/generator, creating a new iterator with transformed iterations.
+ *
+ * ```javascript [playground]
+ * const capitalize = string => string.toUpperCase()
+ *
+ * const abcGeneratorFunc = function* () {
+ *   yield 'a'; yield 'b'; yield 'c'
+ * }
+ *
+ * const abcGenerator = abcGeneratorFunc()
+ * const ABCGenerator = map(abcGeneratorFunc(), capitalize)
+ * const ABCGenerator2 = map(capitalize)(abcGeneratorFunc())
+ *
+ * console.log([...abcGenerator]) // ['a', 'b', 'c']
+ *
+ * console.log([...ABCGenerator]) // ['A', 'B', 'C']
+ *
+ * console.log([...ABCGenerator2]) // ['A', 'B', 'C']
+ * ```
+ *
+ * With asyncIterators (type `AsyncIterator`, or `AsyncGenerator`), `map` applies the mapper function lazily to each value of the asyncIterator, creating a new asyncIterator with transformed iterations
+ *
+ * ```javascript [playground]
+ * const capitalize = string => string.toUpperCase()
+ *
+ * const abcAsyncGeneratorFunc = async function* () {
+ *   yield 'a'; yield 'b'; yield 'c'
+ * }
+ *
+ * const abcAsyncGenerator = abcAsyncGeneratorFunc()
+ * const ABCGenerator = map(abcAsyncGeneratorFunc(), capitalize)
+ * const ABCGenerator2 = map(capitalize)(abcAsyncGeneratorFunc())
+ *
+ * ;(async function () {
+ *   for await (const letter of abcAsyncGenerator) {
+ *     console.log(letter)
+ *     // a
+ *     // b
+ *     // c
+ *   }
+ *
+ *   for await (const letter of ABCGenerator) {
+ *     console.log(letter)
+ *     // A
+ *     // B
+ *     // C
+ *   }
+ *
+ *   for await (const letter of ABCGenerator2) {
+ *     console.log(letter)
+ *     // A
+ *     // B
+ *     // C
+ *   }
+ * })()
+ * ```
+ *
+ * @execution concurrent
+ *
+ * @TODO streamMap
+ */
+declare function map(...args: any[]): any;
+declare namespace map {
+    /**
+     * @name map.entries
+     *
+     * @synopsis
+     * ```coffeescript [specscript]
+     * map.entries(
+     *   mapper ([key any, value any])=>Promise|[any, any],
+     * )(value Map|Object) -> Promise|Map|Object
+     * ```
+     *
+     * @description
+     * `map` over the entries rather than the values of a collection. Accepts collections of type `Map` or `Object`.
+     *
+     * ```javascript [playground]
+     * const upperCaseKeysAndSquareValues =
+     *   map.entries(([key, value]) => [key.toUpperCase(), value ** 2])
+     *
+     * console.log(upperCaseKeysAndSquareValues({ a: 1, b: 2, c: 3 }))
+     * // { A: 1, B: 4, C: 9 }
+     *
+     * console.log(upperCaseKeysAndSquareValues(new Map([['a', 1], ['b', 2], ['c', 3]])))
+     * // Map(3) { 'A' => 1, 'B' => 4, 'C' => 9 }
+     * ```
+     *
+     * @since v1.7.0
+     */
+    function entries(mapper: any): (value: any) => any;
+    /**
+     * @name map.series
+     *
+     * @synopsis
+     * ```coffeescript [specscript]
+     * map.series(
+     *   mapperFunc (value any)=>Promise|any,
+     * )(array Array) -> Promise|Array
+     * ```
+     *
+     * @description
+     * `map` with serial execution.
+     *
+     * ```javascript [playground]
+     * const delayedLog = number => new Promise(function (resolve) {
+     *   setTimeout(function () {
+     *     console.log(number)
+     *     resolve()
+     *   }, 1000)
+     * })
+     *
+     * console.log('start')
+     * map.series(delayedLog)([1, 2, 3, 4, 5])
+     * ```
+     *
+     * @execution series
+     */
+    function series(mapper: any): (value: any) => any;
+    /**
+     * @name map.pool
+     *
+     * @synopsis
+     * ```coffeescript [specscript]
+     * map.pool(
+     *   maxConcurrency number,
+     *   mapper (value any)=>Promise|any,
+     * )(array Array) -> result Promise|Array
+     * ```
+     *
+     * @description
+     * `map` that specifies the maximum concurrency (number of ongoing promises at any time) of the execution. Only works for arrays.
+     *
+     * ```javascript [playground]
+     * const ids = [1, 2, 3, 4, 5]
+     *
+     * const sleep = ms => new Promise(resolve => setTimeout(resolve, ms))
+     *
+     * const delayedIdentity = async value => {
+     *   await sleep(1000)
+     *   return value
+     * }
+     *
+     * map.pool(2, pipe([
+     *   delayedIdentity,
+     *   console.log,
+     * ]))(ids)
+     * ```
+     *
+     * @TODO objectMapPool
+     *
+     * @execution concurrent
+     */
+    function pool(concurrencyLimit: any, mapper: any): (value: any) => any[] | Promise<any>;
+}

package/monad/Instance.d.ts

@@ -0,0 +1,246 @@
+export = Instance;
+/**
+ * @name Instance
+ *
+ * @synopsis
+ * new Instance(value any) -> Instance
+ *
+ * @catchphrase
+ * Type checking
+ */
+declare class Instance {
+    /**
+     * @name Instance.isInstance
+     *
+     * @synopsis
+     * Instance.isInstance(x any) -> boolean
+     *
+     * @catchphrase
+     * `false` <- only for `undefined` and `null`
+     *
+     * @TODO Change to isDefined
+     */
+    static isInstance(x: any): boolean;
+    /**
+     * @name Instance.is
+     *
+     * @synopsis
+     * Instance.is(x any, constructor function) -> boolean
+     */
+    static is(x: any, constructor: any): boolean;
+    /**
+     * @name Instance.isString
+     *
+     * @synopsis
+     * Instance.isString(x any) -> boolean
+     */
+    static isString(x: any): boolean;
+    /**
+     * @name Instance.isNumber
+     *
+     * @synopsis
+     * Instance.isNumber(x any) -> boolean
+     */
+    static isNumber(x: any): boolean;
+    /**
+     * @name Instance.isObject
+     *
+     * @synopsis
+     * Instance.isObject(x any) -> boolean
+     */
+    static isObject(x: any): boolean;
+    /**
+     * @name Instance.isSet
+     *
+     * @synopsis
+     * Instance.isSet(x any) -> boolean
+     */
+    static isSet(x: any): boolean;
+    /**
+     * @name Instance.isMap
+     *
+     * @synopsis
+     * Instance.isMap(x any) -> boolean
+     */
+    static isMap(x: any): boolean;
+    /**
+     * @name Instance.isIterable
+     *
+     * @synopsis
+     * Instance.isIterable(value any) -> boolean
+     */
+    static isIterable(value: any): boolean;
+    /**
+     * @name Instance.isAsyncIterable
+     *
+     * @synopsis
+     * Instance.isAsyncIterable(value any) -> boolean
+     */
+    static isAsyncIterable(value: any): boolean;
+    /**
+     * @name Instance.isFunction
+     *
+     * @synopsis
+     * Instance.isFunction(x any) -> boolean
+     */
+    static isFunction(x: any): boolean;
+    /**
+     * @name Instance.isReadable
+     *
+     * @synopsis
+     * Instance.isReadable(x any) -> boolean
+     */
+    static isReadable(x: any): boolean;
+    /**
+     * @name Instance.isWritable
+     *
+     * @synopsis
+     * Instance.isWritable(x any) -> boolean
+     */
+    static isWritable(x: any): boolean;
+    /**
+     * @name Instance.isPromise
+     *
+     * @synopsis
+     * Instance.isPromise(x any) -> boolean
+     */
+    static isPromise(x: any): boolean;
+    constructor(value: any);
+    value: any;
+    /**
+     * @name Instance.prototype.map
+     *
+     * @synopsis
+     * <A any, B any>new Instance(value A).map(func A=>B) -> Instance<B>
+    Instance.prototype.map = function(func) {
+      return new Instance(func(this.value))
+    } */
+    /**
+     * @name Instance.prototype.join
+     *
+     * @synopsis
+     * <T any>new Instance(Instance<T>).join() -> Instance<T>
+     *
+     * <T any>new Instance(value T).join() -> value T
+    Instance.prototype.join = function() {
+      return this.value
+    } */
+    /**
+     * @name Instance.prototype.*chain
+     *
+     * @synopsis
+     * <A any, B any>new Instance(x A).chain(f A=>Instance<B>) -> Instance<B>
+     *
+     * @catchphrase
+     * For associativity
+     *
+     * @example
+     * const inst = new Instance(3)
+     * console.log(
+     *   inst.chain(number => new Instance(number ** 2))
+     * ) // Instance { 9 }
+     */
+    chain(f: any): any;
+    /**
+     * @name Instance.prototype.isArray
+     *
+     * @synopsis
+     * new Instance(x any).isArray() -> boolean
+     */
+    isArray(): boolean;
+    /**
+     * @name Instance.prototype.isTypedArray
+     *
+     * @synopsis
+     * new Instance(x any).isTypedArray() -> boolean
+     */
+    isTypedArray(): boolean;
+    /**
+     * @name Instance.prototype.is
+     *
+     * @synopsis
+     * new Instance(x any).is(constructor function) -> boolean
+     */
+    is(constructor: any): boolean;
+    /**
+     * @name Instance.prototype.isString
+     *
+     * @synopsis
+     * new Instance(x any).isString() -> boolean
+     */
+    isString(): boolean;
+    /**
+     * @name Instance.prototype.isNumber
+     *
+     * @synopsis
+     * new Instance(x any).isNumber() -> boolean
+     */
+    isNumber(): boolean;
+    /**
+     * @name Instance.prototype.isObject
+     *
+     * @synopsis
+     * new Instance(x any).isObject() -> boolean
+     */
+    isObject(): boolean;
+    /**
+     * @name Instance.prototype.isSet
+     *
+     * @synopsis
+     * new Instance(x any).isSet() -> boolean
+     */
+    isSet(): boolean;
+    /**
+     * @name Instance.prototype.isMap
+     *
+     * @synopsis
+     * new Instance(x any).isMap() -> boolean
+     */
+    isMap(): boolean;
+    /**
+     * @name Instance.prototype.isIterable
+     *
+     * @synopsis
+     * new Instance(value any).isIterable() -> boolean
+     */
+    isIterable(): boolean;
+    /**
+     * @name Instance.prototype.isAsyncIterable
+     *
+     * @synopsis
+     * new Instance(value any).isAsyncIterable() -> boolean
+     */
+    isAsyncIterable(): boolean;
+    /**
+     * @name Instance.prototype.isFunction
+     *
+     * @synopsis
+     * new Instance(x any).isFunction() -> boolean
+     */
+    isFunction(): boolean;
+    /**
+     * @name Instance.prototype.isReadable
+     *
+     * @synopsis
+     * new Instance(x any).isReadable() -> boolean
+     */
+    isReadable(): boolean;
+    /**
+     * @name Instance.prototype.isWritable
+     *
+     * @synopsis
+     * new Instance(x any).isWritable() -> boolean
+     */
+    isWritable(): boolean;
+    /**
+     * @name Instance.prototype.isPromise
+     *
+     * @synopsis
+     * new Instance(x any).isPromise() -> boolean
+     */
+    isPromise(): boolean;
+}
+declare namespace Instance {
+    let isArray: (arg: any) => arg is any[];
+    let isTypedArray: (arg: any) => arg is ArrayBufferView;
+}