ramda-adjunct 5.0.0 → 5.0.1

package/src/concatRight.js

@@ -1,30 +0,0 @@
-import { concat, flip } from 'ramda';
-
-/**
- * Returns the result of concatenating the given lists or strings.
- *
- * Note: R.concat expects both arguments to be of the same type, unlike
- * the native Array.prototype.concat method.
- * It will throw an error if you concat an Array with a non-Array value.
- * Dispatches to the concat method of the second argument, if present.
- *
- * @func concatRight
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/1.11.0|v1.11.0}
- * @category List
- * @sig [a] -> [a] -> [a]
- * @sig String -> String -> String
- * @param {Array|String} firstList The first list
- * @param {Array|String} secondList The second list
- * @return {Array|String} A list consisting of the elements of `secondList`
- * followed by the elements of `firstList`.
- * @see {@link http://ramdajs.com/docs/#concat|R.concat}
- * @example
- *
- * RA.concatRight('ABC', 'DEF'); //=> 'DEFABC'
- * RA.concatRight([4, 5, 6], [1, 2, 3]); //=> [1, 2, 3, 4, 5, 6]
- * RA.concatRight([], []); //=> []
- */
-const concatRight = flip(concat);
-
-export default concatRight;

package/src/copyKeys.js

@@ -1,31 +0,0 @@
-import { curryN } from 'ramda';
-
-import renameKeys from './renameKeys.js';
-
-/**
- * Creates a new object with the own properties of the provided object, and the
- * keys copied according to the keysMap object as `{oldKey: newKey}`.
- * When no key from the keysMap is found, then a shallow clone of an object is returned.
- *
- * Keep in mind that in the case of keys conflict is behaviour undefined and
- * the result may vary between various JS engines!
- *
- * @func copyKeys
- * @memberOf RA
- * @category Object
- * @sig {a: b} -> {a: *} -> {b: *}
- * @param {!Object} keysMap
- * @param {!Object} obj
- * @return {!Object} New object with copied keys
- * @see {@link RA.renameKeys|renameKeys}
- * @example
- *
- * copyKeys({ a: 'b' }, { a: true }); //=> { a: true, b: true }
- * copyKeys({ a: 'b' }, { a: true, b: false }); //=> { a: true, b: true }
- */
-const copyKeys = curryN(2, (keysMap, obj) => ({
-  ...obj,
-  ...renameKeys(keysMap, obj),
-}));
-
-export default copyKeys;

package/src/curryRight.js

@@ -1,26 +0,0 @@
-import { converge, length, identity } from 'ramda';
-
-import curryRightN from './curryRightN.js';
-
-/**
- * Returns a curried equivalent of the provided function.
- * This function is like curry, except that the provided arguments order is reversed.
- *
- * @func curryRight
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/1.12.0|v1.12.0}
- * @category Function
- * @sig (* -> a) -> (* -> a)
- * @param {Function} fn The function to curry
- * @return {Function}  A new, curried function
- * @see {@link http://ramdajs.com/docs/#curry|R.curry}, {@link RA.curryRightN|curryRightN}
- * @example
- *
- * const concatStrings = (a, b, c) => a + b + c;
- * const concatStringsCurried = RA.curryRight(concatStrings);
- *
- * concatStringCurried('a')('b')('c'); // => 'cba'
- */
-const curryRight = converge(curryRightN, [length, identity]);
-
-export default curryRight;

package/src/curryRightN.js

@@ -1,29 +0,0 @@
-import { curryN, reverse } from 'ramda';
-
-/**
- * Returns a curried equivalent of the provided function, with the specified arity.
- * This function is like curryN, except that the provided arguments order is reversed.
- *
- * @func curryRightN
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/1.12.0|v1.12.0}
- * @category Function
- * @sig Number -> (* -> a) -> (* -> a)
- * @param {number} length The arity for the returned function
- * @param {Function} fn The function to curry
- * @return {Function}  A new, curried function
- * @see {@link http://ramdajs.com/docs/#curryN|R.curryN}, {@link RA.curryRight|curryRight}
- * @example
- *
- * const concatStrings = (a, b, c) => a + b + c;
- * const concatStringsCurried = RA.curryRightN(3, concatStrings);
- *
- * concatStringCurried('a')('b')('c'); // => 'cba'
- */
-const curryRightN = curryN(2, (arity, fn) =>
-  curryN(arity, function wrapper(...args) {
-    return fn.apply(this, reverse(args));
-  })
-);
-
-export default curryRightN;

package/src/defaultWhen.js

