rambda 10.3.4 → 11.0.0

package/index.d.ts

@@ -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`.
  * 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rambda",
-  "version": "10.3.4",
+  "version": "11.0.0",
   "scripts": {
     "out": "yarn populatedocs && yarn populatereadme && yarn build && yarn create-docsify",
     "build": "yarn build:main && yarn build:web && yarn build:esm",

package/rambda.js

@@ -18,6 +18,7 @@ export * from './src/countBy.js'
 export * from './src/createObjectFromKeys.js'
 export * from './src/defaultTo.js'
 export * from './src/descend.js'
+export * from './src/difference.js'
 export * from './src/drop.js'
 export * from './src/dropLast.js'
 export * from './src/dropLastWhile.js'
@@ -28,6 +29,7 @@ export * from './src/eqProps.js'
 export * from './src/equals.js'
 export * from './src/evolve.js'
 export * from './src/excludes.js'
+export * from './src/exists.js'
 export * from './src/filter.js'
 export * from './src/filterAsync.js'
 export * from './src/filterObject.js'
@@ -45,9 +47,9 @@ export * from './src/includes.js'
 export * from './src/indexBy.js'
 export * from './src/indexOf.js'
 export * from './src/init.js'
-export * from './src/innerJoin.js'
 export * from './src/interpolate.js'
 export * from './src/intersection.js'
+export * from './src/intersectionWith.js'
 export * from './src/intersperse.js'
 export * from './src/join.js'
 export * from './src/last.js'
@@ -86,6 +88,7 @@ export * from './src/propEq.js'
 export * from './src/propOr.js'
 export * from './src/propSatisfies.js'
 export * from './src/range.js'
+export * from './src/rangeDescending.js'
 export * from './src/reduce.js'
 export * from './src/reject.js'
 export * from './src/rejectObject.js'
@@ -112,6 +115,7 @@ export * from './src/test.js'
 export * from './src/tryCatch.js'
 export * from './src/type.js'
 export * from './src/union.js'
+export * from './src/unionWith.js'
 export * from './src/uniq.js'
 export * from './src/uniqBy.js'
 export * from './src/uniqWith.js'

package/src/difference.js

@@ -0,0 +1,9 @@
+import { filter } from './filter.js'
+import { includes } from './includes.js'
+
+export function difference(x) {
+	return y => ([
+		...filter(value => !includes(value)(y))(x),
+		...filter(value => !includes(value)(x))(y),
+	])
+}

package/src/exists.js

@@ -0,0 +1,7 @@
+import { find } from './find.js'
+
+export function exists(predicate) {
+  return list => {
+		return find(predicate)(list) !== undefined
+  }
+}

package/src/{innerJoin.js → intersectionWith.js}

@@ -28,6 +28,6 @@ function _filter(fn, list) {
   return result
 }
 
-export function innerJoin(pred, xs) {
+export function intersectionWith(pred, xs) {
   return ys => _filter(x => _includesWith(pred, x, ys), xs)
 }

package/src/range.js

@@ -1,34 +1,9 @@
-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
-}
-
-export 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
+export 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)
 }
-
-

package/src/rangeDescending.js

@@ -0,0 +1,8 @@
+export 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)
+}

package/src/unionWith.js

@@ -0,0 +1,11 @@
+export function unionWith(predicate, x) {
+  return y => {
+    const filtered = y.filter(yInstance => {
+			return x.every(xInstance => {
+				return !predicate(xInstance, yInstance)
+			})
+    })
+
+    return [...x, ...filtered]
+  }
+}