rambda 8.0.0 → 8.1.0

package/README.md

@@ -96,7 +96,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 79 Ramda methods not implemented in Rambda 
 </summary>
 
 - __
@@ -114,7 +114,6 @@ Closing the issue is usually accompanied by publishing a new patch version of `R
 - construct
 - constructN
 - descend
-- differenceWith
 - dissocPath
 - dropRepeatsBy
 - empty
@@ -350,7 +349,7 @@ adjust<T>(index: number, replaceFn: (x: T) => T, list: T[]): T[]
 
 It replaces `index` in array `list` with the result of `replaceFn(list[i])`.
 
-<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?R.adjust(%0A%20%200%2C%0A%20%20a%20%3D%3E%20a%20%2B%201%2C%0A%20%20%5B0%2C%20100%5D%0Aconst%20result%20%3D%20)%20%2F%2F%20%3D%3E%20%5B1%2C%20100%5D">Try this <strong>R.adjust</strong> example in Rambda REPL</a>
+<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20result%20%3D%20R.adjust(%0A%20%200%2C%0A%20%20a%20%3D%3E%20a%20%2B%201%2C%0A%20%20%5B0%2C%20100%5D%0A)%20%2F%2F%20%3D%3E%20%5B1%2C%20100%5D">Try this <strong>R.adjust</strong> example in Rambda REPL</a>
 
 <details>
 
@@ -1092,7 +1091,7 @@ test('applies function to argument list', () => {
 
 test('provides no way to specify context', () => {
   const obj = {
-    method : function (){
+    method (){
       return this === obj
     },
   }
@@ -1683,6 +1682,22 @@ test('string can be used as path input', () => {
   expect(result).toEqual(expected)
 })
 
+test('difference with ramda - doesn\'t overwrite primitive values with keys in the path', () => {
+  const obj = { a : 'str' }
+  const result = assocPath(
+    [ 'a', 'b' ], 42, obj
+  )
+
+  expect(result).toEqual({
+    a : {
+      0 : 's',
+      1 : 't',
+      2 : 'r',
+      b : 42,
+    },
+  })
+})
+
 test('bug', () => {
   /*
     https://github.com/selfrefactor/rambda/issues/524
@@ -2717,6 +2732,91 @@ describe('R.difference', () => {
 
 [![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#difference)
 
+### differenceWith
+
+```typescript
+
+differenceWith<T1, T2>(
+  pred: (a: T1, b: T2) => boolean,
+  list1: T1[],
+  list2: T2[],
+): T1[]
+```
+
+<details>
+
+<summary>All Typescript definitions</summary>
+
+```typescript
+differenceWith<T1, T2>(
+  pred: (a: T1, b: T2) => boolean,
+  list1: T1[],
+  list2: T2[],
+): T1[];
+differenceWith<T1, T2>(
+  pred: (a: T1, b: T2) => boolean,
+): (list1: T1[], list2: T2[]) => T1[];
+differenceWith<T1, T2>(
+  pred: (a: T1, b: T2) => boolean,
+  list1: T1[],
+): (list2: T2[]) => T1[];
+```
+
+</details>
+
+<details>
+
+<summary><strong>R.differenceWith</strong> source</summary>
+
+```javascript
+import { curry } from './curry.js'
+import { _indexOf } from './equals.js'
+
+export function differenceWithFn(
+  fn, a, b
+){
+  const willReturn = []
+  const [ first, second ] = a.length > b.length ? [ a, b ] : [ b, a ]
+
+  first.forEach(item => {
+    const hasItem = second.some(secondItem => fn(item, secondItem))
+    if (!hasItem && _indexOf(item, willReturn) === -1){
+      willReturn.push(item)
+    }
+  })
+
+  return willReturn
+}
+
+export const differenceWith = curry(differenceWithFn)
+```
+
+</details>
+
+<details>
+
+<summary><strong>Tests</strong></summary>
+
+```javascript
+import { differenceWith } from './differenceWith.js'
+
+test('happy', () => {
+  const foo = [ { a : 1 }, { a : 2 }, { a : 3 } ]
+  const bar = [ { a : 3 }, { a : 4 } ]
+  const fn = function (r, s){
+    return r.a === s.a
+  }
+  const result = differenceWith(
+    fn, foo, bar
+  )
+  expect(result).toEqual([ { a : 1 }, { a : 2 } ])
+})
+```
+
+</details>
+
+[![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#differenceWith)
+
 ### dissoc
 
 It returns a new object that does not contain property `prop`.
@@ -3257,7 +3357,7 @@ describe('R.either', () => {
 
 ```typescript
 
