// Type definitions for ramda 0.26 // Project: https://github.com/donnut/typescript-ramda, https://ramdajs.com // Definitions by: Scott O'Malley // Erwin Poeze // Matt DeKrey // Matt Dziuban // Stephen King // Alejandro Fernandez Haro // Vítor Castro // Jordan Quagliatini // Simon Højberg // Samson Keung // Angelo Ocana // Rayner Pupo // Nikita Moshensky // Ethan Resnick // Jack Leigh // Tomas Szabo // Maciek Blim // Marcin Biernat // Rayhaneh Banyassady // Ryan McCuaig // Drew Wyatt // John Ottenlips // Nitesh Phadatare // Krantisinh Deshmukh // Pierre-Antoine Mills // Brekk Bockrath // Aram Kharazyan // Jituan Lin // Philippe Mills // Saul Mirone // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped // TypeScript Version: 3.5 /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// import { A, F, T, O } from "ts-toolbelt"; declare let R: R.Static; declare namespace R { import ValueOfRecord = Tools.ValueOfRecord; type Omit = Pick>; type Ord = number | string | boolean | Date; type Path = Array<(number | string)>; type KeyValuePair = [K, V]; interface Functor { map(fn: (t: T) => U): Functor; } interface ArrayLike { nodeType: number; } type Arity0Fn = () => any; type Arity1Fn = (a: any) => any; type Arity2Fn = (a: any, b: any) => any; interface ObjFunc { [index: string]: (...a: readonly any[]) => any; } interface ObjFunc2 { [index: string]: (x: any, y: any) => boolean; } type Pred = (...a: readonly any[]) => boolean; type SafePred = (...a: readonly T[]) => boolean; type ObjPred = (value: any, key: string) => boolean; interface Dictionary { [index: string]: T; } interface CharList extends String { push(x: string): void; } interface Lens { (obj: T): U; set(str: string, obj: T): U; } interface Filter { (fn: (value: T) => boolean): FilterOnceApplied; (fn: (value: T) => boolean): (list: readonly T[]) => T[]; (fn: (value: T) => boolean): (list: Dictionary) => Dictionary; (fn: (value: T) => boolean, list: readonly T[]): T[]; (fn: (value: T) => boolean, obj: Dictionary): Dictionary; } type FilterOnceApplied = >(source: K) => K extends Array ? U[] : K extends Dictionary ? Dictionary : never; type Evolve, E extends Evolver> = { [P in keyof O]: P extends keyof E ? EvolveValue : O[P]; }; type EvolveValue = E extends (value: V) => any ? ReturnType : E extends Evolver ? EvolveNestedValue : never; type EvolveNestedValue = V extends object ? (V extends Evolvable ? Evolve : never) : never; interface Evolver { [key: string]: ((value: any) => any) | Evolver; } // Represents all objects evolvable with Evolver E type Evolvable = { [P in keyof E]?: Evolved; }; type Evolved = T extends (value: infer V) => any ? V : T extends Evolver ? Evolvable : never; type Placeholder = A.x & {'@@functional/placeholder': true}; interface Reduced { '@@transducer/value': T; '@@transducer/reduced': true; } type PipeWithFns = [ (x0: V0) => T ] | [ (x0: V0) => any, (x: any) => T ] | [ (x0: V0) => any, (x: any) => any, (x: any) => T ] | [ (x0: V0) => any, (x: any) => any, (x: any) => any, (x: any) => T ] | [ (x0: V0) => any, (x: any) => any, (x: any) => any, (x: any) => any, (x: any) => T ] | [ (x0: V0) => any, (x: any) => any, (x: any) => any, (x: any) => any, (x: any) => any, (x: any) => T ] | [ (x0: V0) => any, (x: any) => any, (x: any) => any, (x: any) => any, (x: any) => any, (x: any) => any, (x: any) => T ] | [ (x0: V0) => any, (x: any) => any, (x: any) => any, (x: any) => any, (x: any) => any, (x: any) => any, (x: any) => any, (x: any) => T ] | [ (x0: V0) => any, (x: any) => any, (x: any) => any, (x: any) => any, (x: any) => any, (x: any) => any, (x: any) => any, (x: any) => any, (x: any) => T ] | [ (x0: V0) => any, (x: any) => any, (x: any) => any, (x: any) => any, (x: any) => any, (x: any) => any, (x: any) => any, (x: any) => any, (x: any) => any, (x: any) => T ]; type ComposeWithFns = [ (x0: V0) => T ] | [ (x: any) => T, (x: V0) => any ] | [ (x: any) => T, (x: any) => any, (x: V0) => any ] | [ (x: any) => T, (x: any) => any, (x: any) => any, (x: V0) => any ] | [ (x: any) => T, (x: any) => any, (x: any) => any, (x: any) => any, (x: V0) => any ] | [ (x: any) => T, (x: any) => any, (x: any) => any, (x: any) => any, (x: any) => any, (x: V0) => any ] | [ (x: any) => T, (x: any) => any, (x: any) => any, (x: any) => any, (x: any) => any, (x: any) => any, (x: V0) => any ] | [ (x: any) => T, (x: any) => any, (x: any) => any, (x: any) => any, (x: any) => any, (x: any) => any, (x: any) => any, (x: V0) => any ] | [ (x: any) => T, (x: any) => any, (x: any) => any, (x: any) => any, (x: any) => any, (x: any) => any, (x: any) => any, (x: any) => any, (x: V0) => any ] | [ (x: any) => T, (x: any) => any, (x: any) => any, (x: any) => any, (x: any) => any, (x: any) => any, (x: any) => any, (x: any) => any, (x: any) => any, (x: V0) => any ]; interface AssocPartialOne { (val: T): (obj: U) => Record & U; (val: T, obj: U): Record & U; } interface Static { /** * Placeholder. When used with functions like curry, or op, the second argument is applied to the second * position, and it returns a function waiting for its first argument. */ __: Placeholder; /* This is used in examples throughout the docs, but I it only seems to be directly explained here: https://ramdajs.com/0.9/docs/#op */ /** * Adds two numbers (or strings). Equivalent to a + b but curried. */ add(a: number, b: number): number; add(a: string, b: string): string; add(a: number): (b: number) => number; add(a: string): (b: string) => string; /** * Creates a new list iteration function from an existing one by adding two new parameters to its callback * function: the current index, and the entire list. */ addIndex(fn: (f: (item: T) => U, list: readonly T[]) => U[]): F.Curry<(a: (item: T, idx: number, list?: T[]) => U, b: readonly T[]) => U[]>; /* Special case for forEach */ addIndex(fn: (f: (item: T) => void, list: readonly T[]) => T[]): F.Curry<(a: (item: T, idx: number, list?: T[]) => void, b: readonly T[]) => T[]>; /* Special case for reduce */ addIndex(fn: (f: (acc: U, item: T) => U, aci: U, list: readonly T[]) => U): F.Curry<(a: (acc: U, item: T, idx: number, list?: T[]) => U, b: U, c: readonly T[]) => U>; /** * Applies a function to the value at the given index of an array, returning a new copy of the array with the * element at the given index replaced with the result of the function application. */ adjust(index: number, fn: (a: T) => T, list: readonly T[]): T[]; adjust(index: number, fn: (a: T) => T): (list: readonly T[]) => T[]; /** * Returns true if all elements of the list match the predicate, false if there are any that don't. */ all(fn: (a: T) => boolean, list: readonly T[]): boolean; all(fn: (a: T) => boolean): (list: readonly T[]) => boolean; /** * Given a list of predicates, returns a new predicate that will be true exactly when all of them are. */ allPass(preds: readonly Pred[]): Pred; /** * Returns a function that always returns the given value. */ always(val: T): () => T; /** * A function that returns the first argument if it's falsy otherwise the second argument. Note that this is * NOT short-circuited, meaning that if expressions are passed they are both evaluated. */ and any); } | number | boolean | string | null>(fn1: T, val2: any): boolean; and any); } | number | boolean | string | null>(fn1: T): (val2: any) => boolean; /** * Returns true if at least one of elements of the list match the predicate, false otherwise. */ any(fn: (a: T) => boolean, list: readonly T[]): boolean; any(fn: (a: T) => boolean): (list: readonly T[]) => boolean; /** * Given a list of predicates returns a new predicate that will be true exactly when any one of them is. */ anyPass(preds: Array>): SafePred; /** * ap applies a list of functions to a list of values. */ ap(fns: Array<((a: T) => U)>, vs: readonly T[]): U[]; ap(fns: Array<((a: T) => U)>): (vs: readonly T[]) => U[]; ap( fn: (x1: X1, x0: X0) => R, fn1: (x1: X1) => X0 ): (x1: X1) => R; /** * Returns a new list, composed of n-tuples of consecutive elements If n is greater than the length of the list, * an empty list is returned. */ aperture(n: 1, list: readonly T[]): Array<[T]>; aperture(n: 2, list: readonly T[]): Array<[T, T]>; aperture(n: 3, list: readonly T[]): Array<[T, T, T]>; aperture(n: 4, list: readonly T[]): Array<[T, T, T, T]>; aperture(n: 5, list: readonly T[]): Array<[T, T, T, T, T]>; aperture(n: 6, list: readonly T[]): Array<[T, T, T, T, T, T]>; aperture(n: 7, list: readonly T[]): Array<[T, T, T, T, T, T, T]>; aperture(n: 8, list: readonly T[]): Array<[T, T, T, T, T, T, T, T]>; aperture(n: 9, list: readonly T[]): Array<[T, T, T, T, T, T, T, T, T]>; aperture(n: 10, list: readonly T[]): Array<[T, T, T, T, T, T, T, T, T, T]>; aperture(n: number, list: readonly T[]): T[][]; aperture(n: number): (list: readonly T[]) => T[][]; /** * Returns a new list containing the contents of the given list, followed by the given element. */ append(el: T, list: readonly T[]): T[]; append(el: T): (list: readonly T[]) => T[]; /** * Applies function fn to the argument list args. This is useful for creating a fixed-arity function from * a variadic function. fn should be a bound function if context is significant. */ apply(fn: (arg0: T, ...args: readonly T[]) => TResult, args: readonly U[]): TResult; apply(fn: (arg0: T, ...args: readonly T[]) => TResult): (args: readonly U[]) => TResult; /** * Given a spec object recursively mapping properties to functions, creates a function producing an object * of the same structure, by mapping each property to the result of calling its associated function with * the supplied arguments. */ applySpec any>>( obj: Obj ): ( ...args: Parameters> ) => { [Key in keyof Obj]: ReturnType }; applySpec(obj: any): (...args: readonly any[]) => T; /** * Takes a value and applies a function to it. * This function is also known as the thrush combinator. */ applyTo(el: T, fn: (t: T) => U): U; applyTo(el: T): (fn: (t: T) => U) => U; /** * Makes an ascending comparator function out of a function that returns a value that can be compared with < and >. */ ascend(fn: (obj: T) => any, a: T, b: T): number; ascend(fn: (obj: T) => any): (a: T, b: T) => number; /** * Makes a shallow clone of an object, setting or overriding the specified property with the given value. */ assoc(__: Placeholder, val: T, obj: U): (prop: K) => Record & U; assoc(prop: K, __: Placeholder, obj: U): (val: T) => Record & U; assoc(prop: K, val: T, obj: U): Record & U; assoc(prop: K, val: T): (obj: U) => Record & U; assoc(prop: K): AssocPartialOne; /** * Makes a shallow clone of an object, setting or overriding the nodes required to create the given path, and * placing the specific value at the tail end of that path. */ assocPath(__: Placeholder, val: T, obj: U): (path: Path) => U; assocPath(path: Path, __: Placeholder, obj: U): (val: T) => U; assocPath(path: Path, val: T, obj: U): U; assocPath(path: Path, val: T): (obj: U) => U; assocPath(path: Path): F.Curry<(a: T, b: U) => U>; /** * Wraps a function of any arity (including nullary) in a function that accepts exactly 2 * parameters. Any extraneous parameters will not be passed to the supplied function. */ binary(fn: (...args: readonly any[]) => any): (...a: readonly any[]) => any; /** * Creates a function that is bound to a context. Note: R.bind does not provide the additional argument-binding * capabilities of Function.prototype.bind. */ bind(fn: (...args: readonly any[]) => any, thisObj: T): (...args: readonly any[]) => any; /** * A function wrapping calls to the two functions in an && operation, returning the result of the first function * if it is false-y and the result of the second function otherwise. Note that this is short-circuited, meaning * that the second function will not be invoked if the first returns a false-y value. */ both(pred1: Pred, pred2: Pred): Pred; both(pred1: Pred): (pred2: Pred) => Pred; /** * Returns the result of calling its first argument with the remaining arguments. This is occasionally useful * as a converging function for R.converge: the left branch can produce a function while the right branch * produces a value to be passed to that function as an argument. */ call(fn: (...args: readonly any[]) => (...args: readonly any[]) => any, ...args: readonly any[]): any; /** * `chain` maps a function over a list and concatenates the results. * This implementation is compatible with the Fantasy-land Chain spec */ chain(fn: (n: T) => U[], list: readonly T[]): U[]; chain(fn: (n: T) => U[]): (list: readonly T[]) => U[]; chain(fn: (x0: X0, x1: X1) => R, fn1: (x1: X1) => X0): (x1: X1) => R; /** * Restricts a number to be within a range. * Also works for other ordered types such as Strings and Date */ clamp(min: T, max: T, value: T): T; clamp(min: T, max: T): (value: T) => T; clamp(min: T): (max: T, value: T) => T; clamp(min: T): (max: T) => (value: T) => T; /** * Creates a deep copy of the value which may contain (nested) Arrays and Objects, Numbers, Strings, Booleans and Dates. */ clone(value: T): T; clone(value: readonly T[]): T[]; /** * Makes a comparator function out of a function that reports whether the first element is less than the second. */ // comparator(pred: (a: any, b: any) => boolean): (x: number, y: number) => number; comparator(pred: (a: T, b: T) => boolean): (x: T, y: T) => number; /** * Takes a function f and returns a function g such that: * - applying g to zero or more arguments will give true if applying the same arguments to f gives * a logical false value; and * - applying g to zero or more arguments will give false if applying the same arguments to f gives * a logical true value. */ complement(pred: (...args: readonly any[]) => boolean): (...args: readonly any[]) => boolean; /** * Performs right-to-left function composition. The rightmost function may have any arity; the remaining * functions must be unary. */ // generic rest parameters in TS 3.0 allows writing a single variant for any number of Vx // compose(fn0: (...args: V) => T1): (...args: V) => T1; // compose(fn1: (x: T1) => T2, fn0: (...args: V) => T1): (...args: V) => T2; // but requiring TS>=3.0 sounds like a breaking change, so just leaving a comment for the future compose(fn0: () => T1): () => T1; compose(fn0: (x0: V0) => T1): (x0: V0) => T1; compose(fn0: (x0: V0, x1: V1) => T1): (x0: V0, x1: V1) => T1; compose(fn0: (x0: V0, x1: V1, x2: V2) => T1): (x0: V0, x1: V1, x2: V2) => T1; compose(fn1: (x: T1) => T2, fn0: () => T1): () => T2; compose(fn1: (x: T1) => T2, fn0: (x0: V0) => T1): (x0: V0) => T2; compose(fn1: (x: T1) => T2, fn0: (x0: V0, x1: V1) => T1): (x0: V0, x1: V1) => T2; compose(fn1: (x: T1) => T2, fn0: (x0: V0, x1: V1, x2: V2) => T1): (x0: V0, x1: V1, x2: V2) => T2; compose(fn2: (x: T2) => T3, fn1: (x: T1) => T2, fn0: () => T1): () => T3; compose(fn2: (x: T2) => T3, fn1: (x: T1) => T2, fn0: (x: V0) => T1): (x: V0) => T3; compose(fn2: (x: T2) => T3, fn1: (x: T1) => T2, fn0: (x0: V0, x1: V1) => T1): (x0: V0, x1: V1) => T3; compose(fn2: (x: T2) => T3, fn1: (x: T1) => T2, fn0: (x0: V0, x1: V1, x2: V2) => T1): (x0: V0, x1: V1, x2: V2) => T3; compose(fn3: (x: T3) => T4, fn2: (x: T2) => T3, fn1: (x: T1) => T2, fn0: () => T1): () => T4; compose(fn3: (x: T3) => T4, fn2: (x: T2) => T3, fn1: (x: T1) => T2, fn0: (x: V0) => T1): (x: V0) => T4; compose(fn3: (x: T3) => T4, fn2: (x: T2) => T3, fn1: (x: T1) => T2, fn0: (x0: V0, x1: V1) => T1): (x0: V0, x1: V1) => T4; compose(fn3: (x: T3) => T4, fn2: (x: T2) => T3, fn1: (x: T1) => T2, fn0: (x0: V0, x1: V1, x2: V2) => T1): (x0: V0, x1: V1, x2: V2) => T4; compose(fn4: (x: T4) => T5, fn3: (x: T3) => T4, fn2: (x: T2) => T3, fn1: (x: T1) => T2, fn0: () => T1): () => T5; compose(fn4: (x: T4) => T5, fn3: (x: T3) => T4, fn2: (x: T2) => T3, fn1: (x: T1) => T2, fn0: (x: V0) => T1): (x: V0) => T5; compose(fn4: (x: T4) => T5, fn3: (x: T3) => T4, fn2: (x: T2) => T3, fn1: (x: T1) => T2, fn0: (x0: V0, x1: V1) => T1): (x0: V0, x1: V1) => T5; compose(fn4: (x: T4) => T5, fn3: (x: T3) => T4, fn2: (x: T2) => T3, fn1: (x: T1) => T2, fn0: (x0: V0, x1: V1, x2: V2) => T1): (x0: V0, x1: V1, x2: V2) => T5; compose(fn5: (x: T5) => T6, fn4: (x: T4) => T5, fn3: (x: T3) => T4, fn2: (x: T2) => T3, fn1: (x: T1) => T2, fn0: () => T1): () => T6; compose(fn5: (x: T5) => T6, fn4: (x: T4) => T5, fn3: (x: T3) => T4, fn2: (x: T2) => T3, fn1: (x: T1) => T2, fn0: (x: V0) => T1): (x: V0) => T6; compose( fn5: (x: T5) => T6, fn4: (x: T4) => T5, fn3: (x: T3) => T4, fn2: (x: T2) => T3, fn1: (x: T1) => T2, fn0: (x0: V0, x1: V1) => T1): (x0: V0, x1: V1) => T6; compose( fn5: (x: T5) => T6, fn4: (x: T4) => T5, fn3: (x: T3) => T4, fn2: (x: T2) => T3, fn1: (x: T1) => T2, fn0: (x0: V0, x1: V1, x2: V2) => T1): (x0: V0, x1: V1, x2: V2) => T6; /** * Returns the right-to-left Kleisli composition of the provided functions, each of which must return a value of a type supported by chain. * The typings only support arrays for now. * All functions must be unary. * R.composeK(h, g, f) is equivalent to R.compose(R.chain(h), R.chain(g), f). * * @deprecated since 0.26 in favor of composeWith(chain) */ composeK( fn0: (x0: V0) => T1[]): (x0: V0) => T1[]; composeK( fn1: (x: T1) => T2[], fn0: (x0: V0) => T1[]): (x0: V0) => T2[]; composeK( fn2: (x: T2) => T3[], fn1: (x: T1) => T2[], fn0: (x: V0) => T1[]): (x: V0) => T3[]; composeK( fn3: (x: T3) => T4[], fn2: (x: T2) => T3[], fn1: (x: T1) => T2[], fn0: (x: V0) => T1[]): (x: V0) => T4[]; composeK( fn4: (x: T4) => T5[], fn3: (x: T3) => T4[], fn2: (x: T2) => T3[], fn1: (x: T1) => T2[], fn0: (x: V0) => T1[]): (x: V0) => T5[]; composeK( fn5: (x: T5) => T6[], fn4: (x: T4) => T5[], fn3: (x: T3) => T4[], fn2: (x: T2) => T3[], fn1: (x: T1) => T2[], fn0: (x: V0) => T1[]): (x: V0) => T6[]; /** * Performs right-to-left composition of one or more Promise-returning functions. * All functions must be unary. * * @deprecated since 0.26 in favor of composeWith(then) */ composeP( fn0: (x0: V0) => Promise): (x0: V0) => Promise; composeP( fn1: (x: T1) => Promise, fn0: (x0: V0) => Promise): (x0: V0) => Promise; composeP( fn2: (x: T2) => Promise, fn1: (x: T1) => Promise, fn0: (x: V0) => Promise): (x: V0) => Promise; composeP( fn3: (x: T3) => Promise, fn2: (x: T2) => Promise, fn1: (x: T1) => Promise, fn0: (x: V0) => Promise): (x: V0) => Promise; composeP( fn4: (x: T4) => Promise, fn3: (x: T3) => Promise, fn2: (x: T2) => Promise, fn1: (x: T1) => Promise, fn0: (x: V0) => Promise): (x: V0) => Promise; composeP( fn5: (x: T5) => Promise, fn4: (x: T4) => Promise, fn3: (x: T3) => Promise, fn2: (x: T2) => Promise, fn1: (x: T1) => Promise, fn0: (x: V0) => Promise): (x: V0) => Promise; /** * Performs right-to-left function composition using transforming function. * With the current typings, all functions must be unary. */ composeWith(composer: (a: any) => any, fns: ComposeWithFns): (x0: V0) => T; composeWith(composer: (a: any) => any): (fns: ComposeWithFns) => (x: V0) => T; /** * Returns a new list consisting of the elements of the first list followed by the elements * of the second. */ concat(placeholder: Placeholder): (list2: readonly T[], list1: readonly T[]) => T[]; concat(placeholder: Placeholder, list2: readonly T[]): (list1: readonly T[]) => T[]; concat(list1: readonly T[], list2: readonly T[]): T[]; concat(list1: readonly T[]): (list2: readonly T[]) => T[]; concat(list1: string, list2: string): string; concat(list1: string): (list2: string) => string; /** * Returns a function, fn, which encapsulates if/else-if/else logic. R.cond takes a list of [predicate, transform] pairs. * All of the arguments to fn are applied to each of the predicates in turn until one returns a "truthy" value, at which * point fn returns the result of applying its arguments to the corresponding transformer. If none of the predicates * matches, fn returns undefined. */ cond(fns: Array<[Pred, (...a: readonly any[]) => any]>): (...a: readonly any[]) => any; cond(fns: Array<[SafePred, (...a: readonly A[]) => B]>): (...a: readonly A[]) => B; /** * Wraps a constructor function inside a curried function that can be called with the same arguments and returns the same type. */ construct(constructor: { new(...a: A): T } | ((...a: A) => T)): (...a: A) => T; /** * Wraps a constructor function inside a curried function that can be called with the same arguments and returns the same type. * The arity of the function returned is specified to allow using variadic constructor functions. */ constructN(n: number, constructor: { new(...a: A): T } | ((...a: A) => T)): (...a: Partial) => T; /** * Returns `true` if the specified item is somewhere in the list, `false` otherwise. * Equivalent to `indexOf(a)(list) > -1`. Uses strict (`===`) equality checking. * * @deprecated since 0.26 in favor of includes */ contains(__: Placeholder, list: string): (a: string) => boolean; contains(__: Placeholder, list: readonly T[]): (a: T) => boolean; contains(__: Placeholder): (list: string, a: string) => boolean; contains(__: Placeholder): (list: readonly T[], a: T) => boolean; contains(a: string, list: string): boolean; contains(a: T, list: readonly T[]): boolean; contains(a: string): (list: string) => boolean; contains(a: T): (list: readonly T[]) => boolean; /** * Accepts a converging function and a list of branching functions and returns a new * function. When invoked, this new function is applied to some arguments, each branching * function is applied to those same arguments. The results of each branching function * are passed as arguments to the converging function to produce the return value. */ converge(after: ((...a: readonly any[]) => any), fns: Array<((...a: readonly any[]) => any)>): (...a: readonly any[]) => any; /** * Counts the elements of a list according to how many match each value * of a key generated by the supplied function. Returns an object * mapping the keys produced by `fn` to the number of occurrences in * the list. Note that all keys are coerced to strings because of how * JavaScript objects work. */ countBy(fn: (a: T) => string | number, list: readonly T[]): { [index: string]: number }; countBy(fn: (a: T) => string | number): (list: readonly T[]) => { [index: string]: number }; /** * Returns a curried equivalent of the provided function. The curried function has two unusual capabilities. * First, its arguments needn't be provided one at a time. */ curry any>(f: F): F.Curry; /** * Returns a curried equivalent of the provided function, with the specified arity. The curried function has * two unusual capabilities. First, its arguments needn't be provided one at a time. */ curryN(length: number, fn: (...args: readonly any[]) => any): (...a: readonly any[]) => any; /** * Decrements its argument. */ dec(n: number): number; /** * Returns the second argument if it is not null or undefined. If it is null or undefined, the * first (default) argument is returned. */ defaultTo(a: T, b: U | null | undefined): T | U; defaultTo(a: T): (b: U | null | undefined) => T | U; /** * Makes a descending comparator function out of a function that returns a value that can be compared with < and >. */ descend(fn: (obj: T) => any, a: T, b: T): number; descend(fn: (obj: T) => any): (a: T, b: T) => number; /** * Finds the set (i.e. no duplicates) of all elements in the first list not contained in the second list. */ difference(list1: readonly T[], list2: readonly T[]): T[]; difference(list1: readonly T[]): (list2: readonly T[]) => T[]; /** * Finds the set (i.e. no duplicates) of all elements in the first list not contained in the second list. * Duplication is determined according to the value returned by applying the supplied predicate to two list * elements. */ differenceWith(pred: (a: T1, b: T2) => boolean, list1: readonly T1[], list2: readonly T2[]): T1[]; differenceWith(pred: (a: T1, b: T2) => boolean): (list1: readonly T1[], list2: readonly T2[]) => T1[]; differenceWith(pred: (a: T1, b: T2) => boolean, list1: readonly T1[]): (list2: readonly T2[]) => T1[]; /* * Returns a new object that does not contain a prop property. */ // It seems impossible to infer the return type, so this may to be specified explicitely dissoc(prop: string, obj: any): T; dissoc(prop: string): (obj: any) => U; /** * Makes a shallow clone of an object, omitting the property at the given path. */ dissocPath(path: Path, obj: any): T; dissocPath(path: Path): (obj: any) => T; /** * Divides two numbers. Equivalent to a / b. */ divide(__: Placeholder, b: number): (a: number) => number; divide(__: Placeholder): (b: number, a: number) => number; divide(a: number, b: number): number; divide(a: number): (b: number) => number; /** * Returns a new list containing all but the first n elements of the given list. */ drop(n: number, xs: readonly T[]): T[]; drop(n: number, xs: string): string; drop(n: number): { (xs: string): string; (xs: readonly T[]): T[]; }; /** * Returns a list containing all but the last n elements of the given list. */ dropLast(n: number, xs: readonly T[]): T[]; dropLast(n: number, xs: string): string; dropLast(n: number): { (xs: readonly T[]): T[]; (xs: string): string; }; /** * Returns a new list containing all but last then elements of a given list, passing each value from the * right to the supplied predicate function, skipping elements while the predicate function returns true. */ dropLastWhile(fn: (a: T) => boolean, list: readonly T[]): T[]; dropLastWhile(fn: (a: T) => boolean): (list: readonly T[]) => T[]; /** * Returns a new list without any consecutively repeating elements. R.equals is used to determine equality. */ dropRepeats(list: readonly T[]): T[]; /** * Returns a new list without any consecutively repeating elements. * Equality is determined by applying the supplied predicate to each pair of consecutive elements. * The first element in a series of equal elements will be preserved. */ dropRepeatsWith(predicate: (left: T, right: T) => boolean, list: readonly T[]): T[]; dropRepeatsWith(predicate: (left: T, right: T) => boolean): (list: readonly T[]) => T[]; /** * Returns a new list containing the last n elements of a given list, passing each value to the supplied * predicate function, skipping elements while the predicate function returns true. */ dropWhile(fn: (a: T) => boolean, list: readonly T[]): T[]; dropWhile(fn: (a: T) => boolean): (list: readonly T[]) => T[]; /** * A function wrapping calls to the two functions in an || operation, returning the result of the first * function if it is truth-y and the result of the second function otherwise. Note that this is * short-circuited, meaning that the second function will not be invoked if the first returns a truth-y value. */ either(pred1: Pred, pred2: Pred): Pred; either(pred1: Pred): (pred2: Pred) => Pred; /** * Returns the empty value of its argument's type. Ramda defines the empty value of Array ([]), Object ({}), * String (''), and Arguments. Other types are supported if they define .empty and/or .prototype.empty. * Dispatches to the empty method of the first argument, if present. */ empty(x: T): T; /** * Checks if a list ends with the provided values */ endsWith(a: string, list: string): boolean; endsWith(a: string): (list: string) => boolean; endsWith(a: T | readonly T[], list: readonly T[]): boolean; endsWith(a: T | readonly T[]): (list: readonly T[]) => boolean; /** * Takes a function and two values in its domain and returns true if the values map to the same value in the * codomain; false otherwise. */ eqBy(fn: (a: T) => U, a: T, b: T): boolean; eqBy(fn: (a: T) => U, a: T): (b: T) => boolean; eqBy(fn: (a: T) => U): F.Curry<(a: T, b: T) => boolean>; /** * Reports whether two functions have the same value for the specified property. */ eqProps(prop: string, obj1: T, obj2: U): boolean; eqProps

