rambda 8.6.0 → 9.0.1

package/README.md

@@ -9,7 +9,7 @@
 ![Library size](https://img.shields.io/bundlephobia/minzip/rambda)
 [![install size](https://packagephobia.com/badge?p=rambda)](https://packagephobia.com/result?p=rambda)
 [![nest badge](https://nest.land/badge.svg)](https://nest.land/package/rambda)
-[![HitCount](https://hits.dwyl.com/selfrefactor/rambda.svg?style=flat-square)](http://hits.dwyl.com/selfrefactor/rambda)
+[![PR's Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat)](https://github.com/selfrefactor/rambda/pulls)
 
 ## ❯ Example use
 
@@ -41,7 +41,15 @@ Still, you need to be aware that functional programming features in `TypeScript`
 
 Important - Rambda version `7.1.0`(or higher) requires TypeScript version `4.3.3`(or higher).
 
-#### Immutable TS definitions
+### Understandable source code due to little usage of internals
+
+`Ramda` uses a lot of internals, which hides a lot of logic. Reading the full source code of a method can be challenging.
+
+### Better VSCode experience
+
+If the project is written in Javascript, then `go to source definition` action will lead you to actual implementation of the method.
+
+### Immutable TS definitions
 
 You can use immutable version of Rambda definitions, which is linted with ESLint `functional/prefer-readonly-type` plugin.
 
@@ -98,13 +106,9 @@ One of the main issues with `Ramda` is the slow process of releasing new version
 
 <details>
 <summary>
-  Click to see the full list of 0 Ramda methods not implemented in Rambda and their status.
+  Click to see the full list of 51 Ramda methods not implemented in Rambda and their status.
 </summary>
 
-- gt
-- gte
-- hasIn
-- innerJoin
 - insert
 - insertAll
 - into
@@ -135,14 +139,12 @@ One of the main issues with `Ramda` is the slow process of releasing new version
 - pipeWith
 - project
 - promap
-- reduceBy
 - reduceRight
 - reduceWhile
 - reduced
 - remove
 - scan
 - sequence
-- sortWith
 - splitWhenever
 - swap
 - symmetricDifferenceWith
@@ -329,10 +331,14 @@ It adds `a` and `b`.
 
 ### addIndex
 
+<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20result%20%3D%20R.addIndex(R.map)((val%2C%20idx)%20%3D%3E%20val%20%2B%20idx%20%2B%201%2C%20%5B1%2C%202%2C%203%5D)%0A%2F%2F%20%3D%3E%20%5B2%2C%204%2C%206%5D">Try this <strong>R.addIndex</strong> example in Rambda REPL</a>
+
 [![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#addIndex)
 
 ### addIndexRight
 
+Same as `R.addIndex`, but it will passed indexes are decreasing, instead of increasing.
+
 [![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#addIndexRight)
 
 ### adjust
@@ -953,6 +959,10 @@ describe('anyPass', () => {
 ap<T, U>(fns: Array<(a: T) => U>[], vs: T[]): U[]
 ```
 
+It takes a list of functions and a list of values. Then it returns a list of values obtained by applying each function to each value.
+
+<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20result%20%3D%20R.ap(%0A%20%20%5B%0A%20%20%20%20x%20%3D%3E%20x%20%2B%201%2C%0A%20%20%20%20x%20%3D%3E%20x%20%2B%202%2C%0A%20%20%5D%2C%0A%20%20%5B1%2C%202%2C%203%5D%0A)%0A%2F%2F%20%3D%3E%20%5B2%2C%203%2C%204%2C%203%2C%204%2C%205%5D">Try this <strong>R.ap</strong> example in Rambda REPL</a>
+
 <details>
 
 <summary>All TypeScript definitions</summary>
@@ -1011,6 +1021,10 @@ test('happy', () => {
 aperture<N extends number, T>(n: N, list: T[]): Array<Tuple<T, N>> | []
 ```
 
+It returns a new list, composed of consecutive `n`-tuples from a `list`.
+
+<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20result%20%3D%20R.aperture(2%2C%20%5B1%2C%202%2C%203%2C%204%5D)%0A%2F%2F%20%3D%3E%20%5B%5B1%2C%202%5D%2C%20%5B2%2C%203%5D%2C%20%5B3%2C%204%5D%5D">Try this <strong>R.aperture</strong> example in Rambda REPL</a>
+
 <details>
 
 <summary>All TypeScript definitions</summary>
@@ -1130,8 +1144,7 @@ export function append(x, input){
 <summary><strong>Tests</strong></summary>
 
 ```javascript
-// import { append } from './append.js'
-import { append } from 'ramda'
+import { append } from './append.js'
 
 test('happy', () => {
   expect(append('tests', [ 'write', 'more' ])).toEqual([
@@ -1761,10 +1774,14 @@ describe('applySpec', () => {
 
 ### applyTo
 
+<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20result%20%3D%20R.applyTo(%0A%20%201%2C%0A%20%20x%20%3D%3E%20x%20%2B%201%0A)%0A%2F%2F%20%3D%3E%202">Try this <strong>R.applyTo</strong> example in Rambda REPL</a>
+
 [![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#applyTo)
 
 ### ascend
 
+<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20result%20%3D%20R.sort(%0A%20%20R.ascend(x%20%3D%3E%20x)%2C%0A%20%20%5B2%2C%201%5D%0A)%0A%2F%2F%20%3D%3E%20%5B1%2C%202%5D">Try this <strong>R.ascend</strong> example in Rambda REPL</a>
+
 [![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#ascend)
 
 ### assoc
@@ -2106,6 +2123,8 @@ describe('R.assocPath - curried', () => {
 
 ### binary
 
+<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20result%20%3D%20R.binary(%0A%20%20(a%2C%20b%2C%20c)%20%3D%3E%20a%20%2B%20b%20%2B%20c%2C%0A)(1%2C%202%2C%203%2C%204)%0A%2F%2F%20%3D%3E%203">Try this <strong>R.binary</strong> example in Rambda REPL</a>
+
 [![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#binary)
 
 ### bind
@@ -2418,6 +2437,8 @@ describe('R.both', () => {
 
 ### call
 
+<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20result%20%3D%20R.call(%0A%20%20(a%2C%20b)%20%3D%3E%20a%20%2B%20b%2C%0A%20%201%2C%0A%20%202%0A)%0A%2F%2F%20%3D%3E%203">Try this <strong>R.call</strong> example in Rambda REPL</a>
+
 [![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#call)
 
 ### chain
@@ -2577,10 +2598,16 @@ It creates a deep copy of the `input`, which may contain (nested) Arrays and Obj
 
 ### collectBy
 
+<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20result%20%3D%20R.collectBy(%0A%20%20x%20%3D%3E%20x%20%25%202%2C%0A%20%20%5B1%2C%202%2C%203%2C%204%5D%0A)%0A%2F%2F%20%3D%3E%20%5B%5B2%2C%204%5D%2C%20%5B1%2C%203%5D%5D">Try this <strong>R.collectBy</strong> example in Rambda REPL</a>
+
 [![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#collectBy)
 
 ### comparator
 
+It returns a comparator function that can be used in `sort` method.
+
+<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20result%20%3D%20R.sort(%0A%20%20R.comparator((a%2C%20b)%20%3D%3E%20a.x%20%3C%20b.x)%2C%0A%20%20%5B%7Bx%3A%202%7D%2C%20%7Bx%3A%201%7D%5D%0A)%0A%2F%2F%20%3D%3E%20%5B%7Bx%3A%201%7D%2C%20%7Bx%3A%202%7D%5D">Try this <strong>R.comparator</strong> example in Rambda REPL</a>
+
 [![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#comparator)
 
 ### complement
@@ -2603,6 +2630,8 @@ It performs right-to-left function composition.
 
 ### composeWith
 
+<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20result%20%3D%20R.composeWith(%0A%20%20(fn%2C%20intermediateResult)%20%3D%3E%20fn(intermediateResult)%2C%0A%20%20%5B%0A%20%20%20%20R.map(x%20%3D%3E%20x%20%2B%201)%2C%0A%20%20%20%20R.map(x%20%3D%3E%20x%20*%202)%2C%0A%20%20%5D%0A)(%5B1%2C%202%2C%203%5D)%0A%2F%2F%20%3D%3E%20%5B3%2C%205%2C%207%5D">Try this <strong>R.composeWith</strong> example in Rambda REPL</a>
+
 [![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#composeWith)
 
 ### concat
@@ -2758,6 +2787,8 @@ It returns a curried equivalent of the provided function, with the specified ari
 
 It decrements a number.
 
+<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20result%20%3D%20R.dec(2)%20%2F%2F%20%3D%3E%201">Try this <strong>R.dec</strong> example in Rambda REPL</a>
+
 [![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#dec)
 
 ### defaultTo
@@ -2865,6 +2896,8 @@ describe('R.defaultTo with Ramda spec', () => {
 
 ### descend
 
+<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?R.sort(%0A%20%20R.descend(x%20%3D%3E%20x)%2C%0A%20%20%5B1%2C%202%5D%0Aconst%20result%20%3D%20)%0A%2F%2F%20%3D%3E%20%5B2%2C%201%5D">Try this <strong>R.descend</strong> example in Rambda REPL</a>
+
 [![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#descend)
 
 ### difference
@@ -2984,6 +3017,8 @@ differenceWith<T1, T2>(
 ): T1[]
 ```
 
+<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20result%20%3D%20R.differenceWith(%0A%20%20(a%2C%20b)%20%3D%3E%20a.x%20%3D%3D%3D%20b.x%2C%0A%20%20%5B%7Bx%3A%201%7D%2C%20%7Bx%3A%202%7D%5D%2C%0A%20%20%5B%7Bx%3A%201%7D%2C%20%7Bx%3A%203%7D%5D%0A)%0A%2F%2F%20%3D%3E%20%5B%7Bx%3A%202%7D%5D">Try this <strong>R.differenceWith</strong> example in Rambda REPL</a>
+
 <details>
 
 <summary>All TypeScript definitions</summary>
@@ -3068,6 +3103,8 @@ It returns a new object that does not contain property `prop`.
 
 ### dissocPath
 
+<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20result%20%3D%20R.dissocPath(%5B'a'%2C%20'b'%5D%2C%20%7Ba%3A%20%7Bb%3A%201%2C%20c%3A%202%7D%7D)%0A%2F%2F%20%3D%3E%20%7Ba%3A%20%7Bc%3A%202%7D%7D">Try this <strong>R.dissocPath</strong> example in Rambda REPL</a>
+
 [![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#dissocPath)
 
 ### divide
@@ -3435,6 +3472,8 @@ describe('R.dropRepeats', () => {
 
 ### dropRepeatsBy
 
+<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20result%20%3D%20R.dropRepeatsBy(%0A%20%20Math.abs%2C%0A%20%20%5B1%2C%20-1%2C%202%2C%203%2C%20-3%5D%0A)%0A%2F%2F%20%3D%3E%20%5B1%2C%202%2C%203%5D">Try this <strong>R.dropRepeatsBy</strong> example in Rambda REPL</a>
+
 [![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#dropRepeatsBy)
 
 ### dropRepeatsWith
@@ -3604,6 +3643,8 @@ describe('R.either', () => {
 
 ### empty
 
+<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20result%20%3D%20%5BR.empty(%5B1%2C2%2C3%5D)%2C%20R.empty('foo')%2C%20R.empty(%7Bx%3A%201%2C%20y%3A%202%7D)%5D%0A%2F%2F%20%3D%3E%20%5B%5B%5D%2C%20''%2C%20%7B%7D%5D">Try this <strong>R.empty</strong> example in Rambda REPL</a>
+
 [![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#empty)
 
 ### endsWith
@@ -3769,6 +3810,8 @@ describe('R.endsWith - string', () => {
 
 ### eqBy
 
+<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20result%20%3D%20R.eqBy(Math.abs%2C%205%2C%20-5)%0A%2F%2F%20%3D%3E%20true">Try this <strong>R.eqBy</strong> example in Rambda REPL</a>
+
 [![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#eqBy)
 
 ### eqProps
@@ -5427,35 +5470,10 @@ forEach<T, U>(fn: ObjectIterator<T, void>): (list: Dictionary<T>) => Dictionary<
 
 ```javascript
 import { isArray } from './_internals/isArray.js'
-import { keys } from './_internals/keys.js'
-
-export function forEachObjIndexedFn(fn, obj){
-  let index = 0
-  const listKeys = keys(obj)
-  const len = listKeys.length
-
-  while (index < len){
-    const key = listKeys[ index ]
-    fn(
-      obj[ key ], key, obj
-    )
-    index++
-  }
-
-  return obj
-}
-
-export function forEachObjIndexed(fn, list){
-  if (arguments.length === 1) return _list => forEachObjIndexed(fn, _list)
-
-  if (list === undefined) return
-
-  return forEachObjIndexedFn(fn, list)
-}
+import { forEachObjIndexedFn } from './forEachObjIndexed.js'
 
 export function forEach(fn, iterable){
   if (arguments.length === 1) return _list => forEach(fn, _list)
-
   if (iterable === undefined) return
 
   if (isArray(iterable)){
@@ -5627,6 +5645,18 @@ It returns separated version of list or string `input`, where separation is done
 
 [![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#groupWith)
 
+### gt
+
+<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20result%20%3D%20%5BR.gt(2%2C%201)%2C%20R.gt(2%2C%203)%5D%0A%2F%2F%20%3D%3E%20%5Btrue%2C%20false%5D">Try this <strong>R.gt</strong> example in Rambda REPL</a>
+
+[![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#gt)
+
+### gte
+
+<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20result%20%3D%20%5BR.gte(2%2C%201)%2C%20R.gte(2%2C%202)%2C%20R.gte(2%2C%203)%5D%0A%2F%2F%20%3D%3E%20%5Btrue%2C%20true%2C%20false%5D">Try this <strong>R.gte</strong> example in Rambda REPL</a>
+
+[![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#gte)
+
 ### has
 
 ```typescript
@@ -5709,6 +5739,12 @@ describe('R.has', () => {
 
 [![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#has)
 
+### hasIn
+
+<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20result%20%3D%20R.hasIn('a'%2C%20%7Ba%3A%201%7D)%0A%2F%2F%20%3D%3E%20true">Try this <strong>R.hasIn</strong> example in Rambda REPL</a>
+
+[![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#hasIn)
+
 ### hasPath
 
 ```typescript
@@ -6487,6 +6523,14 @@ describe('R.init', () => {
 
 [![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#init)
 
+### innerJoin
+
+It returns a new list by applying a `predicate` function to all elements of `list1` and `list2` and keeping only these elements where `predicate` returns `true`.
+
+<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20list1%20%3D%20%5B1%2C%202%2C%203%2C%204%2C%205%5D%0Aconst%20list2%20%3D%20%5B4%2C%205%2C%206%5D%0Aconst%20predicate%20%3D%20(x%2C%20y)%20%3D%3E%20x%20%3E%3D%20y%0Aconst%20result%20%3D%20R.innerJoin(predicate%2C%20list1%2C%20list2)%0A%2F%2F%20%3D%3E%20%5B4%2C%205%5D">Try this <strong>R.innerJoin</strong> example in Rambda REPL</a>
+
+[![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#innerJoin)
+
 ### intersection
 
 It loops through `listA` and `listB` and returns the intersection of the two according to `R.equals`.
@@ -7143,7 +7187,7 @@ test('with length as property', () => {
 
 ```typescript
 
-lens<T, U, V>(getter: (s: T) => U, setter: (a: U, s: T) => V): Lens
+lens<S, A>(getter: (s: S) => A, setter: (a: A, s: S) => S): Lens<S, A>
 ```
 
 It returns a `lens` for the given `getter` and `setter` functions. 
@@ -7159,7 +7203,7 @@ The setter should not mutate the data structure.
 <summary>All TypeScript definitions</summary>
 
 ```typescript
-lens<T, U, V>(getter: (s: T) => U, setter: (a: U, s: T) => V): Lens;
+lens<S, A>(getter: (s: S) => A, setter: (a: A, s: S) => S): Lens<S, A>;
 ```
 
 </details>
@@ -7185,19 +7229,56 @@ export function lens(getter, setter){
 <summary><strong>TypeScript</strong> test</summary>
 
 ```typescript
-import {lens, assoc} from 'rambda'
+import {lens, assoc, lensProp, view, lensIndex, lensPath} from 'rambda'
 
 interface Input {
   foo: string,
 }
+const testObject: Input = {
+  foo: 'Jazz',
+}
 
 describe('R.lens', () => {
   it('happy', () => {
-    const fn = lens<Input, string, string>((x: Input) => {
+    const fn = lens<Input, string>((x: Input) => {
       x.foo // $ExpectType string
       return x.foo
     }, assoc('name'))
-    fn // $ExpectType Lens
+    fn // $ExpectType Lens<Input, string>
+  })
+})
+
+describe('R.lensProp', () => {
+  it('happy', () => {
+    const result = view<Input, string>(lensProp('foo'), testObject)
+    result // $ExpectType string
+  })
+})
+
+describe('R.lensIndex', () => {
+  const testList: Input[] = [{foo: 'bar'}, {foo: 'baz'}]
+  it('happy', () => {
+    const result = view<Input[], Input>(lensIndex(0), testList)
+    result // $ExpectType Input
+    result.foo // $ExpectType string
+  })
+})
+
+describe('R.lensPath', () => {
+  const path = lensPath(['bar', 'a'])
+  it('happy', () => {
+    const result = view<Input, string>(path, testObject)
+    result // $ExpectType string
+  })
+})
+
+describe('R.view', () => {
+  const fooLens = lens<Input, string>((x: Input) => {
+    return x.foo
+  }, assoc('foo'))
+  it('happt', () => {
+    const result = view<Input, string>(fooLens, testObject)
+    result // $ExpectType string
   })
 })
 ```
@@ -7210,7 +7291,7 @@ describe('R.lens', () => {
 
 ```typescript
 
-lensIndex(index: number): Lens
+lensIndex<A>(n: number): Lens<A[], A>
 ```
 
 It returns a lens that focuses on specified `index`.
@@ -7222,7 +7303,8 @@ It returns a lens that focuses on specified `index`.
 <summary>All TypeScript definitions</summary>
 
 ```typescript
-lensIndex(index: number): Lens;
+lensIndex<A>(n: number): Lens<A[], A>;
+lensIndex<A extends any[], N extends number>(n: N): Lens<A, A[N]>;
 ```
 
 </details>
@@ -7308,250 +7390,21 @@ test('get (set(set s v1) v2) === v2', () => {
 
 </details>
 
-<details>
-
-<summary><strong>TypeScript</strong> test</summary>
-
-```typescript
-import {view, lensIndex} from 'rambda'
-
-interface Input {
-  a: number,
-}
-const testList: Input[] = [{a: 1}, {a: 2}, {a: 3}]
-
-describe('R.lensIndex', () => {
-  it('happy', () => {
-    const result = view<Input[], Input>(lensIndex(0), testList)
-    result // $ExpectType Input
-    result.a // $ExpectType number
-  })
-})
-```
-
-</details>
-
 [![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#lensIndex)
 
 ### lensPath
 
-```typescript
-
-lensPath(path: RamdaPath): Lens
-```
-
 It returns a lens that focuses on specified `path`.
 
 <a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20lensPath%20%3D%20R.lensPath(%5B'x'%2C%200%2C%20'y'%5D)%0Aconst%20input%20%3D%20%7Bx%3A%20%5B%7By%3A%202%2C%20z%3A%203%7D%2C%20%7By%3A%204%2C%20z%3A%205%7D%5D%7D%0A%0AR.view(lensPath%2C%20input)%20%2F%2F%20%3D%3E%202%0A%0AR.set(lensPath%2C%201%2C%20input)%20%0A%2F%2F%20%3D%3E%20%7Bx%3A%20%5B%7By%3A%201%2C%20z%3A%203%7D%2C%20%7By%3A%204%2C%20z%3A%205%7D%5D%7D%0A%0Aconst%20result%20%3D%20R.over(xHeadYLens%2C%20R.negate%2C%20input)%20%0A%2F%2F%20%3D%3E%20%7Bx%3A%20%5B%7By%3A%20-2%2C%20z%3A%203%7D%2C%20%7By%3A%204%2C%20z%3A%205%7D%5D%7D">Try this <strong>R.lensPath</strong> example in Rambda REPL</a>
 
-<details>
-
-<summary>All TypeScript definitions</summary>
-
-```typescript
-lensPath(path: RamdaPath): Lens;
-lensPath(path: string): Lens;
-```
-
-</details>
-
-<details>
-
-<summary><strong>R.lensPath</strong> source</summary>
-
-```javascript
-import { assocPath } from './assocPath.js'
-import { lens } from './lens.js'
-import { path } from './path.js'
-
-export function lensPath(key){
-  return lens(path(key), assocPath(key))
-}
-```
-
-</details>
-
-<details>
-
-<summary><strong>Tests</strong></summary>
-
-```javascript
-import { compose } from './compose.js'
-import { identity } from './identity.js'
-import { inc } from './inc.js'
-import { lensPath } from './lensPath.js'
-import { lensProp } from './lensProp.js'
-import { over } from './over.js'
-import { set } from './set.js'
-import { view } from './view.js'
-
-const testObj = {
-  a : [ { b : 1 }, { b : 2 } ],
-  d : 3,
-}
-
-test('view', () => {
-  expect(view(lensPath('d'), testObj)).toBe(3)
-  expect(view(lensPath('a.0.b'), testObj)).toBe(1)
-  // this is different to ramda, as ramda will return a clone of the input object
-  expect(view(lensPath(''), testObj)).toBeUndefined()
-})
-
-test('set', () => {
-  expect(set(
-    lensProp('d'), 0, testObj
-  )).toEqual({
-    a : [ { b : 1 }, { b : 2 } ],
-    d : 0,
-  })
-  expect(set(
-    lensPath('a.0.b'), 0, testObj
-  )).toEqual({
-    a : [ { b : 0 }, { b : 2 } ],
-    d : 3,
-  })
-  expect(set(
-    lensPath('a.0.X'), 0, testObj
-  )).toEqual({
-    a : [
-      {
-        b : 1,
-        X : 0,
-      },
-      { b : 2 },
-    ],
-    d : 3,
-  })
-  expect(set(
-    lensPath([]), 0, testObj
-  )).toBe(0)
-})
-
-test('over', () => {
-  expect(over(
-    lensPath('d'), inc, testObj
-  )).toEqual({
-    a : [ { b : 1 }, { b : 2 } ],
-    d : 4,
-  })
-  expect(over(
-    lensPath('a.1.b'), inc, testObj
-  )).toEqual({
-    a : [ { b : 1 }, { b : 3 } ],
-    d : 3,
-  })
-  expect(over(
-    lensProp('X'), identity, testObj
-  )).toEqual({
-    a : [ { b : 1 }, { b : 2 } ],
-    d : 3,
-    X : undefined,
-  })
-  expect(over(
-    lensPath('a.0.X'), identity, testObj
-  )).toEqual({
-    a : [
-      {
-        b : 1,
-        X : undefined,
-      },
-      { b : 2 },
-    ],
-    d : 3,
-  })
-})
-
-test('compose', () => {
-  const composedLens = compose(lensPath('a'), lensPath('1.b'))
-  expect(view(composedLens, testObj)).toBe(2)
-})
-
-test('set s (get s) === s', () => {
-  expect(set(
-    lensPath([ 'd' ]), view(lensPath([ 'd' ]), testObj), testObj
-  )).toEqual(testObj)
-  expect(set(
-    lensPath([ 'a', 0, 'b' ]),
-    view(lensPath([ 'a', 0, 'b' ]), testObj),
-    testObj
-  )).toEqual(testObj)
-})
-
-test('get (set s v) === v', () => {
-  expect(view(lensPath([ 'd' ]), set(
-    lensPath([ 'd' ]), 0, testObj
-  ))).toBe(0)
-  expect(view(lensPath([ 'a', 0, 'b' ]), set(
-    lensPath([ 'a', 0, 'b' ]), 0, testObj
-  ))).toBe(0)
-})
-
-test('get (set(set s v1) v2) === v2', () => {
-  const p = [ 'd' ]
-  const q = [ 'a', 0, 'b' ]
-  expect(view(lensPath(p), set(
-    lensPath(p), 11, set(
-      lensPath(p), 10, testObj
-    )
-  ))).toBe(11)
-  expect(view(lensPath(q), set(
-    lensPath(q), 11, set(
-      lensPath(q), 10, testObj
-    )
-  ))).toBe(11)
-})
-```
-
-</details>
-
-<details>
-
-<summary><strong>TypeScript</strong> test</summary>
-
-```typescript
-import {lensPath, view} from 'rambda'
-
-interface Input {
-  foo: number[],
-  bar: {
-    a: string,
-    b: string,
-  },
-}
-
-const testObject: Input = {
-  foo: [1, 2],
-  bar: {
-    a: 'x',
-    b: 'y',
-  },
-}
-
-const path = lensPath(['bar', 'a'])
-const pathAsString = lensPath('bar.a')
-
-describe('R.lensPath', () => {
-  it('happy', () => {
-    const result = view<Input, string>(path, testObject)
-    result // $ExpectType string
-  })
-  it('using string as path input', () => {
-    const result = view<Input, string>(pathAsString, testObject)
-    result // $ExpectType string
-  })
-})
-```
-
-</details>
-
 [![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#lensPath)
 
 ### lensProp
 
 ```typescript
 
-lensProp(prop: string): {
-  <T, U>(obj: T): U
+lensProp<S, K extends keyof S = keyof S>(prop: K): Lens<S, S[K]>
 ```
 
 It returns a lens that focuses on specified property `prop`.
@@ -7563,10 +7416,7 @@ It returns a lens that focuses on specified property `prop`.
 <summary>All TypeScript definitions</summary>
 
 ```typescript
-lensProp(prop: string): {
-  <T, U>(obj: T): U;
-  set<T, U, V>(val: T, obj: U): V;
-};
+lensProp<S, K extends keyof S = keyof S>(prop: K): Lens<S, S[K]>;
 ```
 
 </details>
@@ -7690,33 +7540,6 @@ test('get (set(set s v1) v2) === v2', () => {
 
 </details>
 
-<details>
-
-<summary><strong>TypeScript</strong> test</summary>
-
-```typescript
-import {lensProp, view} from 'rambda'
-
-interface Input {
-  foo: string,
-}
-
-const testObject: Input = {
-  foo: 'Led Zeppelin',
-}
-
-const lens = lensProp('foo')
-
-describe('R.lensProp', () => {
-  it('happy', () => {
-    const result = view<Input, string>(lens, testObject)
-    result // $ExpectType string
-  })
-})
-```
-
-</details>
-
 [![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#lensProp)
 
 ### map
@@ -9980,7 +9803,8 @@ Logical OR
 
 ```typescript
 
-over<T>(lens: Lens, fn: Arity1Fn, value: T): T
+over<S, A>(lens: Lens<S, A>): {
+  (fn: (a: A) => A): (value: S) => S
 ```
 
 It returns a copied **Object** or **Array** with modified value received by applying function `fn` to `lens` focus.
@@ -9992,12 +9816,12 @@ It returns a copied **Object** or **Array** with modified value received by appl
 <summary>All TypeScript definitions</summary>
 
 ```typescript
-over<T>(lens: Lens, fn: Arity1Fn, value: T): T;
-over<T>(lens: Lens, fn: Arity1Fn, value: T[]): T[];
-over(lens: Lens, fn: Arity1Fn): <T>(value: T) => T;
-over(lens: Lens, fn: Arity1Fn): <T>(value: T[]) => T[];
-over(lens: Lens): <T>(fn: Arity1Fn, value: T) => T;
-over(lens: Lens): <T>(fn: Arity1Fn, value: T[]) => T[];
+over<S, A>(lens: Lens<S, A>): {
+  (fn: (a: A) => A): (value: S) => S;
+  (fn: (a: A) => A, value: S): S;
+};
+over<S, A>(lens: Lens<S, A>, fn: (a: A) => A): (value: S) => S;
+over<S, A>(lens: Lens<S, A>, fn: (a: A) => A, value: S): S;
 ```
 
 </details>
@@ -11690,6 +11514,10 @@ test('happy', () => {
   expect(pluck('a')([ { a : 1 }, { a : 2 }, { b : 1 } ])).toEqual([ 1, 2 ])
 })
 
+test('with undefined', () => {
+  expect(pluck(undefined)([ { a : 1 }, { a : 2 }, { b : 1 } ])).toEqual([ ])
+})
+
 test('with number', () => {
   const input = [
     [ 1, 2 ],
@@ -11914,12 +11742,16 @@ prop<V>(p: keyof never): (value: unknown) => V;
 <summary><strong>R.prop</strong> source</summary>
 
 ```javascript
-export function prop(propToFind, obj){
-  if (arguments.length === 1) return _obj => prop(propToFind, _obj)
-
+export function propFn(searchProperty, obj){
   if (!obj) return undefined
 
-  return obj[ propToFind ]
+  return obj[ searchProperty ]
+}
+
+export function prop(searchProperty, obj){
+  if (arguments.length === 1) return _obj => prop(searchProperty, _obj)
+
+  return propFn(searchProperty, obj)
 }
 ```
 
@@ -12650,6 +12482,12 @@ describe('R.range', () => {
 
 [![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#reduce)
 
+### reduceBy
+
+<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20result%20%3D%20R.reduceBy(%0A%20%20(acc%2C%20elem)%20%3D%3E%20acc%20%2B%20elem%2C%0A%20%200%2C%0A%20%20x%20%3D%3E%20x%20%3E%202%20%3F%20'big'%20%3A%20'small'%2C%0A%20%20%5B1%2C%202%2C%203%2C%204%2C%205%5D%0A)%0A%2F%2F%20%3D%3E%20%7B%20big%3A%2012%2C%20small%3A%203%20%7D">Try this <strong>R.reduceBy</strong> example in Rambda REPL</a>
+
+[![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#reduceBy)
+
 ### reject
 
 ```typescript
@@ -13169,7 +13007,10 @@ describe('R.reverse', () => {
 
 ```typescript
 
-set<T, U>(lens: Lens, replacer: U, obj: T): T
+set<S, A>(lens: Lens<S, A>): {
+  (a: A): (obj: S) => S
+  (a: A, obj: S): S
+}
 ```
 
 It returns a copied **Object** or **Array** with modified `lens` focus set to `replacer` value.
@@ -13181,9 +13022,12 @@ It returns a copied **Object** or **Array** with modified `lens` focus set to `r
 <summary>All TypeScript definitions</summary>
 
 ```typescript
-set<T, U>(lens: Lens, replacer: U, obj: T): T;
-set<U>(lens: Lens, replacer: U): <T>(obj: T) => T;
-set(lens: Lens): <T, U>(replacer: U, obj: T) => T;
+set<S, A>(lens: Lens<S, A>): {
+  (a: A): (obj: S) => S
+  (a: A, obj: S): S
+};
+set<S, A>(lens: Lens<S, A>, a: A): (obj: S) => S;
+set<S, A>(lens: Lens<S, A>, a: A, obj: S): S;
 ```
 
 </details>
@@ -13599,6 +13443,12 @@ describe('R.sortBy', () => {
 
 [![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#sortBy)
 
+### sortWith
+
+<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20result%20%3D%20R.sortWith(%5B%0A%20%20%20%20(a%2C%20b)%20%3D%3E%20a.a%20%3D%3D%3D%20b.a%20%3F%200%20%3A%20a.a%20%3E%20b.a%20%3F%201%20%3A%20-1%2C%0A%20%20%20%20(a%2C%20b)%20%3D%3E%20a.b%20%3D%3D%3D%20b.b%20%3F%200%20%3A%20a.b%20%3E%20b.b%20%3F%201%20%3A%20-1%2C%0A%5D%2C%20%5B%0A%20%20%7Ba%3A%201%2C%20b%3A%202%7D%2C%0A%20%20%7Ba%3A%202%2C%20b%3A%201%7D%2C%0A%20%20%7Ba%3A%202%2C%20b%3A%202%7D%2C%0A%20%20%7Ba%3A%201%2C%20b%3A%201%7D%2C%0A%5D)%0Aconst%20expected%20%3D%20%5B%0A%20%20%7Ba%3A%201%2C%20b%3A%201%7D%2C%0A%20%20%7Ba%3A%201%2C%20b%3A%202%7D%2C%0A%20%20%7Ba%3A%202%2C%20b%3A%201%7D%2C%0A%20%20%7Ba%3A%202%2C%20b%3A%202%7D%2C%0A%5D%0A%2F%2F%20%3D%3E%20%60result%60%20is%20equal%20to%20%60expected%60">Try this <strong>R.sortWith</strong> example in Rambda REPL</a>
+
+[![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#sortWith)
+
 ### split
 
 ```typescript
@@ -16204,6 +16054,8 @@ describe('R.unless - curried', () => {
 
 ### unnest
 
+<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20result%20%3D%20R.unnest(%5B1%2C%20%5B2%5D%2C%20%5B%5B3%5D%5D%5D)%0A%2F%2F%20%3D%3E%20%5B1%2C%202%2C%20%5B3%5D%5D">Try this <strong>R.unnest</strong> example in Rambda REPL</a>
+
 [![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#unnest)
 
 ### unwind
@@ -16362,7 +16214,6 @@ import { type } from './type.js'
 
 export function values(obj){
   if (type(obj) !== 'Object') return []
-
   return Object.values(obj)
 }
 ```
@@ -16426,7 +16277,7 @@ describe('R.values', () => {
 
 ```typescript
 
-view<T, U>(lens: Lens): (target: T) => U
+view<S, A>(lens: Lens<S, A>): (obj: S) => A
 ```
 
 It returns the value of `lens` focus over `target` object.
@@ -16438,8 +16289,8 @@ It returns the value of `lens` focus over `target` object.
 <summary>All TypeScript definitions</summary>
 
 ```typescript
-view<T, U>(lens: Lens): (target: T) => U;
-view<T, U>(lens: Lens, target: T): U;
+view<S, A>(lens: Lens<S, A>): (obj: S) => A;
+view<S, A>(lens: Lens<S, A>, obj: S): A;
 ```
 
 </details>
@@ -16483,35 +16334,6 @@ test('happy', () => {
 
 </details>
 
-<details>
-
-<summary><strong>TypeScript</strong> test</summary>
-
-```typescript
-import {lens, view, assoc} from 'rambda'
-
-interface Input {
-  foo: string,
-}
-
-const testObject: Input = {
-  foo: 'Led Zeppelin',
-}
-
-const fooLens = lens<Input, string, string>((x: Input) => {
-  return x.foo
-}, assoc('foo'))
-
-describe('R.view', () => {
-  it('happt', () => {
-    const result = view<Input, string>(fooLens, testObject)
-    result // $ExpectType string
-  })
-})
-```
-
-</details>
-
 [![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#view)
 
 ### when
@@ -16521,6 +16343,11 @@ describe('R.view', () => {
 when<T, U>(predicate: (x: T) => boolean, whenTrueFn: (a: T) => U, input: T): T | U
 ```
 
+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`.
+
+<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>
+
 <details>
 
 <summary>All TypeScript definitions</summary>
@@ -17423,12 +17250,22 @@ describe('R.zipWith', () => {
 
 ## ❯ CHANGELOG
 
+9.0.1
+
+- Fix bad TS typings, due to missing declaration - [Issue #716](https://github.com/selfrefactor/rambda/issues/716)
+
+9.0.0
+
+Breaking change in TS definitions of `lenses` as now they are synced to `Ramda` types.
+
+- Add `R.sortWith` - [Issue #707](https://github.com/selfrefactor/rambda/issues/707)
+
+- Add `R.innerJoin`, `R.gt`, `R.gte`, `R.reduceBy`, `R.hasIn`
+
 8.6.0
 
 - Wrong typing for `R.dissocPath` - [Issue #709](https://github.com/selfrefactor/rambda/issues/709)
 
-- Add `R.sortWith` - [Issue #7097](https://github.com/selfrefactor/rambda/issues/707)
-
 - Update build dependencies
 
 8.5.0