rambda 10.0.0-alpha.0 → 10.0.0-beta.1

package/immutable.d.ts

@@ -1,22 +1,18 @@
-export type RambdaTypes = "Object" | "Number" | "Boolean" | "String" | "Null" | "Array" | "RegExp" | "NaN" | "Function" | "Undefined" | "Async" | "Promise" | "Symbol" | "Set" | "Error" | "Map" | "WeakMap" | "Generator" | "GeneratorFunction" | "BigInt" | "ArrayBuffer" | "Date"
+export type RambdaTypes = "Object" | "Number" | "Boolean" | "String" | "Null" | "Array" | "RegExp" | "NaN" | "Function" | "Undefined" | "Async" | "Promise" | "Symbol" | "Set" | "Error" | "Map" | "WeakMap" | "Generator" | "GeneratorFunction" | "BigInt" | "ArrayBuffer" | "Date";
 
 export type EqualTypes<X, Y> =
   (<T>() => T extends X ? 1 : 2) extends
-  (<T>() => T extends Y ? 1 : 2) ? true : false
+  (<T>() => T extends Y ? 1 : 2) ? true : false;
 
-export type NonEmptyArray<T> = readonly [T, ...readonly T[]];
-export type ReadonlyNonEmptyArray<T> = readonly [T, ...readonly T[]];
 export type IterableContainer<T = unknown> = ReadonlyArray<T> | readonly [];
 
-
-
 export type Mapped<T extends IterableContainer, K> = { readonly
   -readonly [P in keyof T]: K;
 };
 
 export type ElementOf<Type extends readonly any[]> = Type[number];
 export type MergeTypes<T> = { readonly[KeyType in keyof T]: T[KeyType]} & {};
-export type Simplify<T> = T extends infer O ? { readonly [K in keyof O]: O[K] } : never;
+export type MergeTypesAlternative<T> = T extends infer O ? { readonly [K in keyof O]: O[K] } : never;
 
 export type EntryForKey<T, Key extends keyof T> = Key extends number | string
   ? readonly [key: `${Key}`, value: Required<T>[Key]]
