ramda-adjunct 2.34.0

package/es/isPositive.js

@@ -0,0 +1,24 @@
+import { both, lt } from 'ramda';
+import isNumber from './isNumber';
+/**
+ * Checks if value is a positive `Number` primitive or object. Zero is not considered positive.
+ *
+ * @func isPositive
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/1.15.0|v1.15.0}
+ * @category Type
+ * @sig * -> Boolean
+ * @param {*} val The value to test
+ * @return {boolean}
+ * @see {@link RA.isNegative|isNegative}
+ * @example
+ *
+ * RA.isPositive(1); // => true
+ * RA.isPositive(Number.MAX_VALUE); // => true
+ * RA.isPositive(-Infinity); // => false
+ * RA.isPositive(NaN); // => false
+ * RA.isPositive('5'); // => false
+ */
+
+var isPositive = both(isNumber, lt(0));
+export default isPositive;

package/es/isPositiveZero.js

@@ -0,0 +1,22 @@
+import { identical } from 'ramda';
+/**
+ * Checks if value is a positive zero (+0).
+ *
+ * @func isPositiveZero
+ * @memberof RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.22.0|v2.22.0}
+ * @category Type
+ * @sig * -> Boolean
+ * @param {*} val The value to test
+ * @return {boolean}
+ * @see {@link RA.isNegativeZero|isNegativeZero}
+ * @example
+ *
+ * RA.isPositiveZero(+0); //=> true
+ * RA.isPositiveZero(0); //=> true
+ * RA.isPositiveZero(-0); //=> false
+ * RA.isPositiveZero(null); //=> false
+ */
+
+var isPositiveZero = identical(+0);
+export default isPositiveZero;

package/es/isPrimitive.js

@@ -0,0 +1,31 @@
+import { both, anyPass } from 'ramda';
+import isNotObj from './isNotObj';
+import isString from './isString';
+import isNumber from './isNumber';
+import isBigInt from './isBigInt';
+import isBoolean from './isBoolean';
+import isUndefined from './isUndefined';
+import isNull from './isNull';
+import isSymbol from './isSymbol';
+/**
+ * Checks if value is a primitive data type. There are 6 primitive data types: `string`, `number`, `bigint`, `boolean`, `undefined`, `symbol` and a special case of `null`.
+ * See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Primitive_values
+ * for definition of what sub-types comprise a primitive.
+ *
+ * @func isPrimitive
+ * @category Type
+ * @sig * -> Boolean
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.32.0|v2.32.0}
+ * @param {*} val The value to test
+ * @return {boolean}
+ * @see {@link RA.isNotPrimitive|isNotPrimitive}, {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#primitive_values|MDN Primitive values}, {@link https://developer.mozilla.org/en-US/docs/Glossary/Primitive|MDN Primitive}
+ * @example
+ *
+ * RA.isPrimitive("string"); //=> true
+ * RA.isPrimitive(1); //=> true
+ * RA.isPrimitive(new String("string")); //=> false
+ * RA.isPrimitive(new Number(1)); //=> false
+ */
+
+var isPrimitive = both(isNotObj, anyPass([isString, isNumber, isBigInt, isBoolean, isUndefined, isNull, isSymbol]));
+export default isPrimitive;

package/es/isPromise.js

@@ -0,0 +1,27 @@
+import { both, pipe, toString, equals, curryN } from 'ramda';
+import isObj from './isObj';
+/**
+ * Checks if input value is a native `Promise`.
+ * The Promise object represents the eventual completion (or failure)
+ * of an asynchronous operation, and its resulting value.
+ *
+ * @func isPromise
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.1.0|v2.1.0}
+ * @category Type
+ * @sig * -> Boolean
+ * @param {*} val The value to test
+ * @return {boolean}
+ * @see {@link https://promisesaplus.com/|Promises/A+}, {@link RA.isThenable|isThenable}
+ * @example
+ *
+ * RA.isPromise(null); // => false
+ * RA.isPromise(undefined); // => false
+ * RA.isPromise([]); // => false
+ * RA.isPromise(Promise.resolve()); // => true
+ * RA.isPromise(Promise.reject()); // => true
+ * RA.isPromise({ then: () => 1 }); // => false
+ */
+
+var isPromise = curryN(1, both(isObj, pipe(toString, equals('[object Promise]'))));
+export default isPromise;