(p: P): (list: Array>) => T[]; pluck(p: number): (list: Array<{ [k: number]: T }>) => T[]; /** * Returns a new list with the given element at the front, followed by the contents of the * list. */ prepend(el: T, list: readonly T[]): T[]; prepend(el: T): (list: readonly T[]) => T[]; /** * Multiplies together all the elements of a list. */ product(list: readonly number[]): number; /** * Reasonable analog to SQL `select` statement. */ project(props: readonly string[], objs: readonly T[]): U[]; project(props: readonly string[]): (objs: readonly T[]) => U[]; /** * Returns a function that when supplied an object returns the indicated property of that object, if it exists. */ prop(__: Placeholder, obj: T):

(p: P) => T[P]; prop

(p: P, obj: T): T[P]; prop

(p: P): (obj: Record) => T; prop

(p: P): (obj: Record) => T; /** * Determines whether the given property of an object has a specific * value according to strict equality (`===`). Most likely used to * filter a list. */ propEq(name: string | number, val: T, obj: any): boolean; propEq(name: string | number, val: T): (obj: any) => boolean; propEq(name: string | number): { (val: T, obj: any): boolean; (val: T): (obj: any) => boolean; }; /** * Returns true if the specified object property is of the given type; false otherwise. */ propIs(type: any, name: string, obj: any): boolean; propIs(type: any, name: string): (obj: any) => boolean; propIs(type: any): { (name: string, obj: any): boolean; (name: string): (obj: any) => boolean; }; /** * If the given, non-null object has an own property with the specified name, returns the value of that property. * Otherwise returns the provided default value. */ propOr(val: T, __: Placeholder, obj: U): (p: string) => V; propOr(__: Placeholder, p: string, obj: U): (val: T) => V; propOr(val: T, p: string, obj: U): V; propOr(val: T, p: string): (obj: U) => V; propOr(val: T): (p: string, obj: U) => V; /** * Returns the value at the specified property. * The only difference from `prop` is the parameter order. * Note: TS1.9 # replace any by dictionary */ props

