rambda 10.3.4 → 11.0.0

package/dist/rambda.umd.js

@@ -262,60 +262,6 @@
     }
   }
 
-  function drop(howManyToDrop, ) {
-    return list => list.slice(howManyToDrop > 0 ? howManyToDrop : 0)
-  }
-
-  function dropLast(numberItems) {
-    return list => (numberItems > 0 ? list.slice(0, -numberItems) : list.slice())
-  }
-
-  function dropLastWhile(predicate) {
-    return list => {
-      if (list.length === 0) {
-        return list
-      }
-
-      const toReturn = [];
-      let counter = list.length;
-
-      while (counter) {
-        const item = list[--counter];
-        if (!predicate(item, counter)) {
-          toReturn.push(item);
-          break
-        }
-      }
-
-      while (counter) {
-        toReturn.push(list[--counter]);
-      }
-
-      return toReturn.reverse()
-    }
-  }
-
-  function dropWhile(predicate) {
-    return iterable => {
-      const toReturn = [];
-      let counter = 0;
-
-      while (counter < iterable.length) {
-        const item = iterable[counter++];
-        if (!predicate(item, counter)) {
-          toReturn.push(item);
-          break
-        }
-      }
-
-      while (counter < iterable.length) {
-        toReturn.push(iterable[counter++]);
-      }
-
-      return toReturn
-    }
-  }
-
   function type(input) {
     if (input === null) {
       return 'Null'
@@ -539,6 +485,83 @@
     return b => equalsFn(a, b)
   }
 
+  function includes(valueToFind) {
+    return iterable => {
+      if (typeof iterable === 'string') {
+        return iterable.includes(valueToFind)
+      }
+      if (!iterable) {
+        throw new TypeError(`Cannot read property \'indexOf\' of ${iterable}`)
+      }
+      if (!isArray(iterable)) {
+        return false
+      }
+
+      return _indexOf(valueToFind, iterable) > -1
+    }
+  }
+
+  function difference(x) {
+  	return y => ([
+  		...filter(value => !includes(value)(y))(x),
+  		...filter(value => !includes(value)(x))(y),
+  	])
+  }
+
+  function drop(howManyToDrop, ) {
+    return list => list.slice(howManyToDrop > 0 ? howManyToDrop : 0)
+  }
+
+  function dropLast(numberItems) {
+    return list => (numberItems > 0 ? list.slice(0, -numberItems) : list.slice())
+  }
+
+  function dropLastWhile(predicate) {
+    return list => {
+      if (list.length === 0) {
+        return list
+      }
+
+      const toReturn = [];
+      let counter = list.length;
+
+      while (counter) {
+        const item = list[--counter];
+        if (!predicate(item, counter)) {
+          toReturn.push(item);
+          break
+        }
+      }
+
+      while (counter) {
+        toReturn.push(list[--counter]);
+      }
+
+      return toReturn.reverse()
+    }
+  }
+
+  function dropWhile(predicate) {
+    return iterable => {
+      const toReturn = [];
+      let counter = 0;
+
+      while (counter < iterable.length) {
+        const item = iterable[counter++];
+        if (!predicate(item, counter)) {
+          toReturn.push(item);
+          break
+        }
+      }
+
+      while (counter < iterable.length) {
+        toReturn.push(iterable[counter++]);
+      }
+
+      return toReturn
+    }
+  }
+
   class _Set {
     constructor() {
       this.set = new Set();
@@ -617,24 +640,30 @@
     return mapObject((x, prop) => type(rules[prop]) === 'Function' ? rules[prop](x): x)
   }
 
-  function includes(valueToFind) {
-    return iterable => {
-      if (typeof iterable === 'string') {
-        return iterable.includes(valueToFind)
-      }
-      if (!iterable) {
-        throw new TypeError(`Cannot read property \'indexOf\' of ${iterable}`)
-      }
-      if (!isArray(iterable)) {
-        return false
-      }
+  function excludes(valueToFind) {
+    return iterable => !includes(valueToFind)(iterable)
+  }
 
-      return _indexOf(valueToFind, iterable) > -1
+  function find(predicate) {
+    return list => {
+      let index = 0;
+      const len = list.length;
+
+      while (index < len) {
+        const x = list[index];
+        if (predicate(x)) {
+          return x
+        }
+
+        index++;
+      }
     }
   }
 
-  function excludes(valueToFind) {
-    return iterable => !includes(valueToFind)(iterable)
+  function exists(predicate) {
+    return list => {
+  		return find(predicate)(list) !== undefined
+    }
   }
 
   function filterAsync(predicate) {
@@ -666,22 +695,6 @@
     }
   }
 
-  function find(predicate) {
-    return list => {
-      let index = 0;
-      const len = list.length;
-
-      while (index < len) {
-        const x = list[index];
-        if (predicate(x)) {
-          return x
-        }
-
-        index++;
-      }
-    }
-  }
-
   function findIndex(predicate) {
     return list => {
       const len = list.length;
@@ -911,40 +924,6 @@
     return input.length ? baseSlice(input, 0, -1) : []
   }
 
-  function _includesWith(pred, x, list) {
-    let idx = 0;
-    const len = list.length;
-
-    while (idx < len) {
-      if (pred(x, list[idx])) {
-        return true
-      }
-
-      idx += 1;
-    }
-
-    return false
-  }
-  function _filter(fn, list) {
-    let idx = 0;
-    const len = list.length;
-    const result = [];
-
-    while (idx < len) {
-      if (fn(list[idx])) {
-        result[result.length] = list[idx];
-      }
-
-      idx += 1;
-    }
-
-    return result
-  }
-
-  function innerJoin(pred, xs) {
-    return ys => _filter(x => _includesWith(pred, x, ys), xs)
-  }
-
   const getOccurrences = input => input.match(/{{\s*.+?\s*}}/g);
   const getOccurrenceProp = occurrence => occurrence.replace(/{{\s*|\s*}}/g, '');
 
@@ -979,6 +958,40 @@
     return listB => filter(x => includes(x)(listA))(listB)
   }
 
+  function _includesWith(pred, x, list) {
+    let idx = 0;
+    const len = list.length;
+
+    while (idx < len) {
+      if (pred(x, list[idx])) {
+        return true
+      }
+
+      idx += 1;
+    }
+
+    return false
+  }
+  function _filter(fn, list) {
+    let idx = 0;
+    const len = list.length;
+    const result = [];
+
+    while (idx < len) {
+      if (fn(list[idx])) {
+        result[result.length] = list[idx];
+      }
+
+      idx += 1;
+    }
+
+    return result
+  }
+
+  function intersectionWith(pred, xs) {
+    return ys => _filter(x => _includesWith(pred, x, ys), xs)
+  }
+
   function intersperse(separator) {
     return list => {
       let index = -1;
@@ -1511,37 +1524,23 @@
     return obj => predicate(obj[property])
   }
 
-  function rangeDescending(start, end) {
-  	const len = start - end;
-  	const willReturn = Array(len);
-
-  	for (let i = 0; i < len; i++) {
-  		willReturn[i] = start - i;
-  	}
-
-  	return willReturn
+  function range(a, b) {
+    const start = b === undefined ? 0 : a;
+    const end = b === undefined ? a : b;
+    if (end<=  start) {
+  		return []
+    }
+    const len = end - start;
+  	return Array.from({ length: len + 1 }, (_, i) => start + i)
   }
 
-  function range(start) {
-    return end => {
-      if (Number.isNaN(Number(start)) || Number.isNaN(Number(end))) {
-        throw new TypeError('Both arguments to range must be numbers')
-      }
-
-      if (end === start) {
-        return []
-      }
-  		if (end < start) return rangeDescending(start,end)
-
-      const len = end - start;
-      const willReturn = Array(len);
-
-      for (let i = 0; i < len; i++) {
-        willReturn[i] = start + i;
-      }
-
-      return willReturn
-    }
+  function rangeDescending(start, b) {
+  	const end = b === undefined ? 0 : b;
+  	if (start <= end) {
+  		return []
+  	}
+    const len = start - end;
+   	return Array.from({ length: len + 1 }, (_, i) => start - i)
   }
 
   function replace(pattern, replacer) {
@@ -1789,6 +1788,18 @@
     }
   }
 
+  function unionWith(predicate, x) {
+    return y => {
+      const filtered = y.filter(yInstance => {
+  			return x.every(xInstance => {
+  				return !predicate(xInstance, yInstance)
+  			})
+      });
+
+      return [...x, ...filtered]
+    }
+  }
+
   function uniq(list) {
     const set = new _Set();
     const willReturn = [];
@@ -1914,6 +1925,7 @@
   exports.createObjectFromKeys = createObjectFromKeys;
   exports.defaultTo = defaultTo;
   exports.descend = descend;
+  exports.difference = difference;
   exports.drop = drop;
   exports.dropLast = dropLast;
   exports.dropLastWhile = dropLastWhile;
@@ -1925,6 +1937,7 @@
   exports.equalsFn = equalsFn;
   exports.evolve = evolve;
   exports.excludes = excludes;
+  exports.exists = exists;
   exports.filter = filter;
   exports.filterAsync = filterAsync;
   exports.filterObject = filterObject;
@@ -1944,9 +1957,9 @@
   exports.indexBy = indexBy;
   exports.indexOf = indexOf;
   exports.init = init;
-  exports.innerJoin = innerJoin;
   exports.interpolate = interpolate;
   exports.intersection = intersection;
+  exports.intersectionWith = intersectionWith;
   exports.intersperse = intersperse;
   exports.join = join;
   exports.last = last;
@@ -1986,6 +1999,7 @@
   exports.propOr = propOr;
   exports.propSatisfies = propSatisfies;
   exports.range = range;
+  exports.rangeDescending = rangeDescending;
   exports.reduce = reduce;
   exports.reject = reject;
   exports.rejectObject = rejectObject;
@@ -2014,6 +2028,7 @@
   exports.tryCatch = tryCatch;
   exports.type = type;
   exports.union = union;
+  exports.unionWith = unionWith;
   exports.uniq = uniq;
   exports.uniqBy = uniqBy;
   exports.uniqWith = uniqWith;

package/index.d.cts

@@ -88,6 +88,8 @@ MergeTypes<
 
 type StrictNonNullable<T> = Exclude<T, null | undefined>;
 
+type ExcludeFalsy<T> = Exclude<T, null | undefined | false | true | 0 | "">;
+
 type Flatten<T> = T extends object
 	? T extends readonly any[]
 		? T
@@ -198,8 +200,8 @@ export function anyPass<F extends (...args: any[]) => boolean>(predicates: reado
 /**
  * It adds element `x` at the end of `iterable`.
  */
-export function append<T>(el: T): (list: T[]) => T[];
 export function append<T>(el: T): (list: readonly T[]) => T[];
+export function append<T>(el: T): (list: T[]) => T[];
 
 /**
  * Helper function to be used with `R.sort` to sort list in ascending order.
@@ -275,6 +277,13 @@ export function defaultTo<T>(defaultValue: T): (input: unknown) => T;
  */
 export function descend<T>(fn: (obj: T) => Ord): (a: T, b: T)=> Ordering;
 
+/**
+ * It returns a merged list of `x` and `y` with all equal elements removed.
+ * 
+ * `R.equals` is used to determine equality.
+ */
+export function difference<T>(x: T[]): (y: T[]) => T[];
+
 /**
  * It returns `howMany` items dropped from beginning of list.
  */
@@ -323,8 +332,13 @@ export function evolve<T>(rules: {
  * 
  * `R.equals` is used to determine equality.
  */
-export function excludes<T extends string>(valueToFind: T): (input: string) => boolean;
-export function excludes<T>(valueToFind: T): (input: T[]) => boolean;
+export function excludes(list: readonly string[] | string): (substringToFind: string) => boolean;
+export function excludes<T>(list: readonly T[]): (target: T) => boolean;
+
+/**
+ * It returns `true` if there is at least one element in `list` that satisfy the `predicate`.
+ */
+export function exists<T>(predicate: (x: T) => boolean): (list: T[]) => boolean;
 
 /**
  * It filters list or object `input` using a `predicate` function.
@@ -334,10 +348,10 @@ export function filter<T, S extends T>(
 ): (list: T[]) => S[];
 export function filter<T>(
 	predicate: BooleanConstructor,
-): (list: readonly T[]) => StrictNonNullable<T>[];
+): (list: readonly T[]) => ExcludeFalsy<T>[];
 export function filter<T>(
 	predicate: BooleanConstructor,
-): (list: T[]) => StrictNonNullable<T>[];
+): (list: T[]) => ExcludeFalsy<T>[];
 export function filter<T>(
 	predicate: (value: T) => boolean,
 ): (list: T[]) => T[];
@@ -428,8 +442,8 @@ export function head<T>(listOrString: T): T extends string ? string :
  * 
  * If `input` is array, then `R.equals` is used to define if `valueToFind` belongs to the list.
  */
-export function includes(s: string): (list: readonly string[] | string) => boolean;
-export function includes<T>(target: T): (list: readonly T[]) => boolean;
+export function includes<T>(list: readonly T[]): (target: T) => boolean;
+export function includes(list: readonly string[] | string): (substringToFind: string) => boolean;
 
 /**
  * It transforms list of objects to object using specified property as the base for the returned object.
@@ -455,14 +469,6 @@ export function indexOf<T>(valueToFind: T): (list: T[]) => number;
 export function init<T extends unknown[]>(input: T): T extends readonly [...infer U, any] ? U : [...T];
 export function init(input: string): string;
 
-/**
- * It returns a new list by applying a `predicate` function to all elements of `list1` and `list2` and keeping only these elements where `predicate` returns `true`.
- */
-export function innerJoin<T1, T2>(
-  pred: (a: T1, b: T2) => boolean,
-  list1: T1[],
-): (list2: T2[]) => T1[];
-
 /**
  * It generates a new string from `inputWithTags` by replacing all `{{x}}` occurrences with values provided by `templateArguments`.
  */
@@ -473,6 +479,14 @@ export function interpolate(inputWithTags: string): (templateArguments: object)
  */
 export function intersection<T>(listA: T[]): (listB: T[]) => T[];
 
+/**
+ * It returns a new list by applying a `predicate` function to all elements of `list1` and `list2` and keeping only these elements where `predicate` returns `true`.
+ */
+export function intersectionWith<T1, T2>(
+  pred: (a: T1, b: T2) => boolean,
+  list1: T1[],
+): (list2: T2[]) => T1[];
+
 /**
  * It adds a `separator` between members of `list`.
  */
@@ -1778,10 +1792,16 @@ export function propOr<T, P extends string>(property: P, defaultValue: T): (obj:
 export function propSatisfies<T>(predicate: (x: T) => boolean, property: string): (obj: Record<PropertyKey, T>) => boolean;
 
 /**
- * It returns list of numbers between `startInclusive` to `endExclusive` markers.
- * If `start` is greater than `end`, then the result will be in descending order.
+ * It returns list of numbers between `startInclusive` to `endInclusive` markers.
  */
-export function range(startInclusive: number): (endExclusive: number) => number[];
+export function range(endInclusive: number) : number[];
+export function range(startInclusive: number, endInclusive: number) : number[];
+
+/**
+ * It returns list of numbers between `endInclusive` to `startInclusive` markers.
+ */
+export function rangeDescending(startInclusive: number, endInclusive: number) : number[];
+export function rangeDescending(endInclusive: number) : number[];
 
 export function reduce<T, TResult>(reducer: (prev: TResult, current: T, i: number) => TResult, initialValue: TResult): (list: T[]) => TResult;
 
@@ -2189,11 +2209,11 @@ export function split(separator: string | RegExp): (str: string) => string[];
 export function splitEvery<T>(sliceLength: number): (input: T[]) => (T[])[];
 
 /**
- * It returns a merged list of `x` and `y` with all equal elements removed.
+ * It returns all items that are in either of the lists, but not in both.
  * 
  * `R.equals` is used to determine equality.
  */
-export function symmetricDifference<T>(x: T[]): <T>(y: T[]) => T[];
+export function symmetricDifference<T>(x: T[]): (y: T[]) => T[];
 
 /**
  * It returns all but the first element of `input`.
@@ -2206,8 +2226,8 @@ export function tail(input: string): string;
  */
 export function take<T>(howMany: number): {
   (input: string): string;
-  (input: T[]): T[];
   (input: readonly T[]): T[];
+  (input: T[]): T[];
 };
 
 /**
@@ -2215,8 +2235,8 @@ export function take<T>(howMany: number): {
  */
 export function takeLast<T>(howMany: number): {
   (input: string): string;
-  (input: T[]): T[];
   (input: readonly T[]): T[];
+  (input: T[]): T[];
 };
 
 export function takeLastWhile<T>(predicate: (x: T) => boolean): (input: T[]) => T[];
@@ -2262,6 +2282,8 @@ export function type(x: any): RambdaTypes;
  */
 export function union<T>(x: T[]): (y: T[]) => T[];
 
+export function unionWith<T>(predicate: (x: T, y: T) => boolean, x: T[]): (y: T[]) => T[];
+
 /**
  * It returns a new array containing only one copy of each element of `list`.
  *