package/es/isPrototypeOf.js

@@ -0,0 +1,34 @@
+import { curry } from 'ramda';
+import invokeArgs from './invokeArgs';
+/**
+ * Checks if an object exists in another object's prototype chain.
+ *
+ * @func isPrototypeOf
+ * @category Object
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.31.0|v2.31.0}
+ * @sig * -> Boolean
+ * @param {Object} type The prototype that we're searching for
+ * @param {Object} object The object whose prototype chain will be searched
+ * @return {boolean}
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/isPrototypeOf|Object.prorotype.isPrototypeOf}
+ * @example
+ * function Foo() {}
+ * function Bar() {}
+ * function Baz() {}
+ *
+ * Bar.prototype = Object.create(Foo.prototype);
+ * Baz.prototype = Object.create(Bar.prototype);
+ *
+ * const baz = new Baz();
+ *
+ * RA.isPrototypeOf(Baz, baz); // => true
+ * RA.isPrototypeOf(Bar, baz); // => true
+ * RA.isPrototypeOf(Foo, baz); // => true
+ * RA.isPrototypeOf(Object, baz); // => true
+ */
+
+var isPrototypeOf = curry(function (type, object) {
+  return Boolean(invokeArgs(['prototype', 'isPrototypeOf'], [object], type));
+});
+export default isPrototypeOf;

package/es/isRegExp.js

@@ -0,0 +1,21 @@
+import { type, identical, pipe, curryN } from 'ramda';
+/**
+ * Checks if value is `RegExp` object.
+ *
+ * @func isRegExp
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.5.0|v2.5.0}
+ * @category Type
+ * @sig * -> Boolean
+ * @param {*} val The value to test
+ * @return {boolean}
+ * @see {@link RA.isNotRegExp|isNotRegExp}
+ * @example
+ *
+ * RA.isRegExp(new RegExp()); //=> true
+ * RA.isRegExp(/(?:)/); //=> true
+ * RA.isRegExp(1); //=> false
+ */
+
+var isRegExp = curryN(1, pipe(type, identical('RegExp')));
+export default isRegExp;

package/es/isSafeInteger.js

@@ -0,0 +1,34 @@
+import { bind, curryN } from 'ramda';
+import isFunction from './isFunction';
+import ponyfill from './internal/ponyfills/Number.isSafeInteger';
+export var isSafeIntegerPonyfill = curryN(1, ponyfill);
+/**
+ * Checks whether the passed value is a safe `integer`.
+ *
+ * @func isSafeInteger
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.22.0|v2.22.0}
+ * @category Type
+ * @sig * -> Boolean
+ * @param {*} val The value to test
+ * @return {boolean}
+ * @example
+ *
+ * RA.isSafeInteger(3); //=> true
+ * RA.isSafeInteger(Math.pow(2, 53)) //=> false
+ * RA.isSafeInteger(Math.pow(2, 53) - 1); //=> true
+ * RA.isSafeInteger(NaN); //=> false
+ * RA.isSafeInteger(Infinity); //=> false
+ * RA.isSafeInteger('3') //=> false
+ * RA.isSafeInteger(3.1); //=> false
+ * RA.isSafeInteger(3.0); //=> true
+ * RA.isSafeInteger('string'); //=> false
+ * RA.isSafeInteger(null); //=> false
+ * RA.isSafeInteger(undefined); //=> false
+ * RA.isSafeInteger({}); //=> false
+ * RA.isSafeInteger(() => { }); //=> false
+ * RA.isSafeInteger(true); //=> false
+ */
+
+var isSafeInteger = isFunction(Number.isSafeInteger) ? curryN(1, bind(Number.isSafeInteger, Number)) : isSafeIntegerPonyfill;
+export default isSafeInteger;

package/es/isSentinelValue.js

