ramda-adjunct 2.34.0

package/es/argsPass.js

@@ -0,0 +1,38 @@
+import { useWith, curry, compose } from 'ramda';
+import list from './list';
+import isTruthy from './isTruthy';
+/**
+ * Takes a combining predicate and a list of functions and returns a function which will map the
+ * arguments it receives to the list of functions and returns the result of passing the values
+ * returned from each function to the combining predicate. A combining predicate is a function that
+ * combines a list of Boolean values into a single Boolean value, such as `R.any` or `R.all`. It
+ * will test each value using `RA.isTruthy`, meaning the functions don't necessarily have to be
+ * predicates.
+ *
+ * The function returned is curried to the number of functions supplied, and if called with more
+ * arguments than functions, any remaining arguments are passed in to the combining predicate
+ * untouched.
+ *
+ * @func argsPass
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.7.0|v2.7.0}
+ * @category Logic
+ * @sig ((* -> Boolean) -> [*] -> Boolean) -> [(* -> Boolean), ...] -> (*...) -> Boolean
+ * @param {Function} combiningPredicate The predicate used to combine the values returned from the
+ * list of functions
+ * @param {Array} functions List of functions
+ * @return {boolean} Returns the combined result of mapping arguments to functions
+ * @example
+ *
+ * RA.argsPass(R.all, [RA.isArray, RA.isBoolean, RA.isString])([], false, 'abc') //=> true
+ * RA.argsPass(R.all, [RA.isArray, RA.isBoolean, RA.isString])([], false, 1) //=> false
+ * RA.argsPass(R.any, [RA.isArray, RA.isBoolean, RA.isString])({}, 1, 'abc') //=> true
+ * RA.argsPass(R.any, [RA.isArray, RA.isBoolean, RA.isString])({}, 1, false) //=> false
+ * RA.argsPass(R.none, [RA.isArray, RA.isBoolean, RA.isString])({}, 1, false) //=> true
+ * RA.argsPass(R.none, [RA.isArray, RA.isBoolean, RA.isString])({}, 1, 'abc') //=> false
+ */
+
+var argsPass = curry(function (combiningPredicate, predicates) {
+  return useWith(compose(combiningPredicate(isTruthy), list), predicates);
+});
+export default argsPass;

package/es/async.js

@@ -0,0 +1,57 @@
+import { curryN, bind } from 'ramda';
+import resolveP from './resolveP';
+import rejectP from './rejectP';
+/**
+ * Takes a generator function and returns an async function.
+ * The async function returned is a curried function whose arity matches that of the generator function.
+ *
+ * Note: This function is handy for environments that does support generators but doesn't support async/await.
+ *
+ * @func async
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.16.0|v2.16.0}
+ * @category Function
+ * @sig Promise c => (a, b, ...) -> a -> b -> ... -> c
+ * @param {Function} generatorFn The generator function
+ * @return {Function} Curried async function
+ * @see {@link https://www.promisejs.org/generators/}
+ * @example
+ *
+ * const asyncFn = RA.async(function* generator(val1, val2) {
+ *   const a = yield Promise.resolve(val1);
+ *   const b = yield Promise.resolve(val2);
+ *
+ *   return a + b;
+ * });
+ *
+ * asyncFn(1, 2); //=> Promise(3)
+ *
+ */
+
+var async = curryN(1, function (generatorFn) {
+  function asyncWrapper() {
+    var iterator = bind(generatorFn, this).apply(void 0, arguments);
+
+    var handle = function handle(result) {
+      var resolved = resolveP(result.value);
+      return result.done ? resolved : resolved.then(function (value) {
+        return handle(iterator.next(value));
+      }, function (error) {
+        return handle(iterator["throw"](error));
+      });
+    };
+
+    try {
+      return handle(iterator.next());
+    } catch (error) {
+      return rejectP(error);
+    }
+  }
+
+  if (generatorFn.length > 0) {
+    return curryN(generatorFn.length, asyncWrapper);
+  }
+
+  return asyncWrapper;
+});
+export default async;

package/es/cata.js

