@types/ramda

Functions

• add()
• addIndex()
• adjust()
• all()
• allPass()
• always()
• and()
• andThen()
• any()
• anyPass()
• ap()
• aperture()
• append()
• apply()
• applySpec()
• applyTo()
• ascend()
• assoc()
• assocPath()
• binary()
• bind()
• both()
• call()
• chain()
• clamp()
• clone()
• collectBy()
• comparator()
• complement()
• compose()
• composeWith()
• concat()
• cond()
• construct()
• constructN()
• converge()
• count()
• countBy()
• curry()
• curryN()
• dec()
• defaultTo()
• descend()
• difference()
• differenceWith()
• dissoc()
• dissocPath()
• divide()
• drop()
• dropLast()
• dropLastWhile()
• dropRepeats()
• dropRepeatsWith()
• dropWhile()
• either()
• empty()
• endsWith()
• eqBy()
• eqProps()
• equals()
• evolve()
• F()
• filter()
• find()
• findIndex()
• findLast()
• findLastIndex()
• flatten()
• flip()
• forEach()
• forEachObjIndexed()
• fromPairs()
• groupBy()
• groupWith()
• gt()
• gte()
• has()
• hasIn()
• hasPath()
• head()
• identical()
• identity()
• ifElse()
• inc()
• includes()
• indexBy()
• indexOf()
• init()
• innerJoin()
• insert()
• insertAll()
• intersection()
• intersperse()
• into()
• invert()
• invertObj()
• invoker()
• is()
• isEmpty()
• isNil()
• join()
• juxt()
• keys()
• keysIn()
• last()
• lastIndexOf()
• length()
• lens()
• lensIndex()
• lensPath()
• lensProp()
• lift()
• liftN()
• lt()
• lte()
• map()
• mapAccum()
• mapAccumRight()
• mapObjIndexed()
• match()
• mathMod()
• max()
• maxBy()
• mean()
• median()
• memoizeWith()
• mergeAll()
• mergeDeepLeft()
• mergeDeepRight()
• mergeDeepWith()
• mergeDeepWithKey()
• mergeLeft()
• mergeRight()
• mergeWith()
• mergeWithKey()
• min()
• minBy()
• modify()
• modulo()
• move()
• multiply()
• nAry()
• negate()
• none()
• not()
• nth()
• nthArg()
• o()
• objOf()
• of()
• omit()
• on()
• once()
• or()
• otherwise()
• over()
• pair()
• partial()
• partialObject()
• partialRight()
• partition()
• path()
• pathEq()
• pathOr()
• paths()
• pathSatisfies()
• pick()
• pickAll()
• pickBy()
• pipe()
• pipeWith()
• pluck()
• prepend()
• product()
• project()
• promap()
• prop()
• propEq()
• propIs()
• propOr()
• props()
• propSatisfies()
• range()
• reduce()
• reduceBy()
• reduced()
• reduceRight()
• reduceWhile()
• reject()
• remove()
• repeat()
• replace()
• reverse()
• scan()
• set()
• slice()
• sort()
• sortBy()
• sortWith()
• split()
• splitAt()
• splitEvery()
• splitWhen()
• splitWhenever()
• startsWith()
• subtract()
• sum()
• symmetricDifference()
• symmetricDifferenceWith()
• T()
• tail()
• take()
• takeLast()
• takeLastWhile()
• takeWhile()
• tap()
• test()
• thunkify()
• times()
• toLower()
• toPairs()
• toPairsIn()
• toString()
• toUpper()
• transduce()
• transpose()
• traverse()
• trim()
• tryCatch()
• type()
• unapply()
• unary()
• uncurryN()
• unfold()
• union()
• unionWith()
• uniq()
• uniqBy()
• uniqWith()
• unless()
• unnest()
• until()
• update()
• useWith()
• values()
• valuesIn()
• view()
• when()
• where()
• whereEq()
• without()
• xor()
• xprod()
• zip()
• zipObj()
• zipWith()

Interfaces