@@ -0,0 +1,26 @@
+import { curryN } from 'ramda';
+import isInteger32 from './isInteger32';
+/**
+ * Checks whether the passed value is {@link https://github.com/getify/You-Dont-Know-JS/blob/9959fc904d584bbf0b02cf41c192f74ff4238581/types-grammar/ch4.md#the-curious-case-of-the-|a sentinel value}.
+ *
+ * @func isSentinelValue
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.33.0|v2.33.0}
+ * @category Type
+ * @sig * -> Boolean
+ * @param {*} val The value to test
+ * @return {boolean}
+ * @example
+ *
+ * RA.isSentinelValue(-1); //=> true
+ *
+ * RA.isSentinelValue('-1'); //=> false
+ * RA.isSentinelValue(1); //=> false
+ * RA.isSentinelValue([-1]); //=> false
+ */
+// eslint-disable-next-line no-bitwise
+
+var isSentinelValue = curryN(1, function (val) {
+  return isInteger32(val) && ~val === 0;
+});
+export default isSentinelValue;

package/es/isSet.js

@@ -0,0 +1,22 @@
+import { type, identical, pipe, curryN } from 'ramda';
+/**
+ * Predicate for determining if a provided value is an instance of a Set.
+ *
+ * @func isSet
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.22.0|v2.22.0}
+ * @category Type
+ * @sig * -> Boolean
+ * @param {*} val The value to test
+ * @return {boolean}
+ * @see {@link RA.isMap|isMap}}
+ * @example
+ *
+ * RA.isSet(new Map()); //=> false
+ * RA.isSet(new Set()); //=> true
+ * RA.isSet(new Set([1,2]); //=> true
+ * RA.isSet(new Object()); //=> false
+ */
+
+var isSet = curryN(1, pipe(type, identical('Set')));
+export default isSet;

package/es/isSparseArray.js

@@ -0,0 +1,30 @@
+import { values, both, complement, pipe, converge, identical, length } from 'ramda';
+import isArray from './isArray';
+/**
+ * Checks if input value is a sparse Array.
+ * An array with at least one "empty slot" in it is often called a "sparse array."
+ * Empty slot doesn't mean that the slot contains `null` or `undefined` values,
+ * but rather that the slots don't exist.
+ *
+ * @func isSparseArray
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.20.0|v2.20.0}
+ * @category Type
+ * @sig * -> Boolean
+ * @param {*} list The list to test
+ * @return {boolean}
+ * @see {@link https://github.com/getify/You-Dont-Know-JS/blob/f0d591b6502c080b92e18fc470432af8144db610/types%20%26%20grammar/ch3.md#array|Sparse Arrays}, {@link RA.isArray|isArray}
+ * @example
+ *
+ * RA.isSparseArray(new Array(3)); // => true
+ * RA.isSparseArray([1,,3]); // => true
+ *
+ * const list = [1, 2, 3];
+ * delete list[1];
+ * RA.isSparseArray(list); // => true
+ *
+ * RA.isSparseArray([1, 2, 3]); // => false
+ */
+
+var isSparseArray = both(isArray, converge(complement(identical), [pipe(values, length), length]));
+export default isSparseArray;

package/es/isString.js

@@ -0,0 +1,20 @@
+import { curryN, pipe, type, identical } from 'ramda';
+/**
+ * Checks if input value is `String`.
+ *
+ * @func isString
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/0.4.0|v0.4.0}
+ * @category Type
+ * @sig * -> Boolean
+ * @param {*} val The value to test
+ * @return {boolean}
+ * @see {@link RA.isNotString|isNotString}
+ * @example
+ *
+ * RA.isString('abc'); //=> true
+ * RA.isString(1); //=> false
+ */
+
+var isString = curryN(1, pipe(type, identical('String')));
+export default isString;

package/es/isSymbol.js

@@ -0,0 +1,27 @@
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+import { type, curryN } from 'ramda';
+/**
+ * Checks if input value is a Symbol.
+ *
+ * @func isSymbol
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.22.0|v2.22.0}
+ * @category Type
+ * @sig * -> Boolean
+ * @param {*} val The value to test
+ * @return {boolean}
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol|MDN Symbol}
+ * @example
+ *
+ * RA.isSymbol(Symbol('1')); //=> true
+ * RA.isSymbol(Symbol(1)); //=> true
+ * RA.isSymbol('string'); //=> false
+ * RA.isSymbol(undefined); //=> false
+ * RA.isSymbol(null); //=> false
+ */
+
+var isSymbol = curryN(1, function (val) {
+  return _typeof(val) === 'symbol' || _typeof(val) === 'object' && type(val) === 'Symbol';
+});
+export default isSymbol;

