diff --git a/CHANGELOG.md b/CHANGELOG.md
index b8848428..6b37beea 100644
--- a/CHANGELOG.md
+++ b/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`.
diff --git a/README.md b/README.md
index 9682287e..efed3f30 100644
--- a/README.md
+++ b/README.md
@@ -532,7 +532,6 @@ 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 = [
@@ -540,12 +539,12 @@ const list = [
   [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`.
diff --git a/dist/rambda.cjs b/dist/rambda.cjs
index 999bcce3..9e439af6 100644
--- a/dist/rambda.cjs
+++ b/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) {
diff --git a/dist/rambda.js b/dist/rambda.js
index 731667f3..c87c3ebb 100644
--- a/dist/rambda.js
+++ b/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) {
diff --git a/dist/rambda.umd.js b/dist/rambda.umd.js
index ce93fa93..8b932614 100644
--- a/dist/rambda.umd.js
+++ b/dist/rambda.umd.js
@@ -485,8 +485,8 @@
     return b => equalsFn(a, b)
   }
 
-  function includes(valueToFind) {
-    return iterable => {
+  function includes(iterable) {
+    return valueToFind => {
       if (typeof iterable === 'string') {
         return iterable.includes(valueToFind)
       }
@@ -501,10 +501,14 @@
     }
   }
 
-  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),
   	])
   }
 
@@ -640,10 +644,6 @@
     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;
@@ -955,7 +955,7 @@
   }
 
   function intersection(listA) {
-    return listB => filter(x => includes(x)(listA))(listB)
+    return listB => filter(includes(listA))(listB)
   }
 
   function _includesWith(pred, x, list) {
@@ -1673,11 +1673,11 @@
     }
   }
 
-  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) {
@@ -1774,18 +1774,11 @@
     }
   }
 
-  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) {
diff --git a/docs/README.md b/docs/README.md
index 9682287e..efed3f30 100644
--- a/docs/README.md
+++ b/docs/README.md
@@ -532,7 +532,6 @@ 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 = [
@@ -540,12 +539,12 @@ const list = [
   [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`.
diff --git a/source/allPass.spec.js b/source/allPass.spec.js
index 2487f88d..1566af05 100644
--- a/source/allPass.spec.js
+++ b/source/allPass.spec.js
@@ -1,6 +1,5 @@
 import { allPass } from './allPass.js'
 import { filter } from './filter.js'
-import { includes } from './includes.js'
 import { pipe } from './pipe.js'
 
 const list = [
@@ -8,11 +7,11 @@ const list = [
   [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([])
 })
diff --git a/source/difference.js b/source/difference.js
index 64af0b8e..86bfc8a5 100644
--- a/source/difference.js
+++ b/source/difference.js
@@ -1,9 +1,9 @@
 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),
 	])
 }
diff --git a/source/excludes.js b/source/excludes.js
index 403f668a..40b82a63 100644
--- a/source/excludes.js
+++ b/source/excludes.js
@@ -1,5 +1,5 @@
 import { includes } from './includes.js'
 
-export function excludes(valueToFind) {
-  return iterable => !includes(valueToFind)(iterable)
+export function excludes(iterable) {
+  return valueToFind => !includes(iterable)(valueToFind)
 }
diff --git a/source/excludes.spec.js b/source/excludes.spec.js
index ec72d1e4..fc0e34c5 100644
--- a/source/excludes.spec.js
+++ b/source/excludes.spec.js
@@ -3,13 +3,13 @@ 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()
 })
diff --git a/source/includes.js b/source/includes.js
index b10e87f6..e2854e47 100644
--- a/source/includes.js
+++ b/source/includes.js
@@ -1,8 +1,8 @@
 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)
     }
diff --git a/source/includes.spec.js b/source/includes.spec.js
index 5474b870..e8ca17c4 100644
--- a/source/includes.spec.js
+++ b/source/includes.spec.js
@@ -3,29 +3,29 @@ 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()
-})
+})
\ No newline at end of file
diff --git a/source/intersection.js b/source/intersection.js
index 9d696eef..ea348283 100644
--- a/source/intersection.js
+++ b/source/intersection.js
@@ -2,5 +2,5 @@ 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)
 }
diff --git a/source/symmetricDifference.js b/source/symmetricDifference.js
index 8915fdca..1dd5759e 100644
--- a/source/symmetricDifference.js
+++ b/source/symmetricDifference.js
@@ -1,9 +1,9 @@
 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),
+	]
 }
diff --git a/source/union.js b/source/union.js
index 9e4159a5..d7aeb952 100644
--- a/source/union.js
+++ b/source/union.js
@@ -1,16 +1,8 @@
-import { cloneList } from './_internals/cloneList.js'
-import { includes } from './includes.js'
+import { excludes } from './excludes.js'
 
-export function union(x) {
-  return y => {
-    const toReturn = cloneList(x)
-
-    y.forEach(yInstance => {
-      if (!includes(yInstance)(x)) {
-        toReturn.push(yInstance)
-      }
-    })
-
-    return toReturn
-  }
+export function union(listA) {
+  return listB => [
+		...listA,
+		...listB.filter(excludes(listA)),
+	]
 }
diff --git a/src/difference.js b/src/difference.js
index 64af0b8e..86bfc8a5 100644
--- a/src/difference.js
+++ b/src/difference.js
@@ -1,9 +1,9 @@
 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),
 	])
 }
diff --git a/src/excludes.js b/src/excludes.js
index 403f668a..40b82a63 100644
--- a/src/excludes.js
+++ b/src/excludes.js
@@ -1,5 +1,5 @@
 import { includes } from './includes.js'
 
-export function excludes(valueToFind) {
-  return iterable => !includes(valueToFind)(iterable)
+export function excludes(iterable) {
+  return valueToFind => !includes(iterable)(valueToFind)
 }
diff --git a/src/includes.js b/src/includes.js
index b10e87f6..e2854e47 100644
--- a/src/includes.js
+++ b/src/includes.js
@@ -1,8 +1,8 @@
 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)
     }
diff --git a/src/intersection.js b/src/intersection.js
index 9d696eef..ea348283 100644
--- a/src/intersection.js
+++ b/src/intersection.js
@@ -2,5 +2,5 @@ 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)
 }
diff --git a/src/symmetricDifference.js b/src/symmetricDifference.js
index 8915fdca..1dd5759e 100644
--- a/src/symmetricDifference.js
+++ b/src/symmetricDifference.js
@@ -1,9 +1,9 @@
 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),
+	]
 }
diff --git a/src/union.js b/src/union.js
index 9e4159a5..d7aeb952 100644
--- a/src/union.js
+++ b/src/union.js
@@ -1,16 +1,8 @@
-import { cloneList } from './_internals/cloneList.js'
-import { includes } from './includes.js'
+import { excludes } from './excludes.js'
 
-export function union(x) {
-  return y => {
-    const toReturn = cloneList(x)
-
-    y.forEach(yInstance => {
-      if (!includes(yInstance)(x)) {
-        toReturn.push(yInstance)
-      }
-    })
-
-    return toReturn
-  }
+export function union(listA) {
+  return listB => [
+		...listA,
+		...listB.filter(excludes(listA)),
+	]
 }