rambda 8.0.0 → 8.2.0

package/immutable.d.ts

@@ -23,6 +23,7 @@ export type IndexedIterator<T, U> = (x: T, i: number) => U;
 export type Iterator<T, U> = (x: T) => U;
 export type ObjectIterator<T, U> = (x: T, prop: string, inputObj: Dictionary<T>) => U;
 type Ord = number | string | boolean | Date;
+type Ordering = -1 | 0 | 1;
 type Path = string | readonly (number | string)[];
 export type RamdaPath = readonly (number | string)[];
 type Predicate<T> = (x: T) => boolean;
@@ -56,6 +57,9 @@ type Pred = (...x: readonly any[]) => boolean;
 export interface Dictionary<T> {readonly [index: string]: T}
 type Partial<T> = { readonly [P in keyof T]?: T[P]};
 
+type _TupleOf<T, N extends number, R extends readonly unknown[]> = R['length'] extends N ? R : _TupleOf<T, N, readonly [T, ...R]>;
+export type Tuple<T, N extends number> = N extends N ? (number extends N ? readonly T[] : _TupleOf<T, N, readonly []>) : never;
+
 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);
@@ -178,6 +182,12 @@ export function T(): boolean;
 export function add(a: number, b: number): number;
 export function add(a: number): (b: number) => number;
 
+export function addIndex(originalFn: any): (fn: any) => (list: readonly any[]) => readonly any[];
+export function addIndex(originalFn: any): (fn: any, list: readonly any[]) => readonly any[];
+
+export function addIndexRight(originalFn: any): (fn: any) => (list: readonly any[]) => readonly any[];
+export function addIndexRight(originalFn: any): (fn: any, list: readonly any[]) => readonly any[];
+
 /**
  * It replaces `index` in array `list` with the result of `replaceFn(list[i])`.
  */
@@ -219,6 +229,13 @@ export function any<T>(predicate: (x: T) => boolean): (list: readonly T[]) => bo
 export function anyPass<T>(predicates: readonly ((x: T) => boolean)[]): (input: T) => boolean;
 export function anyPass<T>(predicates: readonly ((...inputs: readonly T[]) => boolean)[]): (...inputs: readonly T[]) => boolean;
 
+export function ap<T, U>(fns: readonly ReadonlyArray<(a: T) => U>[], vs: readonly T[]): readonly U[];
+export function ap<T, U>(fns: ReadonlyArray<(a: T) => U>): (vs: readonly T[]) => readonly U[];
+export function ap<R, A, B>(fn: (r: R, a: A) => B, fn1: (r: R) => A): (r: R) => B;
+
+export function aperture<N extends number, T>(n: N, list: readonly T[]): ReadonlyArray<Tuple<T, N>> | readonly [];
+export function aperture<N extends number>(n: N): <T>(list: readonly T[]) => ReadonlyArray<Tuple<T, N>> | readonly [];
+
 /**
  * It adds element `x` at the end of `list`.
  */
@@ -240,6 +257,12 @@ export function applySpec<Spec extends Record<string, AnyFunction>>(
 ) => { readonly [Key in keyof Spec]: ReturnType<Spec[Key]> };
 export function applySpec<T>(spec: any): (...args: readonly unknown[]) => T;
 
+export function applyTo<T, U>(el: T, fn: (t: T) => U): U;
+export function applyTo<T>(el: T): <U>(fn: (t: T) => U) => U;
+
+export function ascend<T>(fn: (obj: T) => Ord, a: T, b: T): Ordering;
+export function ascend<T>(fn: (obj: T) => Ord): (a: T, b: T) => Ordering;
+
 /**
  * It makes a shallow clone of `obj` with setting or overriding the property `prop` with `newValue`.
  */
@@ -426,6 +449,9 @@ export function dec(x: number): number;
 export function defaultTo<T>(defaultValue: T, input: T | null | undefined): T;
 export function defaultTo<T>(defaultValue: T): (input: T | null | undefined) => T;
 