package/es/isThenable.js

@@ -0,0 +1,26 @@
+import { pathSatisfies } from 'ramda';
+import isFunction from './isFunction';
+/**
+ * Checks if input value is a `thenable`.
+ * `thenable` is an object or function that defines a `then` method.
+ *
+ * @func isThenable
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.1.0|v2.1.0}
+ * @category Type
+ * @sig * -> Boolean
+ * @param {*} val The value to test
+ * @return {boolean}
+ * @see {@link RA.isPromise|isPromise}
+ * @example
+ *
+ * RA.isThenable(null); // => false
+ * RA.isThenable(undefined); // => false
+ * RA.isThenable([]); // => false
+ * RA.isThenable(Promise.resolve()); // => true
+ * RA.isThenable(Promise.reject()); // => true
+ * RA.isThenable({ then: () => 1 }); // => true
+ */
+
+var isThenable = pathSatisfies(isFunction, ['then']);
+export default isThenable;

package/es/isTrue.js

@@ -0,0 +1,25 @@
+import { identical } from 'ramda';
+/**
+ * Checks if input value is the Boolean primitive `true`. Will return false for Boolean objects
+ * created using the `Boolean` function as a constructor.
+ *
+ * @func isTrue
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.6.0|v2.6.0}
+ * @category Type
+ * @sig * -> Boolean
+ * @param {*} val The value to test
+ * @return {boolean}
+ * @see {@link RA.isFalse|isFalse}, {@link RA.isTruthy|isTruthy}, {@link RA.isFalsy|isFalsy}
+ * @example
+ *
+ * RA.isTrue(true); // => true
+ * RA.isTrue(Boolean(true)); // => true
+ * RA.isTrue(false); // => false
+ * RA.isTrue(1); // => false
+ * RA.isTrue('true'); // => false
+ * RA.isTrue(new Boolean(true)); // => false
+ */
+
+var isTrue = identical(true);
+export default isTrue;

package/es/isTruthy.js

@@ -0,0 +1,27 @@
+import { curryN } from 'ramda';
+/**
+ * In JavaScript, a `truthy` value is a value that is considered true
+ * when evaluated in a Boolean context. All values are truthy unless
+ * they are defined as falsy (i.e., except for `false`, `0`, `""`, `null`, `undefined`, and `NaN`).
+ *
+ * @func isTruthy
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.2.0|v2.2.0}
+ * @category Type
+ * @sig * -> Boolean
+ * @param {*} val The value to test
+ * @return {boolean}
+ * @see {@link https://developer.mozilla.org/en-US/docs/Glossary/Truthy|truthy}, {@link RA.isFalsy|isFalsy}
+ * @example
+ *
+ * RA.isTruthy({}); // => true
+ * RA.isTruthy([]); // => true
+ * RA.isTruthy(42); // => true
+ * RA.isTruthy(3.14); // => true
+ * RA.isTruthy('foo'); // => true
+ * RA.isTruthy(new Date()); // => true
+ * RA.isTruthy(Infinity); // => true
+ */
+
+var isTruthy = curryN(1, Boolean);
+export default isTruthy;

package/es/isUndefined.js

@@ -0,0 +1,22 @@
+import { equals } from 'ramda';
+import stubUndefined from './stubUndefined';
+/**
+ * Checks if input value is `undefined`.
+ *
+ * @func isUndefined
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/0.0.1|v0.0.1}
+ * @category Type
+ * @sig * -> Boolean
+ * @param {*} val The value to test
+ * @return {boolean}
+ * @see {@link RA.isNotUndefined|isNotUndefined}
+ * @example
+ *
+ * RA.isUndefined(1); //=> false
+ * RA.isUndefined(undefined); //=> true
+ * RA.isUndefined(null); //=> false
+ */
+
+var isUndefined = equals(stubUndefined());
+export default isUndefined;

package/es/isValidDate.js

