rambda 9.2.0 → 9.3.0

package/CHANGELOG.md

@@ -1,4 +1,16 @@
-9.1.2
+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)
+
+9.2.0
 
 - `R.once` TS type definition miss to context argument and its type - [Issue #728](https://github.com/selfrefactor/rambda/issues/728)
 

package/README.md

@@ -106,59 +106,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 +214,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.29.1).
+The benchmarks results are produced from latest versions of *Rambda*, *Lodash*(4.17.21) and *Ramda*(0.30.1).
 
 </summary>
 
@@ -5853,7 +5851,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 +5862,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 +5936,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', () => {
@@ -6595,12 +6594,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 +6628,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 +6705,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 +6940,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 +6951,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 +7263,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 +7287,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', () => {
@@ -7570,6 +7586,12 @@ test('get (set(set s v1) v2) === v2', () => {
 
 [![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#lt)
 
+### lte
+
+<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20result%20%3D%20%5BR.lte(2%2C%201)%2C%20R.lte(2%2C%202)%2C%20R.lte(2%2C%203)%5D%0A%2F%2F%20%3D%3E%20%5Bfalse%2C%20true%2C%20true%5D">Try this <strong>R.lte</strong> example in Rambda REPL</a>
+
+[![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#lte)
+
 ### map
 
 ```typescript
@@ -8822,11 +8844,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>
@@ -8836,15 +8854,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>
@@ -8985,23 +9000,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>
@@ -17220,7 +17264,19 @@ describe('R.zipWith', () => {
 
 ## ❯ CHANGELOG
 
-9.1.2
+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)
+
+9.2.0
 
 - `R.once` TS type definition miss to context argument and its type - [Issue #728](https://github.com/selfrefactor/rambda/issues/728)
 
@@ -17640,11 +17696,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
 

package/dist/rambda.js

@@ -834,6 +834,14 @@ function dissoc(prop, obj) {
   return willReturn;
 }
 
+function _defineProperty(e, r, t) {
+  return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+    value: t,
+    enumerable: !0,
+    configurable: !0,
+    writable: !0
+  }) : e[r] = t, e;
+}
 function ownKeys(e, r) {
   var t = Object.keys(e);
   if (Object.getOwnPropertySymbols) {
@@ -855,33 +863,19 @@ function _objectSpread2(e) {
   }
   return e;
 }
-function _defineProperty(obj, key, value) {
-  key = _toPropertyKey(key);
-  if (key in obj) {
-    Object.defineProperty(obj, key, {
-      value: value,
-      enumerable: true,
-      configurable: true,
-      writable: true
-    });
-  } else {
-    obj[key] = value;
-  }
-  return obj;
-}
-function _toPrimitive(input, hint) {
-  if (typeof input !== "object" || input === null) return input;
-  var prim = input[Symbol.toPrimitive];
-  if (prim !== undefined) {
-    var res = prim.call(input, hint || "default");
-    if (typeof res !== "object") return res;
+function _toPrimitive(t, r) {
+  if ("object" != typeof t || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i = e.call(t, r || "default");
+    if ("object" != typeof i) return i;
     throw new TypeError("@@toPrimitive must return a primitive value.");
   }
-  return (hint === "string" ? String : Number)(input);
+  return ("string" === r ? String : Number)(t);
 }
-function _toPropertyKey(arg) {
-  var key = _toPrimitive(arg, "string");
-  return typeof key === "symbol" ? key : String(key);
+function _toPropertyKey(t) {
+  var i = _toPrimitive(t, "string");
+  return "symbol" == typeof i ? i : i + "";
 }
 
 function compare(a, b) {
@@ -1536,11 +1530,6 @@ function isEmpty(input) {
   const inputType = type(input);
   if (['Undefined', 'NaN', 'Number', 'Null'].includes(inputType)) 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;
   }
@@ -1554,6 +1543,10 @@ function isNil(x) {
   return x === undefined || x === null;
 }
 
+function isNotEmpty(input) {
+  return !isEmpty(input);
+}
+
 function isNotNil(input) {
   return input != null;
 }
@@ -1622,6 +1615,11 @@ function lt(a, b) {
   return a < b;
 }
 
+function lte(a, b) {
+  if (arguments.length === 1) return _b => lte(a, _b);
+  return a <= b;
+}
+
 function match(pattern, input) {
   if (arguments.length === 1) return _input => match(pattern, _input);
   const willReturn = input.match(pattern);
@@ -2608,6 +2606,7 @@ exports.intersperse = intersperse;
 exports.is = is;
 exports.isEmpty = isEmpty;
 exports.isNil = isNil;
+exports.isNotEmpty = isNotEmpty;
 exports.isNotNil = isNotNil;
 exports.join = join;
 exports.juxt = juxt;
@@ -2620,6 +2619,7 @@ exports.lensIndex = lensIndex;
 exports.lensPath = lensPath;
 exports.lensProp = lensProp;
 exports.lt = lt;
+exports.lte = lte;
 exports.map = map;
 exports.mapArray = mapArray;
 exports.mapObjIndexed = mapObjIndexed;