+export function descend<T>(fn: (obj: T) => Ord, a: T, b: T): Ordering;
+export function descend<T>(fn: (obj: T) => Ord): (a: T, b: T) => Ordering;
+
 /**
  * It returns the uniq set of all elements in the first list `a` not contained in the second list `b`.
  * 
@@ -434,6 +460,19 @@ export function defaultTo<T>(defaultValue: T): (input: T | null | undefined) =>
 export function difference<T>(a: readonly T[], b: readonly T[]): readonly T[];
 export function difference<T>(a: readonly T[]): (b: readonly T[]) => readonly T[];
 
+export function differenceWith<T1, T2>(
+  pred: (a: T1, b: T2) => boolean,
+  list1: readonly T1[],
+  list2: readonly T2[],
+): readonly T1[];
+export function differenceWith<T1, T2>(
+  pred: (a: T1, b: T2) => boolean,
+): (list1: readonly T1[], list2: readonly T2[]) => readonly T1[];
+export function differenceWith<T1, T2>(
+  pred: (a: T1, b: T2) => boolean,
+  list1: readonly T1[],
+): (list2: readonly T2[]) => readonly T1[];
+
 /**
  * It returns a new object that does not contain property `prop`.
  */
@@ -495,10 +534,10 @@ export function either(firstPredicate: Pred): (secondPredicate: Pred) => Pred;
  * When iterable is a string, then it behaves as `String.prototype.endsWith`.
  * When iterable is a list, then it uses R.equals to determine if the target list ends in the same way as the given target.
  */
-export function endsWith(target: string, iterable: string): boolean;
-export function endsWith(target: string): (iterable: string) => boolean;
-export function endsWith<T>(target: readonly T[], list: readonly T[]): boolean;
-export function endsWith<T>(target: readonly T[]): (list: readonly T[]) => boolean;
+export function endsWith<T extends string>(question: T, str: string): boolean;
+export function endsWith<T extends string>(question: T): (str: string) => boolean;
+export function endsWith<T>(question: readonly T[], list: readonly T[]): boolean;
+export function endsWith<T>(question: readonly T[]): (list: readonly T[]) => boolean;
 
 /**
  * It returns `true` if property `prop` in `obj1` is equal to property `prop` in `obj2` according to `R.equals`.
@@ -622,7 +661,7 @@ export function hasPath<T>(
  */
 export function head(input: string): string;
 export function head(emptyList: readonly []): undefined;
-export function head<T>(input: readonly T[]): T | undefined;
+export function head<T extends readonly unknown[]>(array: T): FirstArrayElement<T>
 
 /**
  * It returns `true` if its arguments `a` and `b` are identical.
@@ -659,8 +698,8 @@ export function inc(x: number): number;
  * 
  * If `input` is array, then `R.equals` is used to define if `valueToFind` belongs to the list.
  */
-export function includes(valueToFind: string, input: readonly string[] | string): boolean;
-export function includes(valueToFind: string): (input: readonly string[] | string) => boolean;
+export function includes<T extends string>(valueToFind: T, input: string): boolean;
+export function includes<T extends string>(valueToFind: T): (input: string) => boolean;
 export function includes<T>(valueToFind: T, input: readonly T[]): boolean;
 export function includes<T>(valueToFind: T): (input: readonly T[]) => boolean;
 
@@ -747,9 +786,9 @@ export function keys<T>(x: T): readonly string[];
 /**
  * It returns the last element of `input`, as the `input` can be either a string or an array.
  */
-export function last(str: string): string;
+export function last(input: string): string;
 export function last(emptyList: readonly []): undefined;
-export function last<T extends any>(list: readonly T[]): T | undefined;
+export function last<T extends readonly unknown[]>(array: T): LastArrayElement<T>
 
 /**
  * It returns the last index of `target` in `list` array.
@@ -952,11 +991,6 @@ export function negate(x: number): number;
 export function none<T>(predicate: (x: T) => boolean, list: readonly T[]): boolean;
 export function none<T>(predicate: (x: T) => boolean): (list: readonly T[]) => boolean;
 
-/**
- * It returns `undefined`.
- */
-export function nop(): void;
-
 /**
  * It returns a boolean negated version of `input`.
  */