@@ -0,0 +1,26 @@
+import { invoker, both, pipe, curryN } from 'ramda';
+import isDate from './isDate';
+import isNotNaN from './isNotNaN';
+/* eslint-disable max-len */
+
+/**
+ * Checks if value is valid `Date` object.
+ *
+ * @func isValidDate
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/1.8.0|v1.8.0}
+ * @category Type
+ * @sig * -> Boolean
+ * @param {*} val The value to test
+ * @return {boolean}
+ * @see {@link RA.isDate|isDate}, {@link RA.isNotDate|isNotDate}, {@link RA.isNotValidDate|isNotValidDate}
+ * @example
+ *
+ * RA.isValidDate(new Date()); //=> true
+ * RA.isValidDate(new Date('a')); //=> false
+ */
+
+/* eslint-enable max-len */
+
+var isValidDate = curryN(1, both(isDate, pipe(invoker(0, 'getTime'), isNotNaN)));
+export default isValidDate;

package/es/isValidNumber.js

@@ -0,0 +1,26 @@
+import { either, curryN } from 'ramda';
+import isFloat from './isFloat';
+import isInteger from './isInteger';
+/**
+ * Checks if value is a valid `Number`. A valid `Number` is a number that is not `NaN`, `Infinity`
+ * or `-Infinity`.
+ *
+ * @func isValidNumber
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.2.0|v2.2.0}
+ * @category Type
+ * @sig * -> Boolean
+ * @param {*} val The value to test
+ * @return {boolean}
+ * @see {@link RA.isNotValidNumber|isNotValidNumber}
+ * @example
+ *
+ * RA.isValidNumber(1); //=> true
+ * RA.isValidNumber(''); //=> false
+ * RA.isValidNumber(NaN); //=> false
+ * RA.isValidNumber(Infinity); //=> false
+ * RA.isValidNumber(-Infinity); //=> false
+ */
+
+var isValidNumber = curryN(1, either(isInteger, isFloat));
+export default isValidNumber;

package/es/lastP.js

@@ -0,0 +1,63 @@
+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 { bind, last, map, curryN } from 'ramda';
+import allP from './allP';
+import lengthEq from './lengthEq';
+import lengthGte from './lengthGte';
+import rejectP from './rejectP';
+import resolveP from './resolveP';
+/**
+ * Returns a promise that is fulfilled by the last given promise to be fulfilled,
+ * or rejected with an array of rejection reasons if all of the given promises are rejected.
+ *
+ * @func lastP
+ * @memberOf RA
+ * @category Function
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.23.0|v2.23.0}
+ * @sig [Promise a] -> Promise a
+ * @param {Iterable.<*>} iterable An iterable object such as an Array or String
+ * @return {Promise} A promise that is fulfilled by the last given promise to be fulfilled, or rejected with an array of rejection reasons if all of the given promises are rejected.
+ * @see {@link RA.anyP|anyP}
+ * @example
+ *
+ * const delayP = timeout => new Promise(resolve => setTimeout(() => resolve(timeout), timeout));
+ * delayP.reject = timeout => new Promise((resolve, reject) => setTimeout(() => reject(timeout), timeout));
+ * RA.lastP([
+ *   1,
+ *   delayP(10),
+ *   delayP(100),
+ *   delayP.reject(1000),
+ * ]); //=> Promise(100)
+ */
+
+var lastP = curryN(1, function (iterable) {
+  var fulfilled = [];
+  var rejected = [];
+  var onFulfill = bind(fulfilled.push, fulfilled);
+  var onReject = bind(rejected.push, rejected);
+  var listOfPromises = map(function (p) {
+    return resolveP(p).then(onFulfill)["catch"](onReject);
+  }, _toConsumableArray(iterable));
+  return allP(listOfPromises).then(function () {
+    if (lengthEq(0, fulfilled) && lengthEq(0, rejected)) {
+      return undefined;
+    }
+
+    if (lengthGte(1, fulfilled)) {
+      return last(fulfilled);
+    }
+
+    return rejectP(rejected);
+  });
+});
+export default lastP;

package/es/lengthEq.js