(ps: readonly P[], obj: Record): T[]; props

(ps: readonly P[]): (obj: Record) => T[]; props

(ps: readonly P[]): (obj: Record) => T[]; /** * Returns true if the specified object property satisfies the given predicate; false otherwise. */ propSatisfies(pred: (val: T) => boolean, name: string, obj: U): boolean; propSatisfies(pred: (val: T) => boolean, name: string): (obj: U) => boolean; propSatisfies(pred: (val: T) => boolean): F.Curry<(a: string, b: U) => boolean>; /** * Returns a list of numbers from `from` (inclusive) to `to` * (exclusive). In mathematical terms, `range(a, b)` is equivalent to * the half-open interval `[a, b)`. */ range(from: number, to: number): number[]; range(from: number): (to: number) => number[]; /** * Returns a single item by iterating through the list, successively calling the iterator * function and passing it an accumulator value and the current value from the array, and * then passing the result to the next call. */ reduce(fn: (acc: TResult, elem: T) => TResult | Reduced, acc: TResult, list: readonly T[]): TResult; reduce(fn: (acc: TResult, elem: T) => TResult | Reduced): (acc: TResult, list: readonly T[]) => TResult; reduce(fn: (acc: TResult, elem: T) => TResult | Reduced, acc: TResult): (list: readonly T[]) => TResult; /** * Groups the elements of the list according to the result of calling the String-returning function keyFn on each * element and reduces the elements of each group to a single value via the reducer function valueFn. */ reduceBy(valueFn: (acc: TResult, elem: T) => TResult, acc: TResult, keyFn: (elem: T) => string, list: readonly T[]): { [index: string]: TResult }; reduceBy(valueFn: (acc: TResult, elem: T) => TResult, acc: TResult, keyFn: (elem: T) => string): (list: readonly T[]) => { [index: string]: TResult }; reduceBy(valueFn: (acc: TResult, elem: T) => TResult, acc: TResult): F.Curry<(a: (elem: T) => string, b: readonly T[]) => { [index: string]: TResult }>; reduceBy(valueFn: (acc: TResult, elem: T) => TResult): F.Curry<(a: TResult, b: (elem: T) => string, c: readonly T[]) => { [index: string]: TResult }>; /** * Returns a value wrapped to indicate that it is the final value of the reduce and * transduce functions. The returned value should be considered a black box: the internal * structure is not guaranteed to be stable. */ reduced(elem: T): Reduced; /** * Returns a single item by iterating through the list, successively calling the iterator * function and passing it an accumulator value and the current value from the array, and * then passing the result to the next call. */ reduceRight(fn: (elem: T, acc: TResult) => TResult, acc: TResult, list: readonly T[]): TResult; reduceRight(fn: (elem: T, acc: TResult) => TResult): (acc: TResult, list: readonly T[]) => TResult; reduceRight(fn: (elem: T, acc: TResult) => TResult, acc: TResult): (list: readonly T[]) => TResult; /** * Like reduce, reduceWhile returns a single item by iterating through the list, successively * calling the iterator function. reduceWhile also takes a predicate that is evaluated before * each step. If the predicate returns false, it "short-circuits" the iteration and returns * the current value of the accumulator. */ reduceWhile(predicate: (acc: TResult, elem: T) => boolean, fn: (acc: TResult, elem: T) => TResult, acc: TResult, list: readonly T[]): TResult; reduceWhile(predicate: (acc: TResult, elem: T) => boolean, fn: (acc: TResult, elem: T) => TResult, acc: TResult): (list: readonly T[]) => TResult; reduceWhile(predicate: (acc: TResult, elem: T) => boolean, fn: (acc: TResult, elem: T) => TResult): F.Curry<(a: TResult, b: readonly T[]) => TResult>; reduceWhile(predicate: (acc: TResult, elem: T) => boolean): F.Curry<(a: (acc: TResult, elem: T) => TResult, b: TResult, c: readonly T[]) => TResult>; /** * Similar to `filter`, except that it keeps only values for which the given predicate * function returns falsy. */ reject: Filter; /** * Removes the sub-list of `list` starting at index `start` and containing `count` elements. */ remove(start: number, count: number, list: readonly T[]): T[]; remove(start: number): (count: number, list: readonly T[]) => T[]; remove(start: number, count: number): (list: readonly T[]) => T[]; /** * Returns a fixed list of size n containing a specified identical value. */ repeat(a: T, n: number): T[]; repeat(a: T): (n: number) => T[]; /** * Replace a substring or regex match in a string with a replacement. */ replace(pattern: RegExp | string, replacement: string | ((match: string, ...args: readonly any[]) => string), str: string): string; replace(pattern: RegExp | string, replacement: string | ((match: string, ...args: readonly any[]) => string)): (str: string) => string; replace(pattern: RegExp | string): (replacement: string | ((match: string, ...args: readonly any[]) => string)) => (str: string) => string; /** * Returns a new list with the same elements as the original list, just in the reverse order. */ reverse(list: readonly T[]): T[]; /** * Returns a new string with the characters in reverse order. */ reverse(str: string): string; /** * Scan is similar to reduce, but returns a list of successively reduced values from the left. */ scan(fn: (acc: TResult, elem: T) => any, acc: TResult, list: readonly T[]): TResult[]; scan(fn: (acc: TResult, elem: T) => any, acc: TResult): (list: readonly T[]) => TResult[]; scan(fn: (acc: TResult, elem: T) => any): (acc: TResult, list: readonly T[]) => TResult[]; /** * Returns the result of "setting" the portion of the given data structure focused by the given lens to the * given value. */ set(lens: Lens, a: U, obj: T): T; set(lens: Lens, a: U): (obj: T) => T; set(lens: Lens): (a: U, obj: T) => T; /** * Returns the elements from `xs` starting at `a` and ending at `b - 1`. */ slice(a: number, b: number, list: string): string; slice(a: number, b: number, list: readonly T[]): T[]; slice(a: number, b: number): { (list: string): string; (list: readonly T[]): T[]; }; slice(a: number): { (b: number, list: string): string; (b: number, list: readonly T[]): T[]; }; /** * Returns a copy of the list, sorted according to the comparator function, which should accept two values at a * time and return a negative number if the first value is smaller, a positive number if it's larger, and zero * if they are equal. */ sort(fn: (a: T, b: T) => number, list: readonly T[]): T[]; sort(fn: (a: T, b: T) => number): (list: readonly T[]) => T[]; /** * Sorts the list according to a key generated by the supplied function. */ sortBy(fn: (a: T) => Ord, list: readonly T[]): T[]; sortBy(fn: (a: any) => Ord): (list: readonly T[]) => T[]; /** * Sorts a list according to a list of comparators. */ sortWith(fns: Array<((a: T, b: T) => number)>, list: readonly T[]): T[]; sortWith(fns: Array<((a: T, b: T) => number)>): (list: readonly T[]) => T[]; /** * Splits a string into an array of strings based on the given * separator. */ split(sep: string | RegExp): (str: string) => string[]; split(sep: string | RegExp, str: string): string[]; /** * Splits a given list or string at a given index. */ splitAt(index: number, list: readonly T[]): [T[], T[]]; splitAt(index: number, list: string): [string, string]; splitAt(index: number): { (list: readonly T[]): [T[], T[]]; (list: string): [string, string]; }; /** * Splits a collection into slices of the specified length. */ splitEvery(a: number, list: readonly T[]): T[][]; splitEvery(a: number, list: string): string[]; splitEvery(a: number): { (list: string): string[]; (list: readonly T[]): T[][]; }; /** * Takes a list and a predicate and returns a pair of lists with the following properties: * - the result of concatenating the two output lists is equivalent to the input list; * - none of the elements of the first output list satisfies the predicate; and * - if the second output list is non-empty, its first element satisfies the predicate. */ splitWhen(pred: (val: T) => boolean, list: readonly U[]): U[][]; splitWhen(pred: (val: T) => boolean): (list: readonly U[]) => U[][]; /** * Checks if a list starts with the provided values */ startsWith(a: string, list: string): boolean; startsWith(a: string): (list: string) => boolean; startsWith(a: T | readonly T[], list: readonly T[]): boolean; startsWith(a: T | readonly T[]): (list: readonly T[]) => boolean; /** * Subtracts two numbers. Equivalent to `a - b` but curried. */ subtract(__: Placeholder, b: number): (a: number) => number; subtract(__: Placeholder): (b: number, a: number) => number; subtract(a: number, b: number): number; subtract(a: number): (b: number) => number; /** * Adds together all the elements of a list. */ sum(list: readonly number[]): number; /** * Finds the set (i.e. no duplicates) of all elements contained in the first or second list, but not both. */ symmetricDifference(list1: readonly T[], list2: readonly T[]): T[]; symmetricDifference(list: readonly T[]): (list: readonly T[]) => T[]; /** * Finds the set (i.e. no duplicates) of all elements contained in the first or second list, but not both. * Duplication is determined according to the value returned by applying the supplied predicate to two list elements. */ symmetricDifferenceWith(pred: (a: T, b: T) => boolean, list1: readonly T[], list2: readonly T[]): T[]; symmetricDifferenceWith(pred: (a: T, b: T) => boolean): F.Curry<(a: readonly T[], b: readonly T[]) => T[]>; /** * A function that always returns true. Any passed in parameters are ignored. */ T(): boolean; /** * Returns all but the first element of a list or string. */ tail(list: string): string; tail(list: readonly T[]): T[]; /** * Returns a new list containing the first `n` elements of the given list. If * `n > * list.length`, returns a list of `list.length` elements. */ take(n: number, xs: readonly T[]): T[]; take(n: number, xs: string): string; take(n: number): { (xs: string): string; (xs: readonly T[]): T[]; }; /** * Returns a new list containing the last n elements of the given list. If n > list.length, * returns a list of list.length elements. */ takeLast(n: number, xs: readonly T[]): T[]; takeLast(n: number, xs: string): string; takeLast(n: number): { (xs: readonly T[]): T[]; (xs: string): string; }; /** * Returns a new list containing the last n elements of a given list, passing each value * to the supplied predicate function, and terminating when the predicate function returns * false. Excludes the element that caused the predicate function to fail. The predicate * function is passed one argument: (value). */ takeLastWhile(pred: (a: T) => boolean, list: readonly T[]): T[]; takeLastWhile(pred: (a: T) => boolean): (list: readonly T[]) => T[]; /** * Returns a new list containing the first `n` elements of a given list, passing each value * to the supplied predicate function, and terminating when the predicate function returns * `false`. */ takeWhile(fn: (x: T) => boolean, list: readonly T[]): T[]; takeWhile(fn: (x: T) => boolean): (list: readonly T[]) => T[]; /** * The function to call with x. The return value of fn will be thrown away. */ tap(fn: (a: T) => any, value: T): T; tap(fn: (a: T) => any): (value: T) => T; /** * Determines whether a given string matches a given regular expression. */ test(regexp: RegExp, str: string): boolean; test(regexp: RegExp): (str: string) => boolean; /** * Returns the result of applying the onSuccess function to the value inside a successfully resolved promise. This is useful for working with promises inside function compositions. */ then(onSuccess: (a: A) => B | Promise, promise: Promise): Promise; then(onSuccess: (a: A) => B | Promise): (promise: Promise) => Promise; /** * Creates a thunk out of a function. * A thunk delays a calculation until its result is needed, providing lazy evaluation of arguments. */ thunkify any>(fn: F): F.Curry<(...args: Parameters) => (() => ReturnType)>; /** * Calls an input function `n` times, returning an array containing the results of those * function calls. */ times(fn: (i: number) => T, n: number): T[]; times(fn: (i: number) => T): (n: number) => T[]; /** * The lower case version of a string. */ toLower(str: string): string; /** * Converts an object into an array of key, value arrays. * Only the object's own properties are used. * Note that the order of the output array is not guaranteed to be * consistent across different JS platforms. */ toPairs(obj: { [k: string]: S } | { [k: number]: S }): Array<[string, S]>; /** * Converts an object into an array of key, value arrays. * The object's own properties and prototype properties are used. * Note that the order of the output array is not guaranteed to be * consistent across different JS platforms. */ toPairsIn(obj: { [k: string]: S } | { [k: number]: S }): Array<[string, S]>; /** * Returns the string representation of the given value. eval'ing the output should * result in a value equivalent to the input value. Many of the built-in toString * methods do not satisfy this requirement. * * If the given value is an [object Object] with a toString method other than * Object.prototype.toString, this method is invoked with no arguments to produce the * return value. This means user-defined constructor functions can provide a suitable * toString method. */ toString(val: T): string; /** * The upper case version of a string. */ toUpper(str: string): string; /** * Initializes a transducer using supplied iterator function. Returns a single item by iterating through the * list, successively calling the transformed iterator function and passing it an accumulator value and the * current value from the array, and then passing the result to the next call. */ transduce(xf: (arg: readonly T[]) => T[], fn: (acc: readonly U[], val: U) => U[], acc: readonly T[], list: readonly T[]): U; transduce(xf: (arg: readonly T[]) => T[]): (fn: (acc: readonly U[], val: U) => U[], acc: readonly T[], list: readonly T[]) => U; transduce(xf: (arg: readonly T[]) => T[], fn: (acc: readonly U[], val: U) => U[]): (acc: readonly T[], list: readonly T[]) => U; transduce(xf: (arg: readonly T[]) => T[], fn: (acc: readonly U[], val: U) => U[], acc: readonly T[]): (list: readonly T[]) => U; /** * Transposes the rows and columns of a 2D list. When passed a list of n lists of length x, returns a list of x lists of length n. */ transpose(list: readonly T[][]): T[][]; /** * Maps an Applicative-returning function over a Traversable, then uses * sequence to transform the resulting Traversable of Applicative into * an Applicative of Traversable. */ traverse(of: (a: B) => B[], fn: (t: A) => B[], list: readonly A[]): B[][]; traverse(of: (a: B) => B[], fn: (t: A) => B[]): (list: readonly A[]) => B[][]; traverse(of: (a: B) => B[]): (fn: (t: A) => B[], list: readonly A[]) => B[][]; /** * Removes (strips) whitespace from both ends of the string. */ trim(str: string): string; /** * tryCatch takes two functions, a tryer and a catcher. The returned function evaluates the tryer; if it does * not throw, it simply returns the result. If the tryer does throw, the returned function evaluates the catcher * function and returns its result. Note that for effective composition with this function, both the tryer and * catcher functions must return the same type of results. */ tryCatch(tryer: (...args: readonly any[]) => T, catcher: (...args: readonly any[]) => T): (...args: readonly any[]) => T; /** * Gives a single-word string description of the (native) type of a value, returning such answers as 'Object', * 'Number', 'Array', or 'Null'. Does not attempt to distinguish user Object types any further, reporting them * all as 'Object'. */ type(val: any): 'Object' | 'Number' | 'Boolean' | 'String' | 'Null' | 'Array' | 'RegExp' | 'Function' | 'Undefined'; /** * Takes a function fn, which takes a single array argument, and returns a function which: * - takes any number of positional arguments; * - passes these arguments to fn as an array; and * - returns the result. * In other words, R.unapply derives a variadic function from a function which takes an array. * R.unapply is the inverse of R.apply. */ unapply(fn: (args: readonly any[]) => T): (...args: readonly any[]) => T; /** * Wraps a function of any arity (including nullary) in a function that accepts exactly 1 parameter. * Any extraneous parameters will not be passed to the supplied function. */ unary(fn: (a: T, ...args: readonly any[]) => any): (a: T) => any; /** * Returns a function of arity n from a (manually) curried function. */ uncurryN(len: number, fn: (a: any) => any): (...a: readonly any[]) => T; /** * Builds a list from a seed value. Accepts an iterator function, which returns either false * to stop iteration or an array of length 2 containing the value to add to the resulting * list and the seed to be used in the next call to the iterator function. */ unfold(fn: (seed: T) => [TResult, T] | false, seed: T): TResult[]; unfold(fn: (seed: T) => [TResult, T] | false): (seed: T) => TResult[]; /** * Combines two lists into a set (i.e. no duplicates) composed of the * elements of each list. */ union(as: readonly T[], bs: readonly T[]): T[]; union(as: readonly T[]): (bs: readonly T[]) => T[]; /** * Combines two lists into a set (i.e. no duplicates) composed of the elements of each list. Duplication is * determined according to the value returned by applying the supplied predicate to two list elements. */ unionWith(pred: (a: T, b: T) => boolean, list1: readonly T[], list2: readonly T[]): T[]; unionWith(pred: (a: T, b: T) => boolean): F.Curry<(a: readonly T[], b: readonly T[]) => T[]>; /** * Returns a new list containing only one copy of each element in the original list. */ uniq(list: readonly T[]): T[]; /** * Returns a new list containing only one copy of each element in the original list, * based upon the value returned by applying the supplied function to each list element. * Prefers the first item if the supplied function produces the same value on two items. * R.equals is used for comparison. */ uniqBy(fn: (a: T) => U, list: readonly T[]): T[]; uniqBy(fn: (a: T) => U): (list: readonly T[]) => T[]; /** * Returns a new list containing only one copy of each element in the original list, based upon the value * returned by applying the supplied predicate to two list elements. */ uniqWith(pred: (x: T, y: T) => boolean, list: readonly T[]): T[]; uniqWith(pred: (x: T, y: T) => boolean): (list: readonly T[]) => T[]; /** * Tests the final argument by passing it to the given predicate function. If the predicate is not satisfied, * the function will return the result of calling the whenFalseFn function with the same argument. If the * predicate is satisfied, the argument is returned as is. */ unless(pred: (a: T) => boolean, whenFalseFn: (a: T) => U, obj: T): U; unless(pred: (a: T) => boolean, whenFalseFn: (a: T) => U): (obj: T) => U; /** * Returns a new list by pulling every item at the first level of nesting out, and putting * them in a new array. */ unnest(list: T): T.UnNest; /** * Takes a predicate, a transformation function, and an initial value, and returns a value of the same type as * the initial value. It does so by applying the transformation until the predicate is satisfied, at which point * it returns the satisfactory value. */ until(pred: (val: T) => boolean, fn: (val: T) => U, init: U): U; until(pred: (val: T) => boolean, fn: (val: T) => U): (init: U) => U; /** * Returns a new copy of the array with the element at the provided index replaced with the given value. */ update(index: number, value: T, list: readonly T[]): T[]; update(index: number, value: T): (list: readonly T[]) => T[]; /** * Accepts a function fn and a list of transformer functions and returns a new curried function. * When the new function is invoked, it calls the function fn with parameters consisting of the * result of calling each supplied handler on successive arguments to the new function. * * If more arguments are passed to the returned function than transformer functions, those arguments * are passed directly to fn as additional parameters. If you expect additional arguments that don't * need to be transformed, although you can ignore them, it's best to pass an identity function so * that the new function reports the correct arity. */ useWith(fn: ((...a: readonly any[]) => any), transformers: Array<((...a: readonly any[]) => any)>): (...a: readonly any[]) => any; /** * Returns a list of all the enumerable own properties of the supplied object. * Note that the order of the output array is not guaranteed across * different JS platforms. */ values(obj: T): Array; /** * Returns a list of all the properties, including prototype properties, of the supplied * object. Note that the order of the output array is not guaranteed to be consistent across different JS platforms. */ valuesIn(obj: any): T[]; /** * Returns a "view" of the given data structure, determined by the given lens. The lens's focus determines which * portion of the data structure is visible. */ view(lens: Lens): (obj: T) => U; view(lens: Lens, obj: T): U; /** * Tests the final argument by passing it to the given predicate function. If the predicate is satisfied, the function * will return the result of calling the whenTrueFn function with the same argument. If the predicate is not satisfied, * the argument is returned as is. */ when(pred: (a: T) => boolean, whenTrueFn: (a: T) => U, obj: T): U; when(pred: (a: T) => boolean, whenTrueFn: (a: T) => U): (obj: T) => U; /** * Takes a spec object and a test object and returns true if the test satisfies the spec. * Any property on the spec that is not a function is interpreted as an equality * relation. * * If the spec has a property mapped to a function, then `where` evaluates the function, passing in * the test object's value for the property in question, as well as the whole test object. * * `where` is well suited to declarativley expressing constraints for other functions, e.g., * `filter`, `find`, `pickWith`, etc. */ where(spec: T, testObj: U): boolean; where(spec: T): (testObj: U) => boolean; where(spec: ObjFunc2, testObj: U): boolean; where(spec: ObjFunc2): (testObj: U) => boolean; /** * Takes a spec object and a test object; returns true if the test satisfies the spec, * false otherwise. An object satisfies the spec if, for each of the spec's own properties, * accessing that property of the object gives the same value (in R.eq terms) as accessing * that property of the spec. */ whereEq(spec: T, obj: U): boolean; whereEq(spec: T): (obj: U) => boolean; /** * Returns a new list without values in the first argument. R.equals is used to determine equality. * Acts as a transducer if a transformer is given in list position. */ without(list1: readonly T[], list2: readonly T[]): T[]; without(list1: readonly T[]): (list2: readonly T[]) => T[]; /** * Creates a new list out of the two supplied by creating each possible pair from the lists. */ xprod(as: readonly K[], bs: readonly V[]): Array>; xprod(as: readonly K[]): (bs: readonly V[]) => Array>; /** * Creates a new list out of the two supplied by pairing up equally-positioned items from * both lists. Note: `zip` is equivalent to `zipWith(function(a, b) { return [a, b] })`. */ zip(list1: readonly K[], list2: readonly V[]): Array>; zip(list1: readonly K[]): (list2: readonly V[]) => Array>; /** * Creates a new object out of a list of keys and a list of values. */ // TODO: Dictionary as a return value is to specific, any seems to loose zipObj(keys: readonly string[], values: readonly T[]): { [index: string]: T }; zipObj(keys: readonly string[]): (values: readonly T[]) => { [index: string]: T }; zipObj(keys: readonly number[], values: readonly T[]): { [index: number]: T }; zipObj(keys: readonly number[]): (values: readonly T[]) => { [index: number]: T }; /** * Creates a new list out of the two supplied by applying the function to each * equally-positioned pair in the lists. */ zipWith(fn: (x: T, y: U) => TResult, list1: readonly T[], list2: readonly U[]): TResult[]; zipWith(fn: (x: T, y: U) => TResult, list1: readonly T[]): (list2: readonly U[]) => TResult[]; zipWith(fn: (x: T, y: U) => TResult): (list1: readonly T[], list2: readonly U[]) => TResult[]; } } export = R; export as namespace R;