• ArrayLike

  • nodeType
• CharList

  • push()
• Dictionary
• Find
• Reduced

  • '@@transducer/reduced'
  • '@@transducer/value'

Type Aliases

• AnyConstructor
• AnyFunction
• Arity0Fn
• Arity1Fn
• Arity2Fn
• AssocPartialOne
• AtLeastOneFunctionsFlow
• AtLeastOneFunctionsFlowFromRightToLeft
• CondPair
• CondPairTypeguard
• EQ
• Evolvable
• Evolve
• Evolver
• Falsy
• Fn
• Functor
• GT
• IfFunctionsArgumentsDoNotOverlap
• InputTypesOfFns
• KeyValuePair
• LargestArgumentsList
• Lens
• LT
• Merge
• MergeAll
• mergeArrWithLeft
• ObjectHavingSome
• ObjPred
• Ord
• Ordering
• Path
• Placeholder
• Pred
• PredTypeguard
• Prop
• ReturnTypesOfFns
• Take
• ToTupleOfArray
• ToTupleOfFunction
• Tuple
• ValueOfRecord
• ValueOfUnion

function add

add: { (a: number, b: number): number; (a: number): (b: number) => number };

• Adds two values. Equivalent to a + b but curried.

  Example 1

  R.add(2, 3);       //=>  5
  R.add(7)(10);      //=> 17

function addIndex

