rambda 7.4.0 → 8.0.0

package/CHANGELOG.md

@@ -1,3 +1,34 @@
+8.0.0
+
+- handle falsy values in merge methods - https://github.com/ramda/ramda/pull/3222
+
+- `R.head`/`R.last` don't return `undefined` for non-empty arrays
+
+- `R.type` supports dates in TS definition - `Rambda` already did support dates in JS.
+
+- Improve typings of `R.endsWith/startsWith` with regard to `string` input. - [PR #622](https://github.com/selfrefactor/rambda/pull/622)
+
+- Handle list as falsy value in `R.reduce` - [Ramda MR](https://github.com/ramda/ramda/pull/2997/files)
+
+- `R.nop` is removed - it will be moved to `Rambdax` as `R.noop`
+
+- `R.includes` is no longer using string literal in Typescript definitions
+
+> Reason for breaking change - synchronize with Ramda `0.29.0` release:
+
+- change order of `R.propEq` - [Ramda MR](https://github.com/ramda/ramda/pull/2938/files)
+
+
+7.5.0
+
+- IMPORTANT: Remove `export` property in `package.json` in order to allow `Rambda`  support for projects with `"type": "module"` in `package.json` - [Issue #667](https://github.com/selfrefactor/rambda/issues/657)
+
+- Add `R.unnest` - [Rambdax issue 89](https://github.com/selfrefactor/rambdax/issues/89)
+
+- `R.uniq` is not using `R.equals` as Ramda does - [Issue #88](https://github.com/selfrefactor/rambdax/issues/88)
+
+- Fix `R.path(['non','existing','path'], obj)` TS definition as 7.4.0 release caused TS errors - [Issue #668](https://github.com/selfrefactor/rambda/issues/668)
+
 7.4.0
 
 - Synchronize with `@types/ramda` - `R.prop`, `R.path`, `R.pickAll`

package/README.md

@@ -61,12 +61,6 @@ R.add(1)('foo') // => will trigger warning in VSCode
 Ramda.add(1)('foo') // => will not trigger warning in VSCode
 ```
 
-### Smaller size
-
-The size of a library affects not only the build bundle size but also the dev bundle size and build time. This is important advantage, expecially for big projects.
-
-<!-- ### Tree-shaking -->
-
 ### Dot notation for `R.path`, `R.paths`, `R.assocPath` and `R.lensPath`
 
 Standard usage of `R.path` is `R.path(['a', 'b'], {a: {b: 1} })`.
@@ -102,11 +96,12 @@ Closing the issue is usually accompanied by publishing a new patch version of `R
 
 <details>
 <summary>
-  Click to see the full list of 77 Ramda methods not implemented in Rambda 
+  Click to see the full list of 80 Ramda methods not implemented in Rambda 
 </summary>
 
 - __
 - addIndex
+- addIndexRight
 - ap
 - aperture
 - applyTo
@@ -121,6 +116,7 @@ Closing the issue is usually accompanied by publishing a new patch version of `R
 - descend
 - differenceWith
 - dissocPath
+- dropRepeatsBy
 - empty
 - eqBy
 - forEachObjIndexed
@@ -134,6 +130,7 @@ Closing the issue is usually accompanied by publishing a new patch version of `R
 - invert
 - invertObj
 - invoker
+- isNotNil
 - keysIn
 - lift
 - liftN
@@ -166,6 +163,7 @@ Closing the issue is usually accompanied by publishing a new patch version of `R
 - sequence
 - sortWith
 - splitWhenever
+- swap
 - symmetricDifferenceWith
 - andThen
 - toPairsIn
@@ -175,7 +173,6 @@ Closing the issue is usually accompanied by publishing a new patch version of `R
 - uncurryN
 - unfold
 - unionWith
-- unnest
 - until
 - useWith
 - valuesIn
@@ -240,7 +237,7 @@ There are methods which are benchmarked only with `Ramda` and `Rambda`(i.e. no `
 
 Note that some of these methods, are called with and without curring. This is done in order to give more detailed performance feedback.
 
-The benchmarks results are produced from latest versions of *Rambda*, *Lodash*(4.17.21) and *Ramda*(0.28.0).
+The benchmarks results are produced from latest versions of *Rambda*, *Lodash*(4.17.21) and *Ramda*(0.29.0).
 
 </summary>
 
@@ -316,6 +313,8 @@ method | Rambda | Ramda | Lodash
 
 ## ❯ Used by
 
+- [ESLint plugin Mocha](https://www.npmjs.com/package/eslint-plugin-mocha)
+
 - [WatermelonDB](https://github.com/Nozbe/WatermelonDB)
 
 - [Walmart Canada](https://www.walmart.ca) reported by [w-b-dev](https://github.com/w-b-dev) 
@@ -2623,7 +2622,7 @@ It returns the uniq set of all elements in the first list `a` not contained in t
 
 `R.equals` is used to determine equality.
 
-<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20a%20%3D%20%5B%201%2C%202%2C%203%2C%204%20%5D%0Aconst%20b%20%3D%20%5B%203%2C%204%2C%205%2C%206%20%5D%0A%0Aconst%20result%20%3D%20difference(a%2C%20b)%0A%2F%2F%20%3D%3E%20%5B%201%2C%202%20%5D">Try this <strong>R.difference</strong> example in Rambda REPL</a>
+<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20a%20%3D%20%5B%201%2C%202%2C%203%2C%204%20%5D%0Aconst%20b%20%3D%20%5B%203%2C%204%2C%205%2C%206%20%5D%0A%0Aconst%20result%20%3D%20R.difference(a%2C%20b)%0A%2F%2F%20%3D%3E%20%5B%201%2C%202%20%5D">Try this <strong>R.difference</strong> example in Rambda REPL</a>
 
 <details>
 
@@ -8148,8 +8147,6 @@ export function mergeDeepRight(target, source){
 <summary><strong>Tests</strong></summary>
 
 ```javascript
-import { mergeDeepRight as mergeDeepRightRamda } from 'ramda'
-
 import { mergeDeepRight } from './mergeDeepRight.js'
 
 const student = {
@@ -8166,6 +8163,23 @@ const teacher = {
   songs   : { title : 'Remains the same' },
 }
 
+test('when merging object with lists inside them', () => {
+  const a = {
+    a : [ 1, 2, 3 ],
+    b : [ 4, 5, 6 ],
+  }
+  const b = {
+    a : [ 7, 8, 9 ],
+    b : [ 10, 11, 12 ],
+  }
+  const result = mergeDeepRight(a, b)
+  const expected = {
+    a : [ 7, 8, 9 ],
+    b : [ 10, 11, 12 ],
+  }
+  expect(result).toEqual(expected)
+})
+
 test('happy', () => {
   const result = mergeDeepRight(student, teacher)
   const curryResult = mergeDeepRight(student)(teacher)
@@ -8390,7 +8404,7 @@ describe('R.mergeLeft', () => {
 
 ### mergeRight
 
-It creates a copy of `target` object with overidden `newProps` properties. Previously known as `R.merge` but renamed after Ramda did the same.
+It creates a copy of `target` object with overwritten `newProps` properties. Previously known as `R.merge` but renamed after Ramda did the same.
 
 <a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20target%20%3D%20%7B%20'foo'%3A%200%2C%20'bar'%3A%201%20%7D%0Aconst%20newProps%20%3D%20%7B%20'foo'%3A%207%20%7D%0A%0Aconst%20result%20%3D%20R.mergeRight(target%2C%20newProps)%0A%2F%2F%20%3D%3E%20%7B%20'foo'%3A%207%2C%20'bar'%3A%201%20%7D">Try this <strong>R.mergeRight</strong> example in Rambda REPL</a>
 
@@ -10330,6 +10344,7 @@ path<
 path<T>(pathToSearch: string, obj: any): T | undefined;
 path<T>(pathToSearch: string): (obj: any) => T | undefined;
 path<T>(pathToSearch: RamdaPath): (obj: any) => T | undefined;
+path<T>(pathToSearch: RamdaPath, obj: any): T | undefined;
 ```
 
 </details>
@@ -10445,12 +10460,31 @@ describe('R.path with list as path', () => {
   test('shallow property', () => {
     // $ExpectType number
     path(['a'], {a: 1})
-    
-    path(['b'], {a: 1}) // $ExpectError
+
+    // $ExpectType unknown
+    path(['b'], {a: 1})
   })
   test('deep property', () => {
+    const testObject = {a: {b: {c: {d: {e: {f: 1}}}}}}
+    const result = path(['a', 'b', 'c', 'd', 'e', 'f'], testObject)
     // $ExpectType number
-    path(['a', 'b', 'c', 'd', 'e', 'f'], {a: {b: {c: {d: {e: {f: 1}}}}}})
+    result
+    const curriedResult = path(['a', 'b', 'c', 'd', 'e', 'f'])(testObject)
+    // $ExpectType unknown
+    curriedResult
+  })
+  test('issue #668 - path is not correct', () => {
+    const object = {
+      is: {
+        a: 'path',
+      },
+    }
+    const result = path(['is', 'not', 'a'], object)
+    // $ExpectType unknown
+    result
+    const curriedResult = path(['is', 'not', 'a'])(object)
+    // $ExpectType unknown
+    curriedResult
   })
 })
 ```
@@ -10885,7 +10919,7 @@ It returns a partial copy of an `input` containing only `propsToPick` properties
 
 `input` can be either an object or an array.
 
-String anotation of `propsToPick` is one of the differences between `Rambda` and `Ramda`.
+String annotation of `propsToPick` is one of the differences between `Rambda` and `Ramda`.
 
 <a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20obj%20%3D%20%7B%0A%20%20a%20%3A%201%2C%0A%20%20b%20%3A%20false%2C%0A%20%20foo%3A%20'cherry'%0A%7D%0Aconst%20list%20%3D%20%5B1%2C%202%2C%203%2C%204%5D%0Aconst%20propsToPick%20%3D%20'a%2Cfoo'%0Aconst%20propsToPickList%20%3D%20%5B'a'%2C%20'foo'%5D%0A%0Aconst%20result%20%3D%20%5B%0A%20%20R.pick(propsToPick%2C%20Record%3Cstring%2C%20unknown%3E)%2C%0A%20%20R.pick(propsToPickList%2C%20Record%3Cstring%2C%20unknown%3E)%2C%0A%20%20R.pick('a%2Cbar'%2C%20Record%3Cstring%2C%20unknown%3E)%2C%0A%20%20R.pick('bar'%2C%20Record%3Cstring%2C%20unknown%3E)%2C%0A%20%20R.pick(%5B0%2C%203%2C%205%5D%2C%20list)%2C%0A%20%20R.pick('0%2C3%2C5'%2C%20list)%2C%0A%5D%0A%0Aconst%20expected%20%3D%20%5B%0A%20%20%7Ba%3A1%2C%20foo%3A%20'cherry'%7D%2C%0A%20%20%7Ba%3A1%2C%20foo%3A%20'cherry'%7D%2C%0A%20%20%7Ba%3A1%7D%2C%0A%20%20%7B%7D%2C%0A%20%20%7B0%3A%201%2C%203%3A%204%7D%2C%0A%20%20%7B0%3A%201%2C%203%3A%204%7D%2C%0A%5D%0A%2F%2F%20%3D%3E%20%60result%60%20is%20equal%20to%20%60expected%60">Try this <strong>R.pick</strong> example in Rambda REPL</a>
 
@@ -14362,17 +14396,16 @@ export function takeLastWhile(predicate, input){
     return _input => takeLastWhile(predicate, _input)
   }
   if (input.length === 0) return input
-  let found = false
+
   const toReturn = []
   let counter = input.length
 
-  while (!found || counter === 0){
-    counter--
-    if (predicate(input[ counter ]) === false){
-      found = true
-    } else if (!found){
-      toReturn.push(input[ counter ])
+  while (counter){
+    const item = input[ --counter ]
+    if (!predicate(item)){
+      break
     }
+    toReturn.push(item)
   }
 
   return isArray(input) ? toReturn.reverse() : toReturn.reverse().join('')
@@ -14398,13 +14431,13 @@ test('happy', () => {
 })
 
 test('predicate is always true', () => {
-  const predicate = x => x > 0
+  const predicate = () => true
   const result = takeLastWhile(predicate)(list)
   expect(result).toEqual(list)
 })
 
 test('predicate is always false', () => {
-  const predicate = x => x < 0
+  const predicate = () => false
   const result = takeLastWhile(predicate, list)
   expect(result).toEqual([])
 })
@@ -14470,7 +14503,7 @@ tap<T>(fn: (x: T) => void, input: T): T
 
 It applies function `fn` to input `x` and returns `x`. 
 
-One use case is debuging in the middle of `R.compose`.
+One use case is debugging in the middle of `R.compose`.
 
 <a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20list%20%3D%20%5B1%2C%202%2C%203%5D%0A%0AR.compose(%0A%20%20R.map(x%20%3D%3E%20x%20*%202)%0A%20%20R.tap(console.log)%2C%0A%20%20R.filter(x%20%3D%3E%20x%20%3E%201)%0A)(list)%0A%2F%2F%20%3D%3E%20%602%60%20and%20%603%60%20will%20be%20logged">Try this <strong>R.tap</strong> example in Rambda REPL</a>
 
@@ -15516,7 +15549,11 @@ describe('R.uniq', () => {
 
 ### uniqBy
 
-<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20result%20%3D%20R.uniqBy(Math.abs%2C%20%5B%20-2%2C%201%2C%200%2C%20-1%2C%202%20%5D)%0A%0A%2F%2F%20%3D%3E%20%5B-2%2C%201%2C%200%5D">Try this <strong>R.uniqBy</strong> example in Rambda REPL</a>
+It applies uniqueness to input list based on function that defines what to be used for comparison between elements.
+
+`R.equals` is used to determine equality.
+
+<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20list%20%3D%20%5B%7Ba%3A1%7D%2C%20%7Ba%3A2%7D%2C%20%7Ba%3A1%7D%5D%0Aconst%20result%20%3D%20R.uniqBy(x%20%3D%3E%20x%2C%20list)%0A%0A%2F%2F%20%3D%3E%20%5B%7Ba%3A1%7D%2C%20%7Ba%3A2%7D%5D">Try this <strong>R.uniqBy</strong> example in Rambda REPL</a>
 
 [![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#uniqBy)
 
@@ -15792,6 +15829,10 @@ describe('R.unless - curried', () => {
 
 [![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#unless)
 
+### unnest
+
+[![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#unnest)
+
 ### unwind
 
 <a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20obj%20%3D%20%7B%0A%20%20a%3A%201%2C%0A%20%20b%3A%20%5B2%2C%203%5D%2C%0A%7D%0Aconst%20result%20%3D%20unwind('b'%2C%20Record%3Cstring%2C%20unknown%3E)%0Aconst%20expected%20%3D%20%5B%7Ba%3A1%2C%20b%3A2%7D%2C%20%7Ba%3A1%2C%20b%3A3%7D%5D%0A%2F%2F%20%3D%3E%20%60result%60%20is%20equal%20to%20%60expected%60">Try this <strong>R.unwind</strong> example in Rambda REPL</a>
@@ -17009,6 +17050,36 @@ describe('R.zipWith', () => {
 
 ## ❯ CHANGELOG
 
+8.0.0
+
+- handle falsy values in merge methods - https://github.com/ramda/ramda/pull/3222
+
+- `R.head`/`R.last` don't return `undefined` for non-empty arrays
+
+- `R.type` supports dates in TS definition - `Rambda` already did support dates in JS.
+
+- Improve typings of `R.endsWith/startsWith` with regard to `string` input. - [PR #622](https://github.com/selfrefactor/rambda/pull/622)
+
+- Handle list as falsy value in `R.reduce` - [Ramda MR](https://github.com/ramda/ramda/pull/2997/files)
+
+- `R.nop` is removed - it will be moved to `Rambdax` as `R.noop`
+
+- `R.includes` is no longer using string literal in Typescript definitions
+
+> Reason for breaking change - synchronize with Ramda `0.29.0` release:
+
+- change order of `R.propEq` - [Ramda MR](https://github.com/ramda/ramda/pull/2938/files)
+
+7.5.0
+
+- IMPORTANT: Remove `export` property in `package.json` in order to allow `Rambda`  support for projects with `"type": "module"` in `package.json` - [Issue #667](https://github.com/selfrefactor/rambda/issues/657)
+
+- Add `R.unnest` - [Rambdax issue 89](https://github.com/selfrefactor/rambdax/issues/89)
+
+- `R.uniq` is not using `R.equals` as Ramda does - [Issue #88](https://github.com/selfrefactor/rambdax/issues/88)
+
+- Fix `R.path(['non','existing','path'], obj)` TS definition as 7.4.0 release caused TS errors - [Issue #668](https://github.com/selfrefactor/rambda/issues/668)
+
 7.4.0
 
 - Synchronize with `@types/ramda` - `R.prop`, `R.path`, `R.pickAll`

package/dist/rambda.js

@@ -324,6 +324,9 @@ class ReduceStopper {
   }
 }
 function reduceFn(reducer, acc, list) {
+  if (list == null) {
+    return acc;
+  }
   if (!isArray(list)) {
     throw new TypeError('reduce: list must be array or iterable');
   }
@@ -764,18 +767,18 @@ function dropLastWhile(predicate, iterable) {
   if (!isArray$1 && typeof iterable !== 'string') {
     throw new Error(`'iterable' is from wrong type ${typeof iterable}`);
   }
-  let found = false;
   const toReturn = [];
   let counter = iterable.length;
-  while (counter > 0) {
-    counter--;
-    if (!found && predicate(iterable[counter]) === false) {
-      found = true;
-      toReturn.push(iterable[counter]);
-    } else if (found) {
-      toReturn.push(iterable[counter]);
+  while (counter) {
+    const item = iterable[--counter];
+    if (!predicate(item)) {
+      toReturn.push(item);
+      break;
     }
   }
+  while (counter) {
+    toReturn.push(iterable[--counter]);
+  }
   return isArray$1 ? toReturn.reverse() : toReturn.reverse().join('');
 }
 
@@ -822,18 +825,19 @@ function dropWhile(predicate, iterable) {
   if (!isArray$1 && typeof iterable !== 'string') {
     throw new Error('`iterable` is neither list nor a string');
   }
-  let flag = false;
-  const holder = [];
-  let counter = -1;
-  while (counter++ < iterable.length - 1) {
-    if (flag) {
-      holder.push(iterable[counter]);
-    } else if (!predicate(iterable[counter])) {
-      if (!flag) flag = true;
-      holder.push(iterable[counter]);
+  const toReturn = [];
+  let counter = 0;
+  while (counter < iterable.length) {
+    const item = iterable[counter++];
+    if (!predicate(item)) {
+      toReturn.push(item);
+      break;
     }
   }
-  return isArray$1 ? holder : holder.join('');
+  while (counter < iterable.length) {
+    toReturn.push(iterable[counter++]);
+  }
+  return isArray$1 ? toReturn : toReturn.join('');
 }
 
 function either(firstPredicate, secondPredicate) {
@@ -1108,11 +1112,7 @@ function createPath(path, delimiter = '.') {
   return typeof path === 'string' ? path.split(delimiter) : path;
 }
 
-function path(pathInput, obj) {
-  if (arguments.length === 1) return _obj => path(pathInput, _obj);
-  if (obj === null || obj === undefined) {
-    return undefined;
-  }
+function pathFn(pathInput, obj) {
   let willReturn = obj;
   let counter = 0;
   const pathArrValue = createPath(pathInput);
@@ -1126,6 +1126,13 @@ function path(pathInput, obj) {
   }
   return willReturn;
 }
+function path(pathInput, obj) {
+  if (arguments.length === 1) return _obj => path(pathInput, _obj);
+  if (obj === null || obj === undefined) {
+    return undefined;
+  }
+  return pathFn(pathInput, obj);
+}
 
 function hasPath(pathInput, obj) {
   if (arguments.length === 1) {
@@ -1403,7 +1410,9 @@ function mergeLeft(x, y) {
   return mergeRight(y, x);
 }
 
-function mergeWithFn(mergeFn, a, b) {
+function mergeWithFn(mergeFn, aInput, bInput) {
+  const a = aInput !== null && aInput !== void 0 ? aInput : {};
+  const b = bInput !== null && bInput !== void 0 ? bInput : {};
   const willReturn = {};
   Object.keys(a).forEach(key => {
     if (b[key] === undefined) {
@@ -1456,6 +1465,7 @@ function _objectSpread2(target) {
   return target;
 }
 function _defineProperty(obj, key, value) {
+  key = _toPropertyKey(key);
   if (key in obj) {
     Object.defineProperty(obj, key, {
       value: value,
@@ -1468,6 +1478,20 @@ function _defineProperty(obj, key, value) {
   }
   return obj;
 }
+function _toPrimitive(input, hint) {
+  if (typeof input !== "object" || input === null) return input;
+  var prim = input[Symbol.toPrimitive];
+  if (prim !== undefined) {
+    var res = prim.call(input, hint || "default");
+    if (typeof res !== "object") return res;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (hint === "string" ? String : Number)(input);
+}
+function _toPropertyKey(arg) {
+  var key = _toPrimitive(arg, "string");
+  return typeof key === "symbol" ? key : String(key);
+}
 
 function isIterable(input) {
   return Array.isArray(input) || type(input) === 'Object';
@@ -1535,8 +1559,6 @@ function none(predicate, list) {
   return true;
 }
 
-function nop() {}
-
 function not(input) {
   return !input;
 }
@@ -1730,7 +1752,7 @@ function prepend(x, input) {
 
 const product = reduce(multiply, 1);
 
-function propEqFn(propToFind, valueToMatch, obj) {
+function propEqFn(valueToMatch, propToFind, obj) {
   if (!obj) return false;
   return equals(valueToMatch, prop(propToFind, obj));
 }
@@ -1892,20 +1914,20 @@ function splitWhen(predicate, input) {
   return [preFound, postFound];
 }
 
-function startsWith(target, iterable) {
-  if (arguments.length === 1) return _iterable => startsWith(target, _iterable);
+function startsWith(question, iterable) {
+  if (arguments.length === 1) return _iterable => startsWith(question, _iterable);
   if (typeof iterable === 'string') {
-    return iterable.startsWith(target);
+    return iterable.startsWith(question);
   }
-  if (!isArray(target)) return false;
+  if (!isArray(question)) return false;
   let correct = true;
-  const filtered = target.filter((x, index) => {
+  const filtered = question.filter((x, index) => {
     if (!correct) return false;
     const result = equals(x, iterable[index]);
     if (!result) correct = false;
     return result;
   });
-  return filtered.length === target.length;
+  return filtered.length === question.length;
 }
 
 function subtract(a, b) {
@@ -1939,16 +1961,14 @@ function takeLastWhile(predicate, input) {
     return _input => takeLastWhile(predicate, _input);
   }
   if (input.length === 0) return input;
-  let found = false;
   const toReturn = [];
   let counter = input.length;
-  while (!found || counter === 0) {
-    counter--;
-    if (predicate(input[counter]) === false) {
-      found = true;
-    } else if (!found) {
-      toReturn.push(input[counter]);
+  while (counter) {
+    const item = input[--counter];
+    if (!predicate(item)) {
+      break;
     }
+    toReturn.push(item);
   }
   return isArray(input) ? toReturn.reverse() : toReturn.reverse().join('');
 }
@@ -1961,17 +1981,16 @@ function takeWhile(predicate, iterable) {
   if (!isArray$1 && typeof iterable !== 'string') {
     throw new Error('`iterable` is neither list nor a string');
   }
-  let flag = true;
-  const holder = [];
-  let counter = -1;
-  while (counter++ < iterable.length - 1) {
-    if (!predicate(iterable[counter])) {
-      if (flag) flag = false;
-    } else if (flag) {
-      holder.push(iterable[counter]);
+  const toReturn = [];
+  let counter = 0;
+  while (counter < iterable.length) {
+    const item = iterable[counter++];
+    if (!predicate(item)) {
+      break;
     }
+    toReturn.push(item);
   }
-  return isArray$1 ? holder : holder.join('');
+  return isArray$1 ? toReturn : toReturn.join('');
 }
 
 function tap(fn, x) {
@@ -2057,12 +2076,8 @@ function uniqBy(fn, list) {
   if (arguments.length === 1) {
     return _list => uniqBy(fn, _list);
   }
-  const set = new Set();
-  return list.filter(item => {
-    if (set.has(fn(item))) return false;
-    set.add(fn(item));
-    return true;
-  });
+  const set = new _Set();
+  return list.filter(item => set.checkUniqueness(fn(item)));
 }
 
 function includesWith(predicate, target, list) {
@@ -2096,6 +2111,15 @@ function unless(predicate, whenFalse) {
   return input => predicate(input) ? input : whenFalse(input);
 }
 
+function unnest(list) {
+  return list.reduce((acc, item) => {
+    if (Array.isArray(item)) {
+      return [...acc, ...item];
+    }
+    return [...acc, item];
+  }, []);
+}
+
 function unwind(property, obj) {
   if (arguments.length === 1) {
     return _obj => unwind(property, _obj);
@@ -2315,7 +2339,6 @@ exports.move = move;
 exports.multiply = multiply;
 exports.negate = negate;
 exports.none = none;
-exports.nop = nop;
 exports.not = not;
 exports.nth = nth;
 exports.objOf = objOf;
@@ -2332,6 +2355,7 @@ exports.partitionArray = partitionArray;
 exports.partitionObject = partitionObject;
 exports.path = path;
 exports.pathEq = pathEq;
+exports.pathFn = pathFn;
 exports.pathOr = pathOr;
 exports.paths = paths;
 exports.pick = pick;
@@ -2388,6 +2412,7 @@ exports.uniq = uniq;
 exports.uniqBy = uniqBy;
 exports.uniqWith = uniqWith;
 exports.unless = unless;
+exports.unnest = unnest;
 exports.unwind = unwind;
 exports.update = update;
 exports.updateFn = updateFn;