A special placeholder value used to specify "gaps" within curried functions, allowing partial application of any combination of arguments, regardless of their positions.

If g is a curried ternary function and _ is R.__, the following are equivalent:

• g(1, 2, 3)
• g(_, 2, 3)(1)
• g(_, _, 3)(1)(2)
• g(_, _, 3)(1, 2)
• g(_, 2, _)(1, 3)
• g(_, 2)(1)(3)
• g(_, 2)(1, 3)
• g(_, 2)(_, 3)(1)

Adds two values.

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, R.map function into one that more closely resembles Array.prototype.map. Note that 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.)

As with addIndex, addIndexRight 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.

Unlike addIndex, addIndexRight iterates from the right to the left.

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.

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.

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.

Returns a function that always returns the given value. Note that 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.

Returns the first argument if it is falsy, otherwise the second argument. Acts as the boolean and statement if both inputs are Booleans.

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.

Returns true if at least one of the 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.

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.

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.

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.

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

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.

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.

Takes a value and applies a function to it.

This function is also known as the thrush combinator.

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

Makes an ascending comparator function out of a function that returns a value that can be compared with natural sorting using localeCompare.

Makes a shallow clone of an object, setting or overriding the specified property with the given value. Note that this copies and flattens prototype properties onto the new object as well. All non-primitive properties are copied by reference.

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. Note that this copies and flattens prototype properties onto the new object as well. All non-primitive properties are copied by reference.

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.

Creates a function that is bound to a context. Note: R.bind does not provide the additional argument-binding capabilities of Function.prototype.bind.

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

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

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

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.

Restricts a number to be within a range.

Also works for other ordered types such as Strings and Dates.

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.

Splits a list into sub-lists, based on the result of calling a key-returning function on each element, and grouping the results according to values returned.

Makes a comparator function out of a function that reports whether the first element is less than the second.

Takes a function f and returns a function g such that if called with the same arguments when f returns a "truthy" value, g returns false and when f returns a "falsy" value g returns true.

R.complement may be applied to any functor

Performs right-to-left function composition. The last argument may have any arity; the remaining arguments must be unary.

Note: The result of compose is not automatically curried.

Performs right-to-left function composition using transforming function. The last function may have any arity; the remaining functions must be unary. Unlike compose, functions are passed in an array.

Note: The result of composeWith is not automatically curried. Transforming function is not used on the last argument.

Returns the result of concatenating the given lists or strings.

Note: R.concat expects both arguments to be of the same type, unlike the native Array.prototype.concat method. It will throw an error if you concat an Array with a non-Array value.

Dispatches to the concat method of the first argument, if present. Can also concatenate two members of a fantasy-land compatible semigroup.

Returns a function, fn, which encapsulates if/else, if/else, ... logic. R.cond takes a list of [predicate, transformer] 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.

Please note: This is not a direct substitute for a switch statement. Remember that both elements of every pair passed to cond are functions, and cond returns a function.

Wraps a constructor function inside a curried function that can be called with the same arguments and returns the same type.

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.

Accepts a converging function and a list of branching functions and returns a new function. The arity of the new function is the same as the arity of the longest branching function. When invoked, this new function is applied to some arguments, and 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.

Returns the number of items in a given list matching the predicate f

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.

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

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. If f is a ternary function and g is R.curry(f), the following are equivalent:

• g(1)(2)(3)
• g(1)(2, 3)
• g(1, 2)(3)
• g(1, 2, 3)

Secondly, the special placeholder value R.__ may be used to specify "gaps", allowing partial application of any combination of arguments, regardless of their positions. If g is as above and _ is R.__, the following are equivalent:

• g(1, 2, 3)
• g(_, 2, 3)(1)
• g(_, _, 3)(1)(2)
• g(_, _, 3)(1, 2)
• g(_, 2)(1)(3)
• g(_, 2)(1, 3)
• g(_, 2)(_, 3)(1)

Please note that default parameters don't count towards a function arity and therefore curry won't work well with those.

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. If g is R.curryN(3, f), the following are equivalent:

• g(1)(2)(3)
• g(1)(2, 3)
• g(1, 2)(3)
• g(1, 2, 3)

Secondly, the special placeholder value R.__ may be used to specify "gaps", allowing partial application of any combination of arguments, regardless of their positions. If g is as above and _ is R.__, the following are equivalent:

• g(1, 2, 3)
• g(_, 2, 3)(1)
• g(_, _, 3)(1)(2)
• g(_, _, 3)(1, 2)
• g(_, 2)(1)(3)
• g(_, 2)(1, 3)
• g(_, 2)(_, 3)(1)

Decrements its argument.

Returns the second argument if it is not null, undefined or NaN; otherwise the first argument is returned.

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

Makes a descending comparator function out of a function that returns a value that can be compared with natural sorting using localeCompare.

Finds the set (i.e. no duplicates) of all elements in the first list not contained in the second list. Objects and Arrays are compared in terms of value equality, not reference equality.

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.