@@ -1,26 +0,0 @@
-import { curry } from 'ramda';
-
-/**
- * Returns the second argument if predicate function returns `true`,
- * otherwise the third argument is returned.
- *
- * @func defaultWhen
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/2.2.0|v2.2.0}
- * @category Logic
- * @sig  (a -> Boolean) -> b -> a -> a | b
- * @param {!function} predicate The predicate function
- * @param {*} defaultVal The default value
- * @param {*} val `val` will be returned instead of `defaultVal` if predicate returns false
- * @return {*} The `val` if predicate returns `false`, otherwise the default value
- * @see {@link http://ramdajs.com/docs/#defaultTo|R.defaultTo}
- * @example
- *
- * RA.defaultWhen(RA.isNull, 1, null); // => 1
- * RA.defaultWhen(RA.isNull, 1, 2); // => 2
- */
-const defaultWhen = curry((predicate, defaultVal, val) =>
-  predicate(val) ? defaultVal : val
-);
-
-export default defaultWhen;

package/src/delayP.js

@@ -1,45 +0,0 @@
-import { curry, propOr, partial, nth } from 'ramda';
-
-import isNonNegative from './isNonNegative.js';
-import isInteger from './isInteger.js';
-
-/**
- * Creates a promise which resolves/rejects after the specified milliseconds.
- *
- * @func delayP
- * @memberOf RA
- * @category Function
- * @sig Number -> Promise Undefined
- * @sig {timeout: Number, value: a} -> Promise a
- * @param {number|Object} milliseconds number of milliseconds or options object
- * @return {Promise} A Promise that is resolved/rejected with the given value (if provided) after the specified delay
- * @example
- *
- * RA.delayP(200); //=> Promise(undefined)
- * RA.delayP({ timeout: 1000, value: 'hello world' }); //=> Promise('hello world')
- * RA.delayP.reject(100); //=> Promise(undefined)
- * RA.delayP.reject({ timeout: 100, value: new Error('error') }); //=> Promise(Error('error'))
- */
-
-const makeDelay = curry((settleFnPicker, opts) => {
-  let timeout;
-  let value;
-
-  if (isInteger(opts) && isNonNegative(opts)) {
-    timeout = opts;
-  } else {
-    timeout = propOr(0, 'timeout', opts);
-    value = propOr(value, 'value', opts);
-  }
-
-  return new Promise((...args) => {
-    const settleFn = settleFnPicker(args);
-
-    setTimeout(partial(settleFn, [value]), timeout);
-  });
-});
-
-const delayP = makeDelay(nth(0));
-delayP.reject = makeDelay(nth(1));
-
-export default delayP;

package/src/dispatch.js

@@ -1,74 +0,0 @@
-import {
-  sort,
-  comparator,
-  prop,
-  pipe,
-  head,
-  curryN,
-  reduce,
-  reduced,
-  curry,
-  ifElse,
-} from 'ramda';
-
-/**
- * Can be used as a way to compose multiple invokers together to form polymorphic functions,
- * or functions that exhibit different behaviors based on their argument(s).
- * Consumes dispatching functions and keep trying to invoke each in turn, until a non-nil value is returned.
- *
- * Accepts a list of dispatching functions and returns a new function.
- * When invoked, this new function is applied to some arguments,
- * each dispatching function is applied to those same arguments until one of the
- * dispatching functions returns a non-nil value.
- *
- * @func dispatch
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/2.6.0|v2.6.0}
- * @category Function
- * @sig [((a, b, ...) -> x1), ((a, b, ...) -> x2), ...] -> x1 | x2 | ...
- * @param {!Array} functions A list of functions
- * @return {*|undefined} Returns the first not-nil value, or undefined if either an empty list is provided or none of the dispatching functions returns a non-nil value
- * @see {@link RA.isNotNil}
- * @example
- *
- * // returns first non-nil value
- * const stubNil = () => null;
- * const stubUndefined = () => undefined;
- * const addOne = v => v + 1;
- * const addTwo = v => v + 2;
- *
- * RA.dispatch([stubNil, stubUndefined, addOne, addTwo])(1); //=> 2
- *
- * // acts as a switch
- * const fnSwitch = RA.dispatch([
- *   R.ifElse(RA.isString, s => `${s}-join`, RA.stubUndefined),
- *   R.ifElse(RA.isNumber, n => n + 1, RA.stubUndefined),
- *   R.ifElse(RA.isDate, R.T, RA.stubUndefined),
- * ]);
- * fnSwitch(1); //=> 2
- */
-import isNotNil from './isNotNil.js';
-import isNonEmptyArray from './isNonEmptyArray.js';
-import stubUndefined from './stubUndefined.js';
-
-const byArity = comparator((a, b) => a.length > b.length);
-
-const getMaxArity = pipe(sort(byArity), head, prop('length'));
-
-const iteratorFn = curry((args, accumulator, fn) => {
-  const result = fn(...args);
-
-  return isNotNil(result) ? reduced(result) : accumulator;
-});
-
-const dispatchImpl = (functions) => {
-  const arity = getMaxArity(functions);
-
-  return curryN(arity, (...args) =>
-    reduce(iteratorFn(args), undefined, functions)
-  );
-};
-
-const dispatch = ifElse(isNonEmptyArray, dispatchImpl, stubUndefined);
-
-export default dispatch;