@@ -0,0 +1,22 @@
+import { equals } from 'ramda';
+import compareLength from './internal/compareLength';
+/**
+ * Returns `true` if the supplied list or string has a length equal to `valueLength`.
+ *
+ * @func lengthEq
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.8.0|v2.8.0}
+ * @category List
+ * @sig Number -> [*] -> Boolean
+ * @param {number} valueLength The length of the list or string
+ * @param {Array|string} value The list or string
+ * @return {boolean}
+ * @see {@link RA.lengthNotEq|lengthNotEq}, {@link RA.lengthLt|lengthLt}, {@link RA.lengthGt|lengthGt}, {@link RA.lengthLte|lengthLte}, {@link RA.lengthGte|lengthGte},, {@link http://ramdajs.com/docs/#equals|equals}, {@link http://ramdajs.com/docs/#length|length}
+ * @example
+ *
+ * RA.lengthEq(3, [1,2,3]); //=> true
+ * RA.lengthEq(3, [1,2,3,4]); //=> false
+ */
+
+var lengthEq = compareLength(equals);
+export default lengthEq;

package/es/lengthGt.js

@@ -0,0 +1,22 @@
+import { flip, gt } from 'ramda';
+import compareLength from './internal/compareLength';
+/**
+ * Returns `true` if the supplied list or string has a length greater than `valueLength`.
+ *
+ * @func lengthGt
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.8.0|v2.8.0}
+ * @category List
+ * @sig Number -> [*] -> Boolean
+ * @param {number} valueLength The length of the list or string
+ * @param {Array|string} value The list or string
+ * @return {boolean}
+ * @see {@link RA.lengthEq|lengthEq}, {@link RA.lengthNotEq|lengthNotEq}, {@link RA.lengthLt|lengthLt}, {@link RA.lengthLte|lengthLte}, {@link RA.lengthGte|lengthGte}, {@link http://ramdajs.com/docs/#gt|gt},  {@link http://ramdajs.com/docs/#length|length}
+ * @example
+ *
+ * RA.lengthGt(3, [1,2,3,4]); //=> true
+ * RA.lengthGt(3, [1,2,3]); //=> false
+ */
+
+var lengthGt = compareLength(flip(gt));
+export default lengthGt;

package/es/lengthGte.js

@@ -0,0 +1,24 @@
+import { flip, gte } from 'ramda';
+import compareLength from './internal/compareLength';
+/**
+ * Returns `true` if the supplied list or string has a length greater than or equal to
+ * `valueLength`.
+ *
+ * @func lengthGte
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.8.0|v2.8.0}
+ * @category List
+ * @sig Number -> [*] -> Boolean
+ * @param {number} valueLength The length of the list or string
+ * @param {Array|string} value The list or string
+ * @return {boolean}
+ * @see {@link RA.lengthEq|lengthEq}, {@link RA.lengthNotEq|lengthNotEq}, {@link RA.lengthLt|lengthLt}, {@link RA.lengthGt|lengthGt}, {@link RA.lengthLte|lengthLte}, {@link http://ramdajs.com/docs/#gte|gte}, {@link http://ramdajs.com/docs/#length|length}
+ * @example
+ *
+ * RA.lengthGte(3, [1,2,3,4]); //=> true
+ * RA.lengthGte(3, [1,2,3]); //=> true
+ * RA.lengthGte(3, [1,2]); //=> false
+ */
+
+var lengthGte = compareLength(flip(gte));
+export default lengthGte;

package/es/lengthLt.js

@@ -0,0 +1,22 @@
+import { flip, lt } from 'ramda';
+import compareLength from './internal/compareLength';
+/**
+ * Returns `true` if the supplied list or string has a length less than `valueLength`.
+ *
+ * @func lengthLt
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.8.0|v2.8.0}
+ * @category List
+ * @sig Number -> [*] -> Boolean
+ * @param {number} valueLength The length of the list or string
+ * @param {Array|string} value The list or string
+ * @return {boolean}
+ * @see {@link RA.lengthEq|lengthEq}, {@link RA.lengthNotEq|lengthNotEq}, {@link RA.lengthGt|lengthGt}, {@link RA.lengthLte|lengthLte}, {@link RA.lengthGte|lengthGte}, {@link http://ramdajs.com/docs/#lt|lt}, {@link http://ramdajs.com/docs/#length|length}
+ * @example
+ *
+ * RA.lengthLt(3, [1,2]); //=> true
+ * RA.lengthLt(3, [1,2,3]); //=> false
+ */
+
+var lengthLt = compareLength(flip(lt));
+export default lengthLt;