addIndex: {
    <T>(fn: (f: (item: T) => void, list: readonly T[]) => T[]): _.F.Curry<
        (a: (item: T, idx: number, list: T[]) => void, b: readonly T[]) => T[]
    >;
    <T>(fn: (f: (item: T) => boolean, list: readonly T[]) => T[]): _.F.Curry<
        (a: (item: T, idx: number, list: T[]) => boolean, b: readonly T[]) => T[]
    >;
    <T, U>(fn: (f: (item: T) => U, list: readonly T[]) => U[]): _.F.Curry<
        (a: (item: T, idx: number, list: T[]) => U, b: readonly T[]) => U[]
    >;
    <T, U>(
        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
    >;
};

• 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.

  This would turn, for instance, function into one that more closely resembles Array.prototype.map.

  This will only work for functions in which the iteration callback function is the first parameter, and where the list is the last parameter. (This latter might be unimportant if the list parameter is not used.)

  See also subtract.

  Example 1

  const mapIndexed = R.addIndex(R.map);
  mapIndexed((val, idx) => idx + '-' + val, ['f', 'o', 'o', 'b', 'a', 'r']);
  //=> ['0-f', '1-o', '2-o', '3-b', '4-a', '5-r']

function adjust

adjust: {
    <T>(index: number, fn: (a: T) => T, list: readonly T[]): T[];
    <T>(index: number, fn: (a: T) => T): (list: readonly T[]) => T[];
};

• 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.

  See also update.

  Example 1

  R.adjust(1, R.toUpper, ['a', 'b', 'c', 'd']);      //=> ['a', 'B', 'c', 'd']
  R.adjust(-1, R.toUpper, ['a', 'b', 'c', 'd']);     //=> ['a', 'b', 'c', 'D']

function all

all: {
    <T>(fn: (a: T) => boolean, list: readonly T[]): boolean;
    <T>(fn: (a: T) => boolean): (list: readonly T[]) => boolean;
};

• Returns true if all elements of the list match the predicate, false if there are any that don't.

  Dispatches to the all method of the second argument, if present.

  Acts as a transducer if a transformer is given in list position.

  See also any, none, transduce.

  Example 1

  const equals3 = R.equals(3);
  R.all(equals3)([3, 3, 3, 3]); //=> true
  R.all(equals3)([3, 3, 1, 3]); //=> false

function allPass

allPass: {
    <T, TF1 extends T, TF2 extends T>(
        preds: [PredTypeguard<T, TF1>, PredTypeguard<T, TF2>]
    ): (a: T) => a is TF1 & TF2;
    <T, TF1 extends T, TF2 extends T, TF3 extends T>(
        preds: [PredTypeguard<T, TF1>, PredTypeguard<T, TF2>, PredTypeguard<T, TF3>]
    ): (a: T) => a is TF1 & TF2 & TF3;
    <T, TF1 extends T, TF2 extends T, TF3 extends T>(
        preds: [PredTypeguard<T, TF1>, PredTypeguard<T, TF2>, PredTypeguard<T, TF3>]
    ): (a: T) => a is TF1 & TF2 & TF3;
    <T, TF1 extends T, TF2 extends T, TF3 extends T, TF4 extends T>(
        preds: [
            PredTypeguard<T, TF1>,
            PredTypeguard<T, TF2>,
            PredTypeguard<T, TF3>,
            PredTypeguard<T, TF4>
        ]
    ): (a: T) => a is TF1 & TF2 & TF3 & TF4;
    <T, TF1 extends T, TF2 extends T, TF3 extends T, TF4 extends T, TF5 extends T>(
        preds: [
            PredTypeguard<T, TF1>,
            PredTypeguard<T, TF2>,
            PredTypeguard<T, TF3>,
            PredTypeguard<T, TF4>,
            PredTypeguard<T, TF5>
        ]
    ): PredTypeguard<T, TF1 & TF2 & TF3 & TF4 & TF5>;
    <
        T,
        TF1 extends T,
        TF2 extends T,
        TF3 extends T,
        TF4 extends T,
        TF5 extends T,
        TF6 extends T
    >(
        preds: [
            PredTypeguard<T, TF1>,
            PredTypeguard<T, TF2>,
            PredTypeguard<T, TF3>,
            PredTypeguard<T, TF4>,
            PredTypeguard<T, TF5>,
            PredTypeguard<T, TF6>
        ]
    ): PredTypeguard<T, TF1 & TF2 & TF3 & TF4 & TF5 & TF6>;
    <F extends Pred<any[]>>(preds: readonly F[]): F;
};

• Takes a list of predicates and returns a predicate that returns true for a given list of arguments if every one of the provided predicates is satisfied by those arguments.

  The function returned is a curried function whose arity matches that of the highest-arity predicate.

  See also anyPass.

  Example 1

  type Card = { rank: string; suit: string; };
  
  const isQueen = R.propEq('rank', 'Q');
  const isSpade = R.propEq('suit', '♠︎');
  const isQueenOfSpades = R.allPass<R.Pred<[Card]>>([isQueen, isSpade]);
  
  isQueenOfSpades({rank: 'Q', suit: '♣︎'}); //=> false
  isQueenOfSpades({rank: 'Q', suit: '♠︎'}); //=> true

function always

always: <T>(val: T) => (...args: unknown[]) => T;

• Returns a function that always returns the given value.

  For non-primitives the value returned is a reference to the original value.

  This function is known as const, constant, or K (for K combinator) in other languages and libraries.

  Example 1

  const t = R.always('Tee');
  t(); //=> 'Tee'

function and

and: { <T, U>(a: T, b: U): T | U; <T>(a: T): <U>(b: U) => T | U };

• A function that returns the first argument if it's falsy otherwise the second argument.

  See also both, or, xor.

  This is **not** short-circuited, meaning that if expressions are passed they are both evaluated.

  Example 1

  R.and(true, true); //=> true
  R.and(true, false); //=> false
  R.and(false, true); //=> false
  R.and(false, false); //=> false

function andThen

andThen: {
    <A, B>(onSuccess: (a: A) => B | Promise<B>, promise: Promise<A>): Promise<B>;
    <A, B>(onSuccess: (a: A) => B | Promise<B>): (promise: Promise<A>) => Promise<B>;
};

• 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.

  See also otherwise.

  Example 1

  type Query = { query: { email: string; }; };
  
  const makeQuery = (email: string) => ({ query: { email }});
  const fetchMember = (request: Query) =>
    Promise.resolve({ firstName: 'Bob', lastName: 'Loblaw', id: 42 });
  
  //getMemberName :: String -> Promise ({ firstName, lastName })
  const getMemberName = R.pipe(
    makeQuery,
    fetchMember,
    R.andThen(R.pick(['firstName', 'lastName']))
  );
  
  getMemberName('bob@gmail.com').then(console.log);

function any

any: {
    <T>(fn: (a: T) => boolean, list: readonly T[]): boolean;
    <T>(fn: (a: T) => boolean): (list: readonly T[]) => boolean;
};

• Returns true if at least one of elements of the list match the predicate, false otherwise.

  Dispatches to the any method of the second argument, if present.

  Acts as a transducer if a transformer is given in list position.

  See also all, none, transduce.

  Example 1

  const lessThan0 = R.flip(R.lt)(0);
  const lessThan2 = R.flip(R.lt)(2);
  R.any(lessThan0)([1, 2]); //=> false
  R.any(lessThan2)([1, 2]); //=> true

function anyPass

anyPass: {
    <T, TF1 extends T, TF2 extends T>(
        preds: [PredTypeguard<T, TF1>, PredTypeguard<T, TF2>]
    ): (a: T) => a is TF1 | TF2;
    <T, TF1 extends T, TF2 extends T, TF3 extends T>(
        preds: [PredTypeguard<T, TF1>, PredTypeguard<T, TF2>, PredTypeguard<T, TF3>]
    ): (a: T) => a is TF1 | TF2 | TF3;
    <T, TF1 extends T, TF2 extends T, TF3 extends T>(
        preds: [PredTypeguard<T, TF1>, PredTypeguard<T, TF2>, PredTypeguard<T, TF3>]
    ): (a: T) => a is TF1 | TF2 | TF3;
    <T, TF1 extends T, TF2 extends T, TF3 extends T, TF4 extends T>(
        preds: [
            PredTypeguard<T, TF1>,
            PredTypeguard<T, TF2>,
            PredTypeguard<T, TF3>,
            PredTypeguard<T, TF4>
        ]
    ): (a: T) => a is TF1 | TF2 | TF3 | TF4;
    <T, TF1 extends T, TF2 extends T, TF3 extends T, TF4 extends T, TF5 extends T>(
        preds: [
            PredTypeguard<T, TF1>,
            PredTypeguard<T, TF2>,
            PredTypeguard<T, TF3>,
            PredTypeguard<T, TF4>,
            PredTypeguard<T, TF5>
        ]
    ): PredTypeguard<T, TF1 | TF2 | TF3 | TF4 | TF5>;
    <
        T,
        TF1 extends T,
        TF2 extends T,
        TF3 extends T,
        TF4 extends T,
        TF5 extends T,
        TF6 extends T
    >(
        preds: [
            PredTypeguard<T, TF1>,
            PredTypeguard<T, TF2>,
            PredTypeguard<T, TF3>,
            PredTypeguard<T, TF4>,
            PredTypeguard<T, TF5>,
            PredTypeguard<T, TF6>
        ]
    ): PredTypeguard<T, TF1 | TF2 | TF3 | TF4 | TF5 | TF6>;
    <F extends Pred<any[]>>(preds: readonly F[]): F;
};

• Takes a list of predicates and returns a predicate that returns true for a given list of arguments if at least one of the provided predicates is satisfied by those arguments.

  The function returned is a curried function whose arity matches that of the highest-arity predicate.

  See also allPass.

  Example 1

  type Card = { rank: string; suit: string; };
  
  const isClub = R.propEq('suit', '♣');
  const isSpade = R.propEq('suit', '♠');
  const isBlackCard = R.anyPass<R.Pred<[Card]>>([isClub, isSpade]);
  
  isBlackCard({rank: '10', suit: '♣'}); //=> true
  isBlackCard({rank: 'Q', suit: '♠'}); //=> true
  isBlackCard({rank: 'Q', suit: '♦'}); //=> false

function ap

ap: {
    <T, U>(fns: readonly ((a: T) => U)[], vs: readonly T[]): U[];
    <T, U>(fns: readonly ((a: T) => U)[]): (vs: readonly T[]) => U[];
    <R, A, B>(fn: (r: R, a: A) => B, fn1: (r: R) => A): (r: R) => B;
};

• ap applies a list of functions to a list of values.

  Dispatches to the ap method of the first argument, if present. Also treats curried functions as applicatives.

  Example 1

  R.ap([R.multiply(2), R.add(3)], [1,2,3]); //=> [2, 4, 6, 4, 5, 6]
  R.ap([R.concat('tasty '), R.toUpper], ['pizza', 'salad']); //=> ["tasty pizza", "tasty salad", "PIZZA", "SALAD"]
  
  // R.ap can also be used as S combinator
  // when only two functions are passed
  R.ap((s, s2) => R.concat(s, s2), R.toUpper)('Ramda') //=> 'RamdaRAMDA'

function aperture

aperture: {
    <N extends number, T>(n: N, list: readonly T[]): Array<Tuple<T, N>> | [];
    <N extends number>(n: N): <T>(list: readonly T[]) => [] | Tuple<T, N>[];
};

• 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.

  Acts as a transducer if a transformer is given in list position.

  See also transduce.

  Example 1

  R.aperture(2, [1, 2, 3, 4, 5]); //=> [[1, 2], [2, 3], [3, 4], [4, 5]]
  R.aperture(3, [1, 2, 3, 4, 5]); //=> [[1, 2, 3], [2, 3, 4], [3, 4, 5]]
  R.aperture(7, [1, 2, 3, 4, 5]); //=> []

function append

append: {
    <T>(el: T, list: readonly T[]): T[];
    <T>(el: T): (list: readonly T[]) => T[];
};

• Returns a new list containing the contents of the given list, followed by the given element.

  See also prepend.

  Example 1

  R.append('tests', ['write', 'more']); //=> ['write', 'more', 'tests']
  R.append('tests', []); //=> ['tests']
  R.append<string | string[]>(['tests'], ['write', 'more']); //=> ['write', 'more', ['tests']]

function apply

apply: {
    <F extends AnyFunction>(fn: F, args: Parameters<F>): ReturnType<F>;
    <F extends AnyFunction>(fn: F): (args: Parameters<F>) => ReturnType<F>;
};

• 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.

  See also call, unapply.

function applySpec

applySpec: {
    <Obj extends Record<string, AnyFunction>>(obj: Obj): (
        ...args: Parameters<Obj[keyof Obj]>
    ) => { [Key in keyof Obj]: ReturnType<Obj[Key]> };
    <T>(obj: any): (...args: unknown[]) => T;
};

• 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.

  See also converge, juxt.

  Example 1

  const getMetrics = R.applySpec({
    sum: R.add,
    nested: { mul: R.multiply }
  });
  getMetrics(2, 4); // => { sum: 6, nested: { mul: 8 } }

function applyTo

applyTo: {
    <T, U>(el: T, fn: (t: T) => U): U;
    <T>(el: T): <U>(fn: (t: T) => U) => U;
};

• Takes a value and applies a function to it.

  This function is also known as the thrush combinator.

  Example 1

  const t42 = R.applyTo(42);
  t42(R.identity); //=> 42
  t42(R.add(1)); //=> 43

function ascend

ascend: {
    <T>(fn: (obj: T) => Ord, a: T, b: T): Ordering;
    <T>(fn: (obj: T) => Ord): (a: T, b: T) => Ordering;
};

• Makes an ascending comparator function out of a function that returns a value that can be compared with < and >.

  See also descend.

  Example 1

  const byAge = R.ascend(R.prop<number>('age'));
  const people = [
    { name: 'Emma', age: 70 },
    { name: 'Peter', age: 78 },
    { name: 'Mikhail', age: 62 },
  ];
  const peopleByYoungestFirst = R.sort(byAge, people);
    //=> [{ name: 'Mikhail', age: 62 },{ name: 'Emma', age: 70 }, { name: 'Peter', age: 78 }]

function assoc

assoc: {
    <T, U>(__: Placeholder, val: T, obj: U): <K extends string>(
        prop: K
    ) => K extends keyof U
        ? T extends U[K]
            ? U
            : Record<K, T> & Omit<U, K>
        : Record<K, T> & Omit<U, K>;
    <U, K extends keyof U>(prop: K, __: any, obj: U): <T>(
        val: T
    ) => T extends U[K] ? U : Record<K, T> & Omit<U, K>;
    <U, K extends string>(prop: K, __: any, obj: U): <T>(
        val: T
    ) => Record<K, T> & Omit<U, K>;
    <K extends keyof U, U>(prop: K, val: U[K], obj: U): U;
    <T, U, K extends string>(prop: K, val: T, obj: U): Record<K, T> & Omit<U, K>;
    <T, K extends string>(prop: K, val: T): <U>(obj: U) => Record<K, T> & Omit<U, K>;
    <K extends string>(prop: K): AssocPartialOne<K>;
};

• Makes a shallow clone of an object, setting or overriding the specified property with the given value.

  This copies and flattens prototype properties onto the new object as well. All non-primitive properties are copied by reference.

  See also dissoc, pick.

  Example 1

  R.assoc('c', 3, {a: 1, b: 2}); //=> {a: 1, b: 2, c: 3}

function assocPath

assocPath: {
    <T, U>(__: Placeholder, val: T, obj: U): (path: Path) => U;
    <T, U>(path: Path, __: any, obj: U): (val: T) => U;
    <T, U>(path: Path, val: T, obj: U): U;
    <T, U>(path: Path, val: T): (obj: U) => U;
    <T, U>(path: Path): _.F.Curry<(a: T, b: U) => U>;
};

• 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.

  This copies and flattens prototype properties onto the new object as well. All non-primitive properties are copied by reference.

  See also dissocPath.

  Example 1

  R.assocPath(['a', 'b', 'c'], 42, {a: {b: {c: 0}}}); //=> {a: {b: {c: 42}}}
  
  // Any missing or non-object keys in path will be overridden
  R.assocPath(['a', 'b', 'c'], 42, {a: 5}); //=> {a: {b: {c: 42}}}

function binary

binary: <T extends AnyFunction>(
    fn: T
) => (...arg: _.T.Take<Parameters<T>, '2'>) => ReturnType<T>;

• 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.

  See also nAry, unary.

  Example 1

  const takesThreeArgs = function(a: number, b: number, c: number) {
    return [a, b, c];
  };
  takesThreeArgs.length; //=> 3
  takesThreeArgs(1, 2, 3); //=> [1, 2, 3]
  
  const takesTwoArgs = R.binary(takesThreeArgs);
  takesTwoArgs.length; //=> 2
  // Only 2 arguments are passed to the wrapped function
  // @ts-expect-error TypeScript is designed to not let you do this
  takesTwoArgs(1, 2, 3); //=> [1, 2, undefined]

function bind

bind: {
    <F extends AnyFunction, T>(fn: F, thisObj: T): (
        ...args: Parameters<F>
    ) => ReturnType<F>;
    <F extends AnyFunction, T>(fn: F): (
        thisObj: T
    ) => (...args: Parameters<F>) => ReturnType<F>;
};

• Creates a function that is bound to a context.

  R.bind does not provide the additional argument-binding capabilities of Function.prototype.bind.

  Example 1

  const log = R.bind(console.log, console);
  R.pipe(R.assoc('a', 2), R.tap(log), R.assoc('a', 3))({a: 1}); //=> {a: 3}
  // logs {a: 2}

function both

both: {
    <T, TF1 extends T, TF2 extends T>(
        pred1: PredTypeguard<T, TF1>,
        pred2: PredTypeguard<T, TF2>
    ): (a: T) => a is TF1 & TF2;
    <T extends Pred<any[]>>(pred1: T, pred2: T): T;
    <T extends Pred<any[]>>(pred1: T): (pred2: T) => T;
};

• A function which calls the two provided functions and returns the && of the results. It returns the result of the first function if it is falsy and the result of the second function otherwise.

  This is short-circuited, meaning that the second function will not be invoked if the first returns a falsy value.

  In addition to functions, R.both also accepts any fantasy-land compatible applicative functor.

  See also either, and.

  Example 1

  const gt10 = R.gt(R.__, 10)
  const lt20 = R.lt(R.__, 20)
  const f = R.both(gt10, lt20);
  f(15); //=> true
  f(30); //=> false

function call

call: <T extends AnyFunction>(fn: T, ...args: Parameters<T>) => ReturnType<T>;

• Returns the result of calling its first argument with the remaining arguments. This is occasionally useful as a converging function for : the first branch can produce a function while the remaining branches produce values to be passed to that function as its arguments.

  See also apply.

  Example 1

  R.call<(a: number, b: number) => number>(R.add, 1, 2); //=> 3
  
  const indentN = R.pipe(
    R.repeat(' '),
    R.join(''),
    R.replace(/^(?!$)/gm)
  );

function chain

chain: {
    <A, B, T = never>(fn: (n: A) => readonly B[], list: readonly A[]): B[];
    <A, B, T = never>(fn: (n: A) => readonly B[]): (list: readonly A[]) => B[];
    <A, Ma extends { chain: (fn: (a: A) => Mb) => Mb }, Mb>(
        fn: (a: A) => Mb,
        monad: Ma
    ): Mb;
    <A, Ma extends { chain: (fn: (a: A) => Mb) => Mb }, Mb>(fn: (a: A) => Mb): (
        monad: Ma
    ) => Mb;
    <A, B, R>(aToMb: (a: A, r: R) => B, Ma: (r: R) => A): (r: R) => B;
    <A, B, R>(aToMb: (a: A, r: R) => B): (Ma: (r: R) => A) => (r: R) => B;
};

• chain maps a function over a list and concatenates the results. chain is also known as flatMap in some libraries.

  Dispatches to the chain method of the second argument, if present, according to the FantasyLand Chain spec.

  If second argument is a function, chain(f, g)(x) is equivalent to f(g(x), x).

  Acts as a transducer if a transformer is given in list position.

  See also transduce.

  Example 1

  const duplicate = <T>(n: T) => [n, n];
  R.chain(duplicate, [1, 2, 3]); //=> [1, 1, 2, 2, 3, 3]
  
  R.chain(R.append, R.head)([1, 2, 3]); //=> [1, 2, 3, 1]

function clamp

clamp: {
    <T>(min: T, max: T, value: T): T;
    <T>(min: T, max: T): (value: T) => T;
    <T>(min: T): (max: T, value: T) => T;
    <T>(min: T): (max: T) => (value: T) => T;
};

• Restricts a number to be within a range. Also works for other ordered types such as strings and Dates.

  Example 1

  R.clamp(1, 10, -5) // => 1
  R.clamp(1, 10, 15) // => 10
  R.clamp(1, 10, 4)  // => 4

function clone

clone: { <T>(value: T): T; <T>(value: readonly T[]): T[] };

• Creates a deep copy of the source that can be used in place of the source object without retaining any references to it. The source object may contain (nested) Arrays and Objects, numbers, strings, booleans and Dates. Functions are assigned by reference rather than copied.

  Dispatches to a clone method if present.

  Note that if the source object has multiple nodes that share a reference, the returned object will have the same structure, but the references will be pointed to the location within the cloned value.

  Example 1

  const objects = [{}, {}, {}];
  const objectsClone = R.clone(objects);
  objects === objectsClone; //=> false
  objects[0] === objectsClone[0]; //=> false

function collectBy

collectBy: {
    <T, K extends PropertyKey>(keyFn: (value: T) => K, list: readonly T[]): T[][];
    <T, K extends PropertyKey>(keyFn: (value: T) => K): (
        list: readonly T[]
    ) => T[][];
};