rambda 8.2.0 → 8.4.0

package/index.d.ts

@@ -1,6 +1,5 @@
 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"
 
-
 type LastArrayElement<ValueType extends readonly unknown[]> =
 	ValueType extends readonly [infer ElementType]
 		? ElementType
@@ -95,6 +94,9 @@ interface AssocPartialOne<K extends keyof any> {
   <T>(val: T): <U>(obj: U) => Record<K, T> & U;
   <T, U>(val: T, obj: U): Record<K, T> & U;
 }
+type AtLeastOneFunctionsFlowFromRightToLeft<TArgs extends any[], TResult> =
+    | [(...args: any) => TResult, ...Array<(args: any) => any>, (...args: TArgs) => any]
+    | [(...args: TArgs) => TResult];
 
 type AnyFunction = (...args: any[]) => unknown;
 type AnyConstructor = new (...args: any[]) => unknown;
@@ -112,6 +114,9 @@ type RegExpReplacerFn =
   | ((m: string, p1: string, p2: string, p3: string, p4: string, p5: string, p6: string, p7: string, p8: string, p9: string, offset: number, s: string, groups?: Record<string, string>) => string)
 type RegExpReplacer = string | RegExpReplacerFn
 
+/** `TSuper`, when `TSuper` is a supertype of `T`; otherwise `never`. */
+type IsFirstSubtypeOfSecond<First, Second> = (First extends Second ? Second : never);
+
 // RAMBDAX INTERFACES
 // ============================================
 type Func<T> = (input: any) => T;
@@ -226,6 +231,7 @@ export function any<T>(predicate: (x: T) => boolean): (list: T[]) => boolean;
 /**
  * It accepts list of `predicates` and returns a function. This function with its `input` will return `true`, if any of `predicates` returns `true` for this `input`.
  */
+export function anyPass<T, U extends T[]>(predicates: { [K in keyof U]: (x: T) => x is U[K]; }): (input: T) => input is U[number];
 export function anyPass<T>(predicates: ((x: T) => boolean)[]): (input: T) => boolean;
 export function anyPass<T>(predicates: ((...inputs: T[]) => boolean)[]): (...inputs: T[]) => boolean;
 
@@ -237,10 +243,12 @@ export function aperture<N extends number, T>(n: N, list: T[]): Array<Tuple<T, N
 export function aperture<N extends number>(n: N): <T>(list: T[]) => Array<Tuple<T, N>> | [];
 
 /**
- * It adds element `x` at the end of `list`.
+ * It adds element `x` at the end of `iterable`.
  */
-export function append<T>(x: T, list: T[]): T[];
-export function append<T>(x: T): <T>(list: T[]) => T[];
+export function append<T>(xToAppend: T, iterable: T[]): T[];
+export function append<T, U>(xToAppend: T, iterable: IsFirstSubtypeOfSecond<T, U>[]) : U[];
+export function append<T>(xToAppend: T): <U>(iterable: IsFirstSubtypeOfSecond<T, U>[]) => U[];
+export function append<T>(xToAppend: T): (iterable: T[]) => T[];
 
 /**
  * It applies function `fn` to the list of arguments.
@@ -277,6 +285,8 @@ export function assocPath<Output>(path: Path, newValue: any, obj: object): Outpu
 export function assocPath<Output>(path: Path, newValue: any): (obj: object) => Output;
 export function assocPath<Output>(path: Path): (newValue: any) => (obj: object) => Output;
 
+export function binary<T extends (...arg: any[]) => any>(fn: T): (...args: any[]) => ReturnType<T>;
+
 /**
  * Creates a function that is bound to a context.
  */
@@ -293,6 +303,8 @@ export function both<T>(pred1: Predicate<T>, pred2: Predicate<T>): Predicate<T>;
 export function both<T>(pred1: Predicate<T>): (pred2: Predicate<T>) => Predicate<T>;
 export function both(pred1: Pred): (pred2: Pred) => Pred;
 
+export function call<T extends (...args: any[]) => any>(fn: T, ...args: Parameters<T>): ReturnType<T>;
+
 /**
  * The method is also known as `flatMap`.
  */