Returns a new object that does not contain a prop property.

Makes a shallow clone of an object, omitting the property at the given path. Note that this copies and flattens prototype properties onto the new object as well. All non-primitive properties are copied by reference.

Divides two numbers. Equivalent to a / b.

Returns all but the first n elements of the given list, string, or transducer/transformer (or object with a drop method).

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

Returns a list containing all but the last n elements of the given list.

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

Returns a new list excluding all the tailing elements of a given list which satisfy the supplied predicate function. It passes each value from the right to the supplied predicate function, skipping elements until the predicate function returns a falsy value. The predicate function is applied to one argument: (value).

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

Returns a new list without any consecutively repeating elements. R.equals is used to determine equality.

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

Returns a new list without any consecutively repeating elements, based upon the value returned by applying the supplied function to each list element. R.equals is used to determine equality.

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

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.

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

Returns a new list excluding the leading elements of a given list which satisfy the supplied predicate function. It passes each value to the supplied predicate function, skipping elements while the predicate function returns true. The predicate function is applied to one argument: (value).

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

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

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.

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

Returns the empty value of its argument's type. Ramda defines the empty value of Array ([]), Object ({}), String (''), TypedArray (Uint8Array [], Float32Array [], etc), and Arguments. Other types are supported if they define <Type>.empty, <Type>.prototype.empty or implement the FantasyLand Monoid spec.

Dispatches to the empty method of the first argument, if present.

Checks if a list ends with the provided sublist.

Similarly, checks if a string ends with the provided substring.

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.

Reports whether two objects have the same value, in R.equals terms, for the specified property. Useful as a curried predicate.

Returns true if its arguments are equivalent, false otherwise. Handles cyclical data structures.

Dispatches symmetrically to the equals methods of both arguments, if present.

Creates a new object by recursively evolving a shallow copy of object, according to the transformation functions. All non-primitive properties are copied by reference.

A transformation function will not be invoked if its corresponding key does not exist in the evolved object.

A function that always returns false. Any passed in parameters are ignored.

Takes a predicate and a Filterable, and returns a new filterable of the same type containing the members of the given filterable which satisfy the given predicate. Filterable objects include plain objects or any object that has a filter method such as Array.

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

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

Returns the first element of the list which matches the predicate, or undefined if no element matches.

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

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

Returns the index of the first element of the list which matches the predicate, or -1 if no element matches.

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

Returns the last element of the list which matches the predicate, or undefined if no element matches.

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

Returns the index of the last element of the list which matches the predicate, or -1 if no element matches.

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

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.

Returns a new function much like the supplied one, except that the first two arguments' order is reversed.

Takes the value of an expression and applies it to a function which is the left-to-right serial composition of the functions given in the second argument.

The functions in the pipeline should be unary functions.