@@ -26,16 +22,13 @@ export type Entry<T> = MergeTypes<{ readonly [P in keyof T]-?: EntryForKey<T, P>
 
 export type Ord = number | string | boolean | Date;
 export type Ordering = -1 | 0 | 1;
-type Path = ReadonlyArray<string> | string;
-type Prop<T, P extends keyof never> = P extends keyof Exclude<T, undefined>
-    ? T extends undefined ? undefined : T[Extract<P, keyof T>]
-    : undefined;
 
 interface KeyValuePair<K, V> extends Array<K | V> {
   readonly 0: K;
   readonly 1: V;
 }
-export type Functor<A> = { readonly map: <B>(fn: (a: A) => B) => Functor<B>; readonly [key: string]: any };
+
+export type Functor<A> = { readonly map: <B>(fn: (x: A) => B) => Functor<B>; readonly [key: string]: any };
 export type DeepModify<Keys extends readonly PropertyKey[], U, T> =
   Keys extends readonly [infer K, ...infer Rest]
     ? K extends keyof U
@@ -52,40 +45,6 @@ export type PickStringToPickPath<T> = T extends `${infer Head},${infer Tail}`
 	: T extends `${infer Head}` ? readonly [Head]
 	: readonly [];
 
-
-export type Partial<T> = { readonly [P in keyof T]?: T[P]};
-
-type Evolvable<E extends Evolver> = { readonly[P in keyof E]?: Evolved<E[P]>};
-
-type Evolver<T extends Evolvable<any> = any> = { readonly   [key in keyof Partial<T>]: ((value: T[key]) => T[key]) | (T[key] extends Evolvable<any> ? Evolver<T[key]> : never);
-};
-
-type Evolve<O extends Evolvable<E>, E extends Evolver> = { readonly   [P in keyof O]: P extends keyof E
-                  ? EvolveValue<O[P], E[P]>
-                  : O[P];
-};
-
-type Evolved<A> =
-    A extends (value: infer V) => any
-    ? V
-    : A extends Evolver
-      ? Evolvable<A>
-      : never;
-
-type EvolveNestedValue<O, E extends Evolver> =
-    O extends object
-    ? O extends Evolvable<E>
-      ? Evolve<O, E>
-      : never
-    : never;
-
-type EvolveValue<V, E> =
-    E extends (value: V) => any
-    ? ReturnType<E>
-    : E extends Evolver
-      ? EvolveNestedValue<V, E>
-      : never;
-
 declare const emptyObjectSymbol: unique symbol;
 type EmptyObject = {readonly [emptyObjectSymbol]?: never};
 type EnumerableStringKeyOf<T> =
@@ -105,12 +64,38 @@ type MappedValues<T extends object, Value> = MergeTypes<{ readonly
 	-readonly [P in keyof T as `${P extends number | string ? P : never}`]: Value;
 }>;
 
-export function T(): boolean;
+type SimpleMerge<Destination, Source> = { readonly
+	[Key in keyof Destination as Key extends keyof Source ? never : Key]: Destination[Key];
+} & Source;
+
+type OmitIndexSignature<ObjectType> = { readonly
+	[KeyType in keyof ObjectType as {} extends Record<KeyType, unknown>
+		? never
+		: KeyType]: ObjectType[KeyType];
+};
+
+type PickIndexSignature<ObjectType> = { readonly
+	[KeyType in keyof ObjectType as {} extends Record<KeyType, unknown>
+		? KeyType
+		: never]: ObjectType[KeyType];
+};
+
+type Merge<Destination, Source> =
+MergeTypes<
+	SimpleMerge<PickIndexSignature<Destination>, PickIndexSignature<Source>>
+	& SimpleMerge<OmitIndexSignature<Destination>, OmitIndexSignature<Source>>
+>;
+
+type StrictNonNullable<T> = Exclude<T, null | undefined>;
+
 
 /**
- * It adds `a` and `b`.
+ * It adds new key-value pair to the object.
  */
-export function add(a: number): (b: number) => number;
+export function addProp<T extends object, P extends PropertyKey, V extends unknown>(
+	prop: P,
+	value: V
+): (obj: T) => MergeTypes<T & Record<P, V>>;
 
 /**
  * It returns `true`, if all members of array `list` returns `true`, when applied as argument to `predicate` function.
@@ -169,11 +154,27 @@ export function anyPass<F extends (...args: readonly any[]) => boolean>(predicat
 export function append<T>(el: T): (list: readonly T[]) => readonly T[];
 export function append<T>(el: T): (list: readonly T[]) => readonly T[];
 
+/**
+ * Helper function to be used with `R.sort` to sort list in ascending order.
+ */
+export function ascend<T>(fn: (obj: T) => Ord): (a: T, b: T)=> Ordering;
+
 /**
  * It returns `true` if all each property in `conditions` returns `true` when applied to corresponding property in `input` object.
  */
 export function checkObjectWithSpec<T>(spec: T): <U>(testObj: U) => boolean;
 
+/**
+ * It removes `null` and `undefined` members from list or object input.
+ */
+export function compact<T>(list: readonly T[]): ReadonlyArray<StrictNonNullable<T>>;
+export function compact<T extends object>(record: T): { readonly
+  [K in keyof T as Exclude<T[K], null | undefined> extends never
+    ? never
+    : K
+  ]: Exclude<T[K], null | undefined>
+};
+
 /**
  * It returns `inverted` version of `origin` function that accept `input` as argument.
  * 
@@ -195,35 +196,41 @@ export function count<T>(predicate: (x: T) => boolean): (list: readonly T[]) =>
 /**
  * It counts elements in a list after each instance of the input list is passed through `transformFn` function.
  */
-export function countBy<T>(fn: (a: T) => string | number): (list: readonly T[]) => { readonly [index: string]: number };
+export function countBy<T>(fn: (x: T) => string | number): (list: readonly T[]) => { readonly [index: string]: number };
 
-/**
- * It decrements a number.
- */
-export function dec(x: number): number;
+export function createObjectFromKeys<const K extends readonly PropertyKey[], V>(
+	fn: (key: K[number]) => V
+): (keys: K) => { readonly [P in K[number]]: V };
+export function createObjectFromKeys<const K extends readonly PropertyKey[], V>(
+	fn: (key: K[number], index: number) => V
+): (keys: K) => { readonly [P in K[number]]: V };
 
 /**
  * It returns `defaultValue`, if all of `inputArguments` are `undefined`, `null` or `NaN`.
  * 
  * Else, it returns the first truthy `inputArguments` instance(from left to right).
  */
-export function defaultTo<T>(defaultValue: T, input: T | null | undefined): T;
-export function defaultTo<T>(defaultValue: T): <U>(input: U | null | undefined) => EqualTypes<U, T> extends true ? T : never
+export function defaultTo<T>(defaultValue: T): (input: unknown) => T;
+
+/**
+ * Helper function to be used with `R.sort` to sort list in descending order.
+ */
+export function descend<T>(fn: (obj: T) => Ord): (a: T, b: T)=> Ordering;
 
 /**
- * It returns `howMany` items dropped from beginning of list or string `input`.
+ * It returns `howMany` items dropped from beginning of list.
  */
 export function drop<T>(howMany: number): (list: readonly T[]) => readonly T[];
 
 /**
- * It returns `howMany` items dropped from  the end of list or string `input`.
+ * It returns `howMany` items dropped from the end of list.
  */
 export function dropLast<T>(howMany: number): (list: readonly T[]) => readonly T[];
 
 export function dropLastWhile<T>(predicate: (x: T, index: number) => boolean): (list: readonly T[]) => readonly T[];
 export function dropLastWhile<T>(predicate: (x: T) => boolean): (list: readonly T[]) => readonly T[];
 
-export function dropRepeatsBy<T, U>(fn: (a: T) => U): (list: readonly T[]) => readonly T[];
+export function dropRepeatsBy<T, U>(fn: (x: T) => U): (list: readonly T[]) => readonly T[];
 
 export function dropRepeatsWith<T>(predicate: (x: T, y: T) => boolean): (list: readonly T[]) => readonly T[];
 
@@ -235,7 +242,7 @@ export function eqBy<T>(fn: (x: T) => unknown, a: T): (b: T) => boolean;
 /**
  * It returns `true` if property `prop` in `obj1` is equal to property `prop` in `obj2` according to `R.equals`.
  */
-export function eqProps<T>(prop: string, obj1: T): <U>(obj2: U) => boolean;
+export function eqProps<T, K extends keyof T>(prop: K, obj1: T): (obj2: T) => boolean;
 
 /**
  * It deeply compares `x` and `y` and returns `true` if they are equal.
@@ -245,8 +252,11 @@ export function equals<T>(x: T): (y: T) => boolean;
 
 /**
  * It takes object of functions as set of rules. These `rules` are applied to the `iterable` input to produce the result.
+ * It doesn't support nested rules, i.e rules are only one level deep.
  */
-export function evolve<E extends Evolver>(rules: E): <V extends Evolvable<E>>(obj: V) => Evolve<V, E>;
+export function evolve<T>(rules: { readonly
+	[K in keyof T]?: (x: T[K]) => T[K]
+}): (obj: T) => T;
 
 /**
  * Opposite of `R.includes`
@@ -264,10 +274,10 @@ export function filter<T, S extends T>(
 ): (list: readonly T[]) => readonly S[];
 export function filter<T>(
 	predicate: BooleanConstructor,
-): (list: readonly T[]) => readonly NonNullable<T>[];
+): (list: readonly T[]) => readonly StrictNonNullable<T>[];
 export function filter<T>(
 	predicate: BooleanConstructor,
-): (list: readonly T[]) => readonly NonNullable<T>[];
+): (list: readonly T[]) => readonly StrictNonNullable<T>[];
 export function filter<T>(
 	predicate: (value: T) => boolean,
 ): (list: readonly T[]) => readonly T[];
@@ -311,6 +321,11 @@ export function findLast<T>(fn: (x: T) => boolean): (list: readonly T[]) => T |
  */
 export function findLastIndex<T>(predicate: (x: T) => boolean): (list: readonly T[]) => number;
 
+/**
+ * It returns the `nth` element of `list` that satisfy the `predicate` function.
+ */
+export function findNth<T>(predicate: (x: T) => boolean, nth: number): (list: readonly T[]) => T | undefined;
+
 /**
  * It maps `fn` over `list` and then flatten the result by one-level.
  */
@@ -318,13 +333,14 @@ export function flatMap<T, U extends unknown>(transformFn: (x: T extends readonl
 
 /**
  * It deeply flattens an array.
+ * You must pass expected output type as a type argument.
  */
 export function flatten<T>(list: readonly any[]): readonly T[];
 
 /**
  * It splits `list` according to a provided `groupFn` function and returns an object.
  */
-export function groupBy<T, K extends string = string>(fn: (a: T) => K): (list: readonly T[]) => Partial<Record<K, readonly T[]>>;
+export function groupBy<T, K extends string = string>(fn: (x: T) => K): (list: readonly T[]) => Partial<Record<K, readonly T[]>>;
 
 /**
  * It returns the first element of list or string `input`. It returns `undefined` if array has length of 0.
@@ -338,18 +354,6 @@ export function head<T>(listOrString: T): T extends string ? string :
 						T extends readonly unknown[] ? T[number] : 
 							undefined;
 
-/**
- * It expects `condition`, `onTrue` and `onFalse` functions as inputs and it returns a new function with example name of `fn`.
- * 
- * When `fn`` is called with `input` argument, it will return either `onTrue(input)` or `onFalse(input)` depending on `condition(input)` evaluation.
- */
-export function ifElse<T, TFiltered extends T, TOnTrueResult, TOnFalseResult>(
-  pred: (a: T) => a is TFiltered,
-  onTrue: (a: TFiltered) => TOnTrueResult,
-  onFalse: (a: Exclude<T, TFiltered>) => TOnFalseResult,
-): (a: T) => TOnTrueResult | TOnFalseResult;
-export function ifElse<TArgs extends readonly any[], TOnTrueResult, TOnFalseResult>(fn: (...args: TArgs) => boolean, onTrue: (...args: TArgs) => TOnTrueResult, onFalse: (...args: TArgs) => TOnFalseResult): (...args: TArgs) => TOnTrueResult | TOnFalseResult;
-
 /**
  * If `input` is string, then this method work as native `String.includes`.
  * 
@@ -377,10 +381,20 @@ export function innerJoin<T1, T2>(
   list1: readonly T1[],
 ): (list2: readonly T2[]) => readonly T1[];
 
+/**
+ * It generates a new string from `inputWithTags` by replacing all `{{x}}` occurrences with values provided by `templateArguments`.
+ */
+export function interpolate(inputWithTags: string): (templateArguments: object) => string;
+
+
+// API_MARKER_END
+// ============================================
+
+export as namespace R
+
 /**
  * It loops through `listA` and `listB` and returns the intersection of the two according to `R.equals`.
  */
-export function intersection<T>(listA: readonly T[], listB: readonly T[]): readonly T[];
 export function intersection<T>(listA: readonly T[]): (listB: readonly T[]) => readonly T[];
 
 /**
@@ -388,14 +402,9 @@ export function intersection<T>(listA: readonly T[]): (listB: readonly T[]) => r
  */
 export function intersperse<T>(separator: T): (list: readonly T[]) => readonly T[];
 
-export function isNotEmpty<T>(value: readonly T[]): value is NonEmptyArray<T>;
-export function isNotEmpty<T>(value: readonly T[]): value is ReadonlyNonEmptyArray<T>;
-export function isNotEmpty(value: any): boolean;
-
 /**
  * It returns a string of all `list` instances joined with a `glue`.
  */
-export function join<T>(glue: string, list: readonly T[]): string;
 export function join<T>(glue: string): (list: readonly T[]) => string;
 
 /**
@@ -417,7 +426,6 @@ export function last<T>(listOrString: T): T extends string ? string :
  * 
  * If there is no such index, then `-1` is returned.
  */
-export function lastIndexOf<T>(target: T, list: readonly T[]): number;
 export function lastIndexOf<T>(target: T): (list: readonly T[]) => number;
 
 /**
@@ -458,6 +466,11 @@ export function mapAsync<T extends IterableContainer, U>(
   data: T
 ): Promise<Mapped<T, U>>;
 
+/**
+ * It returns a copy of `obj` with keys transformed by `fn`.
+ */
+export function mapKeys<T>(fn: (prop: string, value: T) => string): (obj: Record<string, T>) => Record<string, T>;
+
 export function mapObject<T extends object, Value>(
   valueMapper: (
     value: EnumerableStringKeyedValueOf<T>,
@@ -474,57 +487,38 @@ export function mapObjectAsync<T extends object, Value>(
   ) => Promise<Value>,
 ): (data: T) => Promise<MappedValues<T, Value>>;
 
-// API_MARKER_END
-// ============================================
-
-export as namespace R
-
 /**
- * Curried version of `String.prototype.match` which returns empty array, when there is no match.
+ * Wrapper around `Promise.all` for asynchronous mapping with `fn` over members of `list`.
  */
-export function match(regExpression: RegExp, str: string): readonly string[];
-export function match(regExpression: RegExp): (str: string) => readonly string[];
-
-/**
- * `R.mathMod` behaves like the modulo operator should mathematically, unlike the `%` operator (and by extension, `R.modulo`). So while `-17 % 5` is `-2`, `mathMod(-17, 5)` is `3`.
- */
-export function mathMod(x: number, y: number): number;
-export function mathMod(x: number): (y: number) => number;
+export function mapParallelAsync<T extends IterableContainer, U>(
+  fn: (value: T[number], index: number) => Promise<U>,
+): (data: T) => Promise<Mapped<T, U>>;
+export function mapParallelAsync<T extends IterableContainer, U>(
+  fn: (value: T[number]) => Promise<U>,
+): (data: T) => Promise<Mapped<T, U>>;
+export function mapParallelAsync<T extends IterableContainer, U>(
+  fn: (value: T[number], index: number) => Promise<U>,
+  data: T
+): Promise<Mapped<T, U>>;
+export function mapParallelAsync<T extends IterableContainer, U>(
+  fn: (value: T[number]) => Promise<U>,
+  data: T
+): Promise<Mapped<T, U>>;
 
 /**
- * It returns the greater value between `x` and `y`.
+ * Curried version of `String.prototype.match` which returns empty array, when there is no match.
  */
-export function max<T extends Ord>(x: T, y: T): T;
-export function max<T extends Ord>(x: T): (y: T) => T;
+export function match(regExpression: RegExp): (str: string) => readonly string[];
 
 /**
  * It returns the greater value between `x` and `y` according to `compareFn` function.
  */
-export function maxBy<T>(compareFn: (input: T) => Ord, x: T, y: T): T;
 export function maxBy<T>(compareFn: (input: T) => Ord, x: T): (y: T) => T;
-export function maxBy<T>(compareFn: (input: T) => Ord): (x: T) => (y: T) => T;
-
-/**
- * It returns the mean value of `list` input.
- */
-export function mean(list: readonly number[]): number;
 
 /**
- * It returns the median value of `list` input.
+ * It creates a copy of `target` object with overwritten `newProps` properties.
  */
-export function median(list: readonly number[]): number;
-
-/**
- * Same as `R.mergeRight`.
- */
-export function merge<A, B>(target: A, newProps: B): A & B
-export function merge<Output>(target: any): (newProps: any) => Output;
-
-/**
- * It creates a copy of `target` object with overwritten `newProps` properties. Previously known as `R.merge` but renamed after Ramda did the same.
- */
-export function mergeRight<A, B>(target: A, newProps: B): A & B
-export function mergeRight<Output>(target: any): (newProps: any) => Output;
+export function merge<Source>(source: Source): <T>(data: T) => Merge<T, Source>;
 
 /**
  * Helper to merge all calculated TypeScript definitions into one definition.
@@ -532,11 +526,6 @@ export function mergeRight<Output>(target: any): (newProps: any) => Output;
  */
 export function mergeTypes<T>(x: T): MergeTypes<T>;
 
-/**
- * It returns the lesser value between `x` and `y`.
- */
-export function min<T extends Ord>(x: T): (y: T) => T;
-
 /**
  * It returns the lesser value between `x` and `y` according to `compareFn` function.
  */
@@ -545,128 +534,10 @@ export function minBy<T>(compareFn: (input: T) => Ord, x: T): (y: T) => T;
 /**
  * It changes a property with the result of transformer function.
  */
-export function modify<K extends string, A, P>(
+export function modifyProp<T, K extends keyof T>(
   prop: K,
-  fn: (a: A) => P,
-): <T extends Record<K, A>>(target: T) => Omit<T, K> & Record<K, P>;
-
-/**
- * It changes a property of object on the base of provided path and transformer function.
- */
-export function modifyPath<U, T>(path: readonly [], fn: (value: U) => T): (obj: U) => T;
-export function modifyPath<
-  K0 extends keyof U,
-  U,
-  T
->(path: readonly [K0], fn: (value: U[K0]) => T): (obj: U) => DeepModify<readonly [K0], U, T>;
-export function modifyPath<
-  K0 extends keyof U,
-  U,
-  T
->(path: `${K0}`, fn: (value: U[K0]) => T): (obj: U) => DeepModify<readonly [K0], U, T>;
-export function modifyPath<
-  K0 extends keyof U,
-  K1 extends keyof U[K0],
-  U,
-  T
->(path: readonly [K0, K1], fn: (value: U[K0][K1]) => T): (obj: U) => DeepModify<readonly [K0, K1], U, T>;
-export function modifyPath<
-  K0 extends keyof U,
-  K1 extends keyof U[K0],
-  U,
-  T
->(path: `${K0}.${K1}`, fn: (value: U[K0][K1]) => T): (obj: U) => DeepModify<readonly [K0, K1], U, T>;
-export function modifyPath<
-  K0 extends keyof U,
-  K1 extends keyof U[K0],
-  K2 extends keyof U[K0][K1],
-  U,
-  T
->(path: readonly [K0, K1, K2], fn: (value: U[K0][K1][K2]) => T): (obj: U) => DeepModify<readonly [K0, K1, K2], U, T>;
-export function modifyPath<
-  K0 extends keyof U,
-  K1 extends keyof U[K0],
-  K2 extends keyof U[K0][K1],
-  U,
-  T
->(path: `${K0}.${K1}.${K2}`, fn: (value: U[K0][K1][K2]) => T): (obj: U) => DeepModify<readonly [K0, K1, K2], U, T>;
-export function modifyPath<
-  K0 extends keyof U,
-  K1 extends keyof U[K0],
-  K2 extends keyof U[K0][K1],
-  K3 extends keyof U[K0][K1][K2],
-  U,
-  T
->(path: readonly [K0, K1, K2, K3], fn: (value: U[K0][K1][K2][K3]) => T): (obj: U) => DeepModify<readonly [K0, K1, K2, K3], U, T>;
-export function modifyPath<
-  K0 extends keyof U,
-  K1 extends keyof U[K0],
-  K2 extends keyof U[K0][K1],
-  K3 extends keyof U[K0][K1][K2],
-  U,
-  T
->(path: `${K0}.${K1}.${K2}.${K3}`, fn: (value: U[K0][K1][K2][K3]) => T): (obj: U) => DeepModify<readonly [K0, K1, K2, K3], U, T>;
-export function modifyPath<
-  K0 extends keyof U,
-  K1 extends keyof U[K0],
-  K2 extends keyof U[K0][K1],
-  K3 extends keyof U[K0][K1][K2],
-  K4 extends keyof U[K0][K1][K2][K3],
-  U,
-  T
->(path: readonly [K0, K1, K2, K3, K4], fn: (value: U[K0][K1][K2][K3][K4]) => T): (obj: U) => DeepModify<readonly [K0, K1, K2, K3, K4], U, T>;
-export function modifyPath<
-  K0 extends keyof U,
-  K1 extends keyof U[K0],
-  K2 extends keyof U[K0][K1],
-  K3 extends keyof U[K0][K1][K2],
-  K4 extends keyof U[K0][K1][K2][K3],
-  U,
-  T
->(path: `${K0}.${K1}.${K2}.${K3}.${K4}`, fn: (value: U[K0][K1][K2][K3][K4]) => T): (obj: U) => DeepModify<readonly [K0, K1, K2, K3, K4], U, T>;
-export function modifyPath<
-  K0 extends keyof U,
-  K1 extends keyof U[K0],
-  K2 extends keyof U[K0][K1],
-  K3 extends keyof U[K0][K1][K2],
-  K4 extends keyof U[K0][K1][K2][K3],
-  K5 extends keyof U[K0][K1][K2][K3][K4],
-  U,
-  T
->(path: readonly [K0, K1, K2, K3, K4, K5], fn: (value: U[K0][K1][K2][K3][K4][K5]) => T): (obj: U) => DeepModify<readonly [K0, K1, K2, K3, K4, K5], U, T>;
-export function modifyPath<
-  K0 extends keyof U,
-  K1 extends keyof U[K0],
-  K2 extends keyof U[K0][K1],
-  K3 extends keyof U[K0][K1][K2],
-  K4 extends keyof U[K0][K1][K2][K3],
-  K5 extends keyof U[K0][K1][K2][K3][K4],
-  U,
-  T
->(path: `${K0}.${K1}.${K2}.${K3}.${K4}.${K5}`, fn: (value: U[K0][K1][K2][K3][K4][K5]) => T): (obj: U) => DeepModify<readonly [K0, K1, K2, K3, K4, K5], U, T>;
-export function modifyPath<
-  K0 extends keyof U,
-  K1 extends keyof U[K0],
-  K2 extends keyof U[K0][K1],
-  K3 extends keyof U[K0][K1][K2],
-  K4 extends keyof U[K0][K1][K2][K3],
-  K5 extends keyof U[K0][K1][K2][K3][K4],
-  K6 extends keyof U[K0][K1][K2][K3][K4][K5],
-  U,
-  T
->(path: readonly [K0, K1, K2, K3, K4, K5, K6], fn: (value: U[K0][K1][K2][K3][K4][K5][K6]) => T): (obj: U) => DeepModify<readonly [K0, K1, K2, K3, K4, K5, K6], U, T>;
-export function modifyPath<
-  K0 extends keyof U,
-  K1 extends keyof U[K0],
-  K2 extends keyof U[K0][K1],
-  K3 extends keyof U[K0][K1][K2],
-  K4 extends keyof U[K0][K1][K2][K3],
-  K5 extends keyof U[K0][K1][K2][K3][K4],
-  K6 extends keyof U[K0][K1][K2][K3][K4][K5],
-  U,
-  T
->(path: `${K0}.${K1}.${K2}.${K3}.${K4}.${K5}.${K6}`, fn: (value: U[K0][K1][K2][K3][K4][K5][K6]) => T): (obj: U) => DeepModify<readonly [K0, K1, K2, K3, K4, K5, K6], U, T>;
-export function modifyPath<B, A = any>(path: Path, fn: (a: any) => any): (obj: A) => B;
+  fn: (x: T[K]) => T[K],
+): (target: T) => T;
 
 /**
  * It returns `true`, if all members of array `list` returns `false`, when applied as argument to `predicate` function.
@@ -683,7 +554,7 @@ export function objOf<T, K extends PropertyKey>(key: K): (value: T) => { readonl
  * 
  * `R.equals` is used to determine equality.
  */
-export function objectIncludes<T>(specification: T): <U>(obj: U) => boolean;
+export function objectIncludes<T>(specification: T): (obj: Partial<T>) => boolean;
 
 /**
  * It returns a partial copy of an `obj` without `propsToOmit` properties.
@@ -691,11 +562,17 @@ export function objectIncludes<T>(specification: T): <U>(obj: U) => boolean;
 export function omit<
 	S extends string,
 	Keys extends PickStringToPickPath<S>,
->(propsToPick: S): <U extends Partial<Record<ElementOf<Keys>, any>>>(obj: ElementOf<Keys> extends keyof U ? U : never) => ElementOf<Keys> extends keyof U ? MergeTypes<Omit<U, ElementOf<Keys>>> : never;
-export function omit<const Keys extends readonly PropertyKey[]>(propsToPick: Keys): <U extends Partial<Record<ElementOf<Keys>, any>>>(obj: ElementOf<Keys> extends keyof U ? U : never) => ElementOf<Keys> extends keyof U ? MergeTypes<Omit<U, ElementOf<Keys>>> : never;
+>(propsToPick: S): <U extends Partial<Record<ElementOf<Keys>, any>>>(
+	obj: ElementOf<Keys> extends keyof U ? U : never
+) => ElementOf<Keys> extends keyof U ? MergeTypes<Omit<U, ElementOf<Keys>>> : never;
+export function omit<const Keys extends readonly PropertyKey[]>(propsToPick: Keys): <
+	U extends Partial<Record<ElementOf<Keys>, any>>
+>(
+	obj: ElementOf<Keys> extends keyof U ? U : never
+) => ElementOf<Keys> extends keyof U ? MergeTypes<Omit<U, ElementOf<Keys>>> : never;
 
 /**
- * It will return array of two objects/arrays according to `predicate` function. The first member holds all instances of `input` that pass the `predicate` function, while the second member - those who doesn't.
+ * It will return array of two arrays according to `predicate` function. The first member holds all instances of `input` that pass the `predicate` function, while the second member - those who doesn't.
  */
 export function partition<T, S extends T>(
   predicate: (value: T, index: number, data: ReadonlyArray<T>) => value is S,
@@ -704,27 +581,184 @@ export function partition<T>(
   predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean,
 ): (data: ReadonlyArray<T>) => readonly [ReadonlyArray<T>, ReadonlyArray<T>];
 
+/**
+ * It returns an array containing two objects. The first object holds all properties of the input object for which the predicate returns true, while the second object holds those that do not.
+ */
+export function partitionObject<T extends unknown, S extends T>(
+  predicate: (value: T, prop: string, obj: Record<string, T>) => value is S,
+): (obj: Record<string, T>) => readonly [Record<string, S>, Record<string, Exclude<T, S>>];
+export function partitionObject<T extends unknown>(
+  predicate: (value: T, prop: string, obj: Record<string, T>) => boolean,
+): (obj: Record<string, T>) => readonly [Record<string, T>, Record<string, T>];
+
 /**
  * If `pathToSearch` is `'a.b'` then it will return `1` if `obj` is `{a:{b:1}}`.
  * 
  * It will return `undefined`, if such path is not found.
  */
+export function path<S, K0 extends string & keyof S>(path: `${K0}`): (obj: S) => S[K0];
+export function path<S, K0 extends string & keyof S, K1 extends string & keyof S[K0]>(path: `${K0}.${K1}`): (obj: S) => S[K0][K1];
+export function path<
+  S,
+  K0 extends keyof S,
+  K1 extends keyof S[K0],
+  K2 extends keyof S[K0][K1]
+>(path: readonly [K0, K1, K2]): (obj: S) => S[K0][K1][K2];
+export function path<
+  S,
+  K0 extends string & keyof S,
+  K1 extends string & keyof S[K0],
+  K2 extends string & keyof S[K0][K1]
+>(path: `${K0}.${K1}.${K2}`): (obj: S) => S[K0][K1][K2];
+export function path<
+  S,
+  K0 extends keyof S,
+  K1 extends keyof S[K0],
+  K2 extends keyof S[K0][K1],
+  K3 extends keyof S[K0][K1][K2]
+>(path: readonly [K0, K1, K2, K3]): (obj: S) => S[K0][K1][K2][K3];
+export function path<
+  S,
+  K0 extends string & keyof S,
+  K1 extends string & keyof S[K0],
+  K2 extends string & keyof S[K0][K1],
+  K3 extends string & keyof S[K0][K1][K2]
+>(path: `${K0}.${K1}.${K2}.${K3}`): (obj: S) => S[K0][K1][K2][K3];
+export function path<
+  S,
+  K0 extends keyof S,
+  K1 extends keyof S[K0],
+  K2 extends keyof S[K0][K1],
+  K3 extends keyof S[K0][K1][K2],
+  K4 extends keyof S[K0][K1][K2][K3]
+>(path: readonly [K0, K1, K2, K3, K4]): (obj: S) => S[K0][K1][K2][K3][K4];
+export function path<
+  S,
+  K0 extends string & keyof S,
+  K1 extends string & keyof S[K0],
+  K2 extends string & keyof S[K0][K1],
+  K3 extends string & keyof S[K0][K1][K2],
+  K4 extends string & keyof S[K0][K1][K2][K3]
+>(path: `${K0}.${K1}.${K2}.${K3}.${K4}`): (obj: S) => S[K0][K1][K2][K3][K4];
+export function path<
+  S,
+  K0 extends keyof S,
+  K1 extends keyof S[K0],
+  K2 extends keyof S[K0][K1],
+  K3 extends keyof S[K0][K1][K2],
+  K4 extends keyof S[K0][K1][K2][K3]
+>(path: readonly [K0, K1, K2, K3, K4], obj: S): S[K0][K1][K2][K3][K4];
+export function path<
+  S,
+  K0 extends keyof S,
+  K1 extends keyof S[K0],
+  K2 extends keyof S[K0][K1],
+  K3 extends keyof S[K0][K1][K2],
+  K4 extends keyof S[K0][K1][K2][K3],
+  K5 extends keyof S[K0][K1][K2][K3][K4]
+>(path: readonly [K0, K1, K2, K3, K4, K5]): (obj: S) => S[K0][K1][K2][K3][K4][K5];
+export function path<
+  S,
+  K0 extends string & keyof S,
+  K1 extends string & keyof S[K0],
+  K2 extends string & keyof S[K0][K1],
+  K3 extends string & keyof S[K0][K1][K2],
+  K4 extends string & keyof S[K0][K1][K2][K3],
+  K5 extends string & keyof S[K0][K1][K2][K3][K4]
+>(path: `${K0}.${K1}.${K2}.${K3}.${K4}.${K5}`): (obj: S) => S[K0][K1][K2][K3][K4][K5];
+export function path<
+  S,
+  K0 extends keyof S,
+  K1 extends keyof S[K0],
+  K2 extends keyof S[K0][K1],
+  K3 extends keyof S[K0][K1][K2],
+  K4 extends keyof S[K0][K1][K2][K3],
+  K5 extends keyof S[K0][K1][K2][K3][K4]
+>(path: readonly [K0, K1, K2, K3, K4, K5], obj: S): S[K0][K1][K2][K3][K4][K5];
+export function path<
+  S,
+  K0 extends keyof S,
+  K1 extends keyof S[K0],
+  K2 extends keyof S[K0][K1],
+  K3 extends keyof S[K0][K1][K2],
+  K4 extends keyof S[K0][K1][K2][K3],
+  K5 extends keyof S[K0][K1][K2][K3][K4],
+  K6 extends keyof S[K0][K1][K2][K3][K4][K5]
+>(path: readonly [K0, K1, K2, K3, K4, K5, K6]): (obj: S) => S[K0][K1][K2][K3][K4][K5][K6];
+export function path<
+  S,
+  K0 extends string & keyof S,
+  K1 extends string & keyof S[K0],
+  K2 extends string & keyof S[K0][K1],
+  K3 extends string & keyof S[K0][K1][K2],
+  K4 extends string & keyof S[K0][K1][K2][K3],
+  K5 extends string & keyof S[K0][K1][K2][K3][K4],
+  K6 extends string & keyof S[K0][K1][K2][K3][K4][K5]
+>(path: `${K0}.${K1}.${K2}.${K3}.${K4}.${K5}.${K6}`): (obj: S) => S[K0][K1][K2][K3][K4][K5][K6];
+export function path<
+  S,
+  K0 extends keyof S,
+  K1 extends keyof S[K0],
+  K2 extends keyof S[K0][K1],
+  K3 extends keyof S[K0][K1][K2],
+  K4 extends keyof S[K0][K1][K2][K3],
+  K5 extends keyof S[K0][K1][K2][K3][K4],
+  K6 extends keyof S[K0][K1][K2][K3][K4][K5]
+>(path: readonly [K0, K1, K2, K3, K4, K5, K6], obj: S): S[K0][K1][K2][K3][K4][K5][K6];
+export function path<
+  S,
+  K0 extends keyof S,
+  K1 extends keyof S[K0],
+  K2 extends keyof S[K0][K1],
+  K3 extends keyof S[K0][K1][K2],
+  K4 extends keyof S[K0][K1][K2][K3],
+  K5 extends keyof S[K0][K1][K2][K3][K4],
+  K6 extends keyof S[K0][K1][K2][K3][K4][K5],
+  K7 extends keyof S[K0][K1][K2][K3][K4][K5][K6]
+>(path: readonly [K0, K1, K2, K3, K4, K5, K6, K7]): (obj: S) => S[K0][K1][K2][K3][K4][K5][K6][K7];
+export function path<
+  S,
+  K0 extends string & keyof S,
+  K1 extends string & keyof S[K0],
+  K2 extends string & keyof S[K0][K1],
+  K3 extends string & keyof S[K0][K1][K2],
+  K4 extends string & keyof S[K0][K1][K2][K3],
+  K5 extends string & keyof S[K0][K1][K2][K3][K4],
+  K6 extends string & keyof S[K0][K1][K2][K3][K4][K5],
+  K7 extends string & keyof S[K0][K1][K2][K3][K4][K5][K6]
+>(path: `${K0}.${K1}.${K2}.${K3}.${K4}.${K5}.${K6}.${K7}`): (obj: S) => S[K0][K1][K2][K3][K4][K5][K6][K7];
+export function path<
+  S,
+  K0 extends keyof S,
+  K1 extends keyof S[K0],
+  K2 extends keyof S[K0][K1],
+  K3 extends keyof S[K0][K1][K2],
+  K4 extends keyof S[K0][K1][K2][K3],
+  K5 extends keyof S[K0][K1][K2][K3][K4],
+  K6 extends keyof S[K0][K1][K2][K3][K4][K5],
+  K7 extends keyof S[K0][K1][K2][K3][K4][K5][K6],
+  K8 extends keyof S[K0][K1][K2][K3][K4][K5][K6][K7]
+>(path: readonly [K0, K1, K2, K3, K4, K5, K6, K7, K8]): (obj: S) => S[K0][K1][K2][K3][K4][K5][K6][K7][K8];
+export function path<
+  S,
+  K0 extends string & keyof S,
+  K1 extends string & keyof S[K0],
+  K2 extends string & keyof S[K0][K1],
+  K3 extends string & keyof S[K0][K1][K2],
+  K4 extends string & keyof S[K0][K1][K2][K3],
+  K5 extends string & keyof S[K0][K1][K2][K3][K4],
+  K6 extends string & keyof S[K0][K1][K2][K3][K4][K5],
+  K7 extends string & keyof S[K0][K1][K2][K3][K4][K5][K6],
+  K8 extends string & keyof S[K0][K1][K2][K3][K4][K5][K6][K7]
+>(path: `${K0}.${K1}.${K2}.${K3}.${K4}.${K5}.${K6}.${K7}.${K8}`): (obj: S) => S[K0][K1][K2][K3][K4][K5][K6][K7][K8];
 export function path<S, K0 extends keyof S>(path: readonly [K0]): (obj: S) => S[K0];
-export function path<S, K0 extends keyof S>(path: `${K0}`): (obj: S) => S[K0];
 export function path<S, K0 extends keyof S, K1 extends keyof S[K0]>(path: readonly [K0, K1]): (obj: S) => S[K0][K1];
-export function path<S, K0 extends keyof S, K1 extends keyof S[K0]>(path: `${K0}.${K1}`): (obj: S) => S[K0][K1];
 export function path<
     S,
     K0 extends keyof S,
     K1 extends keyof S[K0],
     K2 extends keyof S[K0][K1]
 >(path: readonly [K0, K1, K2]): (obj: S) => S[K0][K1][K2];
-export function path<
-    S,
-    K0 extends keyof S,
-    K1 extends keyof S[K0],
-    K2 extends keyof S[K0][K1]
->(path: `${K0}.${K1}.${K2}`): (obj: S) => S[K0][K1][K2];
 export function path<
     S,
     K0 extends keyof S,
@@ -732,13 +766,6 @@ export function path<
     K2 extends keyof S[K0][K1],
     K3 extends keyof S[K0][K1][K2]
 >(path: readonly [K0, K1, K2, K3]): (obj: S) => S[K0][K1][K2][K3];
-export function path<
-    S,
-    K0 extends keyof S,
-    K1 extends keyof S[K0],
-    K2 extends keyof S[K0][K1],
-    K3 extends keyof S[K0][K1][K2]
->(path: `${K0}.${K1}.${K2}.${K3}`): (obj: S) => S[K0][K1][K2][K3];
 export function path<
     S,
     K0 extends keyof S,
@@ -747,14 +774,6 @@ export function path<
     K3 extends keyof S[K0][K1][K2],
     K4 extends keyof S[K0][K1][K2][K3]
 >(path: readonly [K0, K1, K2, K3, K4]): (obj: S) => S[K0][K1][K2][K3][K4];
-export function path<
-    S,
-    K0 extends keyof S,
-    K1 extends keyof S[K0],
-    K2 extends keyof S[K0][K1],
-    K3 extends keyof S[K0][K1][K2],
-    K4 extends keyof S[K0][K1][K2][K3]
->(path: `${K0}.${K1}.${K2}.${K3}.${K4}`): (obj: S) => S[K0][K1][K2][K3][K4];
 export function path<
     S,
     K0 extends keyof S,
@@ -772,15 +791,6 @@ export function path<
     K4 extends keyof S[K0][K1][K2][K3],
     K5 extends keyof S[K0][K1][K2][K3][K4]
 >(path: readonly [K0, K1, K2, K3, K4, K5]): (obj: S) => S[K0][K1][K2][K3][K4][K5];
-export function path<
-    S,
-    K0 extends keyof S,
-    K1 extends keyof S[K0],
-    K2 extends keyof S[K0][K1],
-    K3 extends keyof S[K0][K1][K2],
-    K4 extends keyof S[K0][K1][K2][K3],
-    K5 extends keyof S[K0][K1][K2][K3][K4]
->(path: `${K0}.${K1}.${K2}.${K3}.${K4}.${K5}`): (obj: S) => S[K0][K1][K2][K3][K4][K5];
 export function path<
     S,
     K0 extends keyof S,
@@ -800,16 +810,6 @@ export function path<
     K5 extends keyof S[K0][K1][K2][K3][K4],
     K6 extends keyof S[K0][K1][K2][K3][K4][K5]
 >(path: readonly [K0, K1, K2, K3, K4, K5, K6]): (obj: S) => S[K0][K1][K2][K3][K4][K5][K6];
-export function path<
-    S,
-    K0 extends keyof S,
-    K1 extends keyof S[K0],
-    K2 extends keyof S[K0][K1],
-    K3 extends keyof S[K0][K1][K2],
-    K4 extends keyof S[K0][K1][K2][K3],
-    K5 extends keyof S[K0][K1][K2][K3][K4],
-    K6 extends keyof S[K0][K1][K2][K3][K4][K5]
->(path: `${K0}.${K1}.${K2}.${K3}.${K4}.${K5}.${K6}`): (obj: S) => S[K0][K1][K2][K3][K4][K5][K6];
 export function path<
     S,
     K0 extends keyof S,
@@ -831,17 +831,6 @@ export function path<
     K6 extends keyof S[K0][K1][K2][K3][K4][K5],
     K7 extends keyof S[K0][K1][K2][K3][K4][K5][K6]
 >(path: readonly [K0, K1, K2, K3, K4, K5, K6, K7]): (obj: S) => S[K0][K1][K2][K3][K4][K5][K6][K7];
-export function path<
-    S,
-    K0 extends keyof S,
-    K1 extends keyof S[K0],
-    K2 extends keyof S[K0][K1],
-    K3 extends keyof S[K0][K1][K2],
-    K4 extends keyof S[K0][K1][K2][K3],
-    K5 extends keyof S[K0][K1][K2][K3][K4],
-    K6 extends keyof S[K0][K1][K2][K3][K4][K5],
-    K7 extends keyof S[K0][K1][K2][K3][K4][K5][K6]
->(path: `${K0}.${K1}.${K2}.${K3}.${K4}.${K5}.${K6}.${K7}`): (obj: S) => S[K0][K1][K2][K3][K4][K5][K6][K7];
 export function path<
     S,
     K0 extends keyof S,
@@ -854,18 +843,8 @@ export function path<
     K7 extends keyof S[K0][K1][K2][K3][K4][K5][K6],
     K8 extends keyof S[K0][K1][K2][K3][K4][K5][K6][K7]
 >(path: readonly [K0, K1, K2, K3, K4, K5, K6, K7, K8]): (obj: S) => S[K0][K1][K2][K3][K4][K5][K6][K7][K8];
-export function path<
-    S,
-    K0 extends keyof S,
-    K1 extends keyof S[K0],
-    K2 extends keyof S[K0][K1],
-    K3 extends keyof S[K0][K1][K2],
-    K4 extends keyof S[K0][K1][K2][K3],
-    K5 extends keyof S[K0][K1][K2][K3][K4],
-    K6 extends keyof S[K0][K1][K2][K3][K4][K5],
-    K7 extends keyof S[K0][K1][K2][K3][K4][K5][K6],
-    K8 extends keyof S[K0][K1][K2][K3][K4][K5][K6][K7]
->(path: `${K0}.${K1}.${K2}.${K3}.${K4}.${K5}.${K6}.${K7}.${K8}`): (obj: S) => S[K0][K1][K2][K3][K4][K5][K6][K7][K8];
+
+export function permutations<T>(list: readonly T[]): readonly T[][];
 
 /**
  * It returns a partial copy of an `input` containing only `propsToPick` properties.
@@ -1418,6 +1397,9 @@ export function propEq<T>(val: T): {
 export function propEq<T, K extends PropertyKey>(val: T, name: K): (obj: Record<K, T>) => boolean;
 export function propEq<K extends keyof U, U>(val: U[K], name: K, obj: U): boolean;
 
+/**
+ * It returns either `defaultValue` or the value of `property` in `obj`.
+ */
 export function propOr<T, P extends string>(defaultValue: T, property: P): (obj: Partial<Record<P, T>>) => T;
 
 /**
@@ -1426,10 +1408,15 @@ export function propOr<T, P extends string>(defaultValue: T, property: P): (obj:
 export function propSatisfies<T>(predicate: (x: T) => boolean, property: string): (obj: Record<PropertyKey, T>) => boolean;
 
 /**
- * It returns list of numbers between `startInclusive` to `endExclusive` markers.
+ * It returns list of numbers between `startInclusive` to `endInclusive` markers.
  */
 export function range(startInclusive: number): (endExclusive: number) => readonly number[];
 
+/**
+ * Same as `R.range` but in descending order.
+ */
+export function rangeDescending(startInclusive: number): (endExclusive: number) => readonly number[];
+
 export function reduce<T, TResult>(reducer: (prev: TResult, current: T, i: number) => TResult, initialValue: TResult): (list: readonly T[]) => TResult;
 
 /**
@@ -1470,17 +1457,26 @@ export function replace(strOrRegex: RegExp | string, replacer: RegExp | string):
  */
 export function replaceItemAtIndex<T>(index: number, replaceFn: (x: T) => T): (list: readonly T[]) => readonly T[];
 
+/**
+ * It returns a randomized copy of array.
+ */
+export function shuffle<T>(list: readonly T[]): readonly T[];
+
 /**
  * It returns copy of `list` sorted by `sortFn` function, where `sortFn` needs to return only `-1`, `0` or `1`.
  */
-export function sort<T>(sortFn: (a: T, b: T) => number, list: readonly T[]): readonly T[];
 export function sort<T>(sortFn: (a: T, b: T) => number): (list: readonly T[]) => readonly T[];
 
 /**
  * It returns copy of `list` sorted by `sortFn` function, where `sortFn` function returns a value to compare, i.e. it doesn't need to return only `-1`, `0` or `1`.
  */
-export function sortBy<T>(sortFn: (a: T) => Ord): (list: readonly T[]) => readonly T[];
-export function sortBy(sortFn: (a: any) => Ord): <T>(list: readonly T[]) => readonly T[];
+export function sortBy<T>(sortFn: (x: T) => Ord): (list: readonly T[]) => readonly T[];
+
+/**
+ * It returns a sorted version of `input` object.
+ */
+export function sortObject<T, K extends string & keyof T>(predicate: (aProp: string, bProp: string, aValue: T[K], bValue: T[K]) => number): (obj: T) => T;
+export function sortObject<T>(predicate: (aProp: string, bProp: string) => number): (obj: T) => T;
 
 export function sortWith<T>(fns: ReadonlyArray<(a: T, b: T) => number>): (list: readonly T[]) => readonly T[];
 
@@ -1491,14 +1487,6 @@ export function split(separator: string | RegExp): (str: string) => readonly str
  */
 export function splitEvery<T>(sliceLength: number): (input: readonly T[]) => readonly ((readonly T[]))[];
 
-/**
- * Curried version of `x - y`
- */
-export function subtract(x: number, y: number): number;
-export function subtract(x: number): (y: number) => number;
-
-export function sum(list: readonly number[]): number;
-
 /**
  * It returns a merged list of `x` and `y` with all equal elements removed.
  * 
@@ -1541,25 +1529,15 @@ export function takeWhile<T>(predicate: (x: T) => boolean): (input: readonly T[]
  * 
  * One use case is debugging in the middle of `R.pipe` chain.
  */
-export function tap<T>(fn: (x: T) => void, input: T): T;
 export function tap<T>(fn: (x: T) => void): (input: T) => T;
 
 /**
  * It determines whether `str` matches `regExpression`.
  */
 export function test(regExpression: RegExp): (str: string) => boolean;
-export function test(regExpression: RegExp, str: string): boolean;
-
-/**
- * It returns the result of applying function `fn` over members of range array.
- * 
- * The range array includes numbers between `0` and `howMany`(exclusive).
- */
-export function times<T>(fn: (i: number) => T, howMany: number): readonly T[];
-export function times<T>(fn: (i: number) => T): (howMany: number) => readonly T[];
 
 /**
- * It returns function that runs `fn` in `try/catch` block. If there was an error, then `fallback` is used to return the result. Note that `fn` can be value or asynchronous/synchronous function(unlike `Ramda` where fallback can only be a synchronous function).
+ * It returns function that runs `fn` in `try/catch` block. If there was an error, then `fallback` is used to return the result.
  */
 export function tryCatch<T, U>(
   fn: (input: T) => U,
@@ -1590,14 +1568,14 @@ export function uniq<T>(list: readonly T[]): readonly T[];
  * 
  * `R.equals` is used to determine equality.
  */
-export function uniqBy<T, U>(fn: (a: T) => U): (list: readonly T[]) => readonly T[];
+export function uniqBy<T, U>(fn: (x: T) => U): (list: readonly T[]) => readonly T[];
 
 /**
  * It returns a new array containing only one copy of each element in `list` according to `predicate` function.
  * 
  * This predicate should return true, if two elements are equal.
  */
-export function uniqWith<T, U>(predicate: (x: T, y: T) => boolean): (list: readonly T[]) => readonly T[];
+export function uniqWith<T>(predicate: (x: T, y: T) => boolean): (list: readonly T[]) => readonly T[];
 
 /**
  * The method returns function that will be called with argument `input`.
@@ -1623,8 +1601,8 @@ export function update<T>(index: number, newValue: T): (list: readonly T[]) => r
  * 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`.
  */
-export function when<T>(predicate: (x: T) => boolean, whenTrueFn: (a: T) => T): (input: T) => T;
-export function when<T, U>(predicate: (x: T) => boolean, whenTrueFn: (a: T) => U): (input: T) => T | U;
+export function when<T>(predicate: (x: T) => boolean, whenTrueFn: (x: T) => T): (input: T) => T;
+export function when<T, U>(predicate: (x: T) => boolean, whenTrueFn: (x: T) => U): (input: T) => T | U;
 
 /**
  * It will return a new array containing tuples of equally positions items from both `x` and `y` lists.