@@ -0,0 +1,101 @@
+import { curry } from 'ramda';
+import isFunction from './isFunction';
+/**
+ * The catamorphism is a way of folding a type into a value.
+ *
+ * **Either**
+ *
+ * If the either is right then the right function will be executed with
+ * the `right` value and the value of the function returned. Otherwise the left function
+ * will be called with the `left` value.
+ *
+ * **Maybe**
+ *
+ * If the maybe is Some than the right function will be executed with the `some` value and the value of the function
+ * returned. Otherwise the left function with be called without an argument.
+ *
+ * **Result**
+ *
+ * If the result is Ok than the right function will be executed with the `Ok` value and the value of the function
+ * returned. Otherwise the left function will be called with the `Error` value.
+ *
+ * **Validation**
+ *
+ * If the validation is Success than the right function will be executed with the `Success` value and the value of the function
+ * returned. Otherwise the left function will be called with the `Failure` value.
+ *
+ * Supported monadic libraries: {@link https://monet.github.io/monet.js/|monet.js}, {@link https://folktale.origamitower.com/|folktale}, {@link https://github.com/ramda/ramda-fantasy|ramda-fantasy}
+ *
+ * @func cata
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/1.4.0|v1.4.0}
+ * @category Function
+ * @sig (a -> b) -> (a -> c) -> Cata a -> b | c
+ * @param {Function} leftFn The left function that consumes the left value
+ * @param {Function} rightFn The right function that consumes the right value
+ * @param {Cata} catamorphicObj Either, Maybe or any other type with catamorphic capabilities (`cata` or `either` method)
+ * @return {*}
+ * @see {@link https://monet.github.io/monet.js/#cata|cata explained}
+ * @example
+ *
+ * // Either
+ * const eitherR = Either.Right(1);
+ * const eitherL = Either.Left(2);
+ *
+ * RA.cata(identity, identity, eitherR); //=> 1
+ * RA.cata(identity, identity, eitherL); //=> 2
+ *
+ * // Maybe
+ * const maybeSome = Maybe.Some(1);
+ * const maybeNothing = Maybe.Nothing();
+ *
+ * RA.cata(identity, identity, maybeSome); //=> 1
+ * RA.cata(identity, identity, maybeNothing); //=> undefined
+ */
+
+var catamorphism = curry(function (leftFn, rightFn, catamorphicObj) {
+  // folktale support
+  if (isFunction(catamorphicObj.matchWith)) {
+    return catamorphicObj.matchWith({
+      // Result type
+      Ok: function Ok(_ref) {
+        var value = _ref.value;
+        return rightFn(value);
+      },
+      Error: function Error(_ref2) {
+        var value = _ref2.value;
+        return leftFn(value);
+      },
+      // Maybe type
+      Just: function Just(_ref3) {
+        var value = _ref3.value;
+        return rightFn(value);
+      },
+      Nothing: function Nothing() {
+        return leftFn(undefined);
+      },
+      // Validation type
+      Success: function Success(_ref4) {
+        var value = _ref4.value;
+        return rightFn(value);
+      },
+      Failure: function Failure(_ref5) {
+        var value = _ref5.value;
+        return leftFn(value);
+      }
+    });
+  }
+
+  if (isFunction(catamorphicObj.cata)) {
+    return catamorphicObj.cata(leftFn, rightFn);
+  }
+
+  if (isFunction(catamorphicObj.getOrElse)) {
+    var elseValue = "RA.cata".concat(Math.random());
+    var value = catamorphicObj.getOrElse(elseValue);
+    return value === elseValue ? leftFn() : rightFn(value);
+  }
+
+  return catamorphicObj.either(leftFn, rightFn);
+});
+export default catamorphism;

package/es/catchP.js

@@ -0,0 +1,24 @@
+import { invoker } from 'ramda';
+/**
+ * Composable shortcut for `Promise.catch`.
+ * The catchP function returns a Promise. It takes two arguments: a callback function for the failure of the Promise
+ * and the promise instance itself.
+ *
+ * @func catchP
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.29.0|v2.29.0}
+ * @category Function
+ * @sig (a -> Promise b | b) -> Promise b
+ * @param {Function} onRejected A Function called if the Promise is rejected. This function has one argument, the rejection reason.
+ * @param {Promise} promise Any Promise
+ * @return {Promise} Returns a Promise with dealt rejected cases
+ * @see {@link RA.thenP|thenP}, {@link RA.resolveP|resolveP}, {@link RA.rejectP|rejectP}, {@link RA.allP|allP}
+ *
+ * @example
+ *
+ * RA.catchP(() => 'b', Promise.resolve('a')); //=> Promise('a')
+ * RA.catchP(() => 'b', Promise.reject('a')); //=> Promise('b')
+ */
+
+var catchP = invoker(1, 'catch');
+export default catchP;

