feat: add lengthLt, lengthGt, lengthLte, lengthGte

src/index.d.ts

@@ -793,7 +793,6 @@ declare namespace RamdaAdjunct {
          */
         sliceFrom<T>(fromIndex: number, list: string | T[]): string | T[];
         sliceFrom(fromIndex: number): <T>(list: string | T[]) => string | T[];
-        sliceFrom<T>(fromIndex: number, list: string | T[]): string | T[];
 
         /**
          * Returns the elements of the given list or string (or object with a slice method)
@@ -809,6 +808,32 @@ declare namespace RamdaAdjunct {
         omitIndexes<T>(indexes: number[], list: T[]): T[];
         omitIndexes(indexes: number[]): <T>(list: T[]) => T[];
 
+        /**
+         * Returns `true` if the supplied list or string has a length greater than `valueLength`.
+         */
+        lengthGt<T>(valueLength: number, list: string | T[]): boolean;
+        lengthGt(valueLength: number): <T>(list: string | T[]) => boolean;
+
+        /**
+         * Returns `true` if the supplied list or string has a length less than `valueLength`.
+         */
+        lengthLt<T>(valueLength: number, list: string | T[]): boolean;
+        lengthLt(valueLength: number): <T>(list: string | T[]) => boolean;
+
+        /**
+         * Returns `true` if the supplied list or string has a length less than or equal to
+         * `valueLength`.
+         */
+        lengthLte<T>(valueLength: number, list: string | T[]): boolean;
+        lengthLte(valueLength: number): <T>(list: string | T[]) => boolean;
+
+        /**
+         * Returns `true` if the supplied list or string has a length greater than or equal to
+         * `valueLength`.
+         */
+        lengthGte<T>(valueLength: number, list: string | T[]): boolean;
+        lengthGte(valueLength: number): <T>(list: string | T[]) => boolean;
+
         /**
          * Checks if input value is a `thenable`.
          * `thenable` is an object or function that defines a `then` method.

src/index.js

@@ -111,6 +111,10 @@ export { default as compact } from './compact';
 export { default as appendFlipped } from './appendFlipped';
 export { default as contained } from './contained';
 export { default as move } from './move';
+export { default as lengthGt } from './lengthGt';
+export { default as lengthLt } from './lengthLt';
+export { default as lengthGte } from './lengthGte';
+export { default as lengthLte } from './lengthLte';
 // Object
 export { default as paths } from './paths';
 export { default as renameKeys } from './renameKeys';

src/internal/compareLength.js

@@ -0,0 +1,7 @@
+import { curry, compose, length } from 'ramda';
+
+const compareLength = curry((comparator, value, list) =>
+  compose(comparator(value), length)(list)
+);
+
+export default compareLength;

src/lengthGt.js

@@ -0,0 +1,24 @@
+import { gt, flip } 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 {number} value The list or string
+ * @return {boolean}
+ * @see {@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
+ */
+const lengthGt = compareLength(flip(gt));
+
+export default lengthGt;

src/lengthGte.js

@@ -0,0 +1,26 @@
+import { gte, flip } 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 {number} value The list or string
+ * @return {boolean}
+ * @see {@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,3]); //=> false
+ */
+const lengthGte = compareLength(flip(gte));
+
+export default lengthGte;

src/lengthLt.js