flow is helps to avoid introducing an extra function with named arguments for computing the result of a function pipeline which depends on given initial values. Rather than defining a referential transparent function f = (_x, _y) => R.pipe(g(_x), h(_y), …) which is only later needed once z = f(x, y), the introduction of f, _x and _y can be avoided: z = flow(x, [g, h(y),…]

In some libraries this function is named pipe.

Iterate over an input list, calling a provided function fn for each element in the list.

fn receives one argument: (value).

Note: R.forEach does not skip deleted or unassigned indices (sparse arrays), unlike the native Array.prototype.forEach method. For more details on this behavior, see: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach#Description

Also note that, unlike Array.prototype.forEach, Ramda's forEach returns the original array. In some libraries this function is named each.

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

Iterate over an input object, calling a provided function fn for each key and value in the object.

fn receives three argument: (value, key, obj).

Creates a new object from a list key-value pairs. If a key appears in multiple pairs, the rightmost pair is included in the object.

Splits a list into sub-lists stored in an object, based on the result of calling a key-returning function on each element, and grouping the results according to values returned.

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

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

Takes a list and returns a list of lists where each sublist's elements are all satisfied pairwise comparison according to the provided function. Only adjacent elements are passed to the comparison function.

Returns true if the first argument is greater than the second; false otherwise.

Returns true if the first argument is greater than or equal to the second; false otherwise.

Returns whether or not an object has an own property with the specified name

Returns whether or not an object or its prototype chain has a property with the specified name

Returns whether or not a path exists in an object. Only the object's own properties are checked.

Returns the first element of the given list or string. In some libraries this function is named first.

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.

Note this is merely a curried version of ES6 Object.is.

identical does not support the __ placeholder.

A function that does nothing but return the parameter supplied to it. Good as a default or placeholder function.

Creates a function that will process either the onTrue or the onFalse function depending upon the result of the condition predicate.

Note that ifElse takes its arity from the longest of the three functions passed to it.

Increments its argument.

Returns true if the specified value is equal, in R.equals terms, to at least one element of the given list; false otherwise. Also works with strings.

Given a function that generates a key, turns a list of objects into an object indexing the objects by the given key. Note that if multiple objects generate the same value for the indexing key only the last value will be included in the generated object.

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

Returns the position of the first occurrence of an item in an array, or -1 if the item is not included in the array. R.equals is used to determine equality.

Returns all but the last element of the given list or 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.

Inserts the supplied element into the list, at the specified index. Note that this is not destructive: it returns a copy of the list with the changes. No lists have been harmed in the application of this function.

Inserts the sub-list into the list, at the specified index. Note that this is not destructive: it returns a copy of the list with the changes. No lists have been harmed in the application of this function.

Combines two lists into a set (i.e. no duplicates) composed of those elements common to both lists.

Creates a new list with the separator interposed between elements.

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

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.

The accumulator can be an array, string, object or a transformer. Iterated items will be appended to arrays and concatenated to strings. Objects will be merged directly or 2-item arrays will be merged as key, value pairs.

The accumulator can also be a transformer object that provides a 2-arity reducing iterator function, step, 0-arity initial value function, init, and 1-arity result extraction function result. The step function is used as the iterator function in reduce. The result function is used to convert the final accumulator into the return type and in most cases is R.identity. The init function is used to provide the initial accumulator.

The iteration is performed with R.reduce after initializing the transducer.

Same as R.invertObj, however this accounts for objects with duplicate values by putting the values into an array.

Returns a new object with the keys of the given object as values, and the values of the given object, which are coerced to strings, as keys. Note that the last key found is preferred when handling the same value.

Given an arity (Number) and a name (String) the invoker function returns a curried function that takes arity arguments and a context object. It will "invoke" the name'd function (a method) on the context object.

See if an object (i.e. val) is an instance of the supplied constructor. This function will check up the inheritance chain, if any. If val was created using Object.create, R.is(Object, val) === true.

Returns true if the given value is its type's empty value; false otherwise.

Checks if the input value is null or undefined.

Returns false if the given value is its type's empty value; true otherwise.

Checks if the input value is not null and not undefined.

Returns a string made by inserting the separator between each element and concatenating all the elements into a single string.

juxt applies a list of functions to a list of values.

Returns a list containing the names of all the enumerable own properties of the supplied object. Note that the order of the output array is not guaranteed to be consistent across different JS platforms.

Returns a list containing the names of all the properties of the supplied object, including prototype properties. Note that the order of the output array is not guaranteed to be consistent across different JS platforms.

Returns the last element of the given list or string.

Returns the position of the last occurrence of an item in an array, or -1 if the item is not included in the array. R.equals is used to determine equality.

Returns the number of elements in the array by returning list.length.

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.

Returns a lens whose focus is the specified index.

Returns a lens whose focus is the specified path.

Returns a lens whose focus is the specified property.

"lifts" a function of arity >= 1 so that it may "map over" a list, Function or other object that satisfies the FantasyLand Apply spec.

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

Returns true if the first argument is less than the second; false otherwise.

Returns true if the first argument is less than or equal to the second; false otherwise.

Takes a function and a functor, applies the function to each of the functor's values, and returns a functor of the same shape.

Ramda provides suitable map implementations for Array and Object, so this function may be applied to [1, 2, 3] or {x: 1, y: 2, z: 3}.

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

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

Also treats functions as functors and will compose them together.

The mapAccum function behaves like a combination of map and reduce; it applies a function to each element of a list, passing an accumulating parameter from left to right, and returning a final value of this accumulator together with the new list.

The iterator function receives two arguments, acc and value, and should return a tuple [acc, value].

The mapAccumRight function behaves like a combination of map and reduce; it applies a function to each element of a list, passing an accumulating parameter from right to left, and returning a final value of this accumulator together with the new list.

Similar to mapAccum, except moves through the input list from the right to the left.

The iterator function receives two arguments, acc and value, and should return a tuple [acc, value].

An Object-specific version of map. The function is applied to three arguments: (value, key, obj). If only the value is significant, use map instead.

Tests a regular expression against a String. Note that this function will return an empty array when there are no matches. This differs from String.prototype.match which returns null when there are no matches.

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.

Returns the larger of its two arguments.

Takes a function and two values, and returns whichever value produces the larger result when passed to the provided function.

Returns the mean of the given list of numbers.

Returns the median of the given list of numbers.

Takes a string-returning function keyGen and a function fn and returns a new function that returns cached results for subsequent calls with the same arguments.

When the function is invoked, keyGen is applied to the same arguments and its result becomes the cache key. If the cache contains something under that key, the function simply returns it and does not invoke fn at all.

Otherwise fn is applied to the same arguments and its return value is cached under that key and returned by the function.

Care must be taken when implementing keyGen to avoid key collision, or if tracking references, memory leaks and mutating arguments.

Creates one new object with the own properties from a list of objects. If a key exists in more than one object, the value from the last object it exists in will be used.

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.

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.

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.

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.

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.

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.

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.

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.