@@ -315,6 +327,11 @@ export function clamp(min: number, max: number): (input: number) => number;
 export function clone<T>(input: T): T;
 export function clone<T>(input: T[]): T[];
 
+export function collectBy<T, K extends PropertyKey>(keyFn: (value: T) => K, list: T[]): T[][];
+export function collectBy<T, K extends PropertyKey>(keyFn: (value: T) => K): (list: T[]) => T[][];
+
+export function comparator<T>(pred: (a: T, b: T) => boolean): (x: T, y: T) => Ordering;
+
 /**
  * It returns `inverted` version of `origin` function that accept `input` as argument.
  * 
@@ -390,6 +407,16 @@ export function compose<TArgs extends any[], R1>(
   f1: (...args: TArgs) => R1
 ): (...args: TArgs) => R1;
 
+export function composeWith<TArgs extends any[], TResult>(
+  transformer: (fn: (...args: any[]) => any, intermediatResult: any) => any,
+  fns: AtLeastOneFunctionsFlowFromRightToLeft<TArgs, TResult>,
+): (...args: TArgs) => TResult;
+export function composeWith(
+  transformer: (fn: (...args: any[]) => any, intermediatResult: any) => any,
+): <TArgs extends any[], TResult>(
+  fns: AtLeastOneFunctionsFlowFromRightToLeft<TArgs, TResult>,
+) => (...args: TArgs) => TResult;
+
 /**
  * It returns a new string or array, which is the result of merging `x` and `y`.
  */