@@ -1251,11 +1285,11 @@ export function prop<P extends keyof never, T>(propToFind: P): {
 /**
  * It returns true if `obj` has property `propToFind` and its value is equal to `valueToMatch`.
  */
-export function propEq<K extends string | number>(propToFind: K, valueToMatch: any, obj: Record<K, any>): boolean;
-export function propEq<K extends string | number>(propToFind: K, valueToMatch: any): (obj: Record<K, any>) => boolean;
-export function propEq<K extends string | number>(propToFind: K): {
-  (valueToMatch: any, obj: Record<K, any>): boolean;
-  (valueToMatch: any): (obj: Record<K, any>) => boolean;
+export function propEq<K extends string | number>(valueToMatch: any, propToFind: K, obj: Record<K, any>): boolean;
+export function propEq<K extends string | number>(valueToMatch: any, propToFind: K): (obj: Record<K, any>) => boolean;
+export function propEq(valueToMatch: any): {
+  <K extends string | number>(propToFind: K, obj: Record<K, any>): boolean;
+  <K extends string | number>(propToFind: K): (obj: Record<K, any>) => boolean;
 };
 
 /**
@@ -1318,9 +1352,9 @@ export function repeat<T>(x: T, timesToRepeat: number): readonly T[];
 /**
  * It replaces `strOrRegex` found in `str` with `replacer`.
  */
-export function replace(strOrRegex: RegExp | string, replacer: string, str: string): string;
-export function replace(strOrRegex: RegExp | string, replacer: string): (str: string) => string;
-export function replace(strOrRegex: RegExp | string): (replacer: string) => (str: string) => string;
+export function replace(strOrRegex: RegExp | string, replacer: RegExpReplacer, str: string): string;
+export function replace(strOrRegex: RegExp | string, replacer: RegExpReplacer): (str: string) => string;
+export function replace(strOrRegex: RegExp | string): (replacer: RegExpReplacer) => (str: string) => string;
 
 /**
  * It returns a reversed copy of list or string `input`.
@@ -1397,10 +1431,10 @@ export function splitWhen<T>(predicate: Predicate<T>): <U>(list: readonly U[]) =
  * When iterable is a string, then it behaves as `String.prototype.startsWith`.
  * When iterable is a list, then it uses R.equals to determine if the target list starts in the same way as the given target.
  */
-export function startsWith(target: string, str: string): boolean;
-export function startsWith(target: string): (str: string) => boolean;
-export function startsWith<T>(target: readonly T[], list: readonly T[]): boolean;
-export function startsWith<T>(target: readonly T[]): (list: readonly T[]) => boolean;
+export function startsWith<T extends string>(question: T, input: string): boolean;
+export function startsWith<T extends string>(question: T): (input: string) => boolean;
+export function startsWith<T>(question: readonly T[], input: readonly T[]): boolean;
+export function startsWith<T>(question: readonly T[]): (input: readonly T[]) => boolean;
 
 /**
  * Curried version of `x - y`

package/index.d.ts

@@ -23,6 +23,7 @@ export type IndexedIterator<T, U> = (x: T, i: number) => U;
 export type Iterator<T, U> = (x: T) => U;
 export type ObjectIterator<T, U> = (x: T, prop: string, inputObj: Dictionary<T>) => U;
 type Ord = number | string | boolean | Date;
+type Ordering = -1 | 0 | 1;
 type Path = string | (number | string)[];
 export type RamdaPath = (number | string)[];
 type Predicate<T> = (x: T) => boolean;
@@ -56,6 +57,9 @@ type Pred = (...x: any[]) => boolean;
 export interface Dictionary<T> {[index: string]: T}
 type Partial<T> = { [P in keyof T]?: T[P]};
 
+type _TupleOf<T, N extends number, R extends unknown[]> = R['length'] extends N ? R : _TupleOf<T, N, [T, ...R]>;
+export type Tuple<T, N extends number> = N extends N ? (number extends N ? T[] : _TupleOf<T, N, []>) : never;
+
 type Evolvable<E extends Evolver> = {[P in keyof E]?: Evolved<E[P]>};
 
 type Evolver<T extends Evolvable<any> = any> = {   [key in keyof Partial<T>]: ((value: T[key]) => T[key]) | (T[key] extends Evolvable<any> ? Evolver<T[key]> : never);
@@ -178,6 +182,12 @@ export function T(): boolean;
 export function add(a: number, b: number): number;
 export function add(a: number): (b: number) => number;
 
+export function addIndex(originalFn: any): (fn: any) => (list: any[]) => any[];
+export function addIndex(originalFn: any): (fn: any, list: any[]) => any[];
+
+export function addIndexRight(originalFn: any): (fn: any) => (list: any[]) => any[];
+export function addIndexRight(originalFn: any): (fn: any, list: any[]) => any[];
+
 /**
  * It replaces `index` in array `list` with the result of `replaceFn(list[i])`.
  */
@@ -219,6 +229,13 @@ export function any<T>(predicate: (x: T) => boolean): (list: T[]) => boolean;
 export function anyPass<T>(predicates: ((x: T) => boolean)[]): (input: T) => boolean;
 export function anyPass<T>(predicates: ((...inputs: T[]) => boolean)[]): (...inputs: T[]) => boolean;
 
+export function ap<T, U>(fns: Array<(a: T) => U>[], vs: T[]): U[];
+export function ap<T, U>(fns: Array<(a: T) => U>): (vs: T[]) => U[];
+export function ap<R, A, B>(fn: (r: R, a: A) => B, fn1: (r: R) => A): (r: R) => B;
+
+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`.
  */
@@ -240,6 +257,12 @@ export function applySpec<Spec extends Record<string, AnyFunction>>(
 ) => { [Key in keyof Spec]: ReturnType<Spec[Key]> };
 export function applySpec<T>(spec: any): (...args: unknown[]) => T;
 
+export function applyTo<T, U>(el: T, fn: (t: T) => U): U;
+export function applyTo<T>(el: T): <U>(fn: (t: T) => U) => U;
+
+export function ascend<T>(fn: (obj: T) => Ord, a: T, b: T): Ordering;
+export function ascend<T>(fn: (obj: T) => Ord): (a: T, b: T) => Ordering;
+
 /**
  * It makes a shallow clone of `obj` with setting or overriding the property `prop` with `newValue`.
  */
@@ -426,6 +449,9 @@ export function dec(x: number): number;
 export function defaultTo<T>(defaultValue: T, input: T | null | undefined): T;
 export function defaultTo<T>(defaultValue: T): (input: T | null | undefined) => T;
 
+export function descend<T>(fn: (obj: T) => Ord, a: T, b: T): Ordering;
+export function descend<T>(fn: (obj: T) => Ord): (a: T, b: T) => Ordering;
+
 /**
  * It returns the uniq set of all elements in the first list `a` not contained in the second list `b`.
  * 
@@ -434,6 +460,19 @@ export function defaultTo<T>(defaultValue: T): (input: T | null | undefined) =>
 export function difference<T>(a: T[], b: T[]): T[];
 export function difference<T>(a: T[]): (b: T[]) => T[];
 
+export function differenceWith<T1, T2>(
+  pred: (a: T1, b: T2) => boolean,
+  list1: T1[],
+  list2: T2[],
+): T1[];
+export function differenceWith<T1, T2>(
+  pred: (a: T1, b: T2) => boolean,
+): (list1: T1[], list2: T2[]) => T1[];
+export function differenceWith<T1, T2>(
+  pred: (a: T1, b: T2) => boolean,
+  list1: T1[],
+): (list2: T2[]) => T1[];
+
 /**
  * It returns a new object that does not contain property `prop`.
  */
@@ -495,10 +534,10 @@ export function either(firstPredicate: Pred): (secondPredicate: Pred) => Pred;
  * When iterable is a string, then it behaves as `String.prototype.endsWith`.
  * When iterable is a list, then it uses R.equals to determine if the target list ends in the same way as the given target.
  */
-export function endsWith(target: string, iterable: string): boolean;
-export function endsWith(target: string): (iterable: string) => boolean;
-export function endsWith<T>(target: T[], list: T[]): boolean;
-export function endsWith<T>(target: T[]): (list: T[]) => boolean;
+export function endsWith<T extends string>(question: T, str: string): boolean;
+export function endsWith<T extends string>(question: T): (str: string) => boolean;
+export function endsWith<T>(question: T[], list: T[]): boolean;
+export function endsWith<T>(question: T[]): (list: T[]) => boolean;
 
 /**
  * It returns `true` if property `prop` in `obj1` is equal to property `prop` in `obj2` according to `R.equals`.
@@ -622,7 +661,7 @@ export function hasPath<T>(
  */
 export function head(input: string): string;
 export function head(emptyList: []): undefined;
-export function head<T>(input: T[]): T | undefined;
+export function head<T extends readonly unknown[]>(array: T): FirstArrayElement<T>
 
 /**
  * It returns `true` if its arguments `a` and `b` are identical.
@@ -659,8 +698,8 @@ export function inc(x: number): number;
  * 
  * If `input` is array, then `R.equals` is used to define if `valueToFind` belongs to the list.
  */
-export function includes(valueToFind: string, input: string[] | string): boolean;
-export function includes(valueToFind: string): (input: string[] | string) => boolean;
+export function includes<T extends string>(valueToFind: T, input: string): boolean;
+export function includes<T extends string>(valueToFind: T): (input: string) => boolean;
 export function includes<T>(valueToFind: T, input: T[]): boolean;
 export function includes<T>(valueToFind: T): (input: T[]) => boolean;
 
@@ -747,9 +786,9 @@ 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(str: string): string;
+export function last(input: string): string;
 export function last(emptyList: []): undefined;
-export function last<T extends any>(list: T[]): T | undefined;
+export function last<T extends readonly unknown[]>(array: T): LastArrayElement<T>
 
 /**
  * It returns the last index of `target` in `list` array.
@@ -952,11 +991,6 @@ export function negate(x: number): number;
 export function none<T>(predicate: (x: T) => boolean, list: T[]): boolean;
 export function none<T>(predicate: (x: T) => boolean): (list: T[]) => boolean;
 
-/**
- * It returns `undefined`.
- */
-export function nop(): void;
-
 /**
  * It returns a boolean negated version of `input`.
  */
@@ -1251,11 +1285,11 @@ export function prop<P extends keyof never, T>(propToFind: P): {
 /**
  * It returns true if `obj` has property `propToFind` and its value is equal to `valueToMatch`.
  */
-export function propEq<K extends string | number>(propToFind: K, valueToMatch: any, obj: Record<K, any>): boolean;
-export function propEq<K extends string | number>(propToFind: K, valueToMatch: any): (obj: Record<K, any>) => boolean;
-export function propEq<K extends string | number>(propToFind: K): {
-  (valueToMatch: any, obj: Record<K, any>): boolean;
-  (valueToMatch: any): (obj: Record<K, any>) => boolean;
+export function propEq<K extends string | number>(valueToMatch: any, propToFind: K, obj: Record<K, any>): boolean;
+export function propEq<K extends string | number>(valueToMatch: any, propToFind: K): (obj: Record<K, any>) => boolean;
+export function propEq(valueToMatch: any): {
+  <K extends string | number>(propToFind: K, obj: Record<K, any>): boolean;
+  <K extends string | number>(propToFind: K): (obj: Record<K, any>) => boolean;
 };
 
 /**
@@ -1318,9 +1352,9 @@ export function repeat<T>(x: T, timesToRepeat: number): T[];
 /**
  * It replaces `strOrRegex` found in `str` with `replacer`.
  */
-export function replace(strOrRegex: RegExp | string, replacer: string, str: string): string;
-export function replace(strOrRegex: RegExp | string, replacer: string): (str: string) => string;
-export function replace(strOrRegex: RegExp | string): (replacer: string) => (str: string) => string;
+export function replace(strOrRegex: RegExp | string, replacer: RegExpReplacer, str: string): string;
+export function replace(strOrRegex: RegExp | string, replacer: RegExpReplacer): (str: string) => string;
+export function replace(strOrRegex: RegExp | string): (replacer: RegExpReplacer) => (str: string) => string;
 
 /**
  * It returns a reversed copy of list or string `input`.
@@ -1397,10 +1431,10 @@ export function splitWhen<T>(predicate: Predicate<T>): <U>(list: U[]) => (U[])[]
  * When iterable is a string, then it behaves as `String.prototype.startsWith`.
  * When iterable is a list, then it uses R.equals to determine if the target list starts in the same way as the given target.
  */
-export function startsWith(target: string, str: string): boolean;
-export function startsWith(target: string): (str: string) => boolean;
-export function startsWith<T>(target: T[], list: T[]): boolean;
-export function startsWith<T>(target: T[]): (list: T[]) => boolean;
+export function startsWith<T extends string>(question: T, input: string): boolean;
+export function startsWith<T extends string>(question: T): (input: string) => boolean;
+export function startsWith<T>(question: T[], input: T[]): boolean;
+export function startsWith<T>(question: T[]): (input: T[]) => boolean;
 
 /**
  * Curried version of `x - y`

package/package.json

@@ -1,40 +1,39 @@
 {
 	"name": "rambda",
-	"version": "8.0.0",
+	"version": "8.2.0",
 	"scripts": {
-		"publishx": "node files/publish",
-		"populatereadme": "cd ../rambda-scripts && yarn populate:readme",
-		"populatereadme:x": "cd ../rambda-scripts && yarn populate:readme:rambdax",
-		"out": "yarn populatereadme && yarn immutable && yarn build",
-		"pull": "cd ../rambda-scripts && git pull",
-		"outx": "yarn pull && yarn out",
-		"x": "yarn populatereadme:x && yarn immutable:x",
-		"github": "cd ../rambda-scripts && yarn github",
+		"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",
-		"usedby": "cd ../rambda-scripts && yarn usedby",
+		"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",
-		"lint": "yarn git:add && yarn lint:staged && yarn git:add",
-		"git:add": "git add -A",
-		"build": "yarn build:main && yarn build:web",
-		"build:web": "cross-env NODE_ENV=build rollup -c files/rollup.web.config.mjs",
-		"build:main": "cross-env NODE_ENV=build rollup -c files/rollup.config.mjs",
-		"docs": "npx docsify-cli init ./docs && yarn fix-docsify",
 		"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:typings": "dtslint --localTs ./node_modules/typescript/lib --expectOnly ./source",
-		"test:all": "jest source/*.spec.js -u --bail=false",
 		"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",
-		"build:step": "yarn populatereadme && yarn build:main",
-		"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",
-		"benchmark": "cd ../rambda-scripts && RAMBDA_RUN_ALL=ON RAMBDA_RUN_INDEXES=ON yarn benchmark",
-		"d:rambda-scripts": "cd ../rambda-scripts && run d",
-		"d": "yarn out && yarn lint && yarn d:rambda-scripts && run d"
+		"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": {

package/rambda.js

@@ -2,6 +2,8 @@
 export * from './src/F.js'
 export * from './src/T.js'
 export * from './src/add.js'
+export * from './src/addIndex.js'
+export * from './src/addIndexRight.js'
 export * from './src/adjust.js'
 export * from './src/all.js'
 export * from './src/allPass.js'
@@ -9,9 +11,13 @@ export * from './src/always.js'
 export * from './src/and.js'
 export * from './src/any.js'
 export * from './src/anyPass.js'
+export * from './src/ap.js'
+export * from './src/aperture.js'
 export * from './src/append.js'
 export * from './src/apply.js'
 export * from './src/applySpec.js'
+export * from './src/applyTo.js'
+export * from './src/ascend.js'
 export * from './src/assoc.js'
 export * from './src/assocPath.js'
 export * from './src/bind.js'
@@ -30,7 +36,9 @@ export * from './src/curry.js'
 export * from './src/curryN.js'
 export * from './src/dec.js'
 export * from './src/defaultTo.js'
+export * from './src/descend.js'
 export * from './src/difference.js'
+export * from './src/differenceWith.js'
 export * from './src/dissoc.js'
 export * from './src/divide.js'
 export * from './src/drop.js'

package/src/_internals/utils.js

@@ -0,0 +1,21 @@
+export function _concat(set1, set2){
+  set1 = set1 || []
+  set2 = set2 || []
+  let idx
+  const len1 = set1.length
+  const len2 = set2.length
+  const result = []
+
+  idx = 0
+  while (idx < len1){
+    result[ result.length ] = set1[ idx ]
+    idx += 1
+  }
+  idx = 0
+  while (idx < len2){
+    result[ result.length ] = set2[ idx ]
+    idx += 1
+  }
+
+  return result
+}

package/src/addIndex.js

@@ -0,0 +1,23 @@
+import { _concat } from './_internals/utils.js'
+import { curryN } from './curryN.js'
+
+export function addIndex(
+  originalFunction,
+  initialIndexFn = () => 0,
+  loopIndexChange = x => x + 1
+){
+  return curryN(originalFunction.length, function (){
+    const origFn = arguments[ 0 ]
+    const list = arguments[ arguments.length - 1 ]
+    let idx = initialIndexFn(list.length)
+    const args = Array.prototype.slice.call(arguments, 0)
+    args[ 0 ] = function (){
+      const result = origFn.apply(this, _concat(arguments, [ idx, list ]))
+      idx = loopIndexChange(idx)
+
+      return result
+    }
+
+    return originalFunction.apply(this, args)
+  })
+}

package/src/addIndexRight.js

@@ -0,0 +1,9 @@
+import { addIndex } from './addIndex.js'
+
+export function addIndexRight(originalFunction){
+  return addIndex(
+    originalFunction,
+    listLength => listLength - 1,
+    x => x - 1
+  )
+}

package/src/ap.js

@@ -0,0 +1,7 @@
+export function ap(functions, input){
+  if (arguments.length === 1){
+    return _inputs => ap(functions, _inputs)
+  }
+
+  return functions.reduce((acc, fn) => [ ...acc, ...input.map(fn) ], [])
+}

package/src/aperture.js

@@ -0,0 +1,15 @@
+export function aperture(step, list){
+  if (arguments.length === 1){
+    return _list => aperture(step, _list)
+  }
+  if (step > list.length) return []
+  let idx = 0
+  const limit = list.length - (step - 1)
+  const acc = new Array(limit)
+  while (idx < limit){
+    acc[ idx ] = list.slice(idx, idx + step)
+    idx += 1
+  }
+
+  return acc
+}

package/src/applyTo.js

@@ -0,0 +1,7 @@
+export function applyTo(input, fn){
+  if (arguments.length === 1){
+    return _fn => applyTo(input, _fn)
+  }
+
+  return fn(input)
+}

package/src/ascend.js

@@ -0,0 +1,23 @@
+export function createCompareFunction(
+  a, b, winner, loser
+){
+  if (a === b) return 0
+
+  return a < b ? winner : loser
+}
+
+export function ascend(
+  getFunction, a, b
+){
+  if (arguments.length === 1){
+    return (_a, _b) => ascend(
+      getFunction, _a, _b
+    )
+  }
+  const aValue = getFunction(a)
+  const bValue = getFunction(b)
+
+  return createCompareFunction(
+    aValue, bValue, -1, 1
+  )
+}

package/src/descend.js

@@ -0,0 +1,17 @@
+import { createCompareFunction } from './ascend.js'
+
+export function descend(
+  getFunction, a, b
+){
+  if (arguments.length === 1){
+    return (_a, _b) => descend(
+      getFunction, _a, _b
+    )
+  }
+  const aValue = getFunction(a)
+  const bValue = getFunction(b)
+
+  return createCompareFunction(
+    aValue, bValue, 1, -1
+  )
+}

package/src/differenceWith.js

@@ -0,0 +1,20 @@
+import { curry } from './curry.js'
+import { _indexOf } from './equals.js'
+
+export function differenceWithFn(
+  fn, a, b
+){
+  const willReturn = []
+  const [ first, second ] = a.length > b.length ? [ a, b ] : [ b, a ]
+
+  first.forEach(item => {
+    const hasItem = second.some(secondItem => fn(item, secondItem))
+    if (!hasItem && _indexOf(item, willReturn) === -1){
+      willReturn.push(item)
+    }
+  })
+
+  return willReturn
+}
+
+export const differenceWith = curry(differenceWithFn)