rambda 10.1.0 → 10.3.0

package/README.md

@@ -1,8 +1,6 @@
 # Rambda
 
-`Rambda` is TypeScript-focused utility library similar to `Remeda`, `Ramda` and `Radashi`. 
-
-Initially it started as faster alternative to functional programming library `Ramda`, but in order to address many TypeScript issues, now `Rambda` takes a separate path. - [Documentation](https://selfrefactor.github.io/rambda/#/)
+`Rambda` is TypeScript-focused utility library similar to `Remeda`, `Ramda` and `Radashi`. - [Documentation site](https://selfrefactor.github.io/rambda/#/)
 
 ![Commit activity](https://img.shields.io/github/commit-activity/y/selfrefactor/rambda)
 ![Library size](https://img.shields.io/bundlephobia/minzip/rambda)
@@ -13,17 +11,17 @@ Initially it started as faster alternative to functional programming library `Ra
 ## ❯ Example use
 
 ```javascript
-import { pipe, map, filter } from 'rambda'
+import { pipe, filter, map } from 'rambda'
 
 const result = pipe(
-	[1, 2, 3, 4],
+  [1, 2, 3, 4],
   filter(x => x > 2),
   map(x => x * 2),
 )
-// => [6, 8]
+//=> [6, 8]
 ```
 
-You can test this example in <a href="https://rambda.now.sh?const%20result%20%3D%20R.compose(%0A%20%20R.map(x%20%3D%3E%20x%20*%202)%2C%0A%20%20R.filter(x%20%3D%3E%20x%20%3E%202)%0A)(%5B1%2C%202%2C%203%2C%204%5D)%0A%0A%2F%2F%20%3D%3E%20%5B6%2C%208%5D">Rambda's REPL</a>
+You can test this example in <a href="https://rambda.now.sh/?const%20result%20%3D%20R.pipe(%0A%20%20%5B1%2C%202%2C%203%2C%204%5D%2C%0A%20%20R.filter(x%20%3D%3E%20x%20%3E%202)%2C%0A%20%20R.map(x%20%3D%3E%20x%20*%202)%2C%0A)%0A%2F%2F%20%3D%3E%20%5B6%2C%208%5D">Rambda's REPL</a>
 
 * [API](#api)
 * [Changelog](#-changelog)
@@ -78,6 +76,8 @@ it('within Ramda.pipe requires explicit types', () => {
 });
 ```
 
+IMPORTANT - all methods are tested to deliver correct types when they are part of `R.pipe/R.pipeAsync` chains. Using them outside(standalone) most likely will result in `unknown` type for inputs.
+
 ### Keep only the most useful methods
 
 The idea is to give `TypeScript` users only the most useful methods and let them implement the rest. No magic logic methods that are hard to remember. You shouldn't need to read the documentation to understand what a method does. Its name and signature should be enough.
@@ -130,38 +130,13 @@ R.pick('a,b', {a: 1 , b: 2, c: 3} })
 // No space allowed between properties
 ```
 
-### Fast performance compared to Ramda
-
-Since `Rambda` methods doesn't use so many internals, it is faster than `Ramda`.
-Prior to version `10`, benchmark summary was included, but now the main selling point is the TypeScript focus, not performance so this is no longer included.
-
 ### Differences between Rambda and Ramda
 
 Up until version `9.4.2`, the aim of Rambda was to match as much as possible the Ramda API.
 
-Documentation site of `Rambda` version `9.4.2` is available [here](https://selfrefactor.github.io/rambda-v9/).
-
-From version `10.0.0` onwards, Rambda will start to diverge from Ramda in order to address some of the issues that Ramda has.
-
-Currently, `Rambda` includes 32 methods that differ from `Ramda` and shares 83 methods with it.
-
-<details>
-<summary>
-	Ramda issues
-</summary>
-
--- Typescript support - this is the main reason for the divergence. Most of design decisions in Rambda are made with Typescript in mind.
-
--- Methods that imply side-effect, which is not FP oriented, e.g. `R.forEach`.
-
--- Naming of methods that doesn't match developer's expectation, such as `R.chain`, which should be called `flatMap`.
+You can find documentation site of **Rambda** version **9.4.2** is [here](https://selfrefactor.github.io/rambda-v9/).
 
--- Naming of methods is sometimes too generic to be remembered such as `R.update`, `R.modify`, `R.where`.
-
--- Methods that are already present in standard JavaScript, such as `R.toLower`, `R.length`.
-
--- `R.compose` doesn't have the best possible TypeScript support.
-</details>
+From version `10.0.0` onwards, **Rambda** is no longer aiming to be drop-in replacement for *Ramda*.
 
 [![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#-rambdas-features)
 
@@ -181,13 +156,13 @@ It adds new key-value pair to the object.
 
 ```javascript
 const result = R.pipe(
-	{ a: 1, b: 'foo' }, 
+	{ a: 1, b: 'foo' },
 	R.addProp('c', 3)
 )
 // => { a: 1, b: 'foo', c: 3 }
 ```
 
-<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20result%20%3D%20R.pipe(%0A%09%7B%20a%3A%201%2C%20b%3A%20'foo'%20%7D%2C%20%0A%09R.addProp('c'%2C%203)%0A)%0A%2F%2F%20%3D%3E%20%7B%20a%3A%201%2C%20b%3A%20'foo'%2C%20c%3A%203%20%7D">Try this <strong>R.addProp</strong> example in Rambda REPL</a>
+<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20result%20%3D%20R.pipe(%0A%09%7B%20a%3A%201%2C%20b%3A%20'foo'%20%7D%2C%0A%09R.addProp('c'%2C%203)%0A)%0A%2F%2F%20%3D%3E%20%7B%20a%3A%201%2C%20b%3A%20'foo'%2C%20c%3A%203%20%7D">Try this <strong>R.addProp</strong> example in Rambda REPL</a>
 
 <details>
 
@@ -264,7 +239,7 @@ addPropToObjects<
 ): (list: T[]) => MergeTypes<T & { [P in K]: R }>[]
 ```
 
-It receives list of objects and add new property to each item. 
+It receives list of objects and add new property to each item.
 
 The value is based on result of `fn` function, which receives the current object as argument.
 
@@ -591,11 +566,11 @@ It returns `true`, if at least one member of `list` returns true, when passed to
 ```javascript
 const list = [1, 2, 3]
 const predicate = x => x * x > 8
-R.any(fn)(list)
+R.any(predicate)(list)
 // => true
 ```
 
-<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20list%20%3D%20%5B1%2C%202%2C%203%5D%0Aconst%20predicate%20%3D%20x%20%3D%3E%20x%20*%20x%20%3E%208%0Aconst%20result%20%3D%20R.any(fn)(list)%0A%2F%2F%20%3D%3E%20true">Try this <strong>R.any</strong> example in Rambda REPL</a>
+<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20list%20%3D%20%5B1%2C%202%2C%203%5D%0Aconst%20predicate%20%3D%20x%20%3D%3E%20x%20*%20x%20%3E%208%0Aconst%20result%20%3D%20R.any(predicate)(list)%0A%2F%2F%20%3D%3E%20true">Try this <strong>R.any</strong> example in Rambda REPL</a>
 
 <details>
 
@@ -688,11 +663,11 @@ const fn = R.anyPass(
   [isBig, isOdd]
 )
 
-const result = fn(input) 
+const result = fn(input)
 // => true
 ```
 
-<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20isBig%20%3D%20x%20%3D%3E%20x%20%3E%2020%0Aconst%20isOdd%20%3D%20x%20%3D%3E%20x%20%25%202%20%3D%3D%3D%201%0Aconst%20input%20%3D%2011%0A%0Aconst%20fn%20%3D%20R.anyPass(%0A%20%20%5BisBig%2C%20isOdd%5D%0A)%0A%0Aconst%20result%20%3D%20fn(input)%20%0A%2F%2F%20%3D%3E%20true">Try this <strong>R.anyPass</strong> example in Rambda REPL</a>
+<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20isBig%20%3D%20x%20%3D%3E%20x%20%3E%2020%0Aconst%20isOdd%20%3D%20x%20%3D%3E%20x%20%25%202%20%3D%3D%3D%201%0Aconst%20input%20%3D%2011%0A%0Aconst%20fn%20%3D%20R.anyPass(%0A%20%20%5BisBig%2C%20isOdd%5D%0A)%0A%0Aconst%20result%20%3D%20fn(input)%0A%2F%2F%20%3D%3E%20true">Try this <strong>R.anyPass</strong> example in Rambda REPL</a>
 
 <details>
 
@@ -1138,11 +1113,11 @@ const input = {
   c : 11,
 }
 
-const result = condition(input) 
+const result = condition(input)
 // => true
 ```
 
-<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20condition%20%3D%20R.checkObjectWithSpec(%7B%0A%20%20a%20%3A%20x%20%3D%3E%20typeof%20x%20%3D%3D%3D%20%22string%22%2C%0A%20%20b%20%3A%20x%20%3D%3E%20x%20%3D%3D%3D%204%0A%7D)%0Aconst%20input%20%3D%20%7B%0A%20%20a%20%3A%20%22foo%22%2C%0A%20%20b%20%3A%204%2C%0A%20%20c%20%3A%2011%2C%0A%7D%0A%0Aconst%20result%20%3D%20condition(input)%20%0A%2F%2F%20%3D%3E%20true">Try this <strong>R.checkObjectWithSpec</strong> example in Rambda REPL</a>
+<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20condition%20%3D%20R.checkObjectWithSpec(%7B%0A%20%20a%20%3A%20x%20%3D%3E%20typeof%20x%20%3D%3D%3D%20%22string%22%2C%0A%20%20b%20%3A%20x%20%3D%3E%20x%20%3D%3D%3D%204%0A%7D)%0Aconst%20input%20%3D%20%7B%0A%20%20a%20%3A%20%22foo%22%2C%0A%20%20b%20%3A%204%2C%0A%20%20c%20%3A%2011%2C%0A%7D%0A%0Aconst%20result%20%3D%20condition(input)%0A%2F%2F%20%3D%3E%20true">Try this <strong>R.checkObjectWithSpec</strong> example in Rambda REPL</a>
 
 <details>
 
@@ -2386,6 +2361,76 @@ describe('R.dropWhile', () => {
 
 [![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#dropWhile)
 
+### duplicateBy
+
+```typescript
+
+duplicateBy<T, U>(fn: (x: T) => U): (list: T[]) => T[]
+```
+
+```javascript
+const list = [{a:1}, {a:2}, {a:1}]
+const result = R.duplicateBy(x => x, list)
+
+// => [{a:1}]
+```
+
+<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.duplicateBy(x%20%3D%3E%20x%2C%20list)%0A%0A%2F%2F%20%3D%3E%20%5B%7Ba%3A1%7D%5D">Try this <strong>R.duplicateBy</strong> example in Rambda REPL</a>
+
+<details>
+
+<summary>All TypeScript definitions</summary>
+
+```typescript
+duplicateBy<T, U>(fn: (x: T) => U): (list: T[]) => T[];
+```
+
+</details>
+
+<details>
+
+<summary><strong>R.duplicateBy</strong> source</summary>
+
+```javascript
+import { _Set } from '../src/_internals/set.js'
+
+export function duplicateBy(fn) {
+  return list => {
+    const set = new _Set()
+
+    return list.filter(item => !set.checkUniqueness(fn(item)))
+  }
+}
+```
+
+</details>
+
+<details>
+
+<summary><strong>Tests</strong></summary>
+
+```javascript
+import { duplicateBy } from './duplicateBy.js'
+
+test('happy', () => {
+  expect(duplicateBy(Math.abs)([-2, -1, 0, 1, 2])).toEqual([1,2])
+})
+
+test('returns an empty array for an empty array', () => {
+  expect(duplicateBy(Math.abs)([])).toEqual([])
+})
+
+test('uses R.uniq', () => {
+  const list = [{ a: 1 }, { a: 2 }, { a: 1 }]
+  const expected = [{ a: 1 }]
+  expect(duplicateBy(x => x)(list)).toEqual(expected)
+})
+```
+
+</details>
+
+[![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#duplicateBy)
+
 ### eqBy
 
 ```typescript
@@ -3050,7 +3095,7 @@ const input = {
 	baz: 'baz',
 }
 const result = R.pipe(
-	input, 
+	input,
 	evolve({
 		foo: x => x + 1,
 	})
@@ -3058,7 +3103,7 @@ const result = R.pipe(
 // => result is { foo: 3, baz: 'baz' }
 ```
 
-<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20input%20%3D%20%7B%0A%09foo%3A%202%2C%0A%09baz%3A%20'baz'%2C%0A%7D%0Aconst%20result%20%3D%20R.pipe(%0A%09input%2C%20%0A%09evolve(%7B%0A%09%09foo%3A%20x%20%3D%3E%20x%20%2B%201%2C%0A%09%7D)%0A)%0A%2F%2F%20%3D%3E%20result%20is%20%7B%20foo%3A%203%2C%20baz%3A%20'baz'%20%7D">Try this <strong>R.evolve</strong> example in Rambda REPL</a>
+<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20input%20%3D%20%7B%0A%09foo%3A%202%2C%0A%09baz%3A%20'baz'%2C%0A%7D%0Aconst%20result%20%3D%20R.pipe(%0A%09input%2C%0A%09evolve(%7B%0A%09%09foo%3A%20x%20%3D%3E%20x%20%2B%201%2C%0A%09%7D)%0A)%0A%2F%2F%20%3D%3E%20result%20is%20%7B%20foo%3A%203%2C%20baz%3A%20'baz'%20%7D">Try this <strong>R.evolve</strong> example in Rambda REPL</a>
 
 <details>
 
@@ -3323,6 +3368,10 @@ test('happy', () => {
 
   expect(filter(isEven)([1, 2, 3, 4])).toEqual([2, 4])
 })
+
+test('using Boolean', () => {
+  expect(filter(Boolean)([null, 0, 1, 2])).toEqual([1,2])
+})
 ```
 
 </details>
@@ -3332,7 +3381,7 @@ test('happy', () => {
 <summary><strong>TypeScript</strong> test</summary>
 
 ```typescript
-import { filter, mergeTypes, pipe } from 'rambda'
+import { filter, pipe } from 'rambda'
 
 const list = [1, 2, 3]
 
@@ -3406,6 +3455,93 @@ describe('R.filter with array', () => {
 
 [![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#filter)
 
+### filterAsync
+
+```typescript
+
+filterAsync<T>(
+	predicate: (value: T) => Promise<boolean>,
+): (list: T[]) => Promise<T[]>
+```
+
+<details>
+
+<summary>All TypeScript definitions</summary>
+
+```typescript
+filterAsync<T>(
+	predicate: (value: T) => Promise<boolean>,
+): (list: T[]) => Promise<T[]>;
+```
+
+</details>
+
+<details>
+
+<summary><strong>R.filterAsync</strong> source</summary>
+
+```javascript
+export function filterAsync(predicate) {
+  return async list => {
+    const willReturn = []
+    let index = 0
+    for (const x of list) {
+      if (await predicate(x, index)) {
+        willReturn.push(list[index])
+      }
+      index++
+    }
+
+    return willReturn
+  }
+}
+```
+
+</details>
+
+<details>
+
+<summary><strong>Tests</strong></summary>
+
+```javascript
+import { filterAsync } from './filterAsync.js'
+
+test('happy', async () => {
+  const isEven = async n => n % 2 === 0
+
+  expect(await filterAsync(isEven)([1, 2, 3, 4])).toEqual([2, 4])
+})
+```
+
+</details>
+
+<details>
+
+<summary><strong>TypeScript</strong> test</summary>
+
+```typescript
+import { filterAsync, pipeAsync } from 'rambda'
+
+const list = [1, 2, 3]
+
+describe('R.filter with array', () => {
+  it('within pipe', async () => {
+    const result = await pipeAsync(
+      list,
+      filterAsync(async x => {
+        x // $ExpectType number
+        return x > 1
+      }),
+    )
+    result // $ExpectType number[]
+  })
+})
+```
+
+</details>
+
+[![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#filterAsync)
+
 ### filterObject
 
 ```typescript
@@ -4070,15 +4206,15 @@ You must pass expected output type as a type argument.
 
 ```javascript
 const result = R.flatten<number>([
-  1, 
-  2, 
-  [3, 30, [300]], 
+  1,
+  2,
+  [3, 30, [300]],
   [4]
 ])
 // => [ 1, 2, 3, 30, 300, 4 ]
 ```
 
-<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20result%20%3D%20R.flatten%3Cnumber%3E(%5B%0A%20%201%2C%20%0A%20%202%2C%20%0A%20%20%5B3%2C%2030%2C%20%5B300%5D%5D%2C%20%0A%20%20%5B4%5D%0A%5D)%0A%2F%2F%20%3D%3E%20%5B%201%2C%202%2C%203%2C%2030%2C%20300%2C%204%20%5D">Try this <strong>R.flatten</strong> example in Rambda REPL</a>
+<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20result%20%3D%20R.flatten%3Cnumber%3E(%5B%0A%20%201%2C%0A%20%202%2C%0A%20%20%5B3%2C%2030%2C%20%5B300%5D%5D%2C%0A%20%20%5B4%5D%0A%5D)%0A%2F%2F%20%3D%3E%20%5B%201%2C%202%2C%203%2C%2030%2C%20300%2C%204%20%5D">Try this <strong>R.flatten</strong> example in Rambda REPL</a>
 
 <details>
 
@@ -4497,13 +4633,13 @@ describe('R.groupBy', () => {
 
 ```typescript
 
-head<T>(listOrString: T): T extends string ? string : 
-	T extends [] ? undefined: 
-		T extends readonly [infer F, ...infer R] ? F : 
+head<T>(listOrString: T): T extends string ? string :
+	T extends [] ? undefined:
+		T extends readonly [infer F, ...infer R] ? F :
 			T extends readonly [infer F] ? F :
 				T extends [infer F] ? F :
-					T extends [infer F, ...infer R] ? F : 
-						T extends unknown[] ? T[number] : 
+					T extends [infer F, ...infer R] ? F :
+						T extends unknown[] ? T[number] :
 							undefined
 ```
 
@@ -4512,25 +4648,25 @@ It returns the first element of list or string `input`. It returns `undefined` i
 ```javascript
 const result = [
   R.head([1, 2, 3]),
-  R.head('foo') 
+  R.head('foo')
 ]
 // => [1, 'f']
 ```
 
-<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20result%20%3D%20%5B%0A%20%20R.head(%5B1%2C%202%2C%203%5D)%2C%0A%20%20R.head('foo')%20%0A%5D%0A%2F%2F%20%3D%3E%20%5B1%2C%20'f'%5D">Try this <strong>R.head</strong> example in Rambda REPL</a>
+<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20result%20%3D%20%5B%0A%20%20R.head(%5B1%2C%202%2C%203%5D)%2C%0A%20%20R.head('foo')%0A%5D%0A%2F%2F%20%3D%3E%20%5B1%2C%20'f'%5D">Try this <strong>R.head</strong> example in Rambda REPL</a>
 
 <details>
 
 <summary>All TypeScript definitions</summary>
 
 ```typescript
-head<T>(listOrString: T): T extends string ? string : 
-	T extends [] ? undefined: 
-		T extends readonly [infer F, ...infer R] ? F : 
+head<T>(listOrString: T): T extends string ? string :
+	T extends [] ? undefined:
+		T extends readonly [infer F, ...infer R] ? F :
 			T extends readonly [infer F] ? F :
 				T extends [infer F] ? F :
-					T extends [infer F, ...infer R] ? F : 
-						T extends unknown[] ? T[number] : 
+					T extends [infer F, ...infer R] ? F :
+						T extends unknown[] ? T[number] :
 							undefined;
 ```
 
@@ -4744,6 +4880,109 @@ describe('R.includes', () => {
 
 [![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#includes)
 
+### indexBy
+
+```typescript
+
+indexBy<T, K extends keyof T>(
+  property: K
+): (list: readonly T[]) => Record<string, T>
+```
+
+It transforms list of objects to object using specified property as the base for the returned object.
+
+```javascript
+const result = R.indexBy(
+	'id'
+)([{id: 'xyz', title: 'A'}, {id: 'abc', title: 'B'}])
+// => {abc: {id: 'abc', title: 'B'}, xyz: {id: 'xyz', title: 'A'}}
+```
+
+<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20result%20%3D%20R.indexBy(%0A%09'id'%0A)(%5B%7Bid%3A%20'xyz'%2C%20title%3A%20'A'%7D%2C%20%7Bid%3A%20'abc'%2C%20title%3A%20'B'%7D%5D)%0A%2F%2F%20%3D%3E%20%7Babc%3A%20%7Bid%3A%20'abc'%2C%20title%3A%20'B'%7D%2C%20xyz%3A%20%7Bid%3A%20'xyz'%2C%20title%3A%20'A'%7D%7D">Try this <strong>R.indexBy</strong> example in Rambda REPL</a>
+
+<details>
+
+<summary>All TypeScript definitions</summary>
+
+```typescript
+indexBy<T, K extends keyof T>(
+  property: K
+): (list: readonly T[]) => Record<string, T>;
+indexBy<T, K extends keyof T>(
+  property: K
+): (list: T[]) => Record<string, T>;
+
+// API_MARKER_END
+// ============================================
+```
+
+</details>
+
+<details>
+
+<summary><strong>R.indexBy</strong> source</summary>
+
+```javascript
+export function indexBy(property){
+	return list => {
+		const toReturn = {}
+		for (let i = 0; i < list.length; i++){
+			const item = list[ i ]
+			const key = item[property]
+			if(key !== undefined){
+				toReturn[ key ] = item
+			}
+		}
+	
+		return toReturn
+	}
+}
+```
+
+</details>
+
+<details>
+
+<summary><strong>Tests</strong></summary>
+
+```javascript
+import { indexBy } from './indexBy.js'
+
+test('happy', () => {
+	const list = [{id: 'xyz', title: 'A'}, {id: 'abc', title: 'B'}]
+
+	expect(
+		indexBy('id')(list)
+	).toEqual(
+		{abc: {id: 'abc', title: 'B'}, xyz: {id: 'xyz', title: 'A'}}
+	)
+})
+```
+
+</details>
+
+<details>
+
+<summary><strong>TypeScript</strong> test</summary>
+
+```typescript
+import { pipe, indexBy } from 'rambda'
+
+it('R.indexBy', () => {
+	const list = [{id: 'xyz', title: 'A'}, {id: 'abc', title: 'B'}]
+	const result = pipe(
+		list,
+		indexBy('id')
+	)
+	result.abc // $ExpectType { id: string; title: string; }
+	result.foo // $ExpectType { id: string; title: string; }
+})
+```
+
+</details>
+
+[![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#indexBy)
+
 ### indexOf
 
 ```typescript
@@ -4802,18 +5041,18 @@ test('will throw with bad input', () => {
   expect(() => indexOf([])(true)).toThrow()
 })
 
-test('without list of objects - no R.equals', () => {
+test('with numbers', () => {
   expect(indexOf(3)([1, 2, 3, 4])).toBe(2)
   expect(indexOf(10)([1, 2, 3, 4])).toBe(-1)
 })
 
-test('list of objects uses R.equals', () => {
+test('list of objects use R.equals', () => {
   const listOfObjects = [{ a: 1 }, { b: 2 }, { c: 3 }]
   expect(indexOf({ c: 4 })(listOfObjects)).toBe(-1)
   expect(indexOf({ c: 3 })(listOfObjects)).toBe(2)
 })
 
-test('list of arrays uses R.equals', () => {
+test('list of arrays use R.equals', () => {
   const listOfLists = [[1], [2, 3], [2, 3, 4], [2, 3], [1], []]
   expect(indexOf([])(listOfLists)).toBe(5)
   expect(indexOf([1])(listOfLists)).toBe(0)
@@ -4855,13 +5094,13 @@ It returns all but the last element of list or string `input`.
 
 ```javascript
 const result = [
-  R.init([1, 2, 3]) , 
+  R.init([1, 2, 3]) ,
   R.init('foo')  // => 'fo'
 ]
 // => [[1, 2], 'fo']
 ```
 
-<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20result%20%3D%20%5B%0A%20%20R.init(%5B1%2C%202%2C%203%5D)%20%2C%20%0A%20%20R.init('foo')%20%20%2F%2F%20%3D%3E%20'fo'%0A%5D%0A%2F%2F%20%3D%3E%20%5B%5B1%2C%202%5D%2C%20'fo'%5D">Try this <strong>R.init</strong> example in Rambda REPL</a>
+<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20result%20%3D%20%5B%0A%20%20R.init(%5B1%2C%202%2C%203%5D)%20%2C%0A%20%20R.init('foo')%20%20%2F%2F%20%3D%3E%20'fo'%0A%5D%0A%2F%2F%20%3D%3E%20%5B%5B1%2C%202%5D%2C%20'fo'%5D">Try this <strong>R.init</strong> example in Rambda REPL</a>
 
 <details>
 
@@ -5097,9 +5336,6 @@ const expected = 'foo is BAR even 1 more'
 
 ```typescript
 interpolate(inputWithTags: string): (templateArguments: object) => string;
-
-// API_MARKER_END
-// ===========================================
 ```
 
 </details>
@@ -5436,13 +5672,13 @@ it('R.join', () => {
 
 ```typescript
 
-last<T>(listOrString: T): T extends string ? string : 
-  T extends [] ? undefined : 
-    T extends readonly [...infer R, infer L] ? L : 
+last<T>(listOrString: T): T extends string ? string :
+  T extends [] ? undefined :
+    T extends readonly [...infer R, infer L] ? L :
       T extends readonly [infer L] ? L :
         T extends [infer L] ? L :
-          T extends [...infer R, infer L] ? L : 
-            T extends unknown[] ? T[number] : 
+          T extends [...infer R, infer L] ? L :
+            T extends unknown[] ? T[number] :
               undefined
 ```
 
@@ -5463,13 +5699,13 @@ const result = [
 <summary>All TypeScript definitions</summary>
 
 ```typescript
-last<T>(listOrString: T): T extends string ? string : 
-  T extends [] ? undefined : 
-    T extends readonly [...infer R, infer L] ? L : 
+last<T>(listOrString: T): T extends string ? string :
+  T extends [] ? undefined :
+    T extends readonly [...infer R, infer L] ? L :
       T extends readonly [infer L] ? L :
         T extends [infer L] ? L :
-          T extends [...infer R, infer L] ? L : 
-            T extends unknown[] ? T[number] : 
+          T extends [...infer R, infer L] ? L :
+            T extends unknown[] ? T[number] :
               undefined;
 ```
 
@@ -5766,16 +6002,6 @@ mapAsync<T extends IterableContainer, U>(
 mapAsync<T extends IterableContainer, U>(
   fn: (value: T[number]) => Promise<U>,
 ): (data: T) => Promise<Mapped<T, U>>;
-mapAsync<T extends IterableContainer, U>(
-  fn: (value: T[number], index: number) => Promise<U>,
-  data: T
-): Promise<Mapped<T, U>>;
-mapAsync<T extends IterableContainer, U>(
-  fn: (value: T[number]) => Promise<U>,
-  data: T
-): Promise<Mapped<T, U>>;
-...
-...
 ```
 
 </details>
@@ -5789,8 +6015,8 @@ export function mapAsync(fn) {
   return async list => {
     const willReturn = []
     let i = 0
-    for (const a of list) {
-      willReturn.push(await fn(a, i++))
+    for (const x of list) {
+      willReturn.push(await fn(x, i++))
     }
 
     return willReturn
@@ -5861,14 +6087,12 @@ test('error', async () => {
 <summary><strong>TypeScript</strong> test</summary>
 
 ```typescript
-import { mapAsync, pipeAsync } from 'rambda'
-import { delay } from 'rambdax'
+import { mapAsync, pipeAsync, map } from 'rambda'
 
 const list = ['a', 'bc', 'def']
+const delay = (ms: number) => new Promise(resolve => setTimeout(resolve, ms))
 
 it('R.mapAsync', async () => {
-	const fn = async (x:unknown) => x as number + 1
-
   const result = await pipeAsync(
     list,
     mapAsync(async x => {
@@ -5877,7 +6101,7 @@ it('R.mapAsync', async () => {
       return x.length % 2 ? x.length + 1 : x.length + 10
     }),
     x => x,
-		mapAsync(fn),
+		map(x => x +1),
     mapAsync(async x => {
       await delay(100)
       return x + 1
@@ -6080,7 +6304,18 @@ describe('R.mapObject', () => {
 
     result // $ExpectType { a: string; }
   })
-  it('iterable with two three arguments', () => {
+  it('iterable with one arguments', () => {
+    const result = pipe(
+      { a: [1,2,3], b: 'foo' },
+      mapObject(a => {
+        a // $ExpectType string | number[]
+        return typeof a as string
+      }),
+    )
+
+    result // $ExpectType { a: string; b: string; }
+  })
+  it('iterable with two arguments', () => {
     const result = pipe(
       { a: 1, b: 'foo' },
       mapObject((a, b) => {
@@ -6242,16 +6477,6 @@ mapParallelAsync<T extends IterableContainer, U>(
 mapParallelAsync<T extends IterableContainer, U>(
   fn: (value: T[number]) => Promise<U>,
 ): (data: T) => Promise<Mapped<T, U>>;
-mapParallelAsync<T extends IterableContainer, U>(
-  fn: (value: T[number], index: number) => Promise<U>,
-  data: T
-): Promise<Mapped<T, U>>;
-mapParallelAsync<T extends IterableContainer, U>(
-  fn: (value: T[number]) => Promise<U>,
-  data: T
-): Promise<Mapped<T, U>>;
-...
-...
 ```
 
 </details>
@@ -6304,46 +6529,173 @@ test('pipeAsync', async () => {
 
 [![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#mapParallelAsync)
 
-### match
+### mapPropObject
 
 ```typescript
 
-match(regExpression: RegExp): (str: string) => string[]
+mapPropObject<T extends object, K extends keyof T, Value>(
+  valueMapper: (
+    value: T[K] extends ReadonlyArray<infer ElementType> ? ElementType : never,
+    data: T[K],
+  ) => Value,
+    prop: K,
+): (data: T) => T[K] extends ReadonlyArray<any>
+  ? MergeTypes<Omit<T, K> & { [P in K]: Value[] }>
+  : never
 ```
 
-Curried version of `String.prototype.match` which returns empty array, when there is no match.
+It maps over a property of object that is a list.
 
 ```javascript
-const result = [
-  R.match('a', 'foo'),
-  R.match(/([a-z]a)/g, 'bananas')
-]
-// => [[], ['ba', 'na', 'na']]
+const result = pipe(
+	{ a: [1,2,3], b: 'foo' },
+	mapPropObject(x => {
+		x // $ExpectType { a: number; b: string; }
+		return {
+			a: x,
+			flag: x > 2,
+		}
+	}, 'a'),
+)
+// => { a: [{ a: 1, flag: false },{ a: 2, flag: false }, { a: 3, flag: true }], b: 'foo' }
 ```
 
-<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20result%20%3D%20%5B%0A%20%20R.match('a'%2C%20'foo')%2C%0A%20%20R.match(%2F(%5Ba-z%5Da)%2Fg%2C%20'bananas')%0A%5D%0A%2F%2F%20%3D%3E%20%5B%5B%5D%2C%20%5B'ba'%2C%20'na'%2C%20'na'%5D%5D">Try this <strong>R.match</strong> example in Rambda REPL</a>
+<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20result%20%3D%20pipe(%0A%09%7B%20a%3A%20%5B1%2C2%2C3%5D%2C%20b%3A%20'foo'%20%7D%2C%0A%09mapPropObject(x%20%3D%3E%20%7B%0A%09%09x%20%2F%2F%20%24ExpectType%20%7B%20a%3A%20number%3B%20b%3A%20string%3B%20%7D%0A%09%09return%20%7B%0A%09%09%09a%3A%20x%2C%0A%09%09%09flag%3A%20x%20%3E%202%2C%0A%09%09%7D%0A%09%7D%2C%20'a')%2C%0A)%0A%2F%2F%20%3D%3E%20%7B%20a%3A%20%5B%7B%20a%3A%201%2C%20flag%3A%20false%20%7D%2C%7B%20a%3A%202%2C%20flag%3A%20false%20%7D%2C%20%7B%20a%3A%203%2C%20flag%3A%20true%20%7D%5D%2C%20b%3A%20'foo'%20%7D">Try this <strong>R.mapPropObject</strong> example in Rambda REPL</a>
 
 <details>
 
 <summary>All TypeScript definitions</summary>
 
 ```typescript
-match(regExpression: RegExp): (str: string) => string[];
+mapPropObject<T extends object, K extends keyof T, Value>(
+  valueMapper: (
+    value: T[K] extends ReadonlyArray<infer ElementType> ? ElementType : never,
+    data: T[K],
+  ) => Value,
+    prop: K,
+): (data: T) => T[K] extends ReadonlyArray<any>
+  ? MergeTypes<Omit<T, K> & { [P in K]: Value[] }>
+  : never;
 ```
 
 </details>
 
 <details>
 
-<summary><strong>R.match</strong> source</summary>
+<summary><strong>R.mapPropObject</strong> source</summary>
 
 ```javascript
-export function match(pattern) {
-  return input => {
-    const willReturn = input.match(pattern)
-
-    return willReturn === null ? [] : willReturn
-  }
+export function mapPropObject(fn, prop) {
+  return obj => {
+		if (!Array.isArray(obj[prop])) return obj
+			
+			return {
+				...obj,
+				[prop]: obj[prop].map(fn)
+			}
+		}
+ 	 }
+```
+
+</details>
+
+<details>
+
+<summary><strong>Tests</strong></summary>
+
+```javascript
+import { mapPropObject } from './mapPropObject.js'
+import { pipe } from './pipe.js'
+
+it('happy', () => {
+  const result = pipe(
+    { a: [1, 2, 3], b: 'foo' },
+    mapPropObject(x => ({ a: x, flag: x > 2 }), 'a'),
+  )
+
+  expect(result).toEqual({
+    a: [
+      { a: 1, flag: false },
+      { a: 2, flag: false },
+      { a: 3, flag: true },
+    ],
+    b: 'foo',
+  })
+})
+```
+
+</details>
+
+<details>
+
+<summary><strong>TypeScript</strong> test</summary>
+
+```typescript
+import {  mapPropObject, pipe } from 'rambda'
+
+describe('R.mapPropObject', () => {
+  it('iterable with one arguments', () => {
+    const result = pipe(
+      { a: [1,2,3], b: 'foo' },
+      mapPropObject(x => {
+        x // $ExpectType number
+        return {
+          a: x,
+          flag: x > 2,
+        }
+      }, 'a'),
+    )
+
+    result.a // $ExpectType { a: number; flag: boolean; }[]
+		result.b // $ExpectType string
+  })
+})
+```
+
+</details>
+
+[![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#mapPropObject)
+
+### match
+
+```typescript
+
+match(regExpression: RegExp): (str: string) => string[]
+```
+
+Curried version of `String.prototype.match` which returns empty array, when there is no match.
+
+```javascript
+const result = [
+  R.match('a', 'foo'),
+  R.match(/([a-z]a)/g, 'bananas')
+]
+// => [[], ['ba', 'na', 'na']]
+```
+
+<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20result%20%3D%20%5B%0A%20%20R.match('a'%2C%20'foo')%2C%0A%20%20R.match(%2F(%5Ba-z%5Da)%2Fg%2C%20'bananas')%0A%5D%0A%2F%2F%20%3D%3E%20%5B%5B%5D%2C%20%5B'ba'%2C%20'na'%2C%20'na'%5D%5D">Try this <strong>R.match</strong> example in Rambda REPL</a>
+
+<details>
+
+<summary>All TypeScript definitions</summary>
+
+```typescript
+match(regExpression: RegExp): (str: string) => string[];
+```
+
+</details>
+
+<details>
+
+<summary><strong>R.match</strong> source</summary>
+
+```javascript
+export function match(pattern) {
+  return input => {
+    const willReturn = input.match(pattern)
+
+    return willReturn === null ? [] : willReturn
+  }
 }
 ```
 
@@ -6643,11 +6995,11 @@ It replaces `index` in array `list` with the result of `replaceFn(list[i])`.
 ```javascript
 const result = R.pipe(
 	[1, 2, 3],
-	R.modifyItemAtIndex(1, R.add(1))
+	R.modifyItemAtIndex(1, x => x + 1)
 ) // => [1, 3, 3]
 ```
 
-<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20result%20%3D%20R.pipe(%0A%09%5B1%2C%202%2C%203%5D%2C%0A%09R.modifyItemAtIndex(1%2C%20R.add(1))%0A)%20%2F%2F%20%3D%3E%20%5B1%2C%203%2C%203%5D">Try this <strong>R.modifyItemAtIndex</strong> example in Rambda REPL</a>
+<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20result%20%3D%20R.pipe(%0A%09%5B1%2C%202%2C%203%5D%2C%0A%09R.modifyItemAtIndex(1%2C%20x%20%3D%3E%20x%20%2B%201)%0A)%20%2F%2F%20%3D%3E%20%5B1%2C%203%2C%203%5D">Try this <strong>R.modifyItemAtIndex</strong> example in Rambda REPL</a>
 
 <details>
 
@@ -6714,6 +7066,135 @@ test('when index is out of bounds', () => {
 
 [![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#modifyItemAtIndex)
 
+### modifyPath
+
+```typescript
+
+modifyPath<U, T>(path: [], fn: (value: U) => T): (obj: U) => T
+```
+
+It changes a property of object on the base of provided path and transformer function.
+
+```javascript
+const result = R.modifyPath('a.b.c', x=> x+1, {a:{b: {c:1}}})
+// => {a:{b: {c:2}}}
+```
+
+<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20result%20%3D%20R.modifyPath('a.b.c'%2C%20x%3D%3E%20x%2B1%2C%20%7Ba%3A%7Bb%3A%20%7Bc%3A1%7D%7D%7D)%0A%2F%2F%20%3D%3E%20%7Ba%3A%7Bb%3A%20%7Bc%3A2%7D%7D%7D">Try this <strong>R.modifyPath</strong> example in Rambda REPL</a>
+
+<details>
+
+<summary>All TypeScript definitions</summary>
+
+```typescript
+modifyPath<U, T>(path: [], fn: (value: U) => T): (obj: U) => T;
+modifyPath<
+  K0 extends keyof U,
+  U,
+  T
+>(path: [K0], fn: (value: U[K0]) => T): (obj: U) => DeepModify<[K0], U, T>;
+modifyPath<
+  K0 extends string & keyof U,
+  U,
+  T
+>(path: `${K0}`, fn: (value: U[K0]) => T): (obj: U) => DeepModify<[K0], U, T>;
+modifyPath<
+  K0 extends keyof U,
+  K1 extends keyof U[K0],
+  U,
+  T
+>(path: [K0, K1], fn: (value: U[K0][K1]) => T): (obj: U) => DeepModify<[K0, K1], U, T>;
+...
+...
+```
+
+</details>
+
+<details>
+
+<summary><strong>R.modifyPath</strong> source</summary>
+
+```javascript
+import { createPath } from './_internals/createPath.js'
+import { path as pathModule } from './path.js'
+
+function assoc(prop, newValue) {
+  return obj => Object.assign({}, obj, { [prop]: newValue })
+}
+
+function modifyPathFn(pathInput, fn, obj) {
+  const path = createPath(pathInput)
+  if (path.length === 1) {
+    return {
+      ...obj,
+      [path[0]]: fn(obj[path[0]]),
+    }
+  }
+  if (pathModule(path)(obj) === undefined) {
+    return obj
+  }
+
+  const val = modifyPathFn(Array.prototype.slice.call(path, 1), fn, obj[path[0]])
+  if (val === obj[path[0]]) {
+    return obj
+  }
+
+  return assoc(path[0], val)(obj)
+}
+
+export function modifyPath(pathInput, fn) {
+  return obj => modifyPathFn(pathInput, fn, obj)
+}
+```
+
+</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 } } })
+})
+```
+
+</details>
+
+<details>
+
+<summary><strong>TypeScript</strong> test</summary>
+
+```typescript
+import { modifyPath, pipe } from 'rambda'
+
+const obj = { a: { b: { c: 1 } } }
+
+describe('R.modifyPath', () => {
+  it('array path', () => {
+    const result = pipe(
+      obj,
+      modifyPath(['a', 'b', 'c'], (x: number) => String(x)),
+    )
+    result.a.b.c // $ExpectType string
+  })
+  it('string path', () => {
+    const result = pipe(
+      obj,
+      modifyPath('a.b.c', (x: number) => String(x)),
+    )
+    result.a.b.c // $ExpectType string
+  })
+})
+```
+
+</details>
+
+[![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#modifyPath)
+
 ### modifyProp
 
 ```typescript
@@ -6731,11 +7212,11 @@ const person = {
   name : 'foo',
   age  : 20,
 }
-const result = R.modifyProp('age', x => x + 1)(person) 
+const result = R.modifyProp('age', x => x + 1)(person)
 // => {name: 'foo', age: 21}
 ```
 
-<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20person%20%3D%20%7B%0A%20%20name%20%3A%20'foo'%2C%0A%20%20age%20%20%3A%2020%2C%0A%7D%0Aconst%20result%20%3D%20R.modifyProp('age'%2C%20x%20%3D%3E%20x%20%2B%201)(person)%20%0A%2F%2F%20%3D%3E%20%7Bname%3A%20'foo'%2C%20age%3A%2021%7D">Try this <strong>R.modifyProp</strong> example in Rambda REPL</a>
+<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20person%20%3D%20%7B%0A%20%20name%20%3A%20'foo'%2C%0A%20%20age%20%20%3A%2020%2C%0A%7D%0Aconst%20result%20%3D%20R.modifyProp('age'%2C%20x%20%3D%3E%20x%20%2B%201)(person)%0A%2F%2F%20%3D%3E%20%7Bname%3A%20'foo'%2C%20age%3A%2021%7D">Try this <strong>R.modifyProp</strong> example in Rambda REPL</a>
 
 <details>
 
@@ -7158,13 +7639,13 @@ const propsToOmit = 'a,c,d'
 const propsToOmitList = ['a', 'c', 'd']
 
 const result = [
-  R.omit(propsToOmit, obj), 
-  R.omit(propsToOmitList, obj) 
+  R.omit(propsToOmit, obj),
+  R.omit(propsToOmitList, obj)
 ]
 // => [{b: 2}, {b: 2}]
 ```
 
-<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20obj%20%3D%20%7Ba%3A%201%2C%20b%3A%202%2C%20c%3A%203%7D%0Aconst%20propsToOmit%20%3D%20'a%2Cc%2Cd'%0Aconst%20propsToOmitList%20%3D%20%5B'a'%2C%20'c'%2C%20'd'%5D%0A%0Aconst%20result%20%3D%20%5B%0A%20%20R.omit(propsToOmit%2C%20obj)%2C%20%0A%20%20R.omit(propsToOmitList%2C%20obj)%20%0A%5D%0A%2F%2F%20%3D%3E%20%5B%7Bb%3A%202%7D%2C%20%7Bb%3A%202%7D%5D">Try this <strong>R.omit</strong> example in Rambda REPL</a>
+<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20obj%20%3D%20%7Ba%3A%201%2C%20b%3A%202%2C%20c%3A%203%7D%0Aconst%20propsToOmit%20%3D%20'a%2Cc%2Cd'%0Aconst%20propsToOmitList%20%3D%20%5B'a'%2C%20'c'%2C%20'd'%5D%0A%0Aconst%20result%20%3D%20%5B%0A%20%20R.omit(propsToOmit%2C%20obj)%2C%0A%20%20R.omit(propsToOmitList%2C%20obj)%0A%5D%0A%2F%2F%20%3D%3E%20%5B%7Bb%3A%202%7D%2C%20%7Bb%3A%202%7D%5D">Try this <strong>R.omit</strong> example in Rambda REPL</a>
 
 <details>
 
@@ -8241,8 +8722,8 @@ test('happy', () => {
 ```typescript
 import {
   type MergeTypes,
-  allPass,
   append,
+  assertType,
   defaultTo,
   drop,
   dropLast,
@@ -8251,12 +8732,9 @@ import {
   find,
   head,
   map,
-  mapObject,
-  path,
   pick,
   pipe,
   split,
-  tap,
   union,
 } from 'rambda'
 type IsNotNever<T> = [T] extends [never] ? false : true
@@ -8275,12 +8753,6 @@ interface Book extends BaseBook {
   }
   status?: Status
 }
-interface MustReadBook extends Book {
-  status: 'must-read'
-}
-interface FamousBook extends Book {
-  status: 'famous'
-}
 interface BookWithBookmarkStatus extends Book {
   bookmarkFlag: boolean
 }
@@ -8288,14 +8760,13 @@ interface BookWithReadStatus extends Book {
   readFlag: boolean
 }
 type BookToRead = BookWithBookmarkStatus & BookWithReadStatus
-interface BookWithDescription extends Book {
-  description: string
-}
-interface BookWithUserRating extends Book {
-  userRating: number
+type FamousBook = Book & {
+	status: 'famous'
 }
-type BookWithDetails = BookWithDescription & BookWithUserRating
 
+const checkIfFamous = (x: Book): x is FamousBook => {
+	return x.status === 'famous'
+}
 const zaratustra: BaseBook = {
   title: 'Zaratustra',
   year: 1956,
@@ -8319,11 +8790,6 @@ const awardedBrothersKaramazov: Book = {
     years: [1869, 1870],
   },
 }
-const awardedBrothersKaramazovToRead: BookToRead = {
-  ...awardedBrothersKaramazov,
-  readFlag: true,
-  bookmarkFlag: true,
-}
 const awardedZaratustraToRead: BookToRead = {
   ...awardedZaratustra,
   readFlag: true,
@@ -8340,40 +8806,9 @@ const awardedBaseValue: Book = {
 
 type Status = 'famous' | 'can be skipped' | 'must-read'
 
-function checkIfMustRead(x: Book): x is MustReadBook {
-  return (x as MustReadBook).status === 'must-read'
-}
-function checkIfFamous(x: Book): x is FamousBook {
-  return (x as FamousBook).status === 'famous'
-}
-function checkReadStatus(x: Book): x is BookWithReadStatus {
-  return (x as BookWithReadStatus).readFlag
-}
-function checkBookmarkStatus(x: Book): x is BookWithBookmarkStatus {
-  return (x as BookWithBookmarkStatus).bookmarkFlag
-}
 function checkBookToRead(x: Book): x is BookToRead {
   return (x as BookToRead).readFlag && (x as BookToRead).bookmarkFlag
 }
-function checkHasDescription(x: Book): x is BookWithDescription {
-  return (x as BookWithDescription).description !== undefined
-}
-function checkHasUserRating(x: Book): x is BookWithUserRating {
-  return (x as BookWithUserRating).userRating !== undefined
-}
-
-function assertType<T, U extends T>(fn: (x: T) => x is U) {
-  return (x: T) => {
-    if (fn(x)) {
-      return x
-    }
-    throw new Error('type assertion failed')
-  }
-}
-function convertToType<T>() {
-  return <U>(x: U) => x as unknown as T
-}
-// const convertToType = <T>(x: unknown)=> x as unknown as T
 
 function tapFn<T, U>(
   transformFn: (x: T) => U,
@@ -8423,17 +8858,10 @@ describe('real use cases - books', () => {
         evolve({
           year: x => x + 1,
         }),
-        // convertToType<BookWithDescription>(),
-        // dissocPath<Book>('description'),
-        // convertToType<Record<string, string>>(),
-        // mapObject((x) => {
-        // 	return x as unknown as number;
-        // }),
         simplify,
         pick('year'),
       )
     const result = getResult(zaratustra)
-    type Foo = MergeTypes<typeof result>
     const final: Expect<IsNotNever<typeof result>> = true
   })
   it('case 3', () => {
@@ -8486,7 +8914,7 @@ const result = await R.pipeAsync(
     await R.delay(100)
     return x + 2
   },
-  R.add(2),
+  x => x +2,
   async x => {
     const delayed = await R.delay(100)
     return delayed + x
@@ -8495,7 +8923,7 @@ const result = await R.pipeAsync(
 // `result` resolves to `RAMBDAX_DELAY104`
 ```
 
-<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20result%20%3D%20await%20R.pipeAsync(%0A%20%20100%2C%0A%20%20async%20x%20%3D%3E%20%7B%0A%20%20%20%20await%20R.delay(100)%0A%20%20%20%20return%20x%20%2B%202%0A%20%20%7D%2C%0A%20%20R.add(2)%2C%0A%20%20async%20x%20%3D%3E%20%7B%0A%20%20%20%20const%20delayed%20%3D%20await%20R.delay(100)%0A%20%20%20%20return%20delayed%20%2B%20x%0A%20%20%7D%0A)%0A%2F%2F%20%60result%60%20resolves%20to%20%60RAMBDAX_DELAY104%60">Try this <strong>R.pipeAsync</strong> example in Rambda REPL</a>
+<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20result%20%3D%20await%20R.pipeAsync(%0A%20%20100%2C%0A%20%20async%20x%20%3D%3E%20%7B%0A%20%20%20%20await%20R.delay(100)%0A%20%20%20%20return%20x%20%2B%202%0A%20%20%7D%2C%0A%20%20x%20%3D%3E%20x%20%2B2%2C%0A%20%20async%20x%20%3D%3E%20%7B%0A%20%20%20%20const%20delayed%20%3D%20await%20R.delay(100)%0A%20%20%20%20return%20delayed%20%2B%20x%0A%20%20%7D%0A)%0A%2F%2F%20%60result%60%20resolves%20to%20%60RAMBDAX_DELAY104%60">Try this <strong>R.pipeAsync</strong> example in Rambda REPL</a>
 
 <details>
 
@@ -8607,11 +9035,11 @@ Basically, this is `R.map(R.prop(property))`.
 const list = [{a: 1}, {a: 2}, {b: 3}]
 const property = 'a'
 
-const result = R.pluck(property)(list) 
+const result = R.pluck(property)(list)
 // => [1, 2]
 ```
 
-<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20list%20%3D%20%5B%7Ba%3A%201%7D%2C%20%7Ba%3A%202%7D%2C%20%7Bb%3A%203%7D%5D%0Aconst%20property%20%3D%20'a'%0A%0Aconst%20result%20%3D%20R.pluck(property)(list)%20%0A%2F%2F%20%3D%3E%20%5B1%2C%202%5D">Try this <strong>R.pluck</strong> example in Rambda REPL</a>
+<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20list%20%3D%20%5B%7Ba%3A%201%7D%2C%20%7Ba%3A%202%7D%2C%20%7Bb%3A%203%7D%5D%0Aconst%20property%20%3D%20'a'%0A%0Aconst%20result%20%3D%20R.pluck(property)(list)%0A%2F%2F%20%3D%3E%20%5B1%2C%202%5D">Try this <strong>R.pluck</strong> example in Rambda REPL</a>
 
 <details>
 
@@ -8619,6 +9047,12 @@ const result = R.pluck(property)(list)
 
 ```typescript
 pluck<T, K extends keyof T>(property: K): (list: T[]) => T[K][];
+pluck<K extends PropertyKey>(prop: K): {
+  <U extends O[keyof O], UK extends keyof U, O extends Record<string, any>>(obj: K extends UK ? O : never): { [OK in keyof O]: O[OK][K] };
+  <U extends readonly unknown[] | Record<K, any>>(list: readonly U[]): U extends readonly (infer T)[] ? T[] : U extends Record<K, infer T> ? T[] : never;
+};
+...
+...
 ```
 
 </details>
@@ -8668,16 +9102,29 @@ test('with undefined', () => {
 <summary><strong>TypeScript</strong> test</summary>
 
 ```typescript
-import { pipe, pluck } from 'rambda'
+import { pipe, pluck } from "rambda";
 
-it('R.pluck', () => {
+it("R.pluck", () => {
   const input = [
-    { a: 1, b: 'foo' },
-    { a: 2, b: 'bar' },
-  ]
-  const result = pipe(input, pluck('b'))
-  result // $ExpectType string[]
-})
+    { a: 1, b: "foo" },
+    { a: 2, b: "bar" },
+  ];
+  const result = pipe(input, pluck("b"));
+  result; // $ExpectType string[]
+});
+
+it("R.pluck without R.pipe", () => {
+  interface Content {
+    text: string;
+  }
+  const content: Content[] = [
+    {
+      text: "foo",
+    },
+  ];
+  const sentences = pluck("text")(content);
+  sentences; // $ExpectType string[]
+});
 ```
 
 </details>
@@ -8756,13 +9203,13 @@ If there is no such property, it returns `undefined`.
 
 ```javascript
 const result = [
-  R.prop('x')({x: 100}), 
-  R.prop('x')({a: 1}) 
+  R.prop('x')({x: 100}),
+  R.prop('x')({a: 1})
 ]
 // => [100, undefined]
 ```
 
-<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20result%20%3D%20%5B%0A%20%20R.prop('x')(%7Bx%3A%20100%7D)%2C%20%0A%20%20R.prop('x')(%7Ba%3A%201%7D)%20%0A%5D%0A%2F%2F%20%3D%3E%20%5B100%2C%20undefined%5D">Try this <strong>R.prop</strong> example in Rambda REPL</a>
+<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20result%20%3D%20%5B%0A%20%20R.prop('x')(%7Bx%3A%20100%7D)%2C%0A%20%20R.prop('x')(%7Ba%3A%201%7D)%0A%5D%0A%2F%2F%20%3D%3E%20%5B100%2C%20undefined%5D">Try this <strong>R.prop</strong> example in Rambda REPL</a>
 
 <details>
 
@@ -9660,6 +10107,98 @@ describe('R.replace', () => {
 
 [![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#replace)
 
+### replaceAll
+
+```typescript
+
+replaceAll(patterns: (RegExp | string)[], replacer: string): (input: string) => string
+```
+
+Same as `R.replace` but it accepts array of string and regular expressions instead of a single value.
+
+```javascript
+const result = [
+	R.replaceAll(['o', /a/g], '|1|')('foa'),
+]
+// => 'f|1||1|'
+```
+
+<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20result%20%3D%20%5B%0A%09R.replaceAll(%5B'o'%2C%20%2Fa%2Fg%5D%2C%20'%7C1%7C')('foa')%2C%0A%5D%0A%2F%2F%20%3D%3E%20'f%7C1%7C%7C1%7C'">Try this <strong>R.replaceAll</strong> example in Rambda REPL</a>
+
+<details>
+
+<summary>All TypeScript definitions</summary>
+
+```typescript
+replaceAll(patterns: (RegExp | string)[], replacer: string): (input: string) => string;
+```
+
+</details>
+
+<details>
+
+<summary><strong>R.replaceAll</strong> source</summary>
+
+```javascript
+export function replaceAll(patterns, replacer) {
+  return input => {
+    let text = input
+    patterns.forEach(singlePattern => {
+      text = text.replace(singlePattern, replacer)
+    })
+
+    return text
+  }
+}
+```
+
+</details>
+
+<details>
+
+<summary><strong>Tests</strong></summary>
+
+```javascript
+import { replaceAll } from './replaceAll.js'
+
+const replacer = '|'
+const patterns = [/foo/g, 'bar']
+const input = 'foo bar baz foo bar'
+
+test('happy', () => {
+  const result = replaceAll(patterns, replacer)(input)
+  const expected = '| | baz | bar'
+
+  expect(result).toEqual(expected)
+})
+```
+
+</details>
+
+<details>
+
+<summary><strong>TypeScript</strong> test</summary>
+
+```typescript
+import { pipe, replaceAll } from 'rambda'
+
+const str = 'foo bar foo'
+const replacer = 'bar'
+const patterns = [/foo/g, 'bar']
+
+describe('R.replaceAll', () => {
+  it('happy', () => {
+    const result = pipe(str, replaceAll(patterns, replacer))
+
+    result // $ExpectType string
+  })
+})
+```
+
+</details>
+
+[![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#replaceAll)
+
 ### shuffle
 
 ```typescript
@@ -9971,6 +10510,25 @@ describe('R.sortBy', () => {
 sortByDescending<T>(sortFn: (a: T, b: T) => number): (list: T[]) => T[]
 ```
 
+```javascript
+const list = [
+  {a: 2},
+  {a: 3},
+  {a: 1}
+]
+const sortFn = x => x.a
+
+const result = R.sortByDescending(sortFn)(list)
+const expected = [
+  {a: 3},
+  {a: 2},
+  {a: 1}
+]
+// => `result` is equal to `expected`
+```
+
+<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20list%20%3D%20%5B%0A%20%20%7Ba%3A%202%7D%2C%0A%20%20%7Ba%3A%203%7D%2C%0A%20%20%7Ba%3A%201%7D%0A%5D%0Aconst%20sortFn%20%3D%20x%20%3D%3E%20x.a%0A%0Aconst%20result%20%3D%20R.sortByDescending(sortFn)(list)%0Aconst%20expected%20%3D%20%5B%0A%20%20%7Ba%3A%203%7D%2C%0A%20%20%7Ba%3A%202%7D%2C%0A%20%20%7Ba%3A%201%7D%0A%5D%0A%2F%2F%20%3D%3E%20%60result%60%20is%20equal%20to%20%60expected%60">Try this <strong>R.sortByDescending</strong> example in Rambda REPL</a>
+
 <details>
 
 <summary>All TypeScript definitions</summary>
@@ -10008,6 +10566,23 @@ sortByPath<S, K0 extends string & keyof S>(
 
 It sorts `list` by the value of `path` property.
 
+```javascript
+const list = [
+	{a: {b: 2}, id:1},
+	{a: {b: 1}, id:2},
+	{a: {b: 3}, id:3},
+]
+const result = R.sortByPath('a.b')(list)
+const expected = [
+	{a: {b: 1}, id:2},
+	{a: {b: 2}, id:1},
+	{a: {b: 3}, id:3}
+]
+// => `result` is equal to `expected`
+```
+
+<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20list%20%3D%20%5B%0A%09%7Ba%3A%20%7Bb%3A%202%7D%2C%20id%3A1%7D%2C%0A%09%7Ba%3A%20%7Bb%3A%201%7D%2C%20id%3A2%7D%2C%0A%09%7Ba%3A%20%7Bb%3A%203%7D%2C%20id%3A3%7D%2C%0A%5D%0Aconst%20result%20%3D%20R.sortByPath('a.b')(list)%0Aconst%20expected%20%3D%20%5B%0A%09%7Ba%3A%20%7Bb%3A%201%7D%2C%20id%3A2%7D%2C%0A%09%7Ba%3A%20%7Bb%3A%202%7D%2C%20id%3A1%7D%2C%0A%09%7Ba%3A%20%7Bb%3A%203%7D%2C%20id%3A3%7D%0A%5D%0A%2F%2F%20%3D%3E%20%60result%60%20is%20equal%20to%20%60expected%60">Try this <strong>R.sortByPath</strong> example in Rambda REPL</a>
+
 <details>
 
 <summary>All TypeScript definitions</summary>
@@ -10112,6 +10687,23 @@ sortByPathDescending<S, K0 extends string & keyof S>(
 ): (list: S[]) => S[]
 ```
 
+```javascript
+const list = [
+	{a: {b: 2}, id:1},
+	{a: {b: 1}, id:2},
+	{a: {b: 3}, id:3},
+]
+const result = R.sortByPathDescending('a.b')(list)
+const expected = [
+	{a: {b: 3}, id:3}
+	{a: {b: 2}, id:1},
+	{a: {b: 1}, id:2},
+]
+// => `result` is equal to `expected`
+```
+
+<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20list%20%3D%20%5B%0A%09%7Ba%3A%20%7Bb%3A%202%7D%2C%20id%3A1%7D%2C%0A%09%7Ba%3A%20%7Bb%3A%201%7D%2C%20id%3A2%7D%2C%0A%09%7Ba%3A%20%7Bb%3A%203%7D%2C%20id%3A3%7D%2C%0A%5D%0Aconst%20result%20%3D%20R.sortByPathDescending('a.b')(list)%0Aconst%20expected%20%3D%20%5B%0A%09%7Ba%3A%20%7Bb%3A%203%7D%2C%20id%3A3%7D%0A%09%7Ba%3A%20%7Bb%3A%202%7D%2C%20id%3A1%7D%2C%0A%09%7Ba%3A%20%7Bb%3A%201%7D%2C%20id%3A2%7D%2C%0A%5D%0A%2F%2F%20%3D%3E%20%60result%60%20is%20equal%20to%20%60expected%60">Try this <strong>R.sortByPathDescending</strong> example in Rambda REPL</a>
+
 <details>
 
 <summary>All TypeScript definitions</summary>
@@ -10185,11 +10777,11 @@ It returns a sorted version of `input` object.
 ```javascript
 const predicate = (propA, propB, valueA, valueB) => valueA > valueB ? -1 : 1
 
-const result = R.sortObject(predicate, {a:1, b: 4, c: 2})
+const result = R.sortObject(predicate)({a:1, b: 4, c: 2})
 // => {b: 4, c: 2, a: 1}
 ```
 
-<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20predicate%20%3D%20(propA%2C%20propB%2C%20valueA%2C%20valueB)%20%3D%3E%20valueA%20%3E%20valueB%20%3F%20-1%20%3A%201%0A%0Aconst%20result%20%3D%20R.sortObject(predicate%2C%20%7Ba%3A1%2C%20b%3A%204%2C%20c%3A%202%7D)%0A%2F%2F%20%3D%3E%20%7Bb%3A%204%2C%20c%3A%202%2C%20a%3A%201%7D">Try this <strong>R.sortObject</strong> example in Rambda REPL</a>
+<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20predicate%20%3D%20(propA%2C%20propB%2C%20valueA%2C%20valueB)%20%3D%3E%20valueA%20%3E%20valueB%20%3F%20-1%20%3A%201%0A%0Aconst%20result%20%3D%20R.sortObject(predicate)(%7Ba%3A1%2C%20b%3A%204%2C%20c%3A%202%7D)%0A%2F%2F%20%3D%3E%20%7Bb%3A%204%2C%20c%3A%202%2C%20a%3A%201%7D">Try this <strong>R.sortObject</strong> example in Rambda REPL</a>
 
 <details>
 
@@ -10550,8 +11142,8 @@ It splits `input` into slices of `sliceLength`.
 
 ```javascript
 const result = [
-  R.splitEvery(2, [1, 2, 3]), 
-  R.splitEvery(3, 'foobar') 
+  R.splitEvery(2)([1, 2, 3]),
+  R.splitEvery(3)('foobar')
 ]
 
 const expected = [
@@ -10561,7 +11153,7 @@ const expected = [
 // => `result` is equal to `expected`
 ```
 
-<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20result%20%3D%20%5B%0A%20%20R.splitEvery(2%2C%20%5B1%2C%202%2C%203%5D)%2C%20%0A%20%20R.splitEvery(3%2C%20'foobar')%20%0A%5D%0A%0Aconst%20expected%20%3D%20%5B%0A%20%20%5B%5B1%2C%202%5D%2C%20%5B3%5D%5D%2C%0A%20%20%5B'foo'%2C%20'bar'%5D%0A%5D%0A%2F%2F%20%3D%3E%20%60result%60%20is%20equal%20to%20%60expected%60">Try this <strong>R.splitEvery</strong> example in Rambda REPL</a>
+<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20result%20%3D%20%5B%0A%20%20R.splitEvery(2)(%5B1%2C%202%2C%203%5D)%2C%0A%20%20R.splitEvery(3)('foobar')%0A%5D%0A%0Aconst%20expected%20%3D%20%5B%0A%20%20%5B%5B1%2C%202%5D%2C%20%5B3%5D%5D%2C%0A%20%20%5B'foo'%2C%20'bar'%5D%0A%5D%0A%2F%2F%20%3D%3E%20%60result%60%20is%20equal%20to%20%60expected%60">Try this <strong>R.splitEvery</strong> example in Rambda REPL</a>
 
 <details>
 
@@ -10648,11 +11240,11 @@ It returns a merged list of `x` and `y` with all equal elements removed.
 const x = [ 1, 2, 3, 4 ]
 const y = [ 3, 4, 5, 6 ]
 
-const result = R.symmetricDifference(x, y)
+const result = R.symmetricDifference(x)(y)
 // => [ 1, 2, 5, 6 ]
 ```
 
-<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20x%20%3D%20%5B%201%2C%202%2C%203%2C%204%20%5D%0Aconst%20y%20%3D%20%5B%203%2C%204%2C%205%2C%206%20%5D%0A%0Aconst%20result%20%3D%20R.symmetricDifference(x%2C%20y)%0A%2F%2F%20%3D%3E%20%5B%201%2C%202%2C%205%2C%206%20%5D">Try this <strong>R.symmetricDifference</strong> example in Rambda REPL</a>
+<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20x%20%3D%20%5B%201%2C%202%2C%203%2C%204%20%5D%0Aconst%20y%20%3D%20%5B%203%2C%204%2C%205%2C%206%20%5D%0A%0Aconst%20result%20%3D%20R.symmetricDifference(x)(y)%0A%2F%2F%20%3D%3E%20%5B%201%2C%202%2C%205%2C%206%20%5D">Try this <strong>R.symmetricDifference</strong> example in Rambda REPL</a>
 
 <details>
 
@@ -10743,13 +11335,13 @@ It returns all but the first element of `input`.
 
 ```javascript
 const result = [
-  R.tail([1, 2, 3]),  
-  R.tail('foo') 
+  R.tail([1, 2, 3]),
+  R.tail('foo')
 ]
 // => [[2, 3], 'oo']
 ```
 
-<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20result%20%3D%20%5B%0A%20%20R.tail(%5B1%2C%202%2C%203%5D)%2C%20%20%0A%20%20R.tail('foo')%20%0A%5D%0A%2F%2F%20%3D%3E%20%5B%5B2%2C%203%5D%2C%20'oo'%5D">Try this <strong>R.tail</strong> example in Rambda REPL</a>
+<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20result%20%3D%20%5B%0A%20%20R.tail(%5B1%2C%202%2C%203%5D)%2C%0A%20%20R.tail('foo')%0A%5D%0A%2F%2F%20%3D%3E%20%5B%5B2%2C%203%5D%2C%20'oo'%5D">Try this <strong>R.tail</strong> example in Rambda REPL</a>
 
 <details>
 
@@ -11212,23 +11804,23 @@ it('R.takeWhile', () => {
 tap<T>(fn: (x: T) => void): (input: T) => T
 ```
 
-It applies function `fn` to input `x` and returns `x`. 
+It applies function `fn` to input `x` and returns `x`.
 
 One use case is debugging in the middle of `R.pipe` chain.
 
 ```javascript
 const list = [1, 2, 3]
 
-R.pipe(
+const result = R.pipe(
 	list,
-  R.map(x => x * 2)
+  R.filter(x => x > 1),
   R.tap(console.log),
-  R.filter(x => x > 1)
+  R.map(x => x * 2)
 )
 // => `2` and `3` will be logged
 ```
 
-<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.pipe(%0A%09list%2C%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)%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>
+<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20list%20%3D%20%5B1%2C%202%2C%203%5D%0A%0Aconst%20result%20%3D%20R.pipe(%0A%09list%2C%0A%20%20R.filter(x%20%3D%3E%20x%20%3E%201)%2C%0A%20%20R.tap(console.log)%2C%0A%20%20R.map(x%20%3D%3E%20x%20*%202)%0A)%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>
 
 <details>
 
@@ -11332,6 +11924,63 @@ it('R.test', () => {
 
 [![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#test)
 
+### transformPropObject
+
+```typescript
+
+transformPropObject<T extends object, K extends keyof T, Value>(
+  valueMapper: (value: T[K]) => Value,
+  prop: K,
+): (data: T) => MergeTypes<Omit<T, K> & { [P in K]: Value }>
+```
+
+```javascript
+const fn = (x) => x > 2
+const obj = {a: 1, b: 2}
+
+const result = R.transformPropObject(fn, 'a')(obj)
+// => {a: false, b: 2}
+```
+
+<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20fn%20%3D%20(x)%20%3D%3E%20x%20%3E%202%0Aconst%20obj%20%3D%20%7Ba%3A%201%2C%20b%3A%202%7D%0A%0Aconst%20result%20%3D%20R.transformPropObject(fn%2C%20'a')(obj)%0A%2F%2F%20%3D%3E%20%7Ba%3A%20false%2C%20b%3A%202%7D">Try this <strong>R.transformPropObject</strong> example in Rambda REPL</a>
+
+<details>
+
+<summary>All TypeScript definitions</summary>
+
+```typescript
+transformPropObject<T extends object, K extends keyof T, Value>(
+  valueMapper: (value: T[K]) => Value,
+  prop: K,
+): (data: T) => MergeTypes<Omit<T, K> & { [P in K]: Value }>;
+```
+
+</details>
+
+<details>
+
+<summary><strong>TypeScript</strong> test</summary>
+
+```typescript
+import {  transformPropObject, pipe } from 'rambda'
+
+it('R.transformPropObject', () => {
+	const result = pipe(
+		{ a: 1, b: 'foo' },
+		transformPropObject(x => {
+			x // $ExpectType number
+			return x > 2
+		}, 'a'),
+	)
+
+	result // $ExpectType { b: string; a: boolean; }
+})
+```
+
+</details>
+
+[![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#transformPropObject)
+
 ### tryCatch
 
 ```typescript
@@ -11726,16 +12375,16 @@ describe('R.type', () => {
 union<T>(x: T[]): (y: T[]) => T[]
 ```
 
-It takes two lists and return a new list containing a merger of both list with removed duplicates. 
+It takes two lists and return a new list containing a merger of both list with removed duplicates.
 
 `R.equals` is used to compare for duplication.
 
 ```javascript
-const result = R.union([1,2,3], [3,4,5]);
+const result = R.union([1,2,3])([3,4,5]);
 // => [1, 2, 3, 4, 5]
 ```
 
-<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20result%20%3D%20R.union(%5B1%2C2%2C3%5D%2C%20%5B3%2C4%2C5%5D)%3B%0A%2F%2F%20%3D%3E%20%5B1%2C%202%2C%203%2C%204%2C%205%5D">Try this <strong>R.union</strong> example in Rambda REPL</a>
+<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20result%20%3D%20R.union(%5B1%2C2%2C3%5D)(%5B3%2C4%2C5%5D)%3B%0A%2F%2F%20%3D%3E%20%5B1%2C%202%2C%203%2C%204%2C%205%5D">Try this <strong>R.union</strong> example in Rambda REPL</a>
 
 <details>
 
@@ -11946,12 +12595,12 @@ It applies uniqueness to input list based on function that defines what to be us
 
 ```javascript
 const list = [{a:1}, {a:2}, {a:1}]
-const result = R.uniqBy(x => x, list)
+const result = R.uniqBy(x => x)(list)
 
 // => [{a:1}, {a:2}]
 ```
 
-<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>
+<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)(list)%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>
 
 <details>
 
@@ -12428,11 +13077,11 @@ const index = 2
 const newValue = 88
 const list = [1, 2, 3, 4, 5]
 
-const result = R.update(index, newValue, list)
+const result = R.update(index, newValue)(list)
 // => [1, 2, 88, 4, 5]
 ```
 
-<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20index%20%3D%202%0Aconst%20newValue%20%3D%2088%0Aconst%20list%20%3D%20%5B1%2C%202%2C%203%2C%204%2C%205%5D%0A%0Aconst%20result%20%3D%20R.update(index%2C%20newValue%2C%20list)%0A%2F%2F%20%3D%3E%20%5B1%2C%202%2C%2088%2C%204%2C%205%5D">Try this <strong>R.update</strong> example in Rambda REPL</a>
+<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20index%20%3D%202%0Aconst%20newValue%20%3D%2088%0Aconst%20list%20%3D%20%5B1%2C%202%2C%203%2C%204%2C%205%5D%0A%0Aconst%20result%20%3D%20R.update(index%2C%20newValue)(list)%0A%2F%2F%20%3D%3E%20%5B1%2C%202%2C%2088%2C%204%2C%205%5D">Try this <strong>R.update</strong> example in Rambda REPL</a>
 
 <details>
 
@@ -12511,31 +13160,29 @@ test('with negative index', () => {
 when<T, U extends T>(predicate: (x: T) => x is U, whenTrueFn: (x: U) => T): (input: T) => T
 ```
 
-It pass `input` to `predicate` function and if the result is `true`, it will return the result of `whenTrueFn(input)`. 
+It pass `input` to `predicate` function and if the result is `true`, it will return the result of `whenTrueFn(input)`.
 If the `predicate` returns `false`, then it will simply return `input`.
 
 ```javascript
 const predicate = x => typeof x === 'number'
-const whenTrueFn = R.add(11)
-
-const fn = when(predicate, whenTrueResult)
+const fn = R.when(predicate)(x => x + 1)
 
 const positiveInput = 88
 const negativeInput = 'foo'
 
 const result = [
   fn(positiveInput),
-  fn(positiveInput),
+  fn(negativeInput),
 ]
 
 const expected = [
-  99,
-  'foo',
+  89,
+  'foo1',
 ]
 // => `result` is equal to `expected`
 ```
 
-<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20predicate%20%3D%20x%20%3D%3E%20typeof%20x%20%3D%3D%3D%20'number'%0Aconst%20whenTrueFn%20%3D%20R.add(11)%0A%0Aconst%20fn%20%3D%20when(predicate%2C%20whenTrueResult)%0A%0Aconst%20positiveInput%20%3D%2088%0Aconst%20negativeInput%20%3D%20'foo'%0A%0Aconst%20result%20%3D%20%5B%0A%20%20fn(positiveInput)%2C%0A%20%20fn(positiveInput)%2C%0A%5D%0A%0Aconst%20expected%20%3D%20%5B%0A%20%2099%2C%0A%20%20'foo'%2C%0A%5D%0A%2F%2F%20%3D%3E%20%60result%60%20is%20equal%20to%20%60expected%60">Try this <strong>R.when</strong> example in Rambda REPL</a>
+<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20predicate%20%3D%20x%20%3D%3E%20typeof%20x%20%3D%3D%3D%20'number'%0Aconst%20fn%20%3D%20R.when(predicate)(x%20%3D%3E%20x%20%2B%201)%0A%0Aconst%20positiveInput%20%3D%2088%0Aconst%20negativeInput%20%3D%20'foo'%0A%0Aconst%20result%20%3D%20%5B%0A%20%20fn(positiveInput)%2C%0A%20%20fn(negativeInput)%2C%0A%5D%0A%0Aconst%20expected%20%3D%20%5B%0A%20%2089%2C%0A%20%20'foo1'%2C%0A%5D%0A%2F%2F%20%3D%3E%20%60result%60%20is%20equal%20to%20%60expected%60">Try this <strong>R.when</strong> example in Rambda REPL</a>
 
 <details>
 
@@ -12638,7 +13285,7 @@ describe('R.when', () => {
 zip<K>(x: K[]): <V>(y: V[]) => KeyValuePair<K, V>[]
 ```
 
-It will return a new array containing tuples of equally positions items from both `x` and `y` lists. 
+It will return a new array containing tuples of equally positions items from both `x` and `y` lists.
 
 The returned list will be truncated to match the length of the shortest supplied list.
 
@@ -12767,11 +13414,11 @@ zipWith<T, U, TResult>(
 const list1 = [ 10, 20, 30, 40 ]
 const list2 = [ 100, 200 ]
 
-const result = R.zipWith(R.add, list1)(list2)
+const result = R.zipWith((x, y) => x + y, list1)(list2)
 // => [110, 220]
 ```
 
-<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20list1%20%3D%20%5B%2010%2C%2020%2C%2030%2C%2040%20%5D%0Aconst%20list2%20%3D%20%5B%20100%2C%20200%20%5D%0A%0Aconst%20result%20%3D%20R.zipWith(R.add%2C%20list1)(list2)%0A%2F%2F%20%3D%3E%20%5B110%2C%20220%5D">Try this <strong>R.zipWith</strong> example in Rambda REPL</a>
+<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20list1%20%3D%20%5B%2010%2C%2020%2C%2030%2C%2040%20%5D%0Aconst%20list2%20%3D%20%5B%20100%2C%20200%20%5D%0A%0Aconst%20result%20%3D%20R.zipWith((x%2C%20y)%20%3D%3E%20x%20%2B%20y%2C%20list1)(list2)%0A%2F%2F%20%3D%3E%20%5B110%2C%20220%5D">Try this <strong>R.zipWith</strong> example in Rambda REPL</a>
 
 <details>
 
@@ -12860,6 +13507,26 @@ describe('R.zipWith', () => {
 
 ## ❯ CHANGELOG
 
+10.3.0
+
+- Add `R.mapPropObject`
+
+- Add `R.duplicateBy`
+
+- Add `R.filterAsync`
+
+- Add `R.indexBy`
+
+- Restore `R.replaceAll`
+
+- Remove option for `R.mapAsync` to be called outside of `R.pipeAsync`. This is done for consistency as all other methods follow this rule, i.e. they are all curried.
+
+- Fix `R.pluck` to work without `R.pipe`
+
+10.2.0
+
+Add `R.modifyPath`
+
 10.1.0
 
 - Add `R.assertType` and `R.convertToType` methods
@@ -12884,7 +13551,7 @@ This is major revamp of `Rambda` library:
 
 - Confusing methods are removed. For example, `R.cond` and `R.ifElse` are removed as their usage inside `R.piped` makes the whole chain less readable. Such logic should be part of your codebase, not part of external library.
 
-- All methods that expect more than 1 input, will have to be called with `R.methodName(input1)(input2)` or `R.methodName(input1, input2)(input3)`. This is to make TypeScript definitions easier to maintain. 
+- All methods that expect more than 1 input, will have to be called with `R.methodName(input1)(input2)` or `R.methodName(input1, input2)(input3)`. This is to make TypeScript definitions easier to maintain.
 
 - Optimize many methods to better work in TypeScript context with `R.pipe`. The focus was passing objects through the `R.pipe` chain.
 
@@ -12896,83 +13563,149 @@ This is major revamp of `Rambda` library:
 - Remove following methods:
 
 -- Lenses - `R.lens`, `R.lensProp`, `R.lensPath`, `R.view`, `R.set`, `R.over`
+
 -- T, F
+
 -- add
+
 -- addIndex, addIndexRight
+
 -- always
+
 -- ap
+
 -- applySpec
+
 -- applyTo
+
 -- assoc, assocPath, dissoc, dissocPath
+
 -- binary
+
 -- bind
+
 -- call
+
 -- collectBy
+
 -- compose
+
 -- composeWith
+
 -- cond
+
 -- converge
+
 -- curry
+
 -- difference, differenceWith
+
 -- divide, multiply, subtract
+
 -- endsWith/startsWith
+
 -- flip
+
 -- forEachObjIndexed
+
 -- fromPairs
+
 -- gte, lte, lt, gt
+
 -- identical
+
 -- ifElse
+
 -- insert
+
 -- juxt
+
 -- length
+
 -- mapObjIndexed
+
 -- mergeAll, mergeLeft, mergeDeepLeft, mergeDeepRight
+
 -- move
+
 -- partitionIndexed
+
 -- pickAll
+
 -- pickBy
+
 -- repeat
+
 -- splitWhen
+
 -- toLower/toUpper
+
 -- unapply
+
 -- unnest
+
 -- update
+
 -- without
 
 - Add following methods:
 
 -- R.pipeAsync
+
 -- R.addProp
+
 -- R.createObjectFromKeys
+
 -- R.mapAsync
+
 -- R.mapParallelAsync
+
 -- R.ascend/R.descend
+
 -- R.shuffle
+
 -- R.permutations
+
 -- R.compact
+
 -- R.rejectObject
+
 -- R.findNth
+
 -- R.combinations
+
 -- R.sortByPath
+
 -- R.sortByPathDescending
+
 -- R.sortByDescending
+
 -- R.flattenObject
+
 -- R.addPropToObjects
 
 - Rename following methods:
 
 -- modifyItemAtIndex -> adjust
--- checkObjectWithSpec -> where 
+
+-- checkObjectWithSpec -> where
+
 -- objectIncludes -> whereEq
+
 -- modify -> modifyProp
+
 -- chain -> flatMap
+
 -- mapObjIndexed -> mapObject
 
 _ Regarding using object as input with TypeScript in methods such as `R.map/filter` - this feature is no longer supported in TypeScript as it has multiple issues when using inside pipes. In JS, it still works as before. Following methods are affected:
 
 -- R.map
+
 -- R.mapIndexed
+
 -- R.filter
+
 -- R.reject
 
 - Regarding using string as path input in `R.omit`, `R.pick` and `R.path` with TypeScript - now it require explicit definition of expected return type.
@@ -13001,36 +13734,63 @@ _ Regarding using object as input with TypeScript in methods such as `R.map/filt
 - Sync with typing of `@types/ramda`:
 
 -- allPass
+
 -- anyPass
+
 -- append
+
 -- both
+
 -- countBy
+
 -- drop
+
 -- dropLast
+
 -- dropRepeatsBy
+
 -- either
+
 -- filter
+
 -- forEach
+
 -- keys
+
 -- map
+
 -- mergeAll
+
 -- modify
+
 -- modifyPath
+
 -- omit
+
 -- partition
+
 -- pluck
+
 -- prepend
+
 -- propEq
+
 -- where
+
 -- whereAny
 
 - Sync with typing of `remeda`:
 
 -- filter
+
 -- reject
+
 -- map
+
 -- mapObject
+
 -- toPairs
+
 -- partition
 
 - Publish to JSR registry - https://jsr.io/@rambda/rambda
@@ -13040,7 +13800,9 @@ _ Regarding using object as input with TypeScript in methods such as `R.map/filt
 - Improve TypeScript definitions of:
 
 -- objOf
+
 -- pluck
+
 -- mergeWith
 
 - Change `Jest` with `Vitest`.
@@ -13086,7 +13848,7 @@ const result = piped(
 
 - Add `R.isNotEmpty` as it is new method in `Ramda`
 
-- Fix `R.head`/`R.last` TS definition - It returns `undefined` if array has length of 0. Before 
+- Fix `R.head`/`R.last` TS definition - It returns `undefined` if array has length of 0. Before
 
 9.2.1
 
@@ -13096,7 +13858,7 @@ const result = piped(
 
 - `R.once` TS type definition miss to context argument and its type - [Issue #728](https://github.com/selfrefactor/rambda/issues/728)
 
-- Fix implementation of `R.unless` function - https://github.com/selfrefactor/rambda/pull/726 
+- Fix implementation of `R.unless` function - https://github.com/selfrefactor/rambda/pull/726
 
 9.1.1
 
@@ -13172,7 +13934,7 @@ Breaking change in TS definitions of `lenses` as now they are synced to `Ramda`
 
 - Fix cannot compare errors in `Deno` with `R.equals` - [Issue #704](https://github.com/selfrefactor/rambda/issues/704).
 
-- Fix cannot compare `BigInt` with `R.equals` 
+- Fix cannot compare `BigInt` with `R.equals`
 
 8.3.0
 
@@ -13256,7 +14018,7 @@ Add the following methods:
 
 7.2.1
 
-- Remove bad typings of `R.propIs` which caused the library to cannot be build with TypeScript. 
+- Remove bad typings of `R.propIs` which caused the library to cannot be build with TypeScript.
 
 - Drop support for `Wallaby` as per [https://github.com/wallabyjs/public/issues/3037](https://github.com/wallabyjs/public/issues/3037)
 
@@ -13350,11 +14112,11 @@ There are several other changes in `@types/ramda` as stated in [this comment](ht
 
 -- R.toUpper
 
-- 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`. 
+- 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`
 
-- `R.startsWith/R.endsWith` now support lists as inputs. This way, it matches current Ramda behavior. 
+- `R.startsWith/R.endsWith` now support lists as inputs. This way, it matches current Ramda behavior.
 
 - Remove unused typing for `R.chain`.
 
@@ -13382,7 +14144,7 @@ There are several other changes in `@types/ramda` as stated in [this comment](ht
 
 - Incorrect benchmarks for `R.pipe/R.compose` - [Issue #608](https://github.com/selfrefactor/rambda/issues/608)
 
-- Fix `R.last/R.head` typings - [Issue #609](https://github.com/selfrefactor/rambda/issues/609) 
+- Fix `R.last/R.head` typings - [Issue #609](https://github.com/selfrefactor/rambda/issues/609)
 
 6.9.0
 
@@ -13397,7 +14159,7 @@ Fixing `R.uniq` was done by improving `R.indexOf` which has performance implicat
 - R.symmetricDifference
 - R.union
 
-- R.without no longer support the following case - `without('0:1', ['0', '0:1']) // => ['0']`. Now it throws as the first argument should be a list, not a string. Ramda, on the other hand, returns an empty list - https://github.com/ramda/ramda/issues/3086. 
+- R.without no longer support the following case - `without('0:1', ['0', '0:1']) // => ['0']`. Now it throws as the first argument should be a list, not a string. Ramda, on the other hand, returns an empty list - https://github.com/ramda/ramda/issues/3086.
 
 6.8.3
 
@@ -13482,25 +14244,25 @@ Fix wrong versions in changelog
 
 > Most influential contributors(in alphabetical order)
 
-- ![farwayer avatar](https://avatars.githubusercontent.com/farwayer) [@farwayer](https://github.com/farwayer) - improving performance in R.find, R.filter; give the idea how to make benchmarks more reliable;
+- [@farwayer](https://github.com/farwayer) - improving performance in R.find, R.filter; give the idea how to make benchmarks more reliable;
 
-- ![thejohnfreeman avatar](https://avatars.githubusercontent.com/thejohnfreeman) [@thejohnfreeman](https://github.com/thejohnfreeman) - add R.assoc, R.chain;
+- [@thejohnfreeman](https://github.com/thejohnfreeman) - add R.assoc, R.chain;
 
-- ![peeja avatar](https://avatars.githubusercontent.com/peeja) [@peeja](https://github.com/peeja) - add several methods and fix mutiple issues; provides great MR documentation
+- [@peeja](https://github.com/peeja) - add several methods and fix mutiple issues; provides great MR documentation
 
-- ![helmuthdu avatar](https://avatars.githubusercontent.com/helmuthdu) [@helmuthdu](https://github.com/helmuthdu) - add R.clone; help improve code style;
+- [@helmuthdu](https://github.com/helmuthdu) - add R.clone; help improve code style;
 
-- ![jpgorman avatar](https://avatars.githubusercontent.com/jpgorman) [@jpgorman](https://github.com/jpgorman) - add R.zip, R.reject, R.without, R.addIndex;
+- [@jpgorman](https://github.com/jpgorman) - add R.zip, R.reject, R.without, R.addIndex;
 
-- ![ku8ar avatar](https://avatars.githubusercontent.com/ku8ar) [@ku8ar](https://github.com/ku8ar) - add R.slice, R.propOr, R.identical, R.propIs and several math related methods; introduce the idea to display missing Ramda methods;
+- [@ku8ar](https://github.com/ku8ar) - add R.slice, R.propOr, R.identical, R.propIs and several math related methods; introduce the idea to display missing Ramda methods;
 
-- ![romgrk avatar](https://avatars.githubusercontent.com/romgrk) [@romgrk](https://github.com/romgrk) - add R.groupBy, R.indexBy, R.findLast, R.findLastIndex;
+- [@romgrk](https://github.com/romgrk) - add R.groupBy, R.indexBy, R.findLast, R.findLastIndex;
 
-- ![squidfunk avatar](https://avatars.githubusercontent.com/squidfunk) [@squidfunk](https://github.com/squidfunk) - add R.assocPath, R.symmetricDifference, R.difference, R.intersperse;
+- [@squidfunk](https://github.com/squidfunk) - add R.assocPath, R.symmetricDifference, R.difference, R.intersperse;
 
-- ![synthet1c avatar](https://avatars.githubusercontent.com/synthet1c) [@synthet1c](https://github.com/synthet1c) - add all lenses methods; add R.applySpec, R.converge;
+- [@synthet1c](https://github.com/synthet1c) - add all lenses methods; add R.applySpec, R.converge;
 
-- ![vlad-zhukov avatar](https://avatars.githubusercontent.com/vlad-zhukov) [@vlad-zhukov](https://github.com/vlad-zhukov) - help with configuring Rollup, Babel; change export file to use ES module exports;
+- [@vlad-zhukov](https://github.com/vlad-zhukov) - help with configuring Rollup, Babel; change export file to use ES module exports;
 
 > Rambda references