Add missing JS change for R.includes and R.excludes methods

CHANGELOG.md

@@ -1,3 +1,7 @@
+11.0.1
+
+- Add missing JS change for `R.includes` and `R.excludes` methods in `11.0.0` release.
+
 11.0.0
 
 - Breaking change: `R.includes` and `R.excludes` now accept list as first argument and value to search as second argument. This makes it more useful when used with `R.filter` and `R.reject`.

README.md

@@ -532,20 +532,19 @@ export function allPass(predicates) {
 ```javascript
 import { allPass } from './allPass.js'
 import { filter } from './filter.js'
-import { includes } from './includes.js'
 import { pipe } from './pipe.js'
 
 const list = [
   [1, 2, 3, 4],
   [3, 4, 5],
 ]
 test('happy', () => {
-  const result = pipe(list, filter(allPass([includes(2), includes(3)])))
+  const result = pipe(list, filter(allPass([x => x.includes(2), x => x.includes(3)])))
   expect(result).toEqual([[1, 2, 3, 4]])
 })
 
 test('when returns false', () => {
-  const result = pipe(list, filter(allPass([includes(12), includes(31)])))
+  const result = pipe(list, filter(allPass([x => x.includes(12), x => x.includes(31)])))
   expect(result).toEqual([])
 })
 ```
@@ -2029,12 +2028,12 @@ difference<T>(x: T[]): (y: T[]) => T[];
 
 ```javascript
 import { filter } from './filter.js'
-import { includes } from './includes.js'
+import { excludes } from './excludes.js'
 
-export function difference(x) {
-	return y => ([
-		...filter(value => !includes(value)(y))(x),
-		...filter(value => !includes(value)(x))(y),
+export function difference(listA) {
+	return listB => ([
+		...filter(value => excludes(listB)(value))(listA),
+		...filter(value => excludes(listA)(value))(listB),
 	])
 }
 ```
@@ -3350,8 +3349,8 @@ excludes<T>(list: readonly T[]): (target: T) => boolean;
 ```javascript
 import { includes } from './includes.js'
 
-export function excludes(valueToFind) {
-  return iterable => !includes(valueToFind)(iterable)
+export function excludes(iterable) {
+  return valueToFind => !includes(iterable)(valueToFind)
 }
 ```
 
@@ -3367,15 +3366,15 @@ import { excludes } from './excludes.js'
 test('excludes with string', () => {
   const str = 'more is less'
 
-  expect(excludes('less')(str)).toBeFalsy()
-  expect(excludes('never')(str)).toBeTruthy()
+  expect(excludes(str)('less')).toBeFalsy()
+  expect(excludes(str)('never')).toBeTruthy()
 })
 
 test('excludes with array', () => {
   const arr = [1, 2, 3]
 
-  expect(excludes(2)(arr)).toBeFalsy()
-  expect(excludes(4)(arr)).toBeTruthy()
+  expect(excludes(arr)(2)).toBeFalsy()
+  expect(excludes(arr)(4)).toBeTruthy()
 })
 ```
 
@@ -5034,8 +5033,8 @@ includes(list: readonly string[] | string): (substringToFind: string) => boolean
 import { isArray } from './_internals/isArray.js'
 import { _indexOf } from './equals.js'
 
-export function includes(valueToFind) {
-  return iterable => {
+export function includes(iterable) {
+  return valueToFind => {
     if (typeof iterable === 'string') {
       return iterable.includes(valueToFind)
     }
@@ -5063,30 +5062,30 @@ import { includes } from './includes.js'
 test('with string as iterable', () => {
   const str = 'foo bar'
 
-  expect(includes('bar')(str)).toBeTruthy()
-  expect(includes('never')(str)).toBeFalsy()
+  expect(includes(str)('foo')).toBeTruthy()
+  expect(includes(str)('never')).toBeFalsy()
 })
 
 test('with array as iterable', () => {
   const arr = [1, 2, 3]
 
-  expect(includes(2)(arr)).toBeTruthy()
-  expect(includes(4)(arr)).toBeFalsy()
+  expect(includes(arr)(2)).toBeTruthy()
+  expect(includes(arr)(4)).toBeFalsy()
 })
 
 test('with list of objects as iterable', () => {
   const arr = [{ a: 1 }, { b: 2 }, { c: 3 }]
 
-  expect(includes({ c: 3 })(arr)).toBeTruthy()
+  expect(includes(arr)({ c: 3 })).toBeTruthy()
 })
 
 test('with NaN', () => {
-  const result = includes(Number.NaN)([Number.NaN])
+  const result = includes([Number.NaN])(Number.NaN)
   expect(result).toBeTruthy()
 })
 
 test('with wrong input that does not throw', () => {
-  const result = includes(1)(/foo/g)
+  const result = includes([1])(/foo/g)
   expect(result).toBeFalsy()
 })
 ```
@@ -5573,7 +5572,7 @@ import { filter } from './filter.js'
 import { includes } from './includes.js'
 
 export function intersection(listA) {
-  return listB => filter(x => includes(x)(listA))(listB)
+  return listB => filter(includes(listA))(listB)
 }
 ```
 
@@ -11638,13 +11637,13 @@ symmetricDifference<T>(x: T[]): (y: T[]) => T[];
 
 ```javascript
 import { filter } from './filter.js'
-import { includes } from './includes.js'
+import { excludes } from './excludes.js'
 
-export function symmetricDifference(x) {
-  return y => [
-    ...filter(value => !includes(value)(y))(x),
-    ...filter(value => !includes(value)(x))(y),
-  ]
+export function symmetricDifference(listA) {
+	return listB => [
+		...filter(excludes(listB))(listA),
+		...filter(excludes(listA))(listB),
+	]
 }
 ```
 
@@ -12777,21 +12776,13 @@ union<T>(x: T[]): (y: T[]) => T[];
 <summary><strong>R.union</strong> source</summary>
 
 ```javascript
-import { cloneList } from './_internals/cloneList.js'
-import { includes } from './includes.js'
-
-export function union(x) {
-  return y => {
-    const toReturn = cloneList(x)
-
-    y.forEach(yInstance => {
-      if (!includes(yInstance)(x)) {
-        toReturn.push(yInstance)
-      }
-    })
+import { excludes } from './excludes.js'
 
-    return toReturn
-  }
+export function union(listA) {
+  return listB => [
+		...listA,
+		...listB.filter(excludes(listA)),
+	]
 }
 ```
 
@@ -13982,6 +13973,10 @@ describe('R.zipWith', () => {
 
 ## ❯ CHANGELOG
 
+11.0.1
+
+- Add missing JS change for `R.includes` and `R.excludes` methods in `11.0.0` release.
+
 11.0.0
 
 - Breaking change: `R.includes` and `R.excludes` now accept list as first argument and value to search as second argument. This makes it more useful when used with `R.filter` and `R.reject`.

dist/rambda.cjs

@@ -481,8 +481,8 @@ function equals(a) {
   return b => equalsFn(a, b)
 }
 
-function includes(valueToFind) {
-  return iterable => {
+function includes(iterable) {
+  return valueToFind => {
     if (typeof iterable === 'string') {
       return iterable.includes(valueToFind)
     }
@@ -497,10 +497,14 @@ function includes(valueToFind) {
   }
 }
 
-function difference(x) {
-	return y => ([
-		...filter(value => !includes(value)(y))(x),
-		...filter(value => !includes(value)(x))(y),
+function excludes(iterable) {
+  return valueToFind => !includes(iterable)(valueToFind)
+}
+
+function difference(listA) {
+	return listB => ([
+		...filter(value => excludes(listB)(value))(listA),
+		...filter(value => excludes(listA)(value))(listB),
 	])
 }
 
@@ -636,10 +640,6 @@ function evolve(rules) {
   return mapObject((x, prop) => type(rules[prop]) === 'Function' ? rules[prop](x): x)
 }
 
-function excludes(valueToFind) {
-  return iterable => !includes(valueToFind)(iterable)
-}
-
 function find(predicate) {
   return list => {
     let index = 0;
@@ -951,7 +951,7 @@ function interpolate(input) {
 }
 
 function intersection(listA) {
-  return listB => filter(x => includes(x)(listA))(listB)
+  return listB => filter(includes(listA))(listB)
 }
 
 function _includesWith(pred, x, list) {
@@ -1669,11 +1669,11 @@ function splitEvery(sliceLength) {
   }
 }
 
-function symmetricDifference(x) {
-  return y => [
-    ...filter(value => !includes(value)(y))(x),
-    ...filter(value => !includes(value)(x))(y),
-  ]
+function symmetricDifference(listA) {
+	return listB => [
+		...filter(excludes(listB))(listA),
+		...filter(excludes(listA))(listB),
+	]
 }
 
 function tail(listOrString) {
@@ -1770,18 +1770,11 @@ function tryCatch(fn, fallback) {
   }
 }
 
-function union(x) {
-  return y => {
-    const toReturn = cloneList(x);
-
-    y.forEach(yInstance => {
-      if (!includes(yInstance)(x)) {
-        toReturn.push(yInstance);
-      }
-    });
-
-    return toReturn
-  }
+function union(listA) {
+  return listB => [
+		...listA,
+		...listB.filter(excludes(listA)),
+	]
 }
 
 function unionWith(predicate, x) {

dist/rambda.js

@@ -479,8 +479,8 @@ function equals(a) {
   return b => equalsFn(a, b)
 }
 
-function includes(valueToFind) {
-  return iterable => {
+function includes(iterable) {
+  return valueToFind => {
     if (typeof iterable === 'string') {
       return iterable.includes(valueToFind)
     }
@@ -495,10 +495,14 @@ function includes(valueToFind) {
   }
 }
 
-function difference(x) {
-	return y => ([
-		...filter(value => !includes(value)(y))(x),
-		...filter(value => !includes(value)(x))(y),
+function excludes(iterable) {
+  return valueToFind => !includes(iterable)(valueToFind)
+}
+
+function difference(listA) {
+	return listB => ([
+		...filter(value => excludes(listB)(value))(listA),
+		...filter(value => excludes(listA)(value))(listB),
 	])
 }
 
@@ -634,10 +638,6 @@ function evolve(rules) {
   return mapObject((x, prop) => type(rules[prop]) === 'Function' ? rules[prop](x): x)
 }
 
-function excludes(valueToFind) {
-  return iterable => !includes(valueToFind)(iterable)
-}
-
 function find(predicate) {
   return list => {
     let index = 0;
@@ -949,7 +949,7 @@ function interpolate(input) {
 }
 
 function intersection(listA) {
-  return listB => filter(x => includes(x)(listA))(listB)
+  return listB => filter(includes(listA))(listB)
 }
 
 function _includesWith(pred, x, list) {
@@ -1667,11 +1667,11 @@ function splitEvery(sliceLength) {
   }
 }
 
-function symmetricDifference(x) {
-  return y => [
-    ...filter(value => !includes(value)(y))(x),
-    ...filter(value => !includes(value)(x))(y),
-  ]
+function symmetricDifference(listA) {
+	return listB => [
+		...filter(excludes(listB))(listA),
+		...filter(excludes(listA))(listB),
+	]
 }
 
 function tail(listOrString) {
@@ -1768,18 +1768,11 @@ function tryCatch(fn, fallback) {
   }
 }
 
-function union(x) {
-  return y => {
-    const toReturn = cloneList(x);
-
-    y.forEach(yInstance => {
-      if (!includes(yInstance)(x)) {
-        toReturn.push(yInstance);
-      }
-    });
-
-    return toReturn
-  }
+function union(listA) {
+  return listB => [
+		...listA,
+		...listB.filter(excludes(listA)),
+	]
 }
 
 function unionWith(predicate, x) {