@@ -0,0 +1,24 @@
+import { lt, flip } 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 {number} value The list or string
+ * @return {boolean}
+ * @see {@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
+ */
+const lengthLt = compareLength(flip(lt));
+
+export default lengthLt;

src/lengthLte.js

@@ -0,0 +1,25 @@
+import { lte, flip } from 'ramda';
+
+import compareLength from './internal/compareLength';
+
+/**
+ * Returns `true` if the supplied list or string has a length less than or equal to `valueLength`.
+ *
+ * @func lengthLte
+ * @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 {number} value The list or string
+ * @return {boolean}
+ * @see {@link http://ramdajs.com/docs/#lte|lte}, {@link http://ramdajs.com/docs/#length|length}
+ * @example
+ *
+ * RA.lengthLte(3, [1,2]); //=> true
+ * RA.lengthLte(3, [1,2,3]); //=> true
+ * RA.lengthLte(3, [1,2,3,4]); //=> false
+ */
+const lengthLte = compareLength(flip(lte));
+
+export default lengthLte;

test/lengthGt.js

@@ -0,0 +1,31 @@
+import * as RA from '../src/index';
+import eq from './shared/eq';
+
+describe('lengthGt', function() {
+  it(`should return true if the length of a list is greater than supplied length`, function() {
+    eq(RA.lengthGt(3, [1, 2, 3, 4]), true);
+    eq(RA.lengthGt(3, [1, 2, 3]), false);
+    eq(RA.lengthGt(0, []), false);
+  });
+
+  it(`should return true if the length of a string is greater than supplied length`, function() {
+    eq(RA.lengthGt(3, 'abcd'), true);
+    eq(RA.lengthGt(3, 'abc'), false);
+    eq(RA.lengthGt(0, ''), false);
+  });
+
+  it(`should return false for values without a length property`, function() {
+    eq(RA.lengthGt(1, NaN), false);
+    eq(RA.lengthGt(1, undefined), false);
+    eq(RA.lengthGt(1, null), false);
+    eq(RA.lengthGt(1, {}), false);
+    eq(RA.lengthGt(1, true), false);
+    eq(RA.lengthGt(1, false), false);
+    eq(RA.lengthGt(1, 5), false);
+  });
+
+  it(`should be curried`, function() {
+    eq(RA.lengthGt(1, [1, 2]), true);
+    eq(RA.lengthGt(1)([1, 2]), true);
+  });
+});

test/lengthGte.js

@@ -0,0 +1,33 @@
+import * as RA from '../src/index';
+import eq from './shared/eq';
+
+describe('lengthGte', function() {
+  it(`should return true if the length of a list is greater than or equal to the supplied length`, function() {
+    eq(RA.lengthGte(3, [1, 2, 3, 4]), true);
+    eq(RA.lengthGte(3, [1, 2, 3]), true);
+    eq(RA.lengthGte(3, [1, 2]), false);
+    eq(RA.lengthGte(0, []), true);
+  });
+
+  it(`should return true if the length of a string is greater than or equal to the supplied length`, function() {
+    eq(RA.lengthGte(3, 'abcd'), true);
+    eq(RA.lengthGte(3, 'abc'), true);
+    eq(RA.lengthGte(3, 'ab'), false);
+    eq(RA.lengthGte(0, ''), true);
+  });
+
+  it(`should return false for values without a length property`, function() {
+    eq(RA.lengthGte(1, NaN), false);
+    eq(RA.lengthGte(1, undefined), false);
+    eq(RA.lengthGte(1, null), false);
+    eq(RA.lengthGte(1, {}), false);
+    eq(RA.lengthGte(1, true), false);
+    eq(RA.lengthGte(1, false), false);
+    eq(RA.lengthGte(1, 5), false);
+  });
+
+  it(`should be curried`, function() {
+    eq(RA.lengthGte(1, [1]), true);
+    eq(RA.lengthGte(1)([1]), true);
+  });
+});

test/lengthLt.js

@@ -0,0 +1,31 @@
+import * as RA from '../src/index';
+import eq from './shared/eq';
+
+describe('lengthLt', function() {
+  it(`should return true if the length of a list is less than supplied length`, function() {
+    eq(RA.lengthLt(3, [1, 2]), true);
+    eq(RA.lengthLt(3, [1, 2, 3]), false);
+    eq(RA.lengthLt(0, []), false);
+  });
+
+  it(`should return true if the length of a string is less than supplied length`, function() {
+    eq(RA.lengthLt(3, 'ab'), true);
+    eq(RA.lengthLt(3, 'abc'), false);
+    eq(RA.lengthLt(0, ''), false);
+  });
+
+  it(`should return false for values without a length property`, function() {
+    eq(RA.lengthLt(1, NaN), false);
+    eq(RA.lengthLt(1, undefined), false);
+    eq(RA.lengthLt(1, null), false);
+    eq(RA.lengthLt(1, {}), false);
+    eq(RA.lengthLt(1, true), false);
+    eq(RA.lengthLt(1, false), false);
+    eq(RA.lengthLt(1, 5), false);
+  });
+
+  it(`should be curried`, function() {
+    eq(RA.lengthLt(2, [1]), true);
+    eq(RA.lengthLt(2)([1]), true);
+  });
+});

test/lengthLte.js

@@ -0,0 +1,33 @@
+import * as RA from '../src/index';
+import eq from './shared/eq';
+
+describe('lengthLte', function() {
+  it(`should return true if the length of a list is less than or equal to the supplied length`, function() {
+    eq(RA.lengthLte(3, [1, 2]), true);
+    eq(RA.lengthLte(3, [1, 2, 3]), true);
+    eq(RA.lengthLte(3, [1, 2, 3, 4]), false);
+    eq(RA.lengthLte(0, []), true);
+  });
+
+  it(`should return true if the length of a string is less than or equal to the supplied length`, function() {
+    eq(RA.lengthLte(3, 'ab'), true);
+    eq(RA.lengthLte(3, 'abc'), true);
+    eq(RA.lengthLte(3, 'abcd'), false);
+    eq(RA.lengthLte(0, ''), true);
+  });
+
+  it(`should return false for values without a length property`, function() {
+    eq(RA.lengthLte(1, NaN), false);
+    eq(RA.lengthLte(1, undefined), false);
+    eq(RA.lengthLte(1, null), false);
+    eq(RA.lengthLte(1, {}), false);
+    eq(RA.lengthLte(1, true), false);
+    eq(RA.lengthLte(1, false), false);
+    eq(RA.lengthLte(1, 5), false);
+  });
+
+  it(`should be curried`, function() {
+    eq(RA.lengthLte(1, [1]), true);
+    eq(RA.lengthLte(1)([1]), true);
+  });
+});