package/es/ceil.js

@@ -0,0 +1,26 @@
+import { bind, curryN } from 'ramda';
+/**
+ * Returns the smallest integer greater than or equal to a given number.
+ *
+ * Note: ceil(null) returns integer 0 and does not give a NaN error.
+ *
+ * @func ceil
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.15.0|v2.15.0}
+ * @category Math
+ * @sig Number -> Number
+ * @param {number} number The number to ceil
+ * @return {number} The smallest integer greater than or equal to the given number
+ * @example
+ *
+ * RA.ceil(.95); //=> 1
+ * RA.ceil(4); //=> 4
+ * RA.ceil(7.004); //=> 8
+ * RA.ceil(-0.95); //=> -0
+ * RA.ceil(-4); //=> -4
+ * RA.ceil(-7.004); //=> -7
+ * RA.ceil(null); //=> 0
+ */
+
+var ceil = curryN(1, bind(Math.ceil, Math));
+export default ceil;

package/es/compact.js

@@ -0,0 +1,21 @@
+import { reject } from 'ramda';
+import isFalsy from './isFalsy';
+/**
+ * Creates an array with all falsy values removed.
+ * The values false, null, 0, "", undefined, and NaN are falsy.
+ *
+ * @func compact
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.5.0|v2.5.0}
+ * @category List
+ * @sig Filterable f => f a -> f a
+ * @param {Array} list The array to compact
+ * @return {Array} Returns the new array of filtered values
+ * @see {@link RA.isFalsy|isFalsy}
+ * @example
+ *
+ * RA.compact([0, 1, false, 2, '', 3]); //=> [1, 2, 3]
+ */
+
+var compact = reject(isFalsy);
+export default compact;

package/es/concatAll.js

@@ -0,0 +1,30 @@
+import { concat, identical, identity, pipe, reduce, when } from 'ramda';
+import stubUndefined from './stubUndefined';
+var leftIdentitySemigroup = {
+  concat: identity
+};
+/**
+ * Returns the result of concatenating the given lists or strings.
+ * Note: RA.concatAll expects all elements to be of the same type. It will throw an error if you concat an Array with a non-Array value.
+ * Dispatches to the concat method of the preceding element, if present. Can also concatenate multiple elements of a [fantasy-land compatible semigroup](https://github.com/fantasyland/fantasy-land#semigroup).
+ * Returns undefined if empty array was passed.
+ *
+ * @func concatAll
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.6.0|v2.6.0}
+ * @category List
+ * @sig [[a]] -> [a] | Undefined
+ * @sig [String] -> String | Undefined
+ * @sig Semigroup s => Foldable s f => f -> s | Undefined
+ * @param {Array.<Array|string>} list List containing elements that will be concatenated
+ * @return {Array|string|undefined} Concatenated elements
+ * @see {@link http://ramdajs.com/docs/#concat|R.concat}, {@link RA.concatRight|concatRight}, {@link http://ramdajs.com/docs/#unnest|R.unnest}, {@link http://ramdajs.com/docs/#join|R.join}
+ * @example
+ *
+ * concatAll([[1], [2], [3]]); //=> [1, 2, 3]
+ * concatAll(['1', '2', '3']); //=> '123'
+ * concatAll([]); //=> undefined;
+ */
+
+var concatAll = pipe(reduce(concat, leftIdentitySemigroup), when(identical(leftIdentitySemigroup), stubUndefined));
+export default concatAll;

package/es/concatRight.js

@@ -0,0 +1,29 @@
+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([], []); //=> []
+ */
+
+var concatRight = flip(concat);
+export default concatRight;

package/es/contained.js