-endsWith(target: string, iterable: string): boolean
+endsWith<T extends string>(question: T, str: string): boolean
 ```
 
 When iterable is a string, then it behaves as `String.prototype.endsWith`.
@@ -3270,10 +3370,10 @@ When iterable is a list, then it uses R.equals to determine if the target list e
 <summary>All Typescript definitions</summary>
 
 ```typescript
-endsWith(target: string, iterable: string): boolean;
-endsWith(target: string): (iterable: string) => boolean;
-endsWith<T>(target: T[], list: T[]): boolean;
-endsWith<T>(target: T[]): (list: T[]) => boolean;
+endsWith<T extends string>(question: T, str: string): boolean;
+endsWith<T extends string>(question: T): (str: string) => boolean;
+endsWith<T>(question: T[], list: T[]): boolean;
+endsWith<T>(question: T[]): (list: T[]) => boolean;
 ```
 
 </details>
@@ -3383,32 +3483,28 @@ describe('brute force', () => {
 ```typescript
 import {endsWith} from 'rambda'
 
-describe('R.endsWith - array as iterable', () => {
+describe('R.endsWith - array', () => {
   const target = [{a: 2}]
-  const iterable = [{a: 1}, {a: 2}]
+  const input = [{a: 1}, {a: 2}]
   it('happy', () => {
-    const result = endsWith(target, iterable)
-
+    const result = endsWith(target, input)
     result // $ExpectType boolean
   })
   it('curried', () => {
-    const result = endsWith(target)(iterable)
-
+    const result = endsWith(target)(input)
     result // $ExpectType boolean
   })
 })
 
-describe('R.endsWith - string as iterable', () => {
+describe('R.endsWith - string', () => {
   const target = 'bar'
-  const iterable = 'foo bar'
+  const input = 'foo bar'
   it('happy', () => {
-    const result = endsWith(target, iterable)
-
+    const result = endsWith(target, input)
     result // $ExpectType boolean
   })
   it('curried', () => {
-    const result = endsWith(target)(iterable)
-
+    const result = endsWith(target)(input)
     result // $ExpectType boolean
   })
 })
@@ -4557,12 +4653,12 @@ import { propEq } from './propEq.js'
 const list = [ { a : 1 }, { a : 2 }, { a : 3 } ]
 
 test('happy', () => {
-  const fn = propEq('a', 2)
+  const fn = propEq(2, 'a')
   expect(find(fn, list)).toEqual({ a : 2 })
 })
 
 test('with curry', () => {
-  const fn = propEq('a', 4)
+  const fn = propEq(4, 'a')
   expect(find(fn)(list)).toBeUndefined()
 })
 
@@ -4658,11 +4754,9 @@ import { propEq } from './propEq.js'
 const list = [ { a : 1 }, { a : 2 }, { a : 3 } ]
 
 test('happy', () => {
-  expect(findIndex(propEq('a', 2), list)).toBe(1)
-
-  expect(findIndex(propEq('a', 1))(list)).toBe(0)
-
-  expect(findIndex(propEq('a', 4))(list)).toEqual(-1)
+  expect(findIndex(propEq(2, 'a'), list)).toBe(1)
+  expect(findIndex(propEq(1, 'a'))(list)).toBe(0)
+  expect(findIndex(propEq(4, 'a'))(list)).toBe(-1)
 })
 ```
 
@@ -4913,7 +5007,7 @@ test('ramda 1', () => {
 })
 
 test('ramda 2', () => {
-  expect(findLastIndex(even, [ 'zing' ])).toEqual(-1)
+  expect(findLastIndex(even, [ 'zing' ])).toBe(-1)
 })
 
 test('ramda 3', () => {
@@ -4921,7 +5015,7 @@ test('ramda 3', () => {
 })
 
 test('ramda 4', () => {
-  expect(findLastIndex(even, [])).toEqual(-1)
+  expect(findLastIndex(even, [])).toBe(-1)
 })
 ```
 
@@ -5474,7 +5568,7 @@ It returns the first element of list or string `input`.
 ```typescript
 head(input: string): string;
 head(emptyList: []): undefined;
-head<T>(input: T[]): T | undefined;
+head<T extends readonly unknown[]>(array: T): FirstArrayElement<T>
 ```
 
 </details>
@@ -5515,6 +5609,7 @@ test('head', () => {
 <summary><strong>Typescript</strong> test</summary>
 
 ```typescript
+import {mixedList, mixedListConst} from '_internals/typescriptTestUtils'
 import {head} from 'rambda'
 
 describe('R.head', () => {
@@ -5522,12 +5617,18 @@ describe('R.head', () => {
     const result = head('foo')
     result // $ExpectType string
   })
-
   it('array', () => {
     const result = head([1, 2, 3])
-    result // $ExpectType number | undefined
+    result // $ExpectType number
+  })
+  it('mixed', () => {
+    const result = head(mixedList)
+    result // $ExpectType string | number
+  })
+  it('mixed const', () => {
+    const result = head(mixedListConst)
+    result // $ExpectType 1
   })
-
   it('empty array - case 1', () => {
     const result = head([])
     result // $ExpectType undefined
@@ -5535,7 +5636,7 @@ describe('R.head', () => {
   it('empty array - case 2', () => {
     const list = ['foo', 'bar'].filter(x => x.startsWith('a'))
     const result = head(list)
-    result // $ExpectType string | undefined
+    result // $ExpectType string
   })
 })
 ```
@@ -5846,7 +5947,7 @@ It increments a number.
 
 ```typescript
 
-includes(valueToFind: string, input: string[] | string): boolean
+includes<T extends string>(valueToFind: T, input: string): boolean
 ```
 
 If `input` is string, then this method work as native `String.includes`.
@@ -5860,8 +5961,8 @@ If `input` is array, then `R.equals` is used to define if `valueToFind` belongs
 <summary>All Typescript definitions</summary>
 
 ```typescript
-includes(valueToFind: string, input: string[] | string): boolean;
-includes(valueToFind: string): (input: string[] | string) => boolean;
+includes<T extends string>(valueToFind: T, input: string): boolean;
+includes<T extends string>(valueToFind: T): (input: string) => boolean;
 includes<T>(valueToFind: T, input: T[]): boolean;
 includes<T>(valueToFind: T): (input: T[]) => boolean;
 ```
@@ -5969,10 +6070,13 @@ describe('R.includes', () => {
   it('happy', () => {
     const result = includes({a: {b: '1'}}, list)
     result // $ExpectType boolean
+    const result2 = includes('oo', ['f', 'oo'])
+    result2 // $ExpectType boolean
   })
   it('with string', () => {
-    const result = includes('oo', 'foo')
-    const curriedResult = includes('oo')('foo')
+    const str = 'foo' as 'foo' | 'bar'
+    const result = includes('oo', str)
+    const curriedResult = includes('oo')(str)
 
     result // $ExpectType boolean
     curriedResult // $ExpectType boolean
@@ -6496,7 +6600,7 @@ describe('R.keys', () => {
 
 ```typescript
 
-last(str: string): string
+last(input: string): string
 ```
 
 It returns the last element of `input`, as the `input` can be either a string or an array.
@@ -6508,9 +6612,9 @@ It returns the last element of `input`, as the `input` can be either a string or
 <summary>All Typescript definitions</summary>
 
 ```typescript
-last(str: string): string;
+last(input: string): string;
 last(emptyList: []): undefined;
-last<T extends any>(list: T[]): T | undefined;
+last<T extends readonly unknown[]>(array: T): LastArrayElement<T>
 ```
 
 </details>
@@ -6556,6 +6660,7 @@ test('with string', () => {
 <summary><strong>Typescript</strong> test</summary>
 
 ```typescript
+import {mixedList, mixedListConst} from '_internals/typescriptTestUtils'
 import {last} from 'rambda'
 
 describe('R.last', () => {
@@ -6563,12 +6668,18 @@ describe('R.last', () => {
     const result = last('foo')
     result // $ExpectType string
   })
-
   it('array', () => {
     const result = last([1, 2, 3])
-    result // $ExpectType number | undefined
+    result // $ExpectType number
+  })
+  it('mixed', () => {
+    const result = last(mixedList)
+    result // $ExpectType string | number
+  })
+  it('mixed const', () => {
+    const result = last(mixedListConst)
+    result // $ExpectType "bar"
   })
-
   it('empty array - case 1', () => {
     const result = last([])
     result // $ExpectType undefined
@@ -6576,7 +6687,7 @@ describe('R.last', () => {
   it('empty array - case 2', () => {
     const list = ['foo', 'bar'].filter(x => x.startsWith('a'))
     const result = last(list)
-    result // $ExpectType string | undefined
+    result // $ExpectType string
   })
 })
 ```
@@ -6645,13 +6756,13 @@ test('with NaN', () => {
 })
 
 test('will throw with bad input', () => {
-  expect(lastIndexOfRamda([], true)).toEqual(-1)
+  expect(lastIndexOfRamda([], true)).toBe(-1)
   expect(() => indexOf([], true)).toThrowErrorMatchingInlineSnapshot('"indexOf is not defined"')
 })
 
 test('without list of objects - no R.equals', () => {
   expect(lastIndexOf(3, [ 1, 2, 3, 4 ])).toBe(2)
-  expect(lastIndexOf(10)([ 1, 2, 3, 4 ])).toEqual(-1)
+  expect(lastIndexOf(10)([ 1, 2, 3, 4 ])).toBe(-1)
 })
 
 test('list of objects uses R.equals', () => {
@@ -8053,6 +8164,29 @@ test('case 2', () => {
     baz : 3,
   })
 })
+
+describe('acts as if nil values are simply empty objects', () => {
+  it('if the first object is nil', () => {
+    expect(mergeAll([ null, { foo : 1 }, { foo : 2 }, { bar : 2 } ])).toEqual({
+      foo : 2,
+      bar : 2,
+    })
+  })
+
+  it('if the last object is nil', () => {
+    expect(mergeAll([ { foo : 1 }, { foo : 2 }, { bar : 2 }, undefined ])).toEqual({
+      foo : 2,
+      bar : 2,
+    })
+  })
+
+  it('if an intermediate object is nil', () => {
+    expect(mergeAll([ { foo : 1 }, { foo : 2 }, null, { bar : 2 } ])).toEqual({
+      foo : 2,
+      bar : 2,
+    })
+  })
+})
 ```
 
 </details>
@@ -8444,8 +8578,10 @@ mergeWith<Output>(fn: (x: any, z: any) => any): <U, V>(a: U, b: V) => Output;
 import { curry } from './curry.js'
 
 function mergeWithFn(
-  mergeFn, a, b
+  mergeFn, aInput, bInput
 ){
+  const a = aInput ?? {}
+  const b = bInput ?? {}
   const willReturn = {}
 
   Object.keys(a).forEach(key => {
@@ -8501,6 +8637,39 @@ test('happy', () => {
   }
   expect(result).toEqual(expected)
 })
+
+// https://github.com/ramda/ramda/pull/3222/files#diff-d925d9188b478d2f1d4b26012c6dddac374f9e9d7a336604d654b9a113bfc857
+describe('acts as if nil values are simply empty objects', () => {
+  it('if the first object is nil and the second empty', () => {
+    expect(mergeWith(
+      concat, undefined, {}
+    )).toEqual({})
+  })
+
+  it('if the first object is empty and the second nil', () => {
+    expect(mergeWith(
+      concat, {}, null
+    )).toEqual({})
+  })
+
+  it('if both objects are nil', () => {
+    expect(mergeWith(
+      concat, undefined, null
+    )).toEqual({})
+  })
+
+  it('if the first object is not empty and the second is nil', () => {
+    expect(mergeWith(
+      concat, { a : 'a' }, null
+    )).toEqual({ a : 'a' })
+  })
+
+  it('if the first object is nil and the second is not empty', () => {
+    expect(mergeWith(
+      concat, undefined, { a : 'a' }
+    )).toEqual({ a : 'a' })
+  })
+})
 ```
 
 </details>
@@ -9004,70 +9173,6 @@ describe('R.none', () => {
 
 [![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#none)
 
-### nop
-
-```typescript
-
-nop(): void
-```
-
-It returns `undefined`.
-
-<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20result%20%3D%20R.nop()%0A%2F%2F%20%3D%3E%20undefined">Try this <strong>R.nop</strong> example in Rambda REPL</a>
-
-<details>
-
-<summary>All Typescript definitions</summary>
-
-```typescript
-nop(): void;
-```
-
-</details>
-
-<details>
-
-<summary><strong>R.nop</strong> source</summary>
-
-```javascript
-export function nop(){}
-```
-
-</details>
-
-<details>
-
-<summary><strong>Tests</strong></summary>
-
-```javascript
-import { nop } from './nop.js'
-
-test('call', () => {
-  expect(nop).not.toThrow()
-})
-```
-
-</details>
-
-<details>
-
-<summary><strong>Typescript</strong> test</summary>
-
-```typescript
-import {nop} from 'rambda'
-
-describe('R.nop', () => {
-  it('call', () => {
-    const result = nop()
-    result // $ExpectType void
-  })
-})
-```
-
-</details>
-
-[![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#nop)
-
 ### not
 
 ```typescript
@@ -10356,12 +10461,7 @@ path<T>(pathToSearch: RamdaPath, obj: any): T | undefined;
 ```javascript
 import { createPath } from './_internals/createPath.js'
 
-export function path(pathInput, obj){
-  if (arguments.length === 1) return _obj => path(pathInput, _obj)
-
-  if (obj === null || obj === undefined){
-    return undefined
-  }
+export function pathFn(pathInput, obj){
   let willReturn = obj
   let counter = 0
 
@@ -10379,6 +10479,16 @@ export function path(pathInput, obj){
 
   return willReturn
 }
+
+export function path(pathInput, obj){
+  if (arguments.length === 1) return _obj => path(pathInput, _obj)
+
+  if (obj === null || obj === undefined){
+    return undefined
+  }
+
+  return pathFn(pathInput, obj)
+}
 ```
 
 </details>
@@ -11633,46 +11743,30 @@ test('prop', () => {
 <summary><strong>Typescript</strong> test</summary>
 
 ```typescript
-import {pipe, prop} from 'rambda'
+import {prop} from 'rambda'
 
 describe('R.prop', () => {
-  const obj = {a: 1, b: 'foo'}
-  interface Something {
-    a?: number,
-    b?: string,
+  interface Foo {
+    a: number,
+    b: string,
+    c?: number,
   }
+  const obj: Foo = {a: 1, b: 'foo'}
 
   it('issue #553', () => {
-    const result = prop('e', {e: 'test1', d: 'test2'})
-    const curriedResult = prop<string>('e')({e: 'test1', d: 'test2'})
-
-    result // $ExpectType string
-    curriedResult // $ExpectType string
-  })
-  it('happy', () => {
-    const result = prop('a', obj)
-
-    result // $ExpectType number
-  })
-  it('curried', () => {
-    const result = prop('b')(obj)
-
-    result // $ExpectType string
-  })
-  it('curried with explicit object type', () => {
-    const result = prop<'a', Something>('a')(obj)
-
-    result // $ExpectType number | undefined
-  })
-  it('curried with implicit object type', () => {
-    const result = pipe(value => value as Something, prop('b'))(obj)
+    const result = {
+      a: prop('a', obj),
+      b: prop('b', obj),
+      c: prop('c', obj),
+    }
+    const curriedResult = {
+      a: prop('a')(obj),
+      b: prop('b')(obj),
+      c: prop('c')(obj),
+    }
 
-    result // $ExpectType undefined
-  })
-  it('curried with explicit result type', () => {
-    const result = prop<'b', string>('b')(obj)
-
-    result // $ExpectType string
+    result // $ExpectType { a: number; b: string; c: number | undefined; }
+    curriedResult // $ExpectType { a: number; b: string; c: number | undefined; }
   })
 })
 
@@ -11700,7 +11794,7 @@ describe('with number as prop', () => {
 
 ```typescript
 
-propEq<K extends string | number>(propToFind: K, valueToMatch: any, obj: Record<K, any>): boolean
+propEq<K extends string | number>(valueToMatch: any, propToFind: K, obj: Record<K, any>): boolean
 ```
 
 It returns true if `obj` has property `propToFind` and its value is equal to `valueToMatch`.
@@ -11712,11 +11806,11 @@ It returns true if `obj` has property `propToFind` and its value is equal to `va
 <summary>All Typescript definitions</summary>
 
 ```typescript
-propEq<K extends string | number>(propToFind: K, valueToMatch: any, obj: Record<K, any>): boolean;
-propEq<K extends string | number>(propToFind: K, valueToMatch: any): (obj: Record<K, any>) => boolean;
-propEq<K extends string | number>(propToFind: K): {
-  (valueToMatch: any, obj: Record<K, any>): boolean;
-  (valueToMatch: any): (obj: Record<K, any>) => boolean;
+propEq<K extends string | number>(valueToMatch: any, propToFind: K, obj: Record<K, any>): boolean;
+propEq<K extends string | number>(valueToMatch: any, propToFind: K): (obj: Record<K, any>) => boolean;
+propEq(valueToMatch: any): {
+  <K extends string | number>(propToFind: K, obj: Record<K, any>): boolean;
+  <K extends string | number>(propToFind: K): (obj: Record<K, any>) => boolean;
 };
 ```
 
@@ -11732,7 +11826,7 @@ import { equals } from './equals.js'
 import { prop } from './prop.js'
 
 function propEqFn(
-  propToFind, valueToMatch, obj
+  valueToMatch, propToFind, obj
 ){
   if (!obj) return false
 
@@ -11749,14 +11843,16 @@ export const propEq = curry(propEqFn)
 <summary><strong>Tests</strong></summary>
 
 ```javascript
+import { BAR, FOO } from './_internals/testUtils.js'
 import { propEq } from './propEq.js'
 
 test('happy', () => {
-  expect(propEq('foo', 'bar')({ foo : 'bar' })).toBeTrue()
-  expect(propEq('foo', 'bar')({ foo : 'baz' })).toBeFalse()
-  expect(propEq('foo')('bar')({ foo : 'baz' })).toBeFalse()
+  const obj = { [ FOO ] : BAR }
+  expect(propEq(BAR, FOO)(obj)).toBeTrue()
+  expect(propEq(1, FOO)(obj)).toBeFalse()
+  expect(propEq(1)(FOO)(obj)).toBeFalse()
   expect(propEq(
-    'foo', 'bar', null
+    1, 1, null
   )).toBeFalse()
 })
 
@@ -11787,12 +11883,12 @@ const objWithNumberIndex = {[numberProperty]: value}
 
 describe('R.propEq', () => {
   it('happy', () => {
-    const result = propEq(property, value, obj)
+    const result = propEq(value, property, obj)
     result // $ExpectType boolean
   })
 
   it('number is property', () => {
-    const result = propEq(1, value, objWithNumberIndex)
+    const result = propEq(value, 1, objWithNumberIndex)
     result // $ExpectType boolean
   })
 
@@ -11804,10 +11900,7 @@ describe('R.propEq', () => {
     const myObject: MyType = {}
     const valueToFind = '1111'
     // @ts-expect-error
-    propEq('optional', valueToFind, myObject)
-
-    // @ts-expect-error
-    propEq('optional', valueToFind, myObject)
+    propEq(valueToFind, 'optional', myObject)
   })
 
   it('imported from @types/ramda', () => {
@@ -11818,11 +11911,11 @@ describe('R.propEq', () => {
       foo: 'bar',
     }
     const value = ''
-    const result = propEq('foo', value)(obj)
+    const result = propEq(value, 'foo')(obj)
     result // $ExpectType boolean
 
     // @ts-expect-error
-    propEq('bar', value)(obj)
+    propEq(value, 'bar')(obj)
   })
 })
 ```
@@ -12560,7 +12653,7 @@ describe('R.repeat', () => {
 
 ```typescript
 
-replace(strOrRegex: RegExp | string, replacer: string, str: string): string
+replace(strOrRegex: RegExp | string, replacer: RegExpReplacer, str: string): string
 ```
 
 It replaces `strOrRegex` found in `str` with `replacer`.
@@ -12572,9 +12665,9 @@ It replaces `strOrRegex` found in `str` with `replacer`.
 <summary>All Typescript definitions</summary>
 
 ```typescript
-replace(strOrRegex: RegExp | string, replacer: string, str: string): string;
-replace(strOrRegex: RegExp | string, replacer: string): (str: string) => string;
-replace(strOrRegex: RegExp | string): (replacer: string) => (str: string) => string;
+replace(strOrRegex: RegExp | string, replacer: RegExpReplacer, str: string): string;
+replace(strOrRegex: RegExp | string, replacer: RegExpReplacer): (str: string) => string;
+replace(strOrRegex: RegExp | string): (replacer: RegExpReplacer) => (str: string) => string;
 ```
 
 </details>
@@ -12606,20 +12699,24 @@ import { replace } from './replace.js'
 
 test('happy', () => {
   expect(replace(
-    'foo', 'yes', 'foo bar baz'
-  )).toBe('yes bar baz')
+    /\s/g, '|', 'foo bar baz'
+  )).toBe('foo|bar|baz')
 })
 
-test('1', () => {
-  expect(replace(/\s/g)('|')('foo bar baz')).toBe('foo|bar|baz')
-})
-
-test('2', () => {
-  expect(replace(/\s/g)('|', 'foo bar baz')).toBe('foo|bar|baz')
-})
+test('with function as replacer input', () => {
+  expect(replace(
+    /\s/g,
+    (
+      match, offset, str
+    ) => {
+      expect(match).toBe(' ')
+      expect([ 3, 7 ].includes(offset)).toBeTrue()
+      expect(str).toBe('foo bar baz')
 
-test('3', () => {
-  expect(replace(/\s/g, '|')('foo bar baz')).toBe('foo|bar|baz')
+      return '|'
+    },
+    'foo bar baz'
+  )).toBe('foo|bar|baz')
 })
 ```
 
@@ -12644,6 +12741,16 @@ describe('R.replace', () => {
   it('with string as search pattern', () => {
     const result = replace('foo', replacer, str)
 
+    result // $ExpectType string
+  })
+  it('with function as replacer', () => {
+    const result = replace('f(o)o', (m: string, p1: string, offset: number) => {
+      m // $ExpectType string
+      p1 // $ExpectType string
+      offset // $ExpectType number
+      return p1
+    }, str)
+
     result // $ExpectType string
   })
 })
@@ -12657,6 +12764,16 @@ describe('R.replace - curried', () => {
   it('with string as search pattern', () => {
     const result = replace('foo', replacer)(str)
 
+    result // $ExpectType string
+  })
+  it('with function as replacer', () => {
+    const result = replace('f(o)o')((m: string, p1: string, offset: number) => {
+      m // $ExpectType string
+      p1 // $ExpectType string
+      offset // $ExpectType number
+      return p1
+    })(str)
+
     result // $ExpectType string
   })
 })
@@ -12693,10 +12810,9 @@ reverse(input: string): string;
 <summary><strong>R.reverse</strong> source</summary>
 
 ```javascript
-export function reverse(listOrString){
-  if (typeof listOrString === 'string'){
-    return listOrString.split('').reverse()
-      .join('')
+export function reverse(listOrString) {
+  if (typeof listOrString === 'string') {
+    return listOrString.split('').reverse().join('')
   }
 
   const clone = listOrString.slice()
@@ -12712,22 +12828,22 @@ export function reverse(listOrString){
 <summary><strong>Tests</strong></summary>
 
 ```javascript
-import { reverse } from './reverse.js'
+import {reverse} from './reverse.js'
 
 test('happy', () => {
-  expect(reverse([ 1, 2, 3 ])).toEqual([ 3, 2, 1 ])
+  expect(reverse([1, 2, 3])).toEqual([3, 2, 1])
 })
 
 test('with string', () => {
   expect(reverse('baz')).toBe('zab')
 })
 
-test('it doesn\'t mutate', () => {
-  const arr = [ 1, 2, 3 ]
+test("it doesn't mutate", () => {
+  const arr = [1, 2, 3]
 
-  expect(reverse(arr)).toEqual([ 3, 2, 1 ])
+  expect(reverse(arr)).toEqual([3, 2, 1])
 
-  expect(arr).toEqual([ 1, 2, 3 ])
+  expect(arr).toEqual([1, 2, 3])
 })
 ```
 
@@ -12782,16 +12898,12 @@ set(lens: Lens): <T, U>(replacer: U, obj: T) => T;
 <summary><strong>R.set</strong> source</summary>
 
 ```javascript
-import { always } from './always.js'
-import { curry } from './curry.js'
-import { over } from './over.js'
+import {always} from './always.js'
+import {curry} from './curry.js'
+import {over} from './over.js'
 
-function setFn(
-  lens, replacer, x
-){
-  return over(
-    lens, always(replacer), x
-  )
+function setFn(lens, replacer, x) {
+  return over(lens, always(replacer), x)
 }
 
 export const set = curry(setFn)
@@ -12804,43 +12916,39 @@ export const set = curry(setFn)
 <summary><strong>Tests</strong></summary>
 
 ```javascript
-import { assoc } from './assoc.js'
-import { lens } from './lens.js'
-import { lensIndex } from './lensIndex.js'
-import { lensPath } from './lensPath.js'
-import { prop } from './prop.js'
-import { set } from './set.js'
+import {assoc} from './assoc.js'
+import {lens} from './lens.js'
+import {lensIndex} from './lensIndex.js'
+import {lensPath} from './lensPath.js'
+import {prop} from './prop.js'
+import {set} from './set.js'
 
 const testObject = {
-  foo : 'bar',
-  baz : {
-    a : 'x',
-    b : 'y',
+  foo: 'bar',
+  baz: {
+    a: 'x',
+    b: 'y',
   },
 }
 
 test('assoc lens', () => {
   const assocLens = lens(prop('foo'), assoc('foo'))
-  const result = set(
-    assocLens, 'FOO', testObject
-  )
+  const result = set(assocLens, 'FOO', testObject)
   const expected = {
     ...testObject,
-    foo : 'FOO',
+    foo: 'FOO',
   }
   expect(result).toEqual(expected)
 })
 
 test('path lens', () => {
   const pathLens = lensPath('baz.a')
-  const result = set(
-    pathLens, 'z', testObject
-  )
+  const result = set(pathLens, 'z', testObject)
   const expected = {
     ...testObject,
-    baz : {
-      a : 'z',
-      b : 'y',
+    baz: {
+      a: 'z',
+      b: 'y',
     },
   }
   expect(result).toEqual(expected)
@@ -12849,10 +12957,8 @@ test('path lens', () => {
 test('index lens', () => {
   const indexLens = lensIndex(0)
 
-  const result = set(
-    indexLens, 3, [ 1, 2 ]
-  )
-  expect(result).toEqual([ 3, 2 ])
+  const result = set(indexLens, 3, [1, 2])
+  expect(result).toEqual([3, 2])
 })
 ```
 
@@ -13688,7 +13794,7 @@ describe('R.splitWhen', () => {
 
 ```typescript
 
-startsWith(target: string, str: string): boolean
+startsWith<T extends string>(question: T, input: string): boolean
 ```
 
 When iterable is a string, then it behaves as `String.prototype.startsWith`.
@@ -13701,10 +13807,10 @@ When iterable is a list, then it uses R.equals to determine if the target list s
 <summary>All Typescript definitions</summary>
 
 ```typescript
-startsWith(target: string, str: string): boolean;
-startsWith(target: string): (str: string) => boolean;
-startsWith<T>(target: T[], list: T[]): boolean;
-startsWith<T>(target: T[]): (list: T[]) => boolean;
+startsWith<T extends string>(question: T, input: string): boolean;
+startsWith<T extends string>(question: T): (input: string) => boolean;
+startsWith<T>(question: T[], input: T[]): boolean;
+startsWith<T>(question: T[]): (input: T[]) => boolean;
 ```
 
 </details>
@@ -13717,17 +13823,17 @@ startsWith<T>(target: T[]): (list: T[]) => boolean;
 import { isArray } from './_internals/isArray.js'
 import { equals } from './equals.js'
 
-export function startsWith(target, iterable){
+export function startsWith(question, iterable){
   if (arguments.length === 1)
-    return _iterable => startsWith(target, _iterable)
+    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
@@ -13735,7 +13841,7 @@ export function startsWith(target, iterable){
     return result
   })
 
-  return filtered.length === target.length
+  return filtered.length === question.length
 }
 ```
 
@@ -13797,32 +13903,28 @@ describe('brute force', () => {
 ```typescript
 import {startsWith} from 'rambda'
 
-describe('R.startsWith - array as iterable', () => {
-  const target = [{a: 1}]
+describe('R.startsWith - array', () => {
+  const question = [{a: 1}]
   const iterable = [{a: 1}, {a: 2}]
   it('happy', () => {
-    const result = startsWith(target, iterable)
-
+    const result = startsWith(question, iterable)
     result // $ExpectType boolean
   })
   it('curried', () => {
-    const result = startsWith(target)(iterable)
-
+    const result = startsWith(question)(iterable)
     result // $ExpectType boolean
   })
 })
 
-describe('R.startsWith - string as iterable', () => {
-  const target = 'foo'
+describe('R.startsWith - string', () => {
+  const question = 'foo'
   const iterable = 'foo bar'
   it('happy', () => {
-    const result = startsWith(target, iterable)
-
+    const result = startsWith(question, iterable)
     result // $ExpectType boolean
   })
   it('curried', () => {
-    const result = startsWith(target)(iterable)
-
+    const result = startsWith(question)(iterable)
     result // $ExpectType boolean
   })
 })
@@ -15835,7 +15937,7 @@ describe('R.unless - curried', () => {
 
 ### 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>
+<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%20R.unwind('b'%2C%20obj)%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>
 
 [![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#unwind)
 
@@ -16560,7 +16662,7 @@ test('with list of objects', () => {
 })
 
 test('ramda accepts string as target input while rambda throws', () => {
-  expect(withoutRamda('0:1', [ '0', '0:1' ])).toEqual([])
+  expect(withoutRamda('0:1', [ '0', '0:1' ])).toEqual([ '0:1' ])
   expect(() =>
     without('0:1', [ '0', '0:1' ])).toThrowErrorMatchingInlineSnapshot('"Cannot read property \'indexOf\' of 0:1"')
   expect(without([ '0:1' ], [ '0', '0:1' ])).toEqual([ '0' ])
@@ -17050,6 +17152,12 @@ describe('R.zipWith', () => {
 
 ## ❯ CHANGELOG
 
+8.1.0
+
+- Fix input order of TS definitions for `R.propEq` method  - [Issue #688](https://github.com/selfrefactor/rambda/issues/688)
+
+- Add `R.differenceWith` method  - [Issue #91](https://github.com/selfrefactor/rambdax/issues/91)
+
 8.0.0
 
 - handle falsy values in merge methods - https://github.com/ramda/ramda/pull/3222