package/src/divideNum.js

@@ -1,20 +0,0 @@
-import { divide, flip } from 'ramda';
-
-/**
- * Divides two numbers, where the second number is divided by the first number.
- *
- * @func divideNum
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/2.22.0|v2.22.0}
- * @category Math
- * @sig Number -> Number -> Number
- * @param {number} divisor the number to divide by
- * @param {number} dividend the number to divide
- * @return {number} A number representing the quotient of dividing the dividend by the divisor
- * @example
- *
- * RA.divideNum(2, 1); //=> 0.5
- */
-const divideNum = flip(divide);
-
-export default divideNum;

package/src/dropArgs.js

@@ -1,23 +0,0 @@
-import { nAry } from 'ramda';
-
-/**
- * Accepts a function with any arity and returns a function with arity of zero.
- * The returned function ignores any arguments supplied to it.
- *
- * @func dropArgs
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/2.10.0|v2.10.0}
- * @category Logic
- * @sig (...a -> b)-> () -> b
- * @param {Function} fn The function with any arity
- * @return {Function} Returns function with arity of zero
- * @see {@link http://ramdajs.com/docs/#nAry|R.nAry}
- * @example
- *
- * const fn = (a = 1, b = 2) => a + b;
- *
- * RA.dropArgs(fn)('ignore1', 'ignore2'); //=> 3
- */
-const dropArgs = nAry(0);
-
-export default dropArgs;

package/src/ensureArray.js

@@ -1,24 +0,0 @@
-import { when, of } from 'ramda';
-
-import isNotArray from './isNotArray.js';
-
-/**
- * Returns a singleton array containing the value provided.
- * If value is already an array, it is returned as is.
- *
- * @func ensureArray
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/2.6.0|v2.6.0}
- * @category List
- * @sig a | [a] -> [a]
- * @param {*|Array} val the value ensure as Array
- * @return {Array}
- * @see {@link http://ramdajs.com/docs/#of|R.of}
- * @example
- *
- * RA.ensureArray(42); //=> [42]
- * RA.ensureArray([42]); //=> [42]
- */
-const ensureArray = when(isNotArray, of(Array));
-
-export default ensureArray;

package/src/escapeRegExp.js

@@ -1,22 +0,0 @@
-import { when, replace } from 'ramda';
-
-import isString from './isString.js';
-
-/**
- * Escapes the RegExp special characters.
- *
- * @func escapeRegExp
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/2.21.0|v2.21.0}
- * @category String
- * @sig String -> String
- * @param {string} val the value to escape
- * @return {string}
- * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions#Escaping|MDN Regular Expressions Escaping}
- * @example
- *
- * RA.escapeRegExp('[ramda-adjunct](https://github.com/char0n/ramda-adjunct)'); //=> '\[ramda\-adjunct\]\(https://github\.com/char0n/ramda\-adjunct\)'
- */
-const escapeRegExp = when(isString, replace(/[.*+?^${}()|[\]\\-]/g, '\\$&'));
-
-export default escapeRegExp;

package/src/fantasy-land/Identity.js

