rambda 9.2.1 → 9.4.0

package/CHANGELOG.md

@@ -1,3 +1,19 @@
+9.4.0
+
+- Fix `deno` release
+
+- Fix too strict `true` condition in `R.ifElse` - [Issue #750](https://github.com/selfrefactor/rambda/issues/750)
+
+- Change `R.groupBy` typings to match `@types/ramda` typings
+
+9.3.0
+
+- Breaking change in relation to TS typings of `R.assoc`, `R.dissoc` and `R.modify` - https://github.com/ramda/types/pull/37
+
+- 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 
+
 9.2.1
 
 - Broken `Deno` build - [Issue #731](https://github.com/selfrefactor/rambda/issues/731)

package/README.md

@@ -2,14 +2,12 @@
 
 `Rambda` is smaller and faster alternative to the popular functional programming library **Ramda**. - [Documentation](https://selfrefactor.github.io/rambda/#/)
 
-[![CircleCI](https://circleci.com/gh/selfrefactor/rambda/tree/master.svg?style=svg)](https://circleci.com/gh/selfrefactor/rambda/tree/master)
 [![codecov](https://codecov.io/gh/selfrefactor/rambda/branch/master/graph/badge.svg)](https://codecov.io/gh/selfrefactor/rambda)
 ![Commit activity](https://img.shields.io/github/commit-activity/y/selfrefactor/rambda)
-![All contributors](https://img.shields.io/github/contributors/selfrefactor/rambda)
 ![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)
 [![PR's Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat)](https://github.com/selfrefactor/rambda/pulls)
+[![GitHub contributors](https://img.shields.io/github/contributors/selfrefactor/rambda.svg)](https://github.com/selfrefactor/rambda/graphs/contributors)
 
 ## ❯ Example use
 
@@ -106,59 +104,57 @@ One of the main issues with `Ramda` is the slow process of releasing new version
 
 <details>
 <summary>
-  Click to see the full list of 43 Ramda methods not implemented in Rambda and their status.
+  Click to see the full list of 46 Ramda methods not implemented in Rambda and their status.
 </summary>
 
-- into
-- invert
+- construct - Using classes is not very functional programming oriented.
+- constructN - same as above
+- into - no support for transducer as it is overly complex to implement, understand and read.
+- invert - overly complicated and limited use case
 - invertObj
 - invoker
-- keysIn
+- keysIn - we shouldn't encourage extending object with `.prototype` 
 - lift
 - liftN
-- mapAccum
+- mapAccum - `Ramda` example doesn't looks convincing
 - mapAccumRight
-- memoizeWith
-- mergeDeepWith
+- memoizeWith - hard to imagine its usage in context of `R.pipe`/`R.compose`
+- mergeDeepWith - limited use case
 - mergeDeepWithKey
 - mergeWithKey
-- nAry
-- nthArg
-- o
-- otherwise
-- pair
-- partialRight
-- pathSatisfies
+- nAry - hard to argument about and hard to create meaningful TypeScript definitions
+- nthArg - limited use case
+- o - enough TypeScript issues with `R.pipe`/`R.compose` to add more composition methods
+- otherwise - naming is confusing
+- pair - `left-pad` types of debacles happens partially because of such methods that should not be hidden, bur rather part of your code base even if they need to exist.
+- partialRight - I dislike `R.partial`, so I don't want to add more methods that are based on it
 - pipeWith
-- project
+- project - naming is confusing, but also limited use case
 - promap
-- reduceRight
-- reduceWhile
+- reduceRight - I find `right/left` methods confusing so I added them only where it makes sense.
+- reduceWhile - functions with 4 inputs - I think that even 3 is too much
 - reduced
-- remove
-- scan
+- remove - nice name but it is too generic. Also, `Rambdax` has such method and there it works very differently
+- scan - hard to explain
 - sequence
 - splitWhenever
 - symmetricDifferenceWith
 - andThen
 - toPairsIn
+- transduce - currently is out of focus
+- traverse - same as above
 - unary
 - uncurryN
-- unfold
-- unionWith
+- unfold - similar to `R.scan` and I find that it doesn't help with readability
+- unionWith - why it has its usage, I want to limit number of methods that accept more than 2 arguments
 - until
-- useWith
+- useWith - hard to explain
 - valuesIn
-- xprod
+- xprod - limited use case
 - thunkify
-- default
-
-  Most of above methods are in progress to be added to **Rambda**. The following methods are not going to be added:
 - __ - placeholder method allows user to further customize the method call. While, it seems useful initially, the price is too high in terms of complexity for TypeScript definitions. If it is not easy exressable in TypeScript, it is not worth it as **Rambda** is a TypeScript first library.
-- construct - Using classes is not very functional programming oriented.
-- constructN - same as above
-- transduce - currently is out of focus
-- traverse - same as above
+
+The following methods are not going to be added(reason for exclusion is provided as a comment):
 </details>
 
 [![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#-missing-ramda-methods)
@@ -216,7 +212,7 @@ There are methods which are benchmarked only with `Ramda` and `Rambda`(i.e. no `
 
 Note that some of these methods, are called with and without curring. This is done in order to give more detailed performance feedback.
 
-The benchmarks results are produced from latest versions of *Rambda*, *Lodash*(4.17.21) and *Ramda*(0.30.0).
+The benchmarks results are produced from latest versions of *Rambda*, *Lodash*(4.17.21) and *Ramda*(0.30.1).
 
 </summary>
 
@@ -1772,7 +1768,7 @@ describe('applySpec', () => {
 
 ### 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>
+<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20result%20%3D%20R.sort(R.descend(x%20%3D%3E%20x)%2C%20%5B2%2C%201%5D)%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)
 
@@ -1869,7 +1865,7 @@ export const assocPath = curry(assocPathFn)
 ```javascript
 import { assocPathFn } from './assocPath.js'
 
-test.only('happy', () => {
+test('happy', () => {
   const path = 'a.c.1'
   const input = {
     a : {
@@ -1910,7 +1906,7 @@ test('string can be used as path input', () => {
 
 test('difference with ramda - doesn\'t overwrite primitive values with keys in the path', () => {
   const obj = { a : 'str' }
-  const result = assocPath(
+  const result = assocPathFn(
     [ 'a', 'b' ], 42, obj
   )
 
@@ -1924,35 +1920,35 @@ test('difference with ramda - doesn\'t overwrite primitive values with keys in t
   })
 })
 
-test('bug', () => {
+test('bug 524', () => {
   /*
     https://github.com/selfrefactor/rambda/issues/524
   */
   const state = {}
 
-  const withDateLike = assocPath(
+  const withDateLike = assocPathFn(
     [ 'outerProp', '2020-03-10' ],
     { prop : 2 },
     state
   )
-  const withNumber = assocPath(
-    [ 'outerProp', '5' ], { prop : 2 }, state
+  const withNumber = assocPathFn(
+    [ 'outerProp,5' ], { prop : 2 }, state
   )
 
   const withDateLikeExpected = { outerProp : { '2020-03-10' : { prop : 2 } } }
   const withNumberExpected = { outerProp : { 5 : { prop : 2 } } }
   expect(withDateLike).toEqual(withDateLikeExpected)
-  expect(withNumber).toEqual(withNumberExpected)
+  // expect(withNumber).toEqual(withNumberExpected)
 })
 
 test('adds a key to an empty object', () => {
-  expect(assocPath(
+  expect(assocPathFn(
     [ 'a' ], 1, {}
   )).toEqual({ a : 1 })
 })
 
 test('adds a key to a non-empty object', () => {
-  expect(assocPath(
+  expect(assocPathFn(
     'b', 2, { a : 1 }
   )).toEqual({
     a : 1,
@@ -1961,7 +1957,7 @@ test('adds a key to a non-empty object', () => {
 })
 
 test('adds a nested key to a non-empty object', () => {
-  expect(assocPath(
+  expect(assocPathFn(
     'b.c', 2, { a : 1 }
   )).toEqual({
     a : 1,
@@ -1969,9 +1965,9 @@ test('adds a nested key to a non-empty object', () => {
   })
 })
 
-test('adds a nested key to a nested non-empty object - curry case 1', () => {
-  expect(assocPath('b.d',
-    3)({
+test('adds a nested key to a nested non-empty object', () => {
+  expect(assocPathFn('b.d',
+    3,{
     a : 1,
     b : { c : 2 },
   })).toEqual({
@@ -1983,74 +1979,58 @@ test('adds a nested key to a nested non-empty object - curry case 1', () => {
   })
 })
 
-test('adds a key to a non-empty object - curry case 1', () => {
-  expect(assocPath('b', 2)({ a : 1 })).toEqual({
+test('adds a key to a non-empty object', () => {
+  expect(assocPathFn('b', 2, { a : 1 })).toEqual({
     a : 1,
     b : 2,
   })
 })
 
-test('adds a nested key to a non-empty object - curry case 1', () => {
-  expect(assocPath('b.c', 2)({ a : 1 })).toEqual({
+test('adds a nested key to a non-empty object', () => {
+  expect(assocPathFn('b.c', 2, { a : 1 })).toEqual({
     a : 1,
     b : { c : 2 },
   })
 })
 
-test('adds a key to a non-empty object - curry case 2', () => {
-  expect(assocPath('b')(2, { a : 1 })).toEqual({
-    a : 1,
-    b : 2,
-  })
-})
-
-test('adds a key to a non-empty object - curry case 3', () => {
-  const result = assocPath('b')(2)({ a : 1 })
-
-  expect(result).toEqual({
-    a : 1,
-    b : 2,
-  })
-})
-
 test('changes an existing key', () => {
-  expect(assocPath(
+  expect(assocPathFn(
     'a', 2, { a : 1 }
   )).toEqual({ a : 2 })
 })
 
 test('undefined is considered an empty object', () => {
-  expect(assocPath(
+  expect(assocPathFn(
     'a', 1, undefined
   )).toEqual({ a : 1 })
 })
 
 test('null is considered an empty object', () => {
-  expect(assocPath(
+  expect(assocPathFn(
     'a', 1, null
   )).toEqual({ a : 1 })
 })
 
 test('value can be null', () => {
-  expect(assocPath(
+  expect(assocPathFn(
     'a', null, null
   )).toEqual({ a : null })
 })
 
 test('value can be undefined', () => {
-  expect(assocPath(
+  expect(assocPathFn(
     'a', undefined, null
   )).toEqual({ a : undefined })
 })
 
 test('assignment is shallow', () => {
-  expect(assocPath(
+  expect(assocPathFn(
     'a', { b : 2 }, { a : { c : 3 } }
   )).toEqual({ a : { b : 2 } })
 })
 
 test('empty array as path', () => {
-  const result = assocPath(
+  const result = assocPathFn(
     [], 3, {
       a : 1,
       b : 2,
@@ -2061,7 +2041,7 @@ test('empty array as path', () => {
 
 test('happy', () => {
   const expected = { foo : { bar : { baz : 42 } } }
-  const result = assocPath(
+  const result = assocPathFn(
     [ 'foo', 'bar', 'baz' ], 42, { foo : null }
   )
   expect(result).toEqual(expected)
@@ -2888,7 +2868,7 @@ 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>
+<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20result%20%3D%20R.sort(R.descend(x%20%3D%3E%20x)%2C%20%5B1%2C%202%5D)%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)
 
@@ -5635,7 +5615,7 @@ It splits `list` according to a provided `groupFn` function and returns an objec
 
 It returns separated version of list or string `input`, where separation is done with equality `compareFn` function.
 
-<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20compareFn%20%3D%20(x%2C%20y)%20%3D%3E%20x%20%3D%3D%3D%20y%0Aconst%20list%20%3D%20%5B1%2C%202%2C%202%2C%201%2C%201%2C%202%5D%0A%0Aconst%20result%20%3D%20R.groupWith(isConsecutive%2C%20list)%0A%2F%2F%20%3D%3E%20%5B%5B1%5D%2C%20%5B2%2C2%5D%2C%20%5B1%2C1%5D%2C%20%5B2%5D%5D">Try this <strong>R.groupWith</strong> example in Rambda REPL</a>
+<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20isConsecutive%20%3D%20(x%2C%20y)%20%3D%3E%20x%20%3D%3D%3D%20y%0Aconst%20list%20%3D%20%5B1%2C%202%2C%202%2C%201%2C%201%2C%202%5D%0A%0Aconst%20result%20%3D%20R.groupWith(isConsecutive%2C%20list)%0A%2F%2F%20%3D%3E%20%5B%5B1%5D%2C%20%5B2%2C2%5D%2C%20%5B1%2C1%5D%2C%20%5B2%5D%5D">Try this <strong>R.groupWith</strong> example in Rambda REPL</a>
 
 [![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#groupWith)
 
@@ -5853,7 +5833,7 @@ describe('R.hasPath', () => {
 head(str: string): string
 ```
 
-It returns the first element of list or string `input`.
+It returns the first element of list or string `input`. It returns `undefined` if array has length of 0.
 
 <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>
 
@@ -5864,6 +5844,7 @@ It returns the first element of list or string `input`.
 ```typescript
 head(str: string): string;
 head(str: ''): undefined;
+head(list: readonly[]): undefined;
 head<T>(list: never[]): undefined;
 head<T extends unknown[]>(array: T): FirstArrayElement<T>
 head<T extends readonly unknown[]>(array: T): FirstArrayElement<T>
@@ -5937,9 +5918,9 @@ describe('R.head', () => {
   it('empty array', () => {
     const list = [] as const
     head(emptyList) // $ExpectType undefined
-    head(list) // $ExpectType never
+    head(list) // $ExpectType undefined
     last(emptyList) // $ExpectType undefined
-    last(list) // $ExpectType never
+    last(list) // $ExpectType undefined
   })
 
   it('mixed', () => {
@@ -6076,10 +6057,9 @@ function ifElseFn(
   condition, onTrue, onFalse
 ){
   return (...input) => {
-    const conditionResult =
+		const conditionResult =
       typeof condition === 'boolean' ? condition : condition(...input)
-
-    if (conditionResult === true){
+    if (Boolean(conditionResult) ){
       return onTrue(...input)
     }
 
@@ -6102,6 +6082,7 @@ import { has } from './has.js'
 import { identity } from './identity.js'
 import { ifElse } from './ifElse.js'
 import { prop } from './prop.js'
+import * as R from 'ramda'
 
 const condition = has('foo')
 const v = function (a){
@@ -6189,6 +6170,17 @@ test('simple arity of 2', () => {
   )(1, 10)
   expect(result).toBe(12)
 })
+
+test('bug 750', () => {
+	const value = 34;
+
+	let result = ifElse(
+	R.identity,
+	R.always('true'),
+	R.always('false')
+	)(value)
+	expect(result).toBe('true')
+})
 ```
 
 </details>
@@ -6595,12 +6587,6 @@ export function isEmpty(input){
     return false
   if (!input) return true
 
-  if (type(input.isEmpty) === 'Function') {
-	return input.isEmpty();
-  } else if (input.isEmpty) {
-	return !!input.isEmpty;
-  }
-
   if (inputType === 'Object'){
     return Object.keys(input).length === 0
   }
@@ -6635,10 +6621,6 @@ test('happy', () => {
   expect(isEmpty(0)).toBeFalse()
   expect(isEmpty(NaN)).toBeFalse()
   expect(isEmpty([ '' ])).toBeFalse()
-  expect(isEmpty({ isEmpty: false})).toBeFalse()
-  expect(isEmpty({ isEmpty: () => false})).toBeFalse()
-  expect(isEmpty({ isEmpty: true})).toBeTrue()
-  expect(isEmpty({ isEmpty: () => true})).toBeTrue()
 })
 ```
 
@@ -6716,6 +6698,27 @@ test('happy', () => {
 
 [![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#isNil)
 
+### isNotEmpty
+
+```typescript
+
+isNotEmpty<T>(value: T[]): value is NonEmptyArray<T>
+```
+
+<details>
+
+<summary>All TypeScript definitions</summary>
+
+```typescript
+isNotEmpty<T>(value: T[]): value is NonEmptyArray<T>;
+isNotEmpty<T>(value: readonly T[]): value is ReadonlyNonEmptyArray<T>;
+isNotEmpty(value: any): boolean;
+```
+
+</details>
+
+[![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#isNotEmpty)
+
 ### isNotNil
 
 <a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20result%20%3D%20%5B%0A%20%20R.isNotNil(null)%2C%0A%20%20R.isNotNil(undefined)%2C%0A%20%20R.isNotNil(%5B%5D)%2C%0A%5D%0A%2F%2F%20%3D%3E%20%5Bfalse%2C%20false%2C%20true%5D">Try this <strong>R.isNotNil</strong> example in Rambda REPL</a>
@@ -6930,7 +6933,7 @@ test('happy', () => {
 last(str: ''): undefined
 ```
 
-It returns the last element of `input`, as the `input` can be either a string or an array.
+It returns the last element of `input`, as the `input` can be either a string or an array. It returns `undefined` if array has length of 0.
 
 <a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20result%20%3D%20%5B%0A%20%20R.last(%5B1%2C%202%2C%203%5D)%2C%0A%20%20R.last('foo')%2C%0A%5D%0A%2F%2F%20%3D%3E%20%5B3%2C%20'o'%5D">Try this <strong>R.last</strong> example in Rambda REPL</a>
 
@@ -6941,9 +6944,11 @@ It returns the last element of `input`, as the `input` can be either a string or
 ```typescript
 last(str: ''): undefined;
 last(str: string): string;
+last(list: readonly[]): undefined;
 last(list: never[]): undefined;
-last<T extends unknown[]>(array: T): LastArrayElement<T>
-last<T extends readonly unknown[]>(array: T): LastArrayElement<T>
+last<T extends unknown[]>(array: T): LastArrayElement<T>;
+last<T extends readonly unknown[]>(array: T): LastArrayElement<T>;
+last(str: string): string | undefined;
 ```
 
 </details>
@@ -7251,7 +7256,7 @@ export function lens(getter, setter){
 <summary><strong>TypeScript</strong> test</summary>
 
 ```typescript
-import {lens, assoc, lensProp, view, lensIndex, lensPath} from 'rambda'
+import {lens, assoc, lensProp, view, lensIndex, over, lensPath} from 'rambda'
 
 interface Input {
   foo: string,
@@ -7275,6 +7280,10 @@ describe('R.lensProp', () => {
     const result = view<Input, string>(lensProp('foo'), testObject)
     result // $ExpectType string
   })
+  it('issue 740', () => {
+    // @ts-expect-error
+    over(lensProp('x'), (n) => String(n), {x: 1})
+  })
 })
 
 describe('R.lensIndex', () => {
@@ -7587,7 +7596,7 @@ It returns the result of looping through `iterable` with `fn`.
 
 It works with both array and object.
 
-<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20fn%20%3D%20x%20%3D%3E%20x%20*%202%0Aconst%20fnWhenObject%20%3D%20(val%2C%20prop)%3D%3E%7B%0A%20%20return%20%60%24%7Bprop%7D-%24%7Bval%7D%60%0A%7D%0A%0Aconst%20iterable%20%3D%20%5B1%2C%202%5D%0Aconst%20obj%20%3D%20%7Ba%3A%201%2C%20b%3A%202%7D%0A%0Aconst%20result%20%3D%20%5B%20%0A%20%20R.map(fn%2C%20list)%2C%0A%20%20R.map(fnWhenObject%2C%20Record%3Cstring%2C%20unknown%3E)%0A%5D%0A%2F%2F%20%3D%3E%20%5B%20%5B1%2C%204%5D%2C%20%7Ba%3A%20'a-1'%2C%20b%3A%20'b-2'%7D%5D">Try this <strong>R.map</strong> example in Rambda REPL</a>
+<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20fn%20%3D%20x%20%3D%3E%20x%20*%202%0Aconst%20fnWhenObject%20%3D%20(val%2C%20prop)%3D%3E%7B%0A%20%20return%20%60%24%7Bprop%7D-%24%7Bval%7D%60%0A%7D%0A%0Aconst%20iterable%20%3D%20%5B1%2C%202%5D%0Aconst%20obj%20%3D%20%7Ba%3A%201%2C%20b%3A%202%7D%0A%0Aconst%20result%20%3D%20%5B%20%0A%20%20R.map(fn%2C%20iterable)%2C%0A%20%20R.map(fnWhenObject%2C%20obj)%0A%5D%0A%2F%2F%20%3D%3E%20%5B%20%5B2%2C%204%5D%2C%20%7Ba%3A%20'a-1'%2C%20b%3A%20'b-2'%7D%5D">Try this <strong>R.map</strong> example in Rambda REPL</a>
 
 <details>
 
@@ -7829,7 +7838,7 @@ mapObjIndexed<T>(fn: ObjectIterator<T, T>, iterable: Dictionary<T>): Dictionary<
 
 It works the same way as `R.map` does for objects. It is added as Ramda also has this method.
 
-<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20fn%20%3D%20(val%2C%20prop)%20%3D%3E%20%7B%0A%20%20return%20%60%24%7Bprop%7D-%24%7Bval%7D%60%0A%7D%0A%0Aconst%20obj%20%3D%20%7Ba%3A%201%2C%20b%3A%202%7D%0A%0Aconst%20result%20%3D%20R.map(mapObjIndexed%2C%20Record%3Cstring%2C%20unknown%3E)%0A%2F%2F%20%3D%3E%20%7Ba%3A%20'a-1'%2C%20b%3A%20'b-2'%7D">Try this <strong>R.mapObjIndexed</strong> example in Rambda REPL</a>
+<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20fn%20%3D%20(val%2C%20prop)%20%3D%3E%20%7B%0A%20%20return%20%60%24%7Bprop%7D-%24%7Bval%7D%60%0A%7D%0A%0Aconst%20obj%20%3D%20%7Ba%3A%201%2C%20b%3A%202%7D%0A%0Aconst%20result%20%3D%20R.mapObjIndexed(fn%2C%20obj)%0A%2F%2F%20%3D%3E%20%7Ba%3A%20'a-1'%2C%20b%3A%20'b-2'%7D">Try this <strong>R.mapObjIndexed</strong> example in Rambda REPL</a>
 
 <details>
 
@@ -8828,11 +8837,7 @@ It returns the lesser value between `x` and `y` according to `compareFn` functio
 
 ```typescript
 
-modify<T extends object, K extends keyof T, P>(
-  prop: K,
-  fn: (a: T[K]) => P,
-  obj: T,
-): Omit<T, K> & Record<K, P>
+modify<K extends PropertyKey, T>(prop: K, fn: (value: T) => T): <U extends Record<K, T>>(object: U) => U
 ```
 
 <a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20result%20%3D%20R.modify()%0A%2F%2F%20%3D%3E">Try this <strong>R.modify</strong> example in Rambda REPL</a>
@@ -8842,15 +8847,12 @@ modify<T extends object, K extends keyof T, P>(
 <summary>All TypeScript definitions</summary>
 
 ```typescript
-modify<T extends object, K extends keyof T, P>(
-  prop: K,
-  fn: (a: T[K]) => P,
-  obj: T,
-): Omit<T, K> & Record<K, P>;
-modify<K extends string, A, P>(
-  prop: K,
-  fn: (a: A) => P,
-): <T extends Record<K, A>>(target: T) => Omit<T, K> & Record<K, P>;
+modify<K extends PropertyKey, T>(prop: K, fn: (value: T) => T): <U extends Record<K, T>>(object: U) => U;
+modify<U, K extends keyof U>(prop: K, fn: (value: U[K]) => U[K], object: U): U;
+modify<K extends PropertyKey>(prop: K): {
+  <T>(fn: (value: T) => T): <U extends Record<K, T>>(object: U) => U;
+  <T, U extends Record<K, T>>(fn: (value: T) => T, object: U): U;
+};
 ```
 
 </details>
@@ -8991,23 +8993,52 @@ describe('brute force', () => {
 <summary><strong>TypeScript</strong> test</summary>
 
 ```typescript
-import {modify, add} from 'rambda'
-const person = {name: 'James', age: 20}
+import { add, identity, map, modify, pipe, toUpper } from 'rambda';
+
+type Obj = {
+	foo: string;
+	bar: number;
+};
 
 describe('R.modify', () => {
-  it('happy', () => {
-    const {age} = modify('age', add(1), person)
-    const {age: ageAsString} = modify('age', String, person)
+	it('ramda tests', () => {
+		const result1 = modify('foo', toUpper, {} as Obj);
+		result1; // $ExpectType Obj
 
-    age // $ExpectType number
-    ageAsString // $ExpectType string
-  })
-  it('curried', () => {
-    const {age} = modify('age', add(1))(person)
+		const result2 = modify('bar', add(1), {} as Obj);
+		result2; // $ExpectType Obj
 
-    age // $ExpectType number
-  })
-})
+		const result3 = modify('foo', toUpper)({} as Obj);
+		result3; // $ExpectType Obj
+
+		const result4 = modify('bar', add(1))({} as Obj);
+		result4; // $ExpectType Obj
+
+		const result5 = modify('foo')(toUpper)({} as Obj);
+		result5; // $ExpectType Obj
+
+		const result6 = modify('bar')(add(1))({} as Obj);
+		result6; // $ExpectType Obj
+
+		const result7 = modify('foo')(toUpper, {} as Obj);
+		result7; // $ExpectType Obj
+
+		const result8 = modify('bar')(add(1), {} as Obj);
+		result8; // $ExpectType Obj
+
+		const result9 = modify('foo', identity, {} as Obj);
+		result9; // $ExpectType Obj
+
+		// @ts-expect-error
+		modify('foo', add(1), {} as Obj);
+		// @ts-expect-error
+		modify('bar', toUpper, {} as Obj);
+
+		const f = pipe(map<Obj, Obj>(modify('foo', toUpper)));
+
+		f([] as Obj[]); // $ExpectType Obj[]
+	});
+});
 ```
 
 </details>
@@ -17226,6 +17257,22 @@ describe('R.zipWith', () => {
 
 ## ❯ CHANGELOG
 
+9.4.0
+
+- Fix `deno` release
+
+- Fix too strict `true` condition in `R.ifElse` - [Issue #750](https://github.com/selfrefactor/rambda/issues/750)
+
+- Change `R.groupBy` typings to match `@types/ramda` typings
+
+9.3.0
+
+- Breaking change in relation to TS typings of `R.assoc`, `R.dissoc` and `R.modify` - https://github.com/ramda/types/pull/37
+
+- 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 
+
 9.2.1
 
 - Broken `Deno` build - [Issue #731](https://github.com/selfrefactor/rambda/issues/731)
@@ -17650,11 +17697,11 @@ Fix wrong versions in changelog
 
 > Links to Rambda
 
-- [https://github.com/stoeffel/awesome-fp-js](awesome-fp-js)
+- [awesome-fp-js](https://github.com/stoeffel/awesome-fp-js)
 
-- [ https://mailchi.mp/webtoolsweekly/web-tools-280 ]( Web Tools Weekly #280 )
+- [Web Tools Weekly #280](https://mailchi.mp/webtoolsweekly/web-tools-280)
 
-- [https://github.com/docsifyjs/awesome-docsify](awesome-docsify)
+- [awesome-docsify](https://github.com/docsifyjs/awesome-docsify)
 
 > Deprecated from `Used by` section