(prop: P): (obj1: Record, obj2: Record) => boolean; eqProps(prop: string, obj1: T): (obj2: U) => boolean; /** * Returns true if its arguments are equivalent, false otherwise. Dispatches to an equals method if present. * Handles cyclical data structures. */ equals(a: T, b: T): boolean; equals(a: T): (b: T) => boolean; /** * Creates a new object by evolving a shallow copy of object, according to the transformation functions. */ evolve>(transformations: E, obj: V): Evolve; evolve(transformations: E): >(obj: V) => Evolve; /* * A function that always returns false. Any passed in parameters are ignored. */ F(): boolean; /** * Returns a new list containing only those items that match a given predicate function. The predicate function is passed one argument: (value). */ filter: Filter; /** * Returns the first element of the list which matches the predicate, or `undefined` if no * element matches. */ find(fn: (a: T) => boolean, list: readonly T[]): T | undefined; find(fn: (a: T) => boolean): (list: readonly T[]) => T | undefined; /** * Returns the index of the first element of the list which matches the predicate, or `-1` * if no element matches. */ findIndex(fn: (a: T) => boolean, list: readonly T[]): number; findIndex(fn: (a: T) => boolean): (list: readonly T[]) => number; /** * Returns the last element of the list which matches the predicate, or `undefined` if no * element matches. */ findLast(fn: (a: T) => boolean, list: readonly T[]): T | undefined; findLast(fn: (a: T) => boolean): (list: readonly T[]) => T | undefined; /** * Returns the index of the last element of the list which matches the predicate, or * `-1` if no element matches. */ findLastIndex(fn: (a: T) => boolean, list: readonly T[]): number; findLastIndex(fn: (a: T) => boolean): (list: readonly T[]) => number; /** * Returns a new list by pulling every item out of it (and all its sub-arrays) and putting * them in a new array, depth-first. */ flatten(list: T): T.Flatten; /** * Returns a new function much like the supplied one, except that the first two arguments' * order is reversed. */ flip(fn: (arg0: T, arg1: U) => TResult): (arg1: U, arg0?: T) => TResult; flip any, P extends F.Parameters>(fn: F): F.Curry<(...args: T.Merge<[P[1], P[0]], P>) => F.Return>; /** * Iterate over an input list, calling a provided function fn for each element in the list. */ forEach(fn: (x: T) => void, list: readonly T[]): T[]; forEach(fn: (x: T) => void): (list: readonly T[]) => T[]; forEach(fn: (x: T) => void, list: readonly T[]): T[]; forEach(fn: (x: T) => void): (list: readonly T[]) => T[]; /** * Iterate over an input object, calling a provided function fn for each key and value in the object. */ forEachObjIndexed(fn: (value: T[keyof T], key: keyof T, obj: T) => void, obj: T): T; forEachObjIndexed(fn: (value: T[keyof T], key: keyof T, obj: T) => void): (obj: T) => T; /** * Creates a new object out of a list key-value pairs. */ fromPairs(pairs: Array>): { [index: string]: V }; fromPairs(pairs: Array>): { [index: number]: V }; /** * Splits a list into sublists stored in an object, based on the result of * calling a String-returning function * on each element, and grouping the results according to values returned. */ groupBy(fn: (a: T) => string, list: readonly T[]): { [index: string]: T[] }; groupBy(fn: (a: T) => string): (list: readonly T[]) => { [index: string]: T[] }; /** * Takes a list and returns a list of lists where each sublist's elements are all "equal" according to the provided equality function */ groupWith(fn: (x: T, y: T) => boolean): (list: readonly T[]) => T[][]; groupWith(fn: (x: T, y: T) => boolean, list: readonly T[]): T[][]; groupWith(fn: (x: T, y: T) => boolean, list: string): string[]; /** * Returns true if the first parameter is greater than the second. */ gt(__: Placeholder, b: number): (a: number) => boolean; gt(__: Placeholder): (b: number, a: number) => boolean; gt(a: number, b: number): boolean; gt(a: number): (b: number) => boolean; /** * Returns true if the first parameter is greater than or equal to the second. */ gte(__: Placeholder, b: number): (a: number) => boolean; gte(__: Placeholder): (b: number, a: number) => boolean; gte(a: number, b: number): boolean; gte(a: number): (b: number) => boolean; /** * Returns whether or not an object has an own property with the specified name. */ has(__: Placeholder, obj: T): (s: string) => boolean; has(__: Placeholder): (obj: T, s: string) => boolean; has(s: string, obj: T): boolean; has(s: string): (obj: T) => boolean; /** * Returns whether or not an object or its prototype chain has a property with the specified name */ hasIn(s: string, obj: T): boolean; hasIn(s: string): (obj: T) => boolean; /** * Returns whether or not a path exists in an object. Only the object's own properties are checked. */ hasPath(list: readonly string[], obj: T): boolean; hasPath(list: readonly string[]): (obj: T) => boolean; /** * Returns the first element in a list. * In some libraries this function is named `first`. */ head(str: string): string; head(list: readonly []): undefined; head(list: readonly T[]): T | undefined; /** * Returns true if its arguments are identical, false otherwise. Values are identical if they reference the * same memory. NaN is identical to NaN; 0 and -0 are not identical. */ identical(a: T, b: T): boolean; identical(a: T): (b: T) => boolean; /** * A function that does nothing but return the parameter supplied to it. Good as a default * or placeholder function. */ identity(a: T): T; /** * Creates a function that will process either the onTrue or the onFalse function depending upon the result * of the condition predicate. */ ifElse(fn: Pred, onTrue: Arity1Fn, onFalse: Arity1Fn): Arity1Fn; ifElse(fn: Pred, onTrue: Arity2Fn, onFalse: Arity2Fn): Arity2Fn; /** * Increments its argument. */ inc(n: number): number; /** * Given a target, this function checks a list for the target and returns a boolean. * Given a string, this function checks for the string in another string or list and returns * a boolean. */ includes(s: string, list: readonly string[] | string): boolean; includes(s: string): (list: readonly string[] | string) => boolean; includes(target: T, list: readonly T[]): boolean; includes(target: T): (list: readonly T[]) => boolean; /** * Given a function that generates a key, turns a list of objects into an object indexing the objects * by the given key. */ indexBy(fn: (a: T) => string, list: readonly T[]): { [key: string]: T }; indexBy(fn: (a: T) => string): (list: readonly T[]) => { [key: string]: T }; /** * Returns the position of the first occurrence of an item in an array * (by strict equality), * or -1 if the item is not included in the array. */ indexOf(target: T, list: readonly T[]): number; indexOf(target: T): (list: readonly T[]) => number; /** * Returns all but the last element of a list or string. */ init(list: readonly T[]): T[]; init(list: string): string; /** * Takes a predicate `pred`, a list `xs`, and a list `ys`, and returns a list * `xs'` comprising each of the elements of `xs` which is equal to one or more * elements of `ys` according to `pred`. * * `pred` must be a binary function expecting an element from each list. * * `xs`, `ys`, and `xs'` are treated as sets, semantically, so ordering should * not be significant, but since `xs'` is ordered the implementation guarantees * that its values are in the same order as they appear in `xs`. Duplicates are * not removed, so `xs'` may contain duplicates if `xs` contains duplicates. */ innerJoin(pred: (a: T1, b: T2) => boolean, list1: readonly T1[], list2: readonly T2[]): T1[]; innerJoin(pred: (a: T1, b: T2) => boolean): (list1: readonly T1[], list2: readonly T2[]) => T1[]; innerJoin(pred: (a: T1, b: T2) => boolean, list1: readonly T1[]): (list2: readonly T2[]) => T1[]; /** * Inserts the supplied element into the list, at index index. Note that * this is not destructive: it returns a copy of the list with the changes. */ insert(index: number, elt: T, list: readonly T[]): T[]; insert(index: number, elt: T): (list: readonly T[]) => T[]; insert(index: number): (elt: T, list: readonly T[]) => T[]; /** * Inserts the sub-list into the list, at index `index`. _Note that this * is not destructive_: it returns a copy of the list with the changes. */ insertAll(index: number, elts: readonly T[], list: readonly T[]): T[]; insertAll(index: number, elts: readonly T[]): (list: readonly T[]) => T[]; insertAll(index: number): (elts: readonly T[], list: readonly T[]) => T[]; /** * Combines two lists into a set (i.e. no duplicates) composed of those elements common to both lists. */ intersection(list1: readonly T[], list2: readonly T[]): T[]; intersection(list1: readonly T[]): (list2: readonly T[]) => T[]; /** * Combines two lists into a set (i.e. no duplicates) composed of those * elements common to both lists. Duplication is determined according * to the value returned by applying the supplied predicate to two list * elements. */ intersectionWith(pred: (a: T, b: T) => boolean, list1: readonly T[], list2: readonly T[]): T[]; /** * Creates a new list with the separator interposed between elements. */ intersperse(separator: T, list: readonly T[]): T[]; intersperse(separator: T): (list: readonly T[]) => T[]; /** * Transforms the items of the list with the transducer and appends the transformed items to the accumulator * using an appropriate iterator function based on the accumulator type. */ into(acc: any, xf: (...a: readonly any[]) => any, list: readonly T[]): T[]; into(acc: any, xf: (...a: readonly any[]) => any): (list: readonly T[]) => T[]; into(acc: any): (xf: (...a: readonly any[]) => any, list: readonly T[]) => T[]; /** * Same as R.invertObj, however this accounts for objects with duplicate values by putting the values into an array. */ invert(obj: T): { [index: string]: string[] }; /** * Returns a new object with the keys of the given object as values, and the values of the given object as keys. */ invertObj(obj: { [index: string]: string } | { [index: number]: string }): { [index: string]: string }; /** * Turns a named method with a specified arity into a function that can be called directly * supplied with arguments and a target object. * * The returned function is curried and accepts `arity + 1` parameters where the final * parameter is the target object. */ invoker(arity: number, method: string): (...a: readonly any[]) => any; /** * See if an object (`val`) is an instance of the supplied constructor. * This function will check up the inheritance chain, if any. */ is(ctor: any, val: any): boolean; is(ctor: any): (val: any) => boolean; /** * Reports whether the list has zero elements. */ isEmpty(value: any): boolean; /** * Checks if the input value is null or undefined. */ isNil(value: any): value is null | undefined; /** * Returns a string made by inserting the `separator` between each * element and concatenating all the elements into a single string. */ join(x: string, xs: readonly any[]): string; join(x: string): (xs: readonly any[]) => string; /** * Applies a list of functions to a list of values. */ juxt(fns: [(...a: A) => R1, (...a: A) => R2]): (...a: A) => [R1, R2]; juxt(fns: [(...a: A) => R1, (...a: A) => R2, (...a: A) => R3]): (...a: A) => [R1, R2, R3]; juxt(fns: [(...a: A) => R1, (...a: A) => R2, (...a: A) => R3, (...a: A) => R4]): (...a: A) => [R1, R2, R3, R4]; juxt(fns: [(...a: A) => R1, (...a: A) => R2, (...a: A) => R3, (...a: A) => R4, (...a: A) => R5]): (...a: A) => [R1, R2, R3, R4, R5]; juxt(fns: Array<(...args: A) => U>): (...args: A) => U[]; /** * Returns a list containing the names of all the enumerable own * properties of the supplied object. */ keys(x: T): Array; keys(x: T): string[]; /** * Returns a list containing the names of all the * properties of the supplied object, including prototype properties. */ keysIn(obj: T): string[]; /** * Returns the last element from a list. */ last(str: string): string; last(list: readonly []): undefined; last(list: readonly T[]): T | undefined; /** * Returns the position of the last occurrence of an item (by strict equality) in * an array, or -1 if the item is not included in the array. */ lastIndexOf(target: T, list: readonly T[]): number; /** * Returns the number of elements in the array by returning list.length. */ length(list: readonly T[]): number; /** * Returns a lens for the given getter and setter functions. The getter * "gets" the value of the focus; the setter "sets" the value of the focus. * The setter should not mutate the data structure. */ lens(getter: (s: T) => U, setter: (a: U, s: T) => V): Lens; /** * Creates a lens that will focus on index n of the source array. */ lensIndex(n: number): Lens; /** * Returns a lens whose focus is the specified path. * See also view, set, over. */ lensPath(path: Path): Lens; /** * lensProp creates a lens that will focus on property k of the source object. */ lensProp(str: string): { (obj: T): U; set(val: T, obj: U): V; /*map(fn: (...a: readonly any[]) => any, obj: T): T*/ }; /** * "lifts" a function of arity > 1 so that it may "map over" a list, Function or other object that satisfies * the FantasyLand Apply spec. */ lift(fn: ((...a: readonly any[]) => any), ...args: readonly any[]): any; /** * "lifts" a function to be the specified arity, so that it may "map over" that many lists, Functions or other * objects that satisfy the FantasyLand Apply spec. */ liftN(n: number, fn: ((...a: readonly any[]) => any), ...args: readonly any[]): any; /** * Returns true if the first parameter is less than the second. */ lt(__: Placeholder, b: number): (a: number) => boolean; lt(__: Placeholder): (b: number, a: number) => boolean; lt(a: number, b: number): boolean; lt(a: number): (b: number) => boolean; /** * Returns true if the first parameter is less than or equal to the second. */ lte(__: Placeholder, b: number): (a: number) => boolean; lte(__: Placeholder): (b: number, a: number) => boolean; lte(a: number, b: number): boolean; lte(a: number): (b: number) => boolean; /** * Returns a new list, constructed by applying the supplied function to every element of the supplied list. */ map(fn: (x: T) => U, list: readonly T[]): U[]; map(fn: (x: T) => U): (list: readonly T[]) => U[]; map(fn: (x: T[keyof T & keyof U]) => U[keyof T & keyof U], list: T): U; map(fn: (x: T[keyof T & keyof U]) => U[keyof T & keyof U]): (list: T) => U; map(fn: (x: T) => U, obj: Functor): Functor; // used in functors map(fn: (x: T) => U): (obj: Functor) => Functor; // used in functors /** * The mapAccum function behaves like a combination of map and reduce. */ mapAccum(fn: (acc: U, value: T) => [U, TResult], acc: U, list: readonly T[]): [U, TResult[]]; mapAccum(fn: (acc: U, value: T) => [U, TResult]): (acc: U, list: readonly T[]) => [U, TResult[]]; mapAccum(fn: (acc: U, value: T) => [U, TResult], acc: U): (list: readonly T[]) => [U, TResult[]]; /** * The mapAccumRight function behaves like a combination of map and reduce. */ mapAccumRight(fn: (acc: U, value: T) => [U, TResult], acc: U, list: readonly T[]): [U, TResult[]]; mapAccumRight(fn: (acc: U, value: T) => [U, TResult]): (acc: U, list: readonly T[]) => [U, TResult[]]; mapAccumRight(fn: (acc: U, value: T) => [U, TResult], acc: U): (list: readonly T[]) => [U, TResult[]]; /** * Like mapObj, but but passes additional arguments to the predicate function. */ mapObjIndexed( fn: (value: T, key: TKey, obj?: Record) => TResult, obj: Record ): Record; mapObjIndexed( fn: (value: T, key: TKey, obj?: Record) => TResult ): (obj: Record) => Record; mapObjIndexed( fn: (value: T, key: string, obj?: { [key: string]: T }) => TResult, obj: { [key: string]: T } ): { [key: string]: TResult }; mapObjIndexed(fn: (value: T, key: string, obj?: any) => TResult, obj: any): { [index: string]: TResult }; mapObjIndexed(fn: (value: T, key: string, obj?: any) => TResult): (obj: any) => { [index: string]: TResult }; /** * Tests a regular expression agains a String */ match(regexp: RegExp, str: string): any[]; match(regexp: RegExp): (str: string) => any[]; /** * 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. mathMod requires Integer arguments, and returns NaN * when the modulus is zero or negative. */ mathMod(__: Placeholder, b: number): (a: number) => number; mathMod(__: Placeholder): (b: number, a: number) => number; mathMod(a: number, b: number): number; mathMod(a: number): (b: number) => number; /** * Returns the larger of its two arguments. */ max(a: T, b: T): T; max(a: T): (b: T) => T; /** * Takes a function and two values, and returns whichever value produces * the larger result when passed to the provided function. */ maxBy(keyFn: (a: T) => Ord, a: T, b: T): T; maxBy(keyFn: (a: T) => Ord, a: T): (b: T) => T; maxBy(keyFn: (a: T) => Ord): F.Curry<(a: T, b: T) => T>; /** * Returns the mean of the given list of numbers. */ mean(list: readonly number[]): number; /** * Returns the median of the given list of numbers. */ median(list: readonly number[]): number; /** * Creates a new function that, when invoked, caches the result of calling fn for a given argument set and returns the result. * Subsequent calls to the memoized fn with the same argument set will not result in an additional call to fn; instead, the cached result for that set of arguments will be returned. */ memoizeWith any>(keyFn: (...v: Parameters) => string, fn: T): T; /** * Create a new object with the own properties of a * merged with the own properties of object b. * This function will *not* mutate passed-in objects. * * @deprecated since 0.26 in favor of mergeRight */ merge(__: Placeholder, b: O2): (a: O1) => O.Ensure>; merge(__: Placeholder): (b: O2, a: O1) => O.Ensure>; merge(a: O1, b: O2): O.Ensure>; merge(a: O1): (b: O2) => O.Ensure>; /** * Merges a list of objects together into one object. */ mergeAll(list: Os): O.AssignUp<{}, Os> extends infer M ? {} extends M // nothing merged bcs no `as const` ? T.UnionOf // so we output the default types : O.Ensure // otherwise, we can compute `M` : never; /** * Creates a new object with the own properties of the first object merged with the own properties of the second object. * If a key exists in both objects: * and both values are objects, the two values will be recursively merged * otherwise the value from the first object will be used. */ mergeDeepLeft(o1: O1, o2: O2): O.Ensure>; mergeDeepLeft(o1: O1): (o2: O2) => O.Ensure>; /** * Creates a new object with the own properties of the first object merged with the own properties of the second object. * If a key exists in both objects: * and both values are objects, the two values will be recursively merged * otherwise the value from the second object will be used. */ mergeDeepRight(o1: O1, o2: O2): O.Ensure>; mergeDeepRight(a: O1): (o2: O2) => O.Ensure>; /** * Creates a new object with the own properties of the two provided objects. If a key exists in both objects: * and both associated values are also objects then the values will be recursively merged. * otherwise the provided function is applied to associated values using the resulting value as the new value * associated with the key. If a key only exists in one object, the value will be associated with the key of the resulting object. */ mergeDeepWith(fn: (x: any, z: any) => any, a: T1, b: T2): any; mergeDeepWith(fn: (x: any, z: any) => any, a: T1): (b: T2) => any; mergeDeepWith(fn: (x: any, z: any) => any): (a: T1, b: T2) => any; /** * Creates a new object with the own properties of the two provided objects. If a key exists in both objects: * and both associated values are also objects then the values will be recursively merged. * otherwise the provided function is applied to the key and associated values using the resulting value as * the new value associated with the key. If a key only exists in one object, the value will be associated with * the key of the resulting object. */ mergeDeepWithKey(fn: (k: string, x: any, z: any) => any, a: T1, b: T2): any; mergeDeepWithKey(fn: (k: string, x: any, z: any) => any, a: T1): (b: T2) => any; mergeDeepWithKey(fn: (k: string, x: any, z: any) => any): (a: T1, b: T2) => any; /** * Create a new object with the own properties of the first object merged with the own properties of the second object. * If a key exists in both objects, the value from the first object will be used. */ mergeLeft(a: O1, b: O2): O.Ensure>; mergeLeft(a: O1): (b: O2) => O.Ensure>; /** * Create a new object with the own properties of the first object merged with the own properties of the second object. * If a key exists in both objects, the value from the second object will be used. */ mergeRight(a: O1, b: O2): O.Ensure>; mergeRight(a: O1): (b: O2) => O.Ensure>; /** * Creates a new object with the own properties of the two provided objects. If a key exists in both objects, * the provided function is applied to the values associated with the key in each object, with the result being used as * the value associated with the key in the returned object. The key will be excluded from the returned object if the * resulting value is undefined. */ mergeWith(fn: (x: any, z: any) => any, a: U, b: V): any; mergeWith(fn: (x: any, z: any) => any, a: U): (b: V) => any; mergeWith(fn: (x: any, z: any) => any): (a: U, b: V) => any; /** * Creates a new object with the own properties of the two provided objects. If a key exists in both objects, * the provided function is applied to the key and the values associated with the key in each object, with the * result being used as the value associated with the key in the returned object. The key will be excluded from * the returned object if the resulting value is undefined. */ mergeWithKey(fn: (str: string, x: any, z: any) => any, a: U, b: V): any; mergeWithKey(fn: (str: string, x: any, z: any) => any, a: U): (b: V) => any; mergeWithKey(fn: (str: string, x: any, z: any) => any): (a: U, b: V) => any; /** * Returns the smaller of its two arguments. */ min(a: T, b: T): T; min(a: T): (b: T) => T; /** * Takes a function and two values, and returns whichever value produces * the smaller result when passed to the provided function. */ minBy(keyFn: (a: T) => Ord, a: T, b: T): T; minBy(keyFn: (a: T) => Ord, a: T): (b: T) => T; minBy(keyFn: (a: T) => Ord): F.Curry<(a: T, b: T) => T>; /** * Divides the second parameter by the first and returns the remainder. * The flipped version (`moduloBy`) may be more useful curried. * Note that this functions preserves the JavaScript-style behavior for * modulo. For mathematical modulo see `mathMod` */ modulo(__: Placeholder, b: number): (a: number) => number; modulo(__: Placeholder): (b: number, a: number) => number; modulo(a: number, b: number): number; modulo(a: number): (b: number) => number; /** * Multiplies two numbers. Equivalent to a * b but curried. */ multiply(a: number, b: number): number; multiply(a: number): (b: number) => number; /** * Moves an item, at index `from`, to index `to`, in a `list` of elements. * A new list will be created containing the new elements order. */ move(from: number, to: number, list: readonly T[]): T[]; move(from: number, to: number): (list: readonly T[]) => T[]; move(from: number): { (to: number, list: readonly T[]): T[]; (to: number): (list: readonly T[]) => T[]; }; /** * Wraps a function of any arity (including nullary) in a function that accepts exactly n parameters. * Any extraneous parameters will not be passed to the supplied function. */ nAry(n: number, fn: (...arg: readonly any[]) => any): (...a: readonly any[]) => any; nAry(n: number): (fn: (...arg: readonly any[]) => any) => (...a: readonly any[]) => any; /** * Negates its argument. */ negate(n: number): number; /** * Returns true if no elements of the list match the predicate, false otherwise. */ none(fn: (a: T) => boolean, list: readonly T[]): boolean; none(fn: (a: T) => boolean): (list: readonly T[]) => boolean; /** * A function wrapping a call to the given function in a `!` operation. It will return `true` when the * underlying function would return a false-y value, and `false` when it would return a truth-y one. */ not(value: any): boolean; /** * Returns the nth element in a list. */ nth(n: number, list: readonly T[]): T | undefined; nth(n: number): (list: readonly T[]) => T | undefined; /** * Returns a function which returns its nth argument. */ nthArg(n: number): (...a: readonly any[]) => any; /** * o is a curried composition function that returns a unary function. Like compose, o performs right-to-left function composition. * Unlike compose, the rightmost function passed to o will be invoked with only one argument. * Also, unlike compose, o is limited to accepting only 2 unary functions. * The name o was chosen because of its similarity to the mathematical composition operator ∘. */ o(f: (x: T2) => R, g: (x: T1) => T2, v: T1): R; o(f: (x: T2) => R, g: (x: T1) => T2): (v: T1) => R; o( f: (x: T2) => R, ): { (g: (x: T1) => T2, v: T1): R; (g: (x: T1) => T2): (v: T1) => R; }; /** * Creates an object containing a single key:value pair. */ objOf(key: K, value: T): Record; objOf(key: K): (value: T) => Record; /** * Returns a singleton array containing the value provided. */ of(x: T): T[]; /** * Returns a partial copy of an object omitting the keys specified. */ omit(names: readonly K[], obj: T): Omit; omit(names: readonly K[]): (obj: T) => Omit; /** * Accepts a function fn and returns a function that guards invocation of fn such that fn can only ever be * called once, no matter how many times the returned function is invoked. The first value calculated is * returned in subsequent invocations. */ once(fn: (...a: readonly any[]) => any): (...a: readonly any[]) => any; once(fn: (...a: readonly any[]) => T): (...a: readonly any[]) => T; /** * A function that returns the first truthy of two arguments otherwise the last argument. Note that this is * NOT short-circuited, meaning that if expressions are passed they are both evaluated. * Dispatches to the or method of the first argument if applicable. */ or(a: T, b: U): T | U; or(a: T): (b: U) => T | U; or any); }, U>(fn1: T, val2: U): T | U; or any); }>(fn1: T): (val2: U) => T | U; /** * Returns the result of applying the onFailure function to the value inside a failed promise. * This is useful for handling rejected promises inside function compositions. */ otherwise(onError: (error: any) => B | Promise, promise: Promise): Promise; otherwise(onError: (error: any) => B | Promise): (promise: Promise) => Promise; /** * Returns the result of "setting" the portion of the given data structure * focused by the given lens to the given value. */ over(lens: Lens, fn: Arity1Fn, value: T): T; over(lens: Lens, fn: Arity1Fn, value: readonly T[]): T[]; over(lens: Lens, fn: Arity1Fn): (value: T) => T; over(lens: Lens, fn: Arity1Fn): (value: readonly T[]) => T[]; over(lens: Lens): (fn: Arity1Fn, value: T) => T; over(lens: Lens): (fn: Arity1Fn, value: readonly T[]) => T[]; /** * Takes two arguments, fst and snd, and returns [fst, snd]. */ pair(fst: F, snd: S): [F, S]; /** * Takes a function `f` and a list of arguments, and returns a function `g`. * When applied, `g` returns the result of applying `f` to the arguments * provided initially followed by the arguments provided to `g`. */ partial(fn: (x0: V0, x1: V1) => T, args: [V0]): (x1: V1) => T; partial(fn: (x0: V0, x1: V1, x2: V2) => T, args: [V0, V1]): (x2: V2) => T; partial(fn: (x0: V0, x1: V1, x2: V2) => T, args: [V0]): (x1: V1, x2: V2) => T; partial(fn: (x0: V0, x1: V1, x2: V2, x3: V3) => T, args: [V0, V1, V2]): (x2: V3) => T; partial(fn: (x0: V0, x1: V1, x2: V2, x3: V3) => T, args: [V0, V1]): (x2: V2, x3: V3) => T; partial(fn: (x0: V0, x1: V1, x2: V2, x3: V3) => T, args: [V0]): (x1: V1, x2: V2, x3: V3) => T; partial(fn: (...a: readonly any[]) => T, args: readonly any[]): (...a: readonly any[]) => T; /** * Takes a function `f` and a list of arguments, and returns a function `g`. * When applied, `g` returns the result of applying `f` to the arguments * provided to `g` followed by the arguments provided initially. */ partialRight(fn: (x0: V0, x1: V1) => T, args: [V1]): (x1: V0) => T; partialRight(fn: (x0: V0, x1: V1, x2: V2) => T, args: [V1, V2]): (x2: V0) => T; partialRight(fn: (x0: V0, x1: V1, x2: V2) => T, args: [V2]): (x1: V0, x2: V1) => T; partialRight(fn: (x0: V0, x1: V1, x2: V2, x3: V3) => T, args: [V1, V2, V3]): (x0: V0) => T; partialRight(fn: (x0: V0, x1: V1, x2: V2, x3: V3) => T, args: [V2, V3]): (x0: V0, x1: V1) => T; partialRight(fn: (x0: V0, x1: V1, x2: V2, x3: V3) => T, args: [V3]): (x0: V0, x1: V1, x2: V2) => T; partialRight(fn: (...a: readonly any[]) => T, args: readonly any[]): (...a: readonly any[]) => T; /** * Takes a predicate and a list and returns the pair of lists of elements * which do and do not satisfy the predicate, respectively. */ partition(fn: (a: string) => boolean, list: readonly string[]): [string[], string[]]; partition(fn: (a: T) => boolean, list: readonly T[]): [T[], T[]]; partition(fn: (a: T) => boolean): (list: readonly T[]) => [T[], T[]]; partition(fn: (a: string) => boolean): (list: readonly string[]) => [string[], string[]]; /** * Retrieve the value at a given path. */ path(path: Path, obj: any): T | undefined; path(path: Path): (obj: any) => T | undefined; /** * Determines whether a nested path on an object has a specific value, * in `R.equals` terms. Most likely used to filter a list. */ pathEq(path: Path, val: any, obj: any): boolean; pathEq(path: Path, val: any): (obj: any) => boolean; pathEq(path: Path): F.Curry<(a: any, b: any) => boolean>; /** * If the given, non-null object has a value at the given path, returns the value at that path. * Otherwise returns the provided default value. */ pathOr(defaultValue: T, path: Path, obj: any): T; pathOr(defaultValue: T, path: Path): (obj: any) => T; pathOr(defaultValue: T): F.Curry<(a: Path, b: any) => T>; /** * Returns true if the specified object property at given path satisfies the given predicate; false otherwise. */ pathSatisfies(pred: (val: T) => boolean, path: Path, obj: U): boolean; pathSatisfies(pred: (val: T) => boolean, path: Path): (obj: U) => boolean; pathSatisfies(pred: (val: T) => boolean): F.Curry<(a: Path, b: U) => boolean>; /** * Returns a partial copy of an object containing only the keys specified. If the key does not exist, the * property is ignored. */ pick(names: readonly K[], obj: T): Pick>>; pick(names: readonly K[]): (obj: T) => Pick>>; /** * Similar to `pick` except that this one includes a `key: undefined` pair for properties that don't exist. */ pickAll(names: readonly string[], obj: T): U; pickAll(names: readonly string[]): (obj: T) => U; /** * Returns a partial copy of an object containing only the keys that satisfy the supplied predicate. */ pickBy(pred: ObjPred, obj: T): U; pickBy(pred: ObjPred): (obj: T) => U; /** * Creates a new function that runs each of the functions supplied as parameters in turn, * passing the return value of each function invocation to the next function invocation, * beginning with whatever arguments were passed to the initial invocation. */ pipe(fn0: () => T1): () => T1; pipe(fn0: (x0: V0) => T1): (x0: V0) => T1; pipe(fn0: (x0: V0, x1: V1) => T1): (x0: V0, x1: V1) => T1; pipe(fn0: (x0: V0, x1: V1, x2: V2) => T1): (x0: V0, x1: V1, x2: V2) => T1; pipe(fn0: () => T1, fn1: (x: T1) => T2): () => T2; pipe(fn0: (x0: V0) => T1, fn1: (x: T1) => T2): (x0: V0) => T2; pipe(fn0: (x0: V0, x1: V1) => T1, fn1: (x: T1) => T2): (x0: V0, x1: V1) => T2; pipe(fn0: (x0: V0, x1: V1, x2: V2) => T1, fn1: (x: T1) => T2): (x0: V0, x1: V1, x2: V2) => T2; pipe(fn0: () => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3): () => T3; pipe(fn0: (x: V0) => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3): (x: V0) => T3; pipe(fn0: (x0: V0, x1: V1) => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3): (x0: V0, x1: V1) => T3; pipe(fn0: (x0: V0, x1: V1, x2: V2) => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3): (x0: V0, x1: V1, x2: V2) => T3; pipe(fn0: () => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3, fn3: (x: T3) => T4): () => T4; pipe(fn0: (x: V0) => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3, fn3: (x: T3) => T4): (x: V0) => T4; pipe(fn0: (x0: V0, x1: V1) => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3, fn3: (x: T3) => T4): (x0: V0, x1: V1) => T4; pipe(fn0: (x0: V0, x1: V1, x2: V2) => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3, fn3: (x: T3) => T4): (x0: V0, x1: V1, x2: V2) => T4; pipe(fn0: () => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3, fn3: (x: T3) => T4, fn4: (x: T4) => T5): () => T5; pipe(fn0: (x: V0) => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3, fn3: (x: T3) => T4, fn4: (x: T4) => T5): (x: V0) => T5; pipe(fn0: (x0: V0, x1: V1) => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3, fn3: (x: T3) => T4, fn4: (x: T4) => T5): (x0: V0, x1: V1) => T5; pipe(fn0: (x0: V0, x1: V1, x2: V2) => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3, fn3: (x: T3) => T4, fn4: (x: T4) => T5): (x0: V0, x1: V1, x2: V2) => T5; pipe(fn0: () => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3, fn3: (x: T3) => T4, fn4: (x: T4) => T5, fn5: (x: T5) => T6): () => T6; pipe(fn0: (x: V0) => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3, fn3: (x: T3) => T4, fn4: (x: T4) => T5, fn5: (x: T5) => T6): (x: V0) => T6; pipe(fn0: (x0: V0, x1: V1) => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3, fn3: (x: T3) => T4, fn4: (x: T4) => T5, fn5: (x: T5) => T6): (x0: V0, x1: V1) => T6; pipe( fn0: (x0: V0, x1: V1, x2: V2) => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3, fn3: (x: T3) => T4, fn4: (x: T4) => T5, fn5: (x: T5) => T6): (x0: V0, x1: V1, x2: V2) => T6; pipe( fn0: () => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3, fn3: (x: T3) => T4, fn4: (x: T4) => T5, fn5: (x: T5) => T6, fn: (x: T6) => T7): () => T7; pipe( fn0: (x: V0) => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3, fn3: (x: T3) => T4, fn4: (x: T4) => T5, fn5: (x: T5) => T6, fn: (x: T6) => T7): (x: V0) => T7; pipe( fn0: (x0: V0, x1: V1) => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3, fn3: (x: T3) => T4, fn4: (x: T4) => T5, fn5: (x: T5) => T6, fn6: (x: T6) => T7): (x0: V0, x1: V1) => T7; pipe( fn0: (x0: V0, x1: V1, x2: V2) => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3, fn3: (x: T3) => T4, fn4: (x: T4) => T5, fn5: (x: T5) => T6, fn6: (x: T6) => T7): (x0: V0, x1: V1, x2: V2) => T7; pipe( fn0: () => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3, fn3: (x: T3) => T4, fn4: (x: T4) => T5, fn5: (x: T5) => T6, fn6: (x: T6) => T7, fn: (x: T7) => T8): () => T8; pipe( fn0: (x: V0) => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3, fn3: (x: T3) => T4, fn4: (x: T4) => T5, fn5: (x: T5) => T6, fn6: (x: T6) => T7, fn: (x: T7) => T8): (x: V0) => T8; pipe( fn0: (x0: V0, x1: V1) => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3, fn3: (x: T3) => T4, fn4: (x: T4) => T5, fn5: (x: T5) => T6, fn6: (x: T6) => T7, fn7: (x: T7) => T8): (x0: V0, x1: V1) => T8; pipe( fn0: (x0: V0, x1: V1, x2: V2) => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3, fn3: (x: T3) => T4, fn4: (x: T4) => T5, fn5: (x: T5) => T6, fn6: (x: T6) => T7, fn7: (x: T7) => T8): (x0: V0, x1: V1, x2: V2) => T8; pipe( fn0: () => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3, fn3: (x: T3) => T4, fn4: (x: T4) => T5, fn5: (x: T5) => T6, fn6: (x: T6) => T7, fn7: (x: T7) => T8, fn8: (x: T8) => T9): () => T9; pipe( fn0: (x0: V0) => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3, fn3: (x: T3) => T4, fn4: (x: T4) => T5, fn5: (x: T5) => T6, fn6: (x: T6) => T7, fn7: (x: T7) => T8, fn8: (x: T8) => T9): (x0: V0) => T9; pipe( fn0: (x0: V0, x1: V1) => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3, fn3: (x: T3) => T4, fn4: (x: T4) => T5, fn5: (x: T5) => T6, fn6: (x: T6) => T7, fn7: (x: T7) => T8, fn8: (x: T8) => T9): (x0: V0, x1: V1) => T9; pipe( fn0: (x0: V0, x1: V1, x2: V2) => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3, fn3: (x: T3) => T4, fn4: (x: T4) => T5, fn5: (x: T5) => T6, fn6: (x: T6) => T7, fn7: (x: T7) => T8, fn8: (x: T8) => T9): (x0: V0, x1: V1, x2: V2) => T9; pipe( fn0: () => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3, fn3: (x: T3) => T4, fn4: (x: T4) => T5, fn5: (x: T5) => T6, fn6: (x: T6) => T7, fn7: (x: T7) => T8, fn8: (x: T8) => T9, fn9: (x: T9) => T10): () => T10; pipe( fn0: (x0: V0) => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3, fn3: (x: T3) => T4, fn4: (x: T4) => T5, fn5: (x: T5) => T6, fn6: (x: T6) => T7, fn7: (x: T7) => T8, fn8: (x: T8) => T9, fn9: (x: T9) => T10): (x0: V0) => T10; pipe( fn0: (x0: V0, x1: V1) => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3, fn3: (x: T3) => T4, fn4: (x: T4) => T5, fn5: (x: T5) => T6, fn6: (x: T6) => T7, fn7: (x: T7) => T8, fn8: (x: T8) => T9, fn9: (x: T9) => T10): (x0: V0, x1: V1) => T10; pipe( fn0: (x0: V0, x1: V1, x2: V2) => T1, fn1: (x: T1) => T2, fn2: (x: T2) => T3, fn3: (x: T3) => T4, fn4: (x: T4) => T5, fn5: (x: T5) => T6, fn6: (x: T6) => T7, fn7: (x: T7) => T8, fn8: (x: T8) => T9, fn9: (x: T9) => T10): (x0: V0, x1: V1, x2: V2) => T10; /** * Returns the left-to-right Kleisli composition of the provided functions, each of which must return a value of a type supported by chain. * The typings currently support arrays only as return values. * All functions need to be unary. * R.pipeK(f, g, h) is equivalent to R.pipe(f, R.chain(g), R.chain(h)). * * @deprecated since 0.26 in favor of pipeWith(chain) */ pipeK( fn0: (x0: V0) => T1[]): (x0: V0) => T1[]; pipeK( fn0: (x0: V0) => T1[], fn1: (x: T1) => T2[]): (x0: V0) => T2[]; pipeK( fn0: (x: V0) => T1[], fn1: (x: T1) => T2[], fn2: (x: T2) => T3[]): (x: V0) => T3[]; pipeK( fn0: (x: V0) => T1[], fn1: (x: T1) => T2[], fn2: (x: T2) => T3[], fn3: (x: T3) => T4[]): (x: V0) => T4[]; pipeK( fn0: (x: V0) => T1[], fn1: (x: T1) => T2[], fn2: (x: T2) => T3[], fn3: (x: T3) => T4[], fn4: (x: T4) => T5[]): (x: V0) => T5[]; pipeK( fn0: (x: V0) => T1[], fn1: (x: T1) => T2[], fn2: (x: T2) => T3[], fn3: (x: T3) => T4[], fn4: (x: T4) => T5[], fn5: (x: T5) => T6[]): (x: V0) => T6[]; pipeK( fn0: (x: V0) => T1[], fn1: (x: T1) => T2[], fn2: (x: T2) => T3[], fn3: (x: T3) => T4[], fn4: (x: T4) => T5[], fn5: (x: T5) => T6[], fn: (x: T6) => T7[]): (x: V0) => T7[]; pipeK( fn0: (x: V0) => T1[], fn1: (x: T1) => T2[], fn2: (x: T2) => T3[], fn3: (x: T3) => T4[], fn4: (x: T4) => T5[], fn5: (x: T5) => T6[], fn6: (x: T6) => T7[], fn: (x: T7) => T8[]): (x: V0) => T8[]; pipeK( fn0: (x0: V0) => T1[], fn1: (x: T1) => T2[], fn2: (x: T2) => T3[], fn3: (x: T3) => T4[], fn4: (x: T4) => T5[], fn5: (x: T5) => T6[], fn6: (x: T6) => T7[], fn7: (x: T7) => T8[], fn8: (x: T8) => T9[]): (x0: V0) => T9[]; pipeK( fn0: (x0: V0) => T1[], fn1: (x: T1) => T2[], fn2: (x: T2) => T3[], fn3: (x: T3) => T4[], fn4: (x: T4) => T5[], fn5: (x: T5) => T6[], fn6: (x: T6) => T7[], fn7: (x: T7) => T8[], fn8: (x: T8) => T9[], fn9: (x: T9) => T10[]): (x0: V0) => T10[]; /** * Performs left-to-right composition of one or more Promise-returning functions. * All functions need to be unary. * * @deprecated since 0.26 in favor of pipeWith(then) */ pipeP( fn0: (x0: V0) => Promise): (x0: V0) => Promise; pipeP( fn0: (x0: V0) => Promise, fn1: (x: T1) => Promise): (x0: V0) => Promise; pipeP( fn0: (x: V0) => Promise, fn1: (x: T1) => Promise, fn2: (x: T2) => Promise): (x: V0) => Promise; pipeP( fn0: (x: V0) => Promise, fn1: (x: T1) => Promise, fn2: (x: T2) => Promise, fn3: (x: T3) => Promise): (x: V0) => Promise; pipeP( fn0: (x: V0) => Promise, fn1: (x: T1) => Promise, fn2: (x: T2) => Promise, fn3: (x: T3) => Promise, fn4: (x: T4) => Promise): (x: V0) => Promise; pipeP( fn0: (x: V0) => Promise, fn1: (x: T1) => Promise, fn2: (x: T2) => Promise, fn3: (x: T3) => Promise, fn4: (x: T4) => Promise, fn5: (x: T5) => Promise): (x: V0) => Promise; pipeP( fn0: (x: V0) => Promise, fn1: (x: T1) => Promise, fn2: (x: T2) => Promise, fn3: (x: T3) => Promise, fn4: (x: T4) => Promise, fn5: (x: T5) => Promise, fn: (x: T6) => Promise): (x: V0) => Promise; pipeP( fn0: (x: V0) => Promise, fn1: (x: T1) => Promise, fn2: (x: T2) => Promise, fn3: (x: T3) => Promise, fn4: (x: T4) => Promise, fn5: (x: T5) => Promise, fn6: (x: T6) => Promise, fn: (x: T7) => Promise): (x: V0) => Promise; pipeP( fn0: (x0: V0) => Promise, fn1: (x: T1) => Promise, fn2: (x: T2) => Promise, fn3: (x: T3) => Promise, fn4: (x: T4) => Promise, fn5: (x: T5) => Promise, fn6: (x: T6) => Promise, fn7: (x: T7) => Promise, fn8: (x: T8) => Promise): (x0: V0) => Promise; pipeP( fn0: (x0: V0) => Promise, fn1: (x: T1) => Promise, fn2: (x: T2) => Promise, fn3: (x: T3) => Promise, fn4: (x: T4) => Promise, fn5: (x: T5) => Promise, fn6: (x: T6) => Promise, fn7: (x: T7) => Promise, fn8: (x: T8) => Promise, fn9: (x: T9) => Promise): (x0: V0) => Promise; /* * Performs left-to-right function composition using transforming function. * With the current typings, all functions must be unary. */ pipeWith(composer: (a: any) => any, fns: PipeWithFns): (x0: V0) => T; pipeWith(composer: (a: any) => any): (fns: PipeWithFns) => (x0: V0) => T; /** * Returns a new list by plucking the same named property off all objects in the list supplied. */ pluck(p: K, list: readonly T[]): Array; pluck(p: number, list: Array<{ [k: number]: T }>): T[]; pluck