@@ -479,6 +506,8 @@ export function differenceWith<T1, T2>(
 export function dissoc<T extends object, K extends keyof T>(prop: K, obj: T): Omit<T, K>;
 export function dissoc<K extends string | number>(prop: K): <T extends object>(obj: T) => Omit<T, K>;
 
+export function dissocPath<T>(x: T): T;
+
 export function divide(x: number, y: number): number;
 export function divide(x: number): (y: number) => number;
 
@@ -659,8 +688,10 @@ export function hasPath<T>(
 /**
  * It returns the first element of list or string `input`.
  */
-export function head(input: string): string;
-export function head(emptyList: []): undefined;
+export function head(str: string): string;
+export function head(str: ''): undefined;
+export function head<T>(list: never[]): undefined;
+export function head<T extends unknown[]>(array: T): FirstArrayElement<T>
 export function head<T extends readonly unknown[]>(array: T): FirstArrayElement<T>
 
 /**
@@ -780,14 +811,16 @@ export function juxt<A extends any[], U>(fns: Array<(...args: A) => U>): (...arg
 /**
  * It applies `Object.keys` over `x` and returns its keys.
  */
-export function keys<T extends object>(x: T): (keyof T)[];
+export function keys<T extends object>(x: T): (keyof T & string)[];
 export function keys<T>(x: T): string[];
 
 /**
  * It returns the last element of `input`, as the `input` can be either a string or an array.
  */
-export function last(input: string): string;
-export function last(emptyList: []): undefined;
+export function last(str: ''): undefined;
+export function last(str: string): string;
+export function last(list: never[]): undefined;
+export function last<T extends unknown[]>(array: T): LastArrayElement<T>
 export function last<T extends readonly unknown[]>(array: T): LastArrayElement<T>
 
 /**
@@ -1063,13 +1096,31 @@ export function over(lens: Lens): <T>(fn: Arity1Fn, value: T[]) => T[];
  * `R.partial` will keep returning a function until all the arguments that the function `fn` expects are passed.
  * The name comes from the fact that you partially inject the inputs.
  */
-export function partial<V0, V1, T>(fn: (x0: V0, x1: V1) => T, args: [V0]): (x1: V1) => T;
-export function partial<V0, V1, V2, T>(fn: (x0: V0, x1: V1, x2: V2) => T, args: [V0, V1]): (x2: V2) => T;
-export function partial<V0, V1, V2, T>(fn: (x0: V0, x1: V1, x2: V2) => T, args: [V0]): (x1: V1, x2: V2) => T;
-export function partial<V0, V1, V2, V3, T>(fn: (x0: V0, x1: V1, x2: V2, x3: V3) => T, args: [V0, V1, V2]): (x2: V3) => T;
-export function partial<V0, V1, V2, V3, T>(fn: (x0: V0, x1: V1, x2: V2, x3: V3) => T, args: [V0, V1]): (x2: V2, x3: V3) => T;
-export function partial<V0, V1, V2, V3, T>(fn: (x0: V0, x1: V1, x2: V2, x3: V3) => T, args: [V0]): (x1: V1, x2: V2, x3: V3) => T;
-export function partial<T>(fn: (...a: any[]) => T, args: any[]): (...x: any[]) => T;
+export function partial<
+  Args extends unknown[],
+  ArgsGiven extends [...Partial<Args>],
+  R
+>(
+  fn: (...args: Args) => R,
+  ...args: ArgsGiven
+): Args extends [...{[K in keyof ArgsGiven]: Args[K]}, ...infer ArgsRemaining]
+  ? ArgsRemaining extends []
+    ? R
+    : (...args: ArgsRemaining) => R
+  : never;
+
+export function partial<
+  Args extends readonly unknown[],
+  ArgsGiven extends [...Partial<Args>],
+  R
+>(
+  fn: (...args: Args) => R,
+  args: ArgsGiven
+): Args extends [...{[K in keyof ArgsGiven]: Args[K]}, ...infer ArgsRemaining]
+  ? ArgsRemaining extends []
+    ? R
+    : (...args: ArgsRemaining) => R
+  : never;
 
 /**
  * `R.partialObject` is a curry helper designed specifically for functions accepting object as a single argument.
@@ -1260,8 +1311,10 @@ export function pluck(property: number): <T>(list: { [k: number]: T }[]) => T[];
 /**
  * It adds element `x` at the beginning of `list`.
  */
-export function prepend<T>(x: T, input: T[]): T[];
-export function prepend<T>(x: T): (input: T[]) => T[];
+export function prepend<T>(xToPrepend: T, iterable: T[]): T[];
+export function prepend<T, U>(xToPrepend: T, iterable: IsFirstSubtypeOfSecond<T, U>[]) : U[];
+export function prepend<T>(xToPrepend: T): <U>(iterable: IsFirstSubtypeOfSecond<T, U>[]) => U[];
+export function prepend<T>(xToPrepend: T): (iterable: T[]) => T[];
 
 export function product(list: number[]): number;
 
@@ -1270,17 +1323,10 @@ export function product(list: number[]): number;
  * 
  * If there is no such property, it returns `undefined`.
  */
-export function prop<P extends keyof never, T>(propToFind: P, value: T): Prop<T, P>;
-export function prop<P extends keyof never>(propToFind: P): {
-    <T>(value: Record<P, T>): T;
-    <T>(value: T): Prop<T, P>;
-};
-export function prop<P extends keyof T, T>(propToFind: P): {
-    (value: T): Prop<T, P>;
-};
-export function prop<P extends keyof never, T>(propToFind: P): {
-    (value: Record<P, T>): T;
-};
+export function prop<_, P extends keyof never, T>(p: P, value: T): Prop<T, P>;
+export function prop<V>(p: keyof never, value: unknown): V;
+export function prop<_, P extends keyof never>(p: P): <T>(value: T) => Prop<T, P>;
+export function prop<V>(p: keyof never): (value: unknown) => V;
 
 /**
  * It returns true if `obj` has property `propToFind` and its value is equal to `valueToMatch`.
@@ -1335,8 +1381,8 @@ export function range(startInclusive: number): (endExclusive: number) => number[
 
 export function reduce<T, TResult>(reducer: (prev: TResult, current: T, i: number) => TResult, initialValue: TResult, list: T[]): TResult;
 export function reduce<T, TResult>(reducer: (prev: TResult, current: T) => TResult, initialValue: TResult, list: T[]): TResult;
-export function reduce<T, TResult>(reducer: (prev: TResult, current: T, i?: number) => TResult): (initialValue: TResult, list: T[]) => TResult;
-export function reduce<T, TResult>(reducer: (prev: TResult, current: T, i?: number) => TResult, initialValue: TResult): (list: T[]) => TResult;
+export function reduce<T, TResult>(reducer: (prev: TResult, current: T, i: number) => TResult): (initialValue: TResult, list: T[]) => TResult;
+export function reduce<T, TResult>(reducer: (prev: TResult, current: T, i: number) => TResult, initialValue: TResult): (list: T[]) => TResult;
 
 /**
  * It has the opposite effect of `R.filter`.
@@ -1346,6 +1392,12 @@ export function reject<T>(predicate: Predicate<T>): (list: T[]) => T[];
 export function reject<T>(predicate: Predicate<T>, obj: Dictionary<T>): Dictionary<T>;
 export function reject<T, U>(predicate: Predicate<T>): (obj: Dictionary<T>) => Dictionary<T>;
 
+/**
+ * It returns a copy of `list` input with removed `index`.
+ */
+export function removeIndex<T>(index: number, list: T[]): T[];
+export function removeIndex(index: number): <T>(list: T[]) => T[];
+
 export function repeat<T>(x: T): (timesToRepeat: number) => T[];
 export function repeat<T>(x: T, timesToRepeat: number): T[];
 

package/package.json

@@ -1,107 +1,108 @@
 {
-	"name": "rambda",
-	"version": "8.2.0",
-	"scripts": {
-		"benchmark": "cd ../rambda-scripts && RAMBDA_RUN_ALL=ON RAMBDA_RUN_INDEXES=ON yarn benchmark",
-		"benchmark:all": "yarn build:step && cd ../rambda-scripts && yarn benchmark:all",
-		"benchmark:check": "yarn build:step && METHOD=compose yarn benchmark:check:apply",
-		"benchmark:check:apply": "cd ../rambda-scripts && yarn check-benchmark",
-		"build": "yarn build:main && yarn build:web",
-		"build:main": "cross-env NODE_ENV=build rollup -c files/rollup.config.mjs",
-		"build:step": "yarn populatereadme && yarn build:main",
-		"build:web": "cross-env NODE_ENV=build rollup -c files/rollup.web.config.mjs",
-		"d": "yarn out && yarn lint && run d",
-		"docs": "npx docsify-cli init ./docs && yarn fix-docsify",
-		"fix-docsify": "cd ../rambda-scripts && yarn fix-docsify:rambda",
-		"git:add": "git add -A",
-		"github": "cd ../rambda-scripts && yarn github",
-		"immutable": "cd ../rambda-scripts && yarn immutable:rambda",
-		"immutable:x": "cd ../rambda-scripts && yarn immutable:rambdax",
-		"lint": "yarn git:add && yarn lint:staged && yarn git:add",
-		"lint:all": "cd ../rambda-scripts && yarn lint",
-		"lint:staged": "cd ../rambda-scripts && yarn lint:staged",
-		"new": "cd ../rambda-scripts && yarn new",
-		"out": "yarn populatedocs && yarn populatereadme && yarn immutable && yarn build",
-		"populatedocs": "cd ../rambda-scripts && yarn populate:docs",
-		"populatedocs:x": "cd ../rambda-scripts && yarn populate:docs:rambdax",
-		"populatereadme": "cd ../rambda-scripts && yarn populate:readme",
-		"populatereadme:x": "cd ../rambda-scripts && yarn populate:readme:rambdax",
-		"publish:experimental": "node files/publish",
-		"run:ramda:test": "cd ../rambda-scripts && yarn run:ramda:test",
-		"test": "jest -o -u --watch",
-		"test:all": "jest source/*.spec.js -u --bail=false",
-		"test:ci": "jest source/*.spec.js --coverage --no-cache -w 1",
-		"test:typings": "dtslint --localTs ./node_modules/typescript/lib --expectOnly ./source",
-		"usedby": "cd ../rambda-scripts && yarn usedby",
-		"x": "yarn populatedocs:x && yarn populatereadme:x && yarn immutable:x"
-	},
-	"dependencies": {},
-	"devDependencies": {
-		"@babel/core": "7.21.8",
-		"@babel/plugin-proposal-object-rest-spread": "7.20.7",
-		"@babel/preset-env": "7.21.5",
-		"@rollup/plugin-babel": "6.0.3",
-		"@rollup/plugin-commonjs": "25.0.0",
-		"@rollup/plugin-node-resolve": "15.0.2",
-		"@rollup/plugin-replace": "5.0.2",
-		"@types/jest": "29.5.1",
-		"combinate": "1.1.11",
-		"cross-env": "7.0.3",
-		"dtslint": "4.2.1",
-		"helpers-fn": "1.8.1",
-		"is-ci": "3.0.1",
-		"jest": "29.5.0",
-		"jest-extended": "3.2.4",
-		"lodash": "4.17.21",
-		"rambdax": "9.1.1",
-		"ramda": "0.29.0",
-		"rollup": "3.22.0",
-		"rollup-plugin-cleanup": "3.2.1",
-		"rollup-plugin-sourcemaps": "0.6.3",
-		"rollup-plugin-uglify": "6.0.4",
-		"types-ramda": "0.29.2",
-		"typescript": "5.0.4"
-	},
-	"jest": {
-		"testEnvironment": "node",
-		"testRegex": ".*\\.(spec|test)\\.js$",
-		"setupFilesAfterEnv": [
-			"./files/testSetup.js"
-		],
-		"collectCoverageFrom": [
-			"source/*.js",
-			"!_internals",
-			"!benchmarks"
-		]
-	},
-	"repository": {
-		"type": "git",
-		"url": "git+https://github.com/selfrefactor/rambda.git"
-	},
-	"license": "MIT",
-	"author": "self_refactor",
-	"description": "Lightweight and faster alternative to Ramda with included TS definitions",
-	"keywords": [
-		"ramda",
-		"fp",
-		"functional",
-		"utility",
-		"lodash"
-	],
-	"homepage": "https://github.com/selfrefactor/rambda#readme",
-	"files": [
-		"dist",
-		"src",
-		"README.md",
-		"CHANGELOG.md",
-		"index.d.ts",
-		"immutable.d.ts",
-		"rambda.js",
-		"immutable.js"
-	],
-	"sideEffects": false,
-	"main": "./dist/rambda.js",
-	"umd": "./dist/rambda.umd.js",
-	"module": "./rambda.js",
-	"types": "./index.d.ts"
+  "name": "rambda",
+  "version": "8.4.0",
+  "scripts": {
+    "benchmark": "cd ../rambda-scripts && RAMBDA_RUN_ALL=ON RAMBDA_RUN_INDEXES=ON yarn benchmark",
+    "benchmark:all": "yarn build:step && cd ../rambda-scripts && yarn benchmark:all",
+    "benchmark:check": "yarn build:step && METHOD=compose yarn benchmark:check:apply",
+    "benchmark:check:apply": "cd ../rambda-scripts && yarn check-benchmark",
+    "build": "yarn build:main && yarn build:web",
+    "build:main": "cross-env NODE_ENV=build rollup -c files/rollup.config.mjs",
+    "build:step": "yarn populatereadme && yarn build:main",
+    "build:web": "cross-env NODE_ENV=build rollup -c files/rollup.web.config.mjs",
+    "d": "yarn out && yarn lint && run d",
+    "docs": "npx docsify-cli init ./docs && yarn fix-docsify",
+    "fix-docsify": "cd ../rambda-scripts && yarn fix-docsify:rambda",
+    "git:add": "git add -A",
+    "github": "cd ../rambda-scripts && yarn github",
+    "immutable": "cd ../rambda-scripts && yarn immutable:rambda",
+    "immutable:x": "cd ../rambda-scripts && yarn immutable:rambdax",
+    "lint": "yarn git:add && yarn lint:staged && yarn git:add",
+    "lint:all": "cd ../rambda-scripts && yarn lint",
+    "lint:staged": "cd ../rambda-scripts && yarn lint:staged",
+    "new": "cd ../rambda-scripts && yarn new",
+    "out": "yarn populatedocs && yarn populatereadme && yarn immutable && yarn build",
+    "before": "yarn out && yarn docs",
+    "populatedocs": "cd ../rambda-scripts && yarn populate:docs",
+    "populatedocs:x": "cd ../rambda-scripts && yarn populate:docs:rambdax",
+    "populatereadme": "cd ../rambda-scripts && yarn populate:readme",
+    "populatereadme:x": "cd ../rambda-scripts && yarn populate:readme:rambdax",
+    "run:ramda:test": "cd ../rambda-scripts && yarn run:ramda:test",
+    "test": "jest -o -u --watch",
+    "test:all": "jest source/*.spec.js -u --bail=false",
+    "test:ci": "jest source/*.spec.js --coverage --no-cache -w 1",
+    "test:typings": "dtslint --localTs ./node_modules/typescript/lib --expectOnly ./source",
+    "usedby": "cd ../rambda-scripts && yarn usedby",
+    "x": "yarn populatedocs:x && yarn populatereadme:x && yarn immutable:x"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "@babel/core": "7.21.8",
+    "@babel/plugin-proposal-object-rest-spread": "7.20.7",
+    "@babel/preset-env": "7.21.5",
+    "@definitelytyped/dtslint": "0.0.176",
+    "@rollup/plugin-babel": "6.0.3",
+    "@rollup/plugin-commonjs": "25.0.0",
+    "@rollup/plugin-node-resolve": "15.0.2",
+    "@rollup/plugin-replace": "5.0.2",
+    "@types/jest": "29.5.1",
+    "combinate": "1.1.11",
+    "cross-env": "7.0.3",
+    "fast-check": "^3.11.0",
+    "helpers-fn": "1.8.1",
+    "is-ci": "3.0.1",
+    "jest": "29.5.0",
+    "jest-extended": "3.2.4",
+    "lodash": "4.17.21",
+    "rambdax": "9.1.1",
+    "ramda": "0.29.0",
+    "rollup": "3.22.0",
+    "rollup-plugin-cleanup": "3.2.1",
+    "rollup-plugin-sourcemaps": "0.6.3",
+    "rollup-plugin-uglify": "6.0.4",
+    "types-ramda": "0.29.2",
+    "typescript": "5.2.2"
+  },
+  "jest": {
+    "testEnvironment": "node",
+    "testRegex": ".*\\.(spec|test)\\.js$",
+    "setupFilesAfterEnv": [
+      "./files/testSetup.js"
+    ],
+    "collectCoverageFrom": [
+      "source/*.js",
+      "!_internals",
+      "!benchmarks"
+    ]
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/selfrefactor/rambda.git"
+  },
+  "license": "MIT",
+  "author": "self_refactor",
+  "description": "Lightweight and faster alternative to Ramda with included TS definitions",
+  "keywords": [
+    "ramda",
+    "fp",
+    "functional",
+    "utility",
+    "lodash"
+  ],
+  "homepage": "https://github.com/selfrefactor/rambda#readme",
+  "files": [
+    "dist",
+    "src",
+    "README.md",
+    "CHANGELOG.md",
+    "index.d.ts",
+    "immutable.d.ts",
+    "rambda.js",
+    "immutable.js"
+  ],
+  "sideEffects": false,
+  "main": "./dist/rambda.js",
+  "umd": "./dist/rambda.umd.js",
+  "module": "./rambda.js",
+  "types": "./index.d.ts"
 }

package/rambda.js

@@ -20,13 +20,18 @@ export * from './src/applyTo.js'
 export * from './src/ascend.js'
 export * from './src/assoc.js'
 export * from './src/assocPath.js'
+export * from './src/binary.js'
 export * from './src/bind.js'
 export * from './src/both.js'
+export * from './src/call.js'
 export * from './src/chain.js'
 export * from './src/clamp.js'
 export * from './src/clone.js'
+export * from './src/collectBy.js'
+export * from './src/comparator.js'
 export * from './src/complement.js'
 export * from './src/compose.js'
+export * from './src/composeWith.js'
 export * from './src/concat.js'
 export * from './src/cond.js'
 export * from './src/converge.js'
@@ -40,6 +45,7 @@ export * from './src/descend.js'
 export * from './src/difference.js'
 export * from './src/differenceWith.js'
 export * from './src/dissoc.js'
+export * from './src/dissocPath.js'
 export * from './src/divide.js'
 export * from './src/drop.js'
 export * from './src/dropLast.js'
@@ -142,6 +148,7 @@ export * from './src/props.js'
 export * from './src/range.js'
 export * from './src/reduce.js'
 export * from './src/reject.js'
+export * from './src/removeIndex.js'
 export * from './src/repeat.js'
 export * from './src/replace.js'
 export * from './src/reverse.js'

package/src/_internals/_arity.js

@@ -0,0 +1,64 @@
+export function _arity(n, fn){
+  switch (n){
+  case 0:
+    return function (){
+      return fn.apply(this, arguments)
+    }
+  case 1:
+    return function (_1){
+      return fn.apply(this, arguments)
+    }
+  case 2:
+    return function (_1, _2){
+      return fn.apply(this, arguments)
+    }
+  case 3:
+    return function (
+      _1, _2, _3
+    ){
+      return fn.apply(this, arguments)
+    }
+  case 4:
+    return function (
+      _1, _2, _3, _4
+    ){
+      return fn.apply(this, arguments)
+    }
+  case 5:
+    return function (
+      _1, _2, _3, _4, _5
+    ){
+      return fn.apply(this, arguments)
+    }
+  case 6:
+    return function (
+      _1, _2, _3, _4, _5, _6
+    ){
+      return fn.apply(this, arguments)
+    }
+  case 7:
+    return function (
+      _1, _2, _3, _4, _5, _6, _7
+    ){
+      return fn.apply(this, arguments)
+    }
+  case 8:
+    return function (
+      _1, _2, _3, _4, _5, _6, _7, _8
+    ){
+      return fn.apply(this, arguments)
+    }
+  case 9:
+    return function (
+      _1, _2, _3, _4, _5, _6, _7, _8, _9
+    ){
+      return fn.apply(this, arguments)
+    }
+  default:
+    return function (
+      _1, _2, _3, _4, _5, _6, _7, _8, _9, _10
+    ){
+      return fn.apply(this, arguments)
+    }
+  }
+}

package/src/_internals/compare.js

@@ -0,0 +1,3 @@
+export function compare(a, b){
+  return String(a) === String(b)
+}

package/src/_internals/createPath.js

@@ -1,3 +1,7 @@
+import { isInteger } from './isInteger.js'
+
 export function createPath(path, delimiter = '.'){
-  return typeof path === 'string' ? path.split(delimiter) : path
+  return typeof path === 'string' ?
+    path.split(delimiter).map(x => isInteger(x) ? Number(x) : x) :
+    path
 }

package/src/_internals/createPathInput.js

@@ -0,0 +1,7 @@
+import { isInteger } from './isInteger.js'
+
+export function createPathInput(path){
+  return typeof path === 'string' ?
+    path.split('.').map(x => isInteger(Number(x)) ? Number(x) : x) :
+    path
+}

package/src/_internals/includes.js

@@ -0,0 +1,12 @@
+import { compare } from './compare.js'
+
+export function includes(a, list){
+  let index = -1
+  const { length } = list
+
+  while (++index < length)
+    if (compare(list[ index ], a))
+      return true
+
+  return false
+}

package/src/_internals/isInteger.js

@@ -3,3 +3,8 @@ function _isInteger(n){
 }
 
 export const isInteger = Number.isInteger || _isInteger
+
+/**
+ * Check if `index` is integer even if it is a string.
+ */
+export const isIndexInteger = index => Number.isInteger(Number(index))

package/src/assoc.js

@@ -1,6 +1,6 @@
 import { curry } from './curry.js'
 
-function assocFn(
+export function assocFn(
   prop, newValue, obj
 ){
   return Object.assign(