@@ -0,0 +1,29 @@
+import { flip, contains } from 'ramda';
+/**
+ * Returns true if the specified value is equal, in R.equals terms,
+ * to at least one element of the given list or false otherwise.
+ * Given list can be a string.
+ *
+ * Like {@link http://ramdajs.com/docs/#contains|R.contains} but with argument order reversed.
+ *
+ * @func contained
+ * @aliases included
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.8.0|v2.8.0}
+ * @deprecated since v2.12.0; please use RA.included alias
+ * @category List
+ * @sig [a] -> a -> Boolean
+ * @param {Array|String} list The list to consider
+ * @param {*} a The item to compare against
+ * @return {boolean} Returns Boolean `true` if an equivalent item is in the list or `false` otherwise
+ * @see {@link http://ramdajs.com/docs/#contains|R.contains}
+ * @example
+ *
+ * RA.contained([1, 2, 3], 3); //=> true
+ * RA.contained([1, 2, 3], 4); //=> false
+ * RA.contained([{ name: 'Fred' }], { name: 'Fred' }); //=> true
+ * RA.contained([[42]], [42]); //=> true
+ */
+
+var contained = flip(contains);
+export default contained;

package/es/curryRight.js

@@ -0,0 +1,24 @@
+import { converge, length, identity } from 'ramda';
+import curryRightN from './curryRightN';
+/**
+ * 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'
+ */
+
+var curryRight = converge(curryRightN, [length, identity]);
+export default curryRight;

package/es/curryRightN.js

@@ -0,0 +1,32 @@
+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'
+ */
+
+var curryRightN = curryN(2, function (arity, fn) {
+  return curryN(arity, function wrapper() {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    return fn.apply(this, reverse(args));
+  });
+});
+export default curryRightN;

package/es/defaultWhen.js

@@ -0,0 +1,25 @@
+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
+ */
+
+var defaultWhen = curry(function (predicate, defaultVal, val) {
+  return predicate(val) ? defaultVal : val;
+});
+export default defaultWhen;

package/es/delayP.js

@@ -0,0 +1,44 @@
+import { curry, propOr, partial, nth } from 'ramda';
+import isNonNegative from './isNonNegative';
+import isInteger from './isInteger';
+/**
+ * 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'))
+ */
+
+var makeDelay = curry(function (settleFnPicker, opts) {
+  var timeout;
+  var value;
+
+  if (isInteger(opts) && isNonNegative(opts)) {
+    timeout = opts;
+  } else {
+    timeout = propOr(0, 'timeout', opts);
+    value = propOr(value, 'value', opts);
+  }
+
+  return new Promise(function () {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    var settleFn = settleFnPicker(args);
+    setTimeout(partial(settleFn, [value]), timeout);
+  });
+});
+var delayP = makeDelay(nth(0));
+delayP.reject = makeDelay(nth(1));
+export default delayP;

package/es/dispatch.js

@@ -0,0 +1,75 @@
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+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';
+import isNonEmptyArray from './isNonEmptyArray';
+import stubUndefined from './stubUndefined';
+var byArity = comparator(function (a, b) {
+  return a.length > b.length;
+});
+var getMaxArity = pipe(sort(byArity), head, prop('length'));
+var iteratorFn = curry(function (args, accumulator, fn) {
+  var result = fn.apply(void 0, _toConsumableArray(args));
+  return isNotNil(result) ? reduced(result) : accumulator;
+});
+
+var dispatchImpl = function dispatchImpl(functions) {
+  var arity = getMaxArity(functions);
+  return curryN(arity, function () {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    return reduce(iteratorFn(args), undefined, functions);
+  });
+};
+
+var dispatch = ifElse(isNonEmptyArray, dispatchImpl, stubUndefined);
+export default dispatch;

package/es/divideNum.js

@@ -0,0 +1,19 @@
+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
+ */
+
+var divideNum = flip(divide);
+export default divideNum;

package/es/dropArgs.js

@@ -0,0 +1,22 @@
+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
+ */
+
+var dropArgs = nAry(0);
+export default dropArgs;

package/es/ensureArray.js

@@ -0,0 +1,22 @@
+import { when, of } from 'ramda';
+import isNotArray from './isNotArray';
+/**
+ * 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]
+ */
+
+var ensureArray = when(isNotArray, of);
+export default ensureArray;

package/es/escapeRegExp.js

@@ -0,0 +1,20 @@
+import { when, replace } from 'ramda';
+import isString from './isString';
+/**
+ * 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\)'
+ */
+
+var escapeRegExp = when(isString, replace(/[.*+?^${}()|[\]\\-]/g, '\\$&'));
+export default escapeRegExp;