rambda 7.1.4 → 7.2.0

package/README.md

@@ -98,8 +98,6 @@ R.pick('a,b', {a: 1 , b: 2, c: 3} })
 
 **Rambda** is generally more performant than `Ramda` as the [benchmarks](#-benchmarks) can prove that.
 
-### Deno
-
 ### Support
 
 As the library is smaller than Ramda, issues are much faster resolved.
@@ -112,7 +110,7 @@ Closing the issue is usually accompanied by publishing a new patch version of `R
 
 <details>
 <summary>
-  Click to see the full list of 80 Ramda methods not implemented in Rambda 
+  Click to see the full list of 78 Ramda methods not implemented in Rambda 
 </summary>
 
 - __
@@ -157,7 +155,6 @@ Closing the issue is usually accompanied by publishing a new patch version of `R
 - mergeDeepWithKey
 - mergeWithKey
 - modify
-- modifyPath
 - nAry
 - nthArg
 - o
@@ -187,7 +184,6 @@ Closing the issue is usually accompanied by publishing a new patch version of `R
 - uncurryN
 - unfold
 - unionWith
-- uniqBy
 - unnest
 - until
 - useWith
@@ -261,8 +257,8 @@ method | Rambda | Ramda | Lodash
 --- |--- | --- | ---
  *add* | 🚀 Fastest | 21.52% slower | 82.15% slower
  *adjust* | 8.48% slower | 🚀 Fastest | 🔳
- *all* | 🚀 Fastest | 3.79% slower | 🔳
- *allPass* | 🚀 Fastest | 87.3% slower | 🔳
+ *all* | 🚀 Fastest | 1.81% slower | 🔳
+ *allPass* | 🚀 Fastest | 91.09% slower | 🔳
  *allPass* | 🚀 Fastest | 98.56% slower | 🔳
  *and* | 🚀 Fastest | 89.09% slower | 🔳
  *any* | 🚀 Fastest | 92.87% slower | 45.82% slower
@@ -271,7 +267,7 @@ method | Rambda | Ramda | Lodash
  *applySpec* | 🚀 Fastest | 80.43% slower | 🔳
  *assoc* | 72.32% slower | 60.08% slower | 🚀 Fastest
  *clone* | 🚀 Fastest | 91.86% slower | 86.48% slower
- *compose* | 1.91% slower | 21.6% slower | 🚀 Fastest
+ *compose* | 🚀 Fastest | 32.45% slower | 13.68% slower
  *converge* | 78.63% slower | 🚀 Fastest | 🔳
  *curry* | 🚀 Fastest | 28.86% slower | 🔳
  *curryN* | 🚀 Fastest | 41.05% slower | 🔳
@@ -284,8 +280,8 @@ method | Rambda | Ramda | Lodash
  *findIndex* | 🚀 Fastest | 86.48% slower | 72.27% slower
  *flatten* | 🚀 Fastest | 95.26% slower | 10.27% slower
  *ifElse* | 🚀 Fastest | 58.56% slower | 🔳
- *includes* | 🚀 Fastest | 84.68% slower | 🔳
- *indexOf* | 🚀 Fastest | 83.07% slower | 🔳
+ *includes* | 🚀 Fastest | 84.63% slower | 🔳
+ *indexOf* | 🚀 Fastest | 76.63% slower | 🔳
  *indexOf* | 🚀 Fastest | 82.2% slower | 🔳
  *init* | 🚀 Fastest | 92.24% slower | 13.3% slower
  *is* | 🚀 Fastest | 57.69% slower | 🔳
@@ -301,7 +297,7 @@ method | Rambda | Ramda | Lodash
  *over* | 🚀 Fastest | 56.23% slower | 🔳
  *path* | 37.81% slower | 77.81% slower | 🚀 Fastest
  *pick* | 🚀 Fastest | 19.07% slower | 80.2% slower
- *pipe* | 0.41% slower | 🚀 Fastest | 🔳
+ *pipe* | 0.87% slower | 🚀 Fastest | 🔳
  *prop* | 🚀 Fastest | 87.95% slower | 🔳
  *propEq* | 🚀 Fastest | 91.92% slower | 🔳
  *range* | 🚀 Fastest | 61.8% slower | 57.44% slower
@@ -317,8 +313,8 @@ method | Rambda | Ramda | Lodash
  *takeLast* | 🚀 Fastest | 93.39% slower | 19.22% slower
  *test* | 🚀 Fastest | 82.34% slower | 🔳
  *type* | 🚀 Fastest | 48.6% slower | 🔳
- *uniq* | 🚀 Fastest | 86.73% slower | 🔳
- *uniqWith* | 13.67% slower | 🚀 Fastest | 🔳
+ *uniq* | 🚀 Fastest | 90.24% slower | 🔳
+ *uniqWith* | 18.09% slower | 🚀 Fastest | 🔳
  *uniqWith* | 14.23% slower | 🚀 Fastest | 🔳
  *update* | 🚀 Fastest | 52.35% slower | 🔳
  *view* | 🚀 Fastest | 76.15% slower | 🔳
@@ -727,7 +723,7 @@ describe('all', () => {
 
 <details>
 
-<summary>Rambda is faster than Ramda with 3.79%</summary>
+<summary>Rambda is faster than Ramda with 1.81%</summary>
 
 ```text
 const R = require('../../dist/rambda.js')
@@ -864,7 +860,7 @@ test('works with multiple inputs', () => {
 <summary><strong>Typescript</strong> test</summary>
 
 ```typescript
-import {allPass} from 'rambda'
+import {allPass, filter} from 'rambda'
 
 describe('allPass', () => {
   it('happy', () => {
@@ -880,6 +876,16 @@ describe('allPass', () => {
 
     x // $ExpectType boolean
   })
+  it('issue #642', () => {
+    const isGreater = (num: number) => num > 5;
+    const pred = allPass([isGreater]);
+    const xs = [0, 1, 2, 3];
+    
+    const filtered1 = filter(pred)(xs); 
+    filtered1 // $ExpectType number[]
+    const filtered2 = xs.filter(pred); 
+    filtered2 // $ExpectType number[]
+  })
 })
 ```
 
@@ -887,7 +893,7 @@ describe('allPass', () => {
 
 <details>
 
-<summary>Rambda is faster than Ramda with 87.3%</summary>
+<summary>Rambda is faster than Ramda with 91.09%</summary>
 
 ```text
 const R = require('../../dist/rambda.js')
@@ -1156,7 +1162,7 @@ const any = [
 
 ```typescript
 
-anyPass<T>(predicates: SafePred<T>[]): SafePred<T>
+anyPass<T>(predicates: ((x: T) => boolean)[]): (input: T) => boolean
 ```
 
 It accepts list of `predicates` and returns a function. This function with its `input` will return `true`, if any of `predicates` returns `true` for this `input`.
@@ -1166,7 +1172,7 @@ It accepts list of `predicates` and returns a function. This function with its `
 <summary>All Typescript definitions</summary>
 
 ```typescript
-anyPass<T>(predicates: SafePred<T>[]): SafePred<T>;
+anyPass<T>(predicates: ((x: T) => boolean)[]): (input: T) => boolean;
 ```
 
 </details>
@@ -1211,7 +1217,6 @@ test('happy', () => {
   const rules = [x => typeof x === 'string', x => x > 10]
 
   expect(anyPass(rules)(11)).toBeTrue()
-
   expect(anyPass(rules)(undefined)).toBeFalse()
 })
 
@@ -1253,7 +1258,7 @@ test('works with multiple inputs', () => {
 <summary><strong>Typescript</strong> test</summary>
 
 ```typescript
-import {anyPass} from 'rambda'
+import {anyPass, filter} from 'rambda'
 
 describe('anyPass', () => {
   it('happy', () => {
@@ -1269,6 +1274,16 @@ describe('anyPass', () => {
 
     x // $ExpectType boolean
   })
+  it('issue #642', () => {
+    const isGreater = (num: number) => num > 5;
+    const pred = anyPass([isGreater]);
+    const xs = [0, 1, 2, 3];
+    
+    const filtered1 = filter(pred)(xs); 
+    filtered1 // $ExpectType number[]
+    const filtered2 = xs.filter(pred); 
+    filtered2 // $ExpectType number[]
+  })
 })
 ```
 
@@ -1522,7 +1537,7 @@ describe('R.apply', () => {
 
 ```typescript
 
-applySpec<Spec extends Record<string, (...args: any[]) => any>>(
+applySpec<Spec extends Record<string, AnyFunction>>(
   spec: Spec
 ): (
   ...args: Parameters<ValueOfRecord<Spec>>
@@ -1534,12 +1549,12 @@ applySpec<Spec extends Record<string, (...args: any[]) => any>>(
 <summary>All Typescript definitions</summary>
 
 ```typescript
-applySpec<Spec extends Record<string, (...args: any[]) => any>>(
+applySpec<Spec extends Record<string, AnyFunction>>(
   spec: Spec
 ): (
   ...args: Parameters<ValueOfRecord<Spec>>
 ) => { [Key in keyof Spec]: ReturnType<Spec[Key]> };
-applySpec<T>(spec: any): (...args: any[]) => T;
+applySpec<T>(spec: any): (...args: unknown[]) => T;
 ```
 
 </details>
@@ -2494,7 +2509,7 @@ describe('R.assocPath - curried', () => {
 
 ```typescript
 
-bind<F extends (...args: any[]) => any, T>(fn: F, thisObj: T): (...args: Parameters<F>) => ReturnType<F>
+bind<F extends AnyFunction, T>(fn: F, thisObj: T): (...args: Parameters<F>) => ReturnType<F>
 ```
 
 Creates a function that is bound to a context.
@@ -2504,8 +2519,8 @@ Creates a function that is bound to a context.
 <summary>All Typescript definitions</summary>
 
 ```typescript
-bind<F extends (...args: any[]) => any, T>(fn: F, thisObj: T): (...args: Parameters<F>) => ReturnType<F>;
-bind<F extends (...args: any[]) => any, T>(fn: F): (thisObj: T) => (...args: Parameters<F>) => ReturnType<F>;
+bind<F extends AnyFunction, T>(fn: F, thisObj: T): (...args: Parameters<F>) => ReturnType<F>;
+bind<F extends AnyFunction, T>(fn: F): (thisObj: T) => (...args: Parameters<F>) => ReturnType<F>;
 ```
 
 </details>
@@ -6461,7 +6476,11 @@ describe('R.identity', () => {
 
 ```typescript
 
-ifElse<TArgs extends any[], TOnTrueResult, TOnFalseResult>(fn: (...args: TArgs) => boolean, onTrue: (...args: TArgs) => TOnTrueResult, onFalse: (...args: TArgs) => TOnFalseResult): (...args: TArgs) => TOnTrueResult | TOnFalseResult
+ifElse<T, TFiltered extends T, TOnTrueResult, TOnFalseResult>(
+  pred: (a: T) => a is TFiltered,
+  onTrue: (a: TFiltered) => TOnTrueResult,
+  onFalse: (a: Exclude<T, TFiltered>) => TOnFalseResult,
+): (a: T) => TOnTrueResult | TOnFalseResult
 ```
 
 It expects `condition`, `onTrue` and `onFalse` functions as inputs and it returns a new function with example name of `fn`. 
@@ -6473,6 +6492,11 @@ When `fn`` is called with `input` argument, it will return either `onTrue(input)
 <summary>All Typescript definitions</summary>
 
 ```typescript
+ifElse<T, TFiltered extends T, TOnTrueResult, TOnFalseResult>(
+  pred: (a: T) => a is TFiltered,
+  onTrue: (a: TFiltered) => TOnTrueResult,
+  onFalse: (a: Exclude<T, TFiltered>) => TOnFalseResult,
+): (a: T) => TOnTrueResult | TOnFalseResult;
 ifElse<TArgs extends any[], TOnTrueResult, TOnFalseResult>(fn: (...args: TArgs) => boolean, onTrue: (...args: TArgs) => TOnTrueResult, onFalse: (...args: TArgs) => TOnFalseResult): (...args: TArgs) => TOnTrueResult | TOnFalseResult;
 ```
 
@@ -6624,6 +6648,25 @@ describe('R.ifElse', () => {
     const result = fn(3, 'hello')
     result // $ExpectType string
   })
+  test('DefinitelyTyped#59291', () => {
+    const getLengthIfStringElseDouble = ifElse(
+      (a: string | number): a is string => true,
+      a => a.length,
+      a => a * 2
+    )
+
+    getLengthIfStringElseDouble('foo') // $ExpectType number
+    getLengthIfStringElseDouble(3) // $ExpectType number
+    const result = ifElse(
+      (a: {
+        foo?: string,
+        bar: number | string,
+      }): a is {foo: string, bar: string} => true,
+      (a): [string, string] => [a.foo, a.bar],
+      (a): [string | undefined, string | number] => [a.foo, a.bar]
+    )
+    result // $ExpectType (a: { foo?: string | undefined; bar: string | number; }) => [string, string] | [string | undefined, string | number]
+  })
 })
 ```
 
@@ -6826,7 +6869,7 @@ describe('R.includes', () => {
 
 <details>
 
-<summary>Rambda is faster than Ramda with 84.68%</summary>
+<summary>Rambda is faster than Ramda with 84.63%</summary>
 
 ```text
 const R = require('../../dist/rambda.js')
@@ -8458,6 +8501,9 @@ export function mapArray(
 }
 
 export function mapObject(fn, obj){
+  if (arguments.length === 1){
+    return _obj => mapObject(fn, _obj)
+  }
   let index = 0
   const keys = _keys(obj)
   const len = keys.length
@@ -9241,6 +9287,11 @@ test('ramda compatible test 3', () => {
   }
   expect(result).toEqual(expected)
 })
+
+test('functions are discarded', () => {
+  const obj = { foo : () => {} }
+  expect(mergeDeepRight(obj, {})).toEqual({})
+})
 ```
 
 </details>
@@ -9490,7 +9541,7 @@ const B = {
 describe('R.mergeWith', () => {
   test('no curry | without explicit types', () => {
     const result = mergeWith(concat, A, B)
-    result // $ExpectType Obj
+    result // $ExpectType Record<string, unknown>
   })
   test('no curry | with explicit types', () => {
     const result = mergeWith<Output>(concat, A, B)
@@ -9498,7 +9549,7 @@ describe('R.mergeWith', () => {
   })
   test('curry 1 | without explicit types', () => {
     const result = mergeWith(concat, A)(B)
-    result // $ExpectType Obj
+    result // $ExpectType Record<string, unknown>
   })
   test('curry 1 | with explicit types', () => {
     const result = mergeWith<Output>(concat, A)(B)
@@ -9506,7 +9557,7 @@ describe('R.mergeWith', () => {
   })
   test('curry 2 | without explicit types', () => {
     const result = mergeWith(concat)(A, B)
-    result // $ExpectType Obj
+    result // $ExpectType Record<string, unknown>
   })
   test('curry 2 | with explicit types', () => {
     const result = mergeWith<Output>(concat)(A, B)
@@ -9531,6 +9582,120 @@ It returns the lesser value between `x` and `y` according to `compareFn` functio
 
 [![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#minBy)
 
+### modifyPath
+
+```typescript
+
+modifyPath<T extends Record<string, unknown>>(path: Path, fn: (x: any) => unknown, object: Record<string, unknown>): T
+```
+
+It changes a property of object on the base of provided path and transformer function.
+
+<details>
+
+<summary>All Typescript definitions</summary>
+
+```typescript
+modifyPath<T extends Record<string, unknown>>(path: Path, fn: (x: any) => unknown, object: Record<string, unknown>): T;
+modifyPath<T extends Record<string, unknown>>(path: Path, fn: (x: any) => unknown): (object: Record<string, unknown>) => T;
+modifyPath<T extends Record<string, unknown>>(path: Path): (fn: (x: any) => unknown) => (object: Record<string, unknown>) => T;
+```
+
+</details>
+
+<details>
+
+<summary><strong>R.modifyPath</strong> source</summary>
+
+```javascript
+import { _isArray } from './_internals/_isArray.js'
+import { createPath } from './_internals/createPath.js'
+import { assoc } from './assoc.js'
+import { curry } from './curry.js'
+import { path as pathModule } from './path.js'
+
+export function modifyPathFn(
+  pathInput, fn, object
+){
+  const path = createPath(pathInput)
+  if (path.length === 1){
+    return {
+      ...object,
+      [ path[0] ] : fn(object[ path[0] ]),
+    }
+  }
+  if (pathModule(path, object) === undefined) return object
+
+  const val = modifyPath(
+    Array.prototype.slice.call(path, 1),
+    fn,
+    object[ path[ 0 ] ]
+  )
+  if (val === object[ path[ 0 ] ]){
+    return object
+  }
+
+  return assoc(
+    path[ 0 ], val, object
+  )
+}
+
+export const modifyPath = curry(modifyPathFn)
+```
+
+</details>
+
+<details>
+
+<summary><strong>Tests</strong></summary>
+
+```javascript
+import { modifyPath } from './modifyPath.js'
+
+test('happy', () => {
+  const result = modifyPath(
+    'a.b.c', x => x + 1, { a : { b : { c : 1 } } }
+  )
+  expect(result).toEqual({ a : { b : { c : 2 } } })
+})
+
+test('with array', () => {
+  const input = {foo: [{ bar: '123' }]}
+  const result = modifyPath('foo.0.bar', x => x + 'foo', input)
+  expect(result).toEqual({ foo: { '0': { bar: '123foo' } } })
+})
+```
+
+</details>
+
+<details>
+
+<summary><strong>Typescript</strong> test</summary>
+
+```typescript
+import {modifyPath} from 'rambda'
+
+const obj = {a:{b: {c:1}}}
+
+describe('R.modifyPath', () => {
+  it('happy', () => {
+    const result = modifyPath('a.b.c', (x: number) => x + 1, obj)
+    result // $ExpectType Record<string, unknown>
+  })
+  it('explicit return type', () => {
+    interface Foo extends Record<string, unknown>{
+      a: 1
+    }
+    const result = modifyPath<Foo>('a.b.c', (x: number) => x + 1, obj)
+    result // $ExpectType Foo
+  })
+})
+```
+
+</details>
+
+[![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#modifyPath)
+
 ### modulo
 
 Curried version of `x%y`.
@@ -10170,7 +10335,7 @@ This method is also known as P combinator.
 
 ```typescript
 
-once<T extends (...args: any[]) => any>(func: T): T
+once<T extends AnyFunction>(func: T): T
 ```
 
 It returns a function, which invokes only once `fn` function.
@@ -10180,7 +10345,7 @@ It returns a function, which invokes only once `fn` function.
 <summary>All Typescript definitions</summary>
 
 ```typescript
-once<T extends (...args: any[]) => any>(func: T): T;
+once<T extends AnyFunction>(func: T): T;
 ```
 
 </details>
@@ -12434,13 +12599,15 @@ propEq<K extends string | number>(propToFind: K): {
 
 ```javascript
 import { curry } from './curry.js'
+import { equals } from './equals.js'
+import { prop } from './prop.js'
 
 function propEqFn(
   propToFind, valueToMatch, obj
 ){
   if (!obj) return false
 
-  return obj[ propToFind ] === valueToMatch
+  return equals(valueToMatch, prop(propToFind, obj))
 }
 
 export const propEq = curry(propEqFn)
@@ -12463,6 +12630,15 @@ test('happy', () => {
     'foo', 'bar', null
   )).toBeFalse()
 })
+
+test('returns false if called with a null or undefined object', () => {
+  expect(propEq(
+    'name', 'Abby', null
+  )).toBeFalse()
+  expect(propEq(
+    'name', 'Abby', undefined
+  )).toBeFalse()
+})
 ```
 
 </details>
@@ -12574,7 +12750,7 @@ const propEq = [
 
 ```typescript
 
-propIs<C extends (...args: any[]) => any, K extends keyof any>(type: C, name: K, obj: any): obj is Record<K, ReturnType<C>>
+propIs<C extends AnyFunction, K extends keyof any>(type: C, name: K, obj: any): obj is Record<K, ReturnType<C>>
 ```
 
 It returns `true` if `property` of `obj` is from `target` type.
@@ -12584,15 +12760,15 @@ It returns `true` if `property` of `obj` is from `target` type.
 <summary>All Typescript definitions</summary>
 
 ```typescript
-propIs<C extends (...args: any[]) => any, K extends keyof any>(type: C, name: K, obj: any): obj is Record<K, ReturnType<C>>;
-propIs<C extends new (...args: any[]) => any, K extends keyof any>(type: C, name: K, obj: any): obj is Record<K, InstanceType<C>>;
-propIs<C extends (...args: any[]) => any, K extends keyof any>(type: C, name: K): (obj: any) => obj is Record<K, ReturnType<C>>;
-propIs<C extends new (...args: any[]) => any, K extends keyof any>(type: C, name: K): (obj: any) => obj is Record<K, InstanceType<C>>;
-propIs<C extends (...args: any[]) => any>(type: C): {
+propIs<C extends AnyFunction, K extends keyof any>(type: C, name: K, obj: any): obj is Record<K, ReturnType<C>>;
+propIs<C extends AnyConstructor, K extends keyof any>(type: C, name: K, obj: any): obj is Record<K, InstanceType<C>>;
+propIs<C extends AnyFunction, K extends keyof any>(type: C, name: K): (obj: any) => obj is Record<K, ReturnType<C>>;
+propIs<C extends AnyConstructor, K extends keyof any>(type: C, name: K): (obj: any) => obj is Record<K, InstanceType<C>>;
+propIs<C extends AnyFunction>(type: C): {
     <K extends keyof any>(name: K, obj: any): obj is Record<K, ReturnType<C>>;
     <K extends keyof any>(name: K): (obj: any) => obj is Record<K, ReturnType<C>>;
 };
-propIs<C extends new (...args: any[]) => any>(type: C): {
+propIs<C extends AnyFunction>(type: C): {
     <K extends keyof any>(name: K, obj: any): obj is Record<K, InstanceType<C>>;
     <K extends keyof any>(name: K): (obj: any) => obj is Record<K, InstanceType<C>>;
 };
@@ -13112,237 +13288,6 @@ const range = [
 
 ### reduce
 
-```typescript
-
-reduce<T, TResult>(reducer: (prev: TResult, current: T, i: number) => TResult, initialValue: TResult, list: T[]): TResult
-```
-
-<details>
-
-<summary>All Typescript definitions</summary>
-
-```typescript
-reduce<T, TResult>(reducer: (prev: TResult, current: T, i: number) => TResult, initialValue: TResult, list: T[]): TResult;
-reduce<T, TResult>(reducer: (prev: TResult, current: T) => TResult, initialValue: TResult, list: T[]): TResult;
-reduce<T, TResult>(reducer: (prev: TResult, current: T, i?: number) => TResult): (initialValue: TResult, list: T[]) => TResult;
-reduce<T, TResult>(reducer: (prev: TResult, current: T, i?: number) => TResult, initialValue: TResult): (list: T[]) => TResult;
-```
-
-</details>
-
-<details>
-
-<summary><strong>R.reduce</strong> source</summary>
-
-```javascript
-import { _isArray } from './_internals/_isArray.js'
-import { _keys } from './_internals/_keys.js'
-import { curry } from './curry.js'
-
-export function reduceFn(
-  reducer, acc, list
-){
-  if (!_isArray(list)){
-    throw new TypeError('reduce: list must be array or iterable')
-  }
-  let index = 0
-  const len = list.length
-
-  while (index < len){
-    acc = reducer(
-      acc, list[ index ], index, list
-    )
-    index++
-  }
-
-  return acc
-}
-
-export const reduce = curry(reduceFn)
-```
-
-</details>
-
-<details>
-
-<summary><strong>Tests</strong></summary>
-
-```javascript
-import { reduce } from './reduce.js'
-
-const reducer = (
-  prev, current, i
-) => {
-  expect(i).toBeNumber()
-
-  return prev + current
-}
-const initialValue = 1
-const list = [ 1, 2, 3 ]
-const ERROR = 'reduce: list must be array or iterable'
-
-test('happy', () => {
-  expect(reduce(
-    reducer, initialValue, list
-  )).toEqual(7)
-})
-
-test('with object as iterable', () => {
-  expect(() =>
-    reduce(
-      reducer, initialValue, {
-        a : 1,
-        b : 2,
-      }
-    )).toThrowWithMessage(TypeError, ERROR)
-})
-
-test('with undefined as iterable', () => {
-  expect(() => reduce(
-    reducer, 0, null
-  )).toThrowWithMessage(TypeError, ERROR)
-})
-```
-
-</details>
-
-<details>
-
-<summary><strong>Typescript</strong> test</summary>
-
-```typescript
-import {reduce} from 'rambda'
-
-describe('R.reduce', () => {
-  it('happy', () => {
-    const result = reduce<number, number>(
-      (acc, elem) => {
-        acc // $ExpectType number
-        elem // $ExpectType number
-        return acc + elem
-      },
-      1,
-      [1, 2, 3]
-    )
-
-    result // $ExpectType number
-  })
-
-  it('with two types', () => {
-    const result = reduce<number, string>(
-      (acc, elem) => {
-        acc // $ExpectType string
-        elem // $ExpectType number
-
-        return `${acc}${elem}`
-      },
-      'foo',
-      [1, 2, 3]
-    )
-
-    result // $ExpectType string
-  })
-
-  it('with index', () => {
-    const result = reduce<number, number>(
-      (acc, elem, i) => {
-        acc // $ExpectType number
-        elem // $ExpectType number
-        i // $ExpectType number
-        return acc + elem
-      },
-      1,
-      [1, 2, 3]
-    )
-
-    result // $ExpectType number
-  })
-
-  it('fallback', () => {
-    const result = reduce(
-      (acc, val) => {
-        acc // $ExpectType number
-        return acc + val
-      },
-      1,
-      [1, 2, 3]
-    )
-
-    result // $ExpectType number
-  })
-
-  it('fallback with index', () => {
-    const result = reduce(
-      (acc, val, i) => {
-        acc // $ExpectType number
-        i // $ExpectType number
-        return acc + val
-      },
-      1,
-      [1, 2, 3]
-    )
-
-    result // $ExpectType number
-  })
-
-  it('fallback with two types', () => {
-    const result = reduce(
-      (acc, val) => {
-        acc // $ExpectType string
-        return acc + val
-      },
-      'foo',
-      [1, 2, 3]
-    )
-
-    result // $ExpectType string
-  })
-})
-```
-
-</details>
-
-<details>
-
-<summary>Lodash is fastest. Rambda is 60.48% slower and Ramda is 77.1% slower</summary>
-
-```text
-const R = require('../../dist/rambda.js')
-
-const fn = (acc, value) => acc + value
-const holder = [ 1, 2, 3 ]
-const acc = ''
-
-const reduce = [
-  {
-    label : 'Rambda',
-    fn    : () => {
-      R.reduce(
-        fn, acc, holder
-      )
-    },
-  },
-  {
-    label : 'Ramda',
-    fn    : () => {
-      Ramda.reduce(
-        fn, acc, holder
-      )
-    },
-  },
-  {
-    label : 'Lodash',
-    fn    : () => {
-      _.reduce(
-        holder, fn, acc
-      )
-    },
-  },
-]
-```
-
-</details>
-
 [![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#reduce)
 
 ### reject
@@ -16742,8 +16687,6 @@ export function uniq(list){
 <summary><strong>Tests</strong></summary>
 
 ```javascript
-import { uniq as uniqRamda } from 'ramda'
-
 import { uniq } from './uniq.js'
 
 test('happy', () => {
@@ -16794,7 +16737,7 @@ describe('R.uniq', () => {
 
 <details>
 
-<summary>Rambda is faster than Ramda with 86.73%</summary>
+<summary>Rambda is faster than Ramda with 90.24%</summary>
 
 ```text
 const R = require('../../dist/rambda.js')
@@ -16842,6 +16785,10 @@ const tests = [
 
 [![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#uniq)
 
+### uniqBy
+
+[![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#uniqBy)
+
 ### uniqWith
 
 ```typescript
@@ -16961,7 +16908,7 @@ describe('R.uniqWith', () => {
 
 <details>
 
-<summary>Rambda is slower than Ramda with 13.67%</summary>
+<summary>Rambda is slower than Ramda with 18.09%</summary>
 
 ```text
 const R = require('../../dist/rambda.js')
@@ -18413,9 +18360,27 @@ describe('R.zipWith', () => {
 
 ## ❯ CHANGELOG
 
+7.2.0
+
+- Wrong `R.update` if index is `-1` - [PR #593](https://github.com/selfrefactor/rambda/pull/593)
+
+- Wrong curried typings in `R.anyPass` - [Issue #642](https://github.com/selfrefactor/rambda/issues/642)
+
+- `R.modifyPath` not exported - [Issue #640](https://github.com/selfrefactor/rambda/issues/640)
+
+- Add new method `R.uniqBy`. Implementation is coming from [Ramda MR#2641](https://github.com/ramda/ramda/pull/2641)
+
+- Apply the following changes from `@types/rambda`:
+
+-- [https://github.com/DefinitelyTyped/DefinitelyTyped/commit/bab47272d52fc7bb81e85da36dbe9c905a04d067](add `AnyFunction` and `AnyConstructor`)
+
+-- Improve `R.ifElse` typings - https://github.com/DefinitelyTyped/DefinitelyTyped/pull/59291
+
+-- Make `R.propEq` safe for `null/undefined` arguments - https://github.com/ramda/ramda/pull/2594/files
+
 7.1.4
 
-`R.mergeRight` not found on `Deno` import - [Issue #633](https://github.com/selfrefactor/rambda/issues/633)
+- `R.mergeRight` not found on `Deno` import - [Issue #633](https://github.com/selfrefactor/rambda/issues/633)
 
 7.1.0
 
@@ -18453,7 +18418,7 @@ Rambda doesn't work with `pnpm` due to wrong export configuration - [Issue #619]
 
 7.0.0
 
-- Braking change - sync `R.compose`/`R.pipe` with `@types/ramda`. That is significant change so as safeguard, it will lead a major bump. Important - this lead to raising required Typescript version to `4.2.2`. In other words, to use `Rambda` you'll need Typescript version `4.2.2` or newer.
+- Breaking change - sync `R.compose`/`R.pipe` with `@types/ramda`. That is significant change so as safeguard, it will lead a major bump. Important - this lead to raising required Typescript version to `4.2.2`. In other words, to use `Rambda` you'll need Typescript version `4.2.2` or newer.
 
 Related commit in `@types/ramda` - https://github.com/DefinitelyTyped/DefinitelyTyped/commit/286eff4f76d41eb8f091e7437eabd8a60d97fc1f#diff-4f74803fa83a81e47cb17a7d8a4e46a7e451f4d9e5ce2f1bd7a70a72d91f4bc1
 
@@ -18485,7 +18450,7 @@ There are several other changes in `@types/ramda` as stated in [this comment](ht
 
 -- R.toUpper
 
-- One more reason for the braking change is changing of export declarations in `package.json` based on [this blog post](https://devblogs.microsoft.com/typescript/announcing-typescript-4-5-beta/#packagejson-exports-imports-and-self-referencing) and [this merged Ramda's PR](https://github.com/ramda/ramda/pull/2999). This also led to renaming of `babel.config.js` to `babel.config.cjs`. 
+- One more reason for the breaking change is changing of export declarations in `package.json` based on [this blog post](https://devblogs.microsoft.com/typescript/announcing-typescript-4-5-beta/#packagejson-exports-imports-and-self-referencing) and [this merged Ramda's PR](https://github.com/ramda/ramda/pull/2999). This also led to renaming of `babel.config.js` to `babel.config.cjs`. 
 
 - Add `R.apply`, `R.bind` and `R.unapply`
 
@@ -19153,6 +19118,8 @@ Approve [PR #266](https://github.com/selfrefactor/rambda/pull/266) that adds `R.
 
 - [Awesome functional Javascript programming libraries](https://github.com/stoeffel/awesome-fp-js#libraries)
 
+- [Overview of Rambda pros/cons](https://mobily.github.io/ts-belt/docs/#rambda-%EF%B8%8F)
+
 > Links to Rambda
 
 - [https://mailchi.mp/webtoolsweekly/web-tools-280](Web Tools Weekly)