@@ -1,270 +0,0 @@
-import { empty as emptyR } from 'ramda';
-
-import * as fl from './mapping.js';
-import {
-  applyTrait,
-  functorTrait,
-  setoidTrait,
-  semigroupTrait,
-  chainTrait,
-  ordTrait,
-} from './traits.js';
-
-/**
- * The simplest {@link https://github.com/fantasyland/fantasy-land|fantasy-land}
- * compatible monad which attaches no information to values.
- *
- * The Identity type is a very simple type that has no interesting side effects and
- * is effectively just a container of some value. So why does it exist ?
- * The Identity type is often used as the base monad of a monad
- * transformer when no other behaviour is required.
- *
- * @memberOf RA
- * @implements
- * {@link https://github.com/fantasyland/fantasy-land#apply|Apply},
- * {@link https://github.com/fantasyland/fantasy-land#applicative|Applicative},
- * {@link https://github.com/fantasyland/fantasy-land#functor|Functor},
- * {@link https://github.com/fantasyland/fantasy-land#setoid|Setoid},
- * {@link https://github.com/fantasyland/fantasy-land#semigroup|Semigroup},
- * {@link https://github.com/fantasyland/fantasy-land#chain|Chain},
- * {@link https://github.com/fantasyland/fantasy-land#monad|Monad},
- * {@link https://github.com/fantasyland/fantasy-land#ord|Ord},
- * {@link https://github.com/fantasyland/fantasy-land#monoid|Monoid*},
- * {@link https://github.com/fantasyland/fantasy-land#contravariant|Contravariant}
- * @since {@link https://char0n.github.io/ramda-adjunct/1.8.0|v1.8.0}
- */
-class Identity {
-  /**
-   * Fantasy land {@link https://github.com/fantasyland/fantasy-land#applicative|Applicative} specification.
-   *
-   * @static
-   * @sig of :: Applicative f => a -> f a
-   * @param {*} value
-   * @returns {RA.Identity}
-   * @example
-   *
-   * const a = Identity.of(1); //=> Identity(1)
-   */
-  static [fl.of](value) {
-    return new Identity(value);
-  }
-
-  static of(value) {
-    return new Identity(value);
-  }
-
-  /**
-   * @static
-   */
-  static get ['@@type']() {
-    return 'RA/Identity';
-  }
-
-  /**
-   * Private constructor. Use {@link RA.Identity.of|Identity.of} instead.
-   *
-   * @param {*} value
-   * @return {RA.Identity}
-   */
-  constructor(value) {
-    this.value = value;
-  }
-
-  /**
-   * Catamorphism for a value.
-   * @returns {*}
-   * @example
-   *
-   * const a = Identity.of(1);
-   * a.get(); //=> 1
-   */
-  get() {
-    return this.value;
-  }
-
-  /**
-   * Fantasy land {@link https://github.com/fantasyland/fantasy-land#apply|Apply} specification.
-   *
-   * @sig ap :: Apply f => f a ~> f (a -> b) -> f b
-   * @param {RA.Identity} applyWithFn
-   * @return {RA.Identity}
-   * @example
-   *
-   * const a = Identity.of(1);
-   * const b = Identity.of(1).map(a => b => a + b);
-   *
-   * a.ap(b); //=> Identity(2)
-   */
-  [fl.ap](applyWithFn) {
-    return applyTrait[fl.ap].call(this, applyWithFn);
-  }
-
-  ap(applyWithFn) {
-    return this[fl.ap](applyWithFn);
-  }
-
-  /**
-   * Fantasy land {@link https://github.com/fantasyland/fantasy-land#functor|Functor} specification.
-   *
-   * @sig map :: Functor f => f a ~> (a -> b) -> f b
-   * @param {Function} fn
-   * @return {RA.Identity}
-   * @example
-   *
-   * const a = Identity.of(1);
-   * a.map(a => a + 1); //=> Identity(2)
-   */
-  [fl.map](fn) {
-    return functorTrait[fl.map].call(this, fn);
-  }
-
-  map(fn) {
-    return this[fl.map](fn);
-  }
-
-  /**
-   * Fantasy land {@link https://github.com/fantasyland/fantasy-land#setoid|Setoid} specification.
-   *
-   * @sig equals :: Setoid a => a ~> a -> Boolean
-   * @param {RA.Identity} setoid
-   * @return {boolean}
-   * @example
-   *
-   * const a = Identity.of(1);
-   * const b = Identity.of(1);
-   * const c = Identity.of(2);
-   *
-   * a.equals(b); //=> true
-   * a.equals(c); //=> false
-   */
-  [fl.equals](setoid) {
-    return setoidTrait[fl.equals].call(this, setoid);
-  }
-
-  equals(setoid) {
-    return this[fl.equals](setoid);
-  }
-
-  /**
-   * Fantasy land {@link https://github.com/fantasyland/fantasy-land#semigroup|Semigroup} specification.
-   *
-   * @sig concat :: Semigroup a => a ~> a -> a
-   * @param {RA.Identity} semigroup
-   * @return {RA.Identity}
-   * @example
-   *
-   * const a = Identity.of(1);
-   * const b = Identity.of(1);
-   * a.concat(b); //=> 2
-   *
-   * const c = Identity.of('c');
-   * const d = Identity.of('d');
-   * c.concat(d); //=> 'cd'
-   *
-   * const e = Identity.of(['e']);
-   * const f = Identity.of(['f']);
-   * e.concat(f); //=> ['e', 'f']
-   */
-  [fl.concat](semigroup) {
-    return semigroupTrait[fl.concat].call(this, semigroup);
-  }
-
-  concat(semigroup) {
-    return this[fl.concat](semigroup);
-  }
-
-  /**
-   * Fantasy land {@link https://github.com/fantasyland/fantasy-land#chain|Chain} specification.
-   *
-   * @sig chain :: Chain m => m a ~> (a -> m b) -> m b
-   * @param {Function} fn Function returning the value of the same {@link https://github.com/fantasyland/fantasy-land#semigroup|Chain}
-   * @return {RA.Identity}
-   * @example
-   *
-   * const a = Identity.of(1);
-   * const fn = val => Identity.of(val + 1);
-   *
-   * a.chain(fn).chain(fn); //=> Identity(3)
-   */
-  [fl.chain](fn) {
-    return chainTrait[fl.chain].call(this, fn);
-  }
-
-  chain(fn) {
-    return this[fl.chain](fn);
-  }
-
-  /**
-   * Fantasy land {@link https://github.com/fantasyland/fantasy-land#ord|Ord} specification.
-   *
-   * @sig lte :: Ord a => a ~> a -> Boolean
-   * @param {RA.Identity} ord
-   * @return {boolean}
-   * @example
-   *
-   * const a = Identity.of(1);
-   * const b = Identity.of(1);
-   * const c = Identity.of(2);
-   *
-   * a.lte(b); //=> true
-   * a.lte(c); //=> true
-   * c.lte(a); //=> false
-   */
-  [fl.lte](ord) {
-    return ordTrait[fl.lte].call(this, ord);
-  }
-
-  lte(ord) {
-    return this[fl.lte](ord);
-  }
-
-  /**
-   * Fantasy land {@link https://github.com/fantasyland/fantasy-land#monoid|Monoid*} specification.
-   * Partial implementation of Monoid specification. `empty` method on instance only, returning
-   * identity value of the wrapped type. Using `R.empty` under the hood.
-   *
-   *
-   * @sig empty :: Monoid m => () -> m
-   * @return {RA.Identity}
-   * @example
-   *
-   * const a = Identity.of('test');
-   * const i = a.empty();
-   *
-   * a.concat(i); //=> Identity('string');
-   * i.concat(a); //=> Identity('string');
-   */
-  [fl.empty]() {
-    return this.constructor.of(emptyR(this.value));
-  }
-
-  empty() {
-    return this[fl.empty]();
-  }
-
-  /**
-   * Fantasy land {@link https://github.com/fantasyland/fantasy-land#contravariant|Contravariant} specification.
-   *
-   * @sig contramap :: Contravariant f => f a ~> (b -> a) -> f b
-   * @param {Function} fn
-   * @return {RA.Identity}
-   * @example
-   *
-   * const identity = a => a;
-   * const add1 = a => a + 1;
-   * const divide2 = a => a / 2;
-   *
-   * Identity.of(divide2).contramap(add1).get()(3); //=> 2
-   * Identity.of(identity).contramap(divide2).contramap(add1).get()(3); //=> 2
-   * Identity.of(identity).contramap(a => divide2(add1(a))).get()(3); //=> 2
-   */
-  [fl.contramap](fn) {
-    return this.constructor.of((value) => this.value(fn(value)));
-  }
-
-  contramap(fn) {
-    return this[fl.contramap](fn);
-  }
-}
-
-export default Identity;

package/src/fantasy-land/mapping.js

@@ -1,20 +0,0 @@
-export const equals = 'fantasy-land/equals';
-export const lte = 'fantasy-land/lte';
-export const compose = 'fantasy-land/compose';
-export const id = 'fantasy-land/id';
-export const concat = 'fantasy-land/concat';
-export const empty = 'fantasy-land/empty';
-export const map = 'fantasy-land/map';
-export const contramap = 'fantasy-land/contramap';
-export const ap = 'fantasy-land/ap';
-export const of = 'fantasy-land/of';
-export const alt = 'fantasy-land/alt';
-export const zero = 'fantasy-land/zero';
-export const reduce = 'fantasy-land/reduce';
-export const traverse = 'fantasy-land/traverse';
-export const chain = 'fantasy-land/chain';
-export const chainRec = 'fantasy-land/chainRec';
-export const extend = 'fantasy-land/extend';
-export const extract = 'fantasy-land/extract';
-export const bimap = 'fantasy-land/bimap';
-export const promap = 'fantasy-land/promap';