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)var greet = R.replace('{name}', R.__, 'Hello, {name}!');
greet('Alice'); //=> 'Hello, Alice!' Number → Number → Number
a b Adds two values.
See also subtract.
R.add(2, 3); //=> 5 R.add(7)(10); //=> 17
((a … → b) … → [a] → *) → (a …, Int, [a] → b) … → [a] → *)
fn A list iteration function that does not pass index or list to its callback
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, Ramda's simple 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.)
var 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']
(a → a) → Number → [a] → [a]
fn The function to apply.
idx The index.
list An array-like object whose value at the supplied index will be replaced.
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.
R.adjust(R.add(10), 1, [1, 2, 3]); //=> [1, 12, 3] R.adjust(R.add(10))(1)([1, 2, 3]); //=> [1, 12, 3]
(a → Boolean) → [a] → Boolean
fn The predicate function.
list The array to consider.
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.
var equals3 = R.equals(3); R.all(equals3)([3, 3, 3, 3]); //=> true R.all(equals3)([3, 3, 1, 3]); //=> false
[(*… → Boolean)] → (*… → Boolean)
predicates An array of predicates to check
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.
var isQueen = R.propEq('rank', 'Q');
var isSpade = R.propEq('suit', '♠︎');
var isQueenOfSpades = R.allPass([isQueen, isSpade]);
isQueenOfSpades({rank: 'Q', suit: '♣︎'}); //=> false
isQueenOfSpades({rank: 'Q', suit: '♠︎'}); //=> true a → (* → a)
val The value to wrap in a function
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.
var t = R.always('Tee');
t(); //=> 'Tee' a → b → a | b
a b Returns true if both arguments are true; false otherwise.
See also both.
R.and(true, true); //=> true R.and(true, false); //=> false R.and(false, true); //=> false R.and(false, false); //=> false
(a → Boolean) → [a] → Boolean
fn The predicate function.
list The array to consider.
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.
var lessThan0 = R.flip(R.lt)(0); var lessThan2 = R.flip(R.lt)(2); R.any(lessThan0)([1, 2]); //=> false R.any(lessThan2)([1, 2]); //=> true
[(*… → Boolean)] → (*… → Boolean)
predicates An array of predicates to check
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.
var isClub = R.propEq('suit', '♣');
var isSpade = R.propEq('suit', '♠');
var isBlackCard = R.anyPass([isClub, isSpade]);
isBlackCard({rank: '10', suit: '♣'}); //=> true
isBlackCard({rank: 'Q', suit: '♠'}); //=> true
isBlackCard({rank: 'Q', suit: '♦'}); //=> false [a → b] → [a] → [b]
Apply f => f (a → b) → f a → f bfns An array of functions
vs An array of values
ap applies a list of functions to a list of values.
Dispatches to the ap method of the second argument, if present. Also treats curried functions as applicatives.
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"] Number → [a] → [[a]]
n The size of the tuples to create
list The list to split into n-length tuples
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.
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]); //=> []
a → [a] → [a]
el The element to add to the end of the new list.
list The list of elements to add a new item to. list.
Returns a new list containing the contents of the given list, followed by the given element.
See also prepend.
R.append('tests', ['write', 'more']); //=> ['write', 'more', 'tests']
R.append('tests', []); //=> ['tests']
R.append(['tests'], ['write', 'more']); //=> ['write', 'more', ['tests']] (*… → a) → [*] → a
fn The function which will be called with args
args The arguments to call fn with
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.
var nums = [1, 2, 3, -99, 42, 6, 7]; R.apply(Math.max, nums); //=> 42
{k: ((a, b, …, m) → v)} → ((a, b, …, m) → {k: v}) spec an object recursively mapping properties to functions for producing the values for these properties.
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.
var getMetrics = R.applySpec({
sum: R.add,
nested: { mul: R.multiply }
});
getMetrics(2, 4); // => { sum: 6, nested: { mul: 8 } } Ord b => (a → b) → a → a → Number
fn A function of arity one that returns a value that can be compared
a The first item to be compared.
b The second item to be compared.
Makes an ascending comparator function out of a function that returns a value that can be compared with < and >.
var byAge = R.ascend(R.prop('age'));
var people = [
// ...
];
var peopleByYoungestFirst = R.sort(byAge, people); String → a → {k: v} → {k: v} prop The property name to set
val The new value
obj The object to clone
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.
See also dissoc.
R.assoc('c', 3, {a: 1, b: 2}); //=> {a: 1, b: 2, c: 3} [Idx] → a → {a} → {a} Idx = String | Intpath the path to set
val The new value
obj The object to clone
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.
See also dissocPath.
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}}} (* → c) → (a, b → c)
fn The function to wrap.
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.
var takesThreeArgs = function(a, b, c) {
return [a, b, c];
};
takesThreeArgs.length; //=> 3
takesThreeArgs(1, 2, 3); //=> [1, 2, 3]
var takesTwoArgs = R.binary(takesThreeArgs);
takesTwoArgs.length; //=> 2
// Only 2 arguments are passed to the wrapped function
takesTwoArgs(1, 2, 3); //=> [1, 2, undefined] (* → *) → {*} → (* → *) fn The function to bind to context
thisObj The context to bind fn to
Creates a function that is bound to a context. Note: R.bind does not provide the additional argument-binding capabilities of Function.prototype.bind.
See also partial.
var 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} (*… → Boolean) → (*… → Boolean) → (*… → Boolean)
f A predicate
g Another predicate
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.
See also and.
var gt10 = R.gt(R.__, 10) var lt20 = R.lt(R.__, 20) var f = R.both(gt10, lt20); f(15); //=> true f(30); //=> false
(*… → a),*… → a
fn The function to apply to the remaining arguments.
args Any number of positional arguments.
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.
See also apply.
R.call(R.add, 1, 2); //=> 3
var indentN = R.pipe(R.times(R.always(' ')),
R.join(''),
R.replace(/^(?!$)/gm));
var format = R.converge(R.call, [
R.pipe(R.prop('indent'), indentN),
R.prop('value')
]);
format({indent: 2, value: 'foo\nbar\nbaz\n'}); //=> ' foo\n bar\n baz\n' Chain m => (a → m b) → m a → m b
fn The function to map with
list The list to map over
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.
var duplicate = n => [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]
Ord a => a → a → a → a
minimum The lower limit of the clamp (inclusive)
maximum The upper limit of the clamp (inclusive)
value Value to be clamped
Restricts a number to be within a range.
Also works for other ordered types such as Strings and Dates.
R.clamp(1, 10, -5) // => 1 R.clamp(1, 10, 15) // => 10 R.clamp(1, 10, 4) // => 4
{*} → {*} value The object or array to clone
Creates a deep copy of the value which 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.
var objects = [{}, {}, {}];
var objectsClone = R.clone(objects);
objects === objectsClone; //=> false
objects[0] === objectsClone[0]; //=> false (a, b → Boolean) → (a, b → Number)
pred A predicate function of arity two which will return true if the first argument is less than the second, false otherwise
Makes a comparator function out of a function that reports whether the first element is less than the second.
var byAge = R.comparator((a, b) => a.age < b.age); var people = [ // ... ]; var peopleByIncreasingAge = R.sort(byAge, people);
(*… → *) → (*… → Boolean)
f 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
See also not.
var isNotNil = R.complement(R.isNil); isNil(null); //=> true isNotNil(null); //=> false isNil(7); //=> false isNotNil(7); //=> true
((y → z), (x → y), …, (o → p), ((a, b, …, n) → o)) → ((a, b, …, n) → z)
...functions The functions to compose
Performs right-to-left function composition. The rightmost function may have any arity; the remaining functions must be unary.
Note: The result of compose is not automatically curried.
See also pipe.
var classyGreeting = (firstName, lastName) => "The name's " + lastName + ", " + firstName + " " + lastName
var yellGreeting = R.compose(R.toUpper, classyGreeting);
yellGreeting('James', 'Bond'); //=> "THE NAME'S BOND, JAMES BOND"
R.compose(Math.abs, R.add(1), R.multiply(2))(-4) //=> 7 Chain m => ((y → m z), (x → m y), …, (a → m b)) → (a → m z)
...functions The functions to compose
Returns the right-to-left Kleisli composition of the provided functions, each of which must return a value of a type supported by chain.
R.composeK(h, g, f) is equivalent to R.compose(R.chain(h), R.chain(g), R.chain(f)).
See also pipeK.
// get :: String -> Object -> Maybe *
var get = R.curry((propName, obj) => Maybe(obj[propName]))
// getStateCode :: Maybe String -> Maybe String
var getStateCode = R.composeK(
R.compose(Maybe.of, R.toUpper),
get('state'),
get('address'),
get('user'),
);
getStateCode({"user":{"address":{"state":"ny"}}}); //=> Maybe.Just("NY")
getStateCode({}); //=> Maybe.Nothing() ((y → Promise z), (x → Promise y), …, (a → Promise b)) → (a → Promise z)
functions The functions to compose
Performs right-to-left composition of one or more Promise-returning functions. The rightmost function may have any arity; the remaining functions must be unary.
See also pipeP.
var db = {
users: {
JOE: {
name: 'Joe',
followers: ['STEVE', 'SUZY']
}
}
}
// We'll pretend to do a db lookup which returns a promise
var lookupUser = (userId) => Promise.resolve(db.users[userId])
var lookupFollowers = (user) => Promise.resolve(user.followers)
lookupUser('JOE').then(lookupFollowers)
// followersForUser :: String -> Promise [UserId]
var followersForUser = R.composeP(lookupFollowers, lookupUser);
followersForUser('JOE').then(followers => console.log('Followers:', followers))
// Followers: ["STEVE","SUZY"] [a] → [a] → [a]
String → String → StringfirstList The first list
secondList The second list
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.
R.concat('ABC', 'DEF'); // 'ABCDEF'
R.concat([4, 5, 6], [1, 2, 3]); //=> [4, 5, 6, 1, 2, 3]
R.concat([], []); //=> [] [[(*… → Boolean),(*… → *)]] → (*… → *)
pairs A list of [predicate, transformer]
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.
var fn = R.cond([
[R.equals(0), R.always('water freezes at 0°C')],
[R.equals(100), R.always('water boils at 100°C')],
[R.T, temp => 'nothing special happens at ' + temp + '°C']
]);
fn(0); //=> 'water freezes at 0°C'
fn(50); //=> 'nothing special happens at 50°C'
fn(100); //=> 'water boils at 100°C' (* → {*}) → (* → {*}) fn The constructor function to wrap.
Wraps a constructor function inside a curried function that can be called with the same arguments and returns the same type.
// Constructor function
function Animal(kind) {
this.kind = kind;
};
Animal.prototype.sighting = function() {
return "It's a " + this.kind + "!";
}
var AnimalConstructor = R.construct(Animal)
// Notice we no longer need the 'new' keyword:
AnimalConstructor('Pig'); //=> {"kind": "Pig", "sighting": function (){...}};
var animalTypes = ["Lion", "Tiger", "Bear"];
var animalSighting = R.invoker(0, 'sighting');
var sightNewAnimal = R.compose(animalSighting, AnimalConstructor);
R.map(sightNewAnimal, animalTypes); //=> ["It's a Lion!", "It's a Tiger!", "It's a Bear!"] Number → (* → {*}) → (* → {*}) n The arity of the constructor function.
Fn The constructor function to wrap.
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.
// Variadic Constructor function
function Salad() {
this.ingredients = arguments;
};
Salad.prototype.recipe = function() {
var instructions = R.map((ingredient) => (
'Add a whollop of ' + ingredient, this.ingredients)
)
return R.join('\n', instructions)
}
var ThreeLayerSalad = R.constructN(3, Salad)
// Notice we no longer need the 'new' keyword, and the constructor is curried for 3 arguments.
var salad = ThreeLayerSalad('Mayonnaise')('Potato Chips')('Ketchup')
console.log(salad.recipe());
// Add a whollop of Mayonnaise
// Add a whollop of Potato Chips
// Add a whollop of Potato Ketchup a → [a] → Boolean
a The item to compare against.
list The array to consider.
Returns true if the specified value is equal, in R.equals terms, to at least one element of the given list; false otherwise.
See also any.
R.contains(3, [1, 2, 3]); //=> true
R.contains(4, [1, 2, 3]); //=> false
R.contains({ name: 'Fred' }, [{ name: 'Fred' }]); //=> true
R.contains([42], [[42]]); //=> true (x1 → x2 → … → z) → [(a → b → … → x1), (a → b → … → x2), …] → (a → b → … → z)
after A function. after will be invoked with the return values of fn1 and fn2 as its arguments.
functions A list of functions.
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.
See also useWith.
var average = R.converge(R.divide, [R.sum, R.length])
average([1, 2, 3, 4, 5, 6, 7]) //=> 4
var strangeConcat = R.converge(R.concat, [R.toUpper, R.toLower])
strangeConcat("Yodel") //=> "YODELyodel" (a → String) → [a] → {*} fn The function used to map values to keys.
list The list to count elements from.
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.
var numbers = [1.0, 1.1, 1.2, 2.0, 3.0, 2.2];
R.countBy(Math.floor)(numbers); //=> {'1': 3, '2': 2, '3': 1}
var letters = ['a', 'b', 'A', 'a', 'B', 'c'];
R.countBy(R.toLower)(letters); //=> {'a': 3, 'b': 2, 'c': 1} (* → a) → (* → a)
fn The function to curry.
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) See also curryN.
var addFourNumbers = (a, b, c, d) => a + b + c + d; var curriedAddFourNumbers = R.curry(addFourNumbers); var f = curriedAddFourNumbers(1, 2); var g = f(3); g(4); //=> 10
Number → (* → a) → (* → a)
length The arity for the returned function.
fn The function to 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. 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) See also curry.
var sumArgs = (...args) => R.sum(args); var curriedAddFourNumbers = R.curryN(4, sumArgs); var f = curriedAddFourNumbers(1, 2); var g = f(3); g(4); //=> 10
Number → Number
n Decrements its argument.
See also inc.
R.dec(42); //=> 41
a → b → a | b
default The default value.
val val will be returned instead of default unless val is null, undefined or NaN.
Returns the second argument if it is not null, undefined or NaN otherwise the first argument is returned.
var defaultTo42 = R.defaultTo(42);
defaultTo42(null); //=> 42
defaultTo42(undefined); //=> 42
defaultTo42('Ramda'); //=> 'Ramda'
// parseInt('string') results in NaN
defaultTo42(parseInt('string')); //=> 42 Ord b => (a → b) → a → a → Number
fn A function of arity one that returns a value that can be compared
a The first item to be compared.
b The second item to be compared.
Makes a descending comparator function out of a function that returns a value that can be compared with < and >.
var byAge = R.descend(R.prop('age'));
var people = [
// ...
];
var peopleByOldestFirst = R.sort(byAge, people); [*] → [*] → [*]
list1 The first list.
list2 The second list.
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 are compared in terms of value equality, not reference equality.
See also differenceWith, symmetricDifference, symmetricDifferenceWith.
R.difference([1,2,3,4], [7,6,5,4,3]); //=> [1,2]
R.difference([7,6,5,4,3], [1,2,3,4]); //=> [7,6,5]
R.difference([{a: 1}, {b: 2}], [{a: 1}, {c: 3}]) //=> [{b: 2}] ((a, a) → Boolean) → [a] → [a] → [a]
pred A predicate used to test whether two items are equal.
list1 The first list.
list2 The second list.
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.
See also difference, symmetricDifference, symmetricDifferenceWith.
var cmp = (x, y) => x.a === y.a;
var l1 = [{a: 1}, {a: 2}, {a: 3}];
var l2 = [{a: 3}, {a: 4}];
R.differenceWith(cmp, l1, l2); //=> [{a: 1}, {a: 2}] String → {k: v} → {k: v} prop The name of the property to dissociate
obj The object to clone
Returns a new object that does not contain a prop property.
See also assoc.
R.dissoc('b', {a: 1, b: 2, c: 3}); //=> {a: 1, c: 3} [String] → {k: v} → {k: v} path The path to the value to omit
obj The object to clone
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.
See also assocPath.
R.dissocPath(['a', 'b', 'c'], {a: {b: {c: 42}}}); //=> {a: {b: {}}} Number → Number → Number
a The first value.
b The second value.
Divides two numbers. Equivalent to a / b.
See also multiply.
R.divide(71, 100); //=> 0.71 var half = R.divide(R.__, 2); half(42); //=> 21 var reciprocal = R.divide(1); reciprocal(4); //=> 0.25
Number → [a] → [a]
Number → String → Stringn list 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.
See also take, transduce, dropLast, dropWhile.
R.drop(1, ['foo', 'bar', 'baz']); //=> ['bar', 'baz'] R.drop(2, ['foo', 'bar', 'baz']); //=> ['baz'] R.drop(3, ['foo', 'bar', 'baz']); //=> [] R.drop(4, ['foo', 'bar', 'baz']); //=> [] R.drop(3, 'ramda'); //=> 'da'
Number → [a] → [a]
Number → String → Stringn The number of elements of list to skip.
list The list of elements to consider.
Returns a list containing all but the last n elements of the given list.
See also takeLast, drop, dropWhile, dropLastWhile.
R.dropLast(1, ['foo', 'bar', 'baz']); //=> ['foo', 'bar'] R.dropLast(2, ['foo', 'bar', 'baz']); //=> ['foo'] R.dropLast(3, ['foo', 'bar', 'baz']); //=> [] R.dropLast(4, ['foo', 'bar', 'baz']); //=> [] R.dropLast(3, 'ramda'); //=> 'ra'
(a → Boolean) → [a] → [a]
predicate The function to be called on each element
list The collection to iterate over.
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).
See also takeLastWhile, addIndex, drop, dropWhile.
var lteThree = x => x <= 3; R.dropLastWhile(lteThree, [1, 2, 3, 4, 3, 2, 1]); //=> [1, 2, 3, 4]
[a] → [a]
list The array to consider.
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.
See also transduce.
R.dropRepeats([1, 1, 1, 2, 3, 4, 4, 2, 2]); //=> [1, 2, 3, 4, 2]
(a, a → Boolean) → [a] → [a]
pred A predicate used to test whether two items are equal.
list The array to consider.
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.
See also transduce.
var l = [1, -1, 1, 3, 4, -4, -4, -5, 5, 3, 3]; R.dropRepeatsWith(R.eqBy(Math.abs), l); //=> [1, 3, 4, -5, 3]
(a → Boolean) → [a] → [a]
fn The function called per iteration.
list The collection to iterate over.
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.
See also takeWhile, transduce, addIndex.
var lteTwo = x => x <= 2; R.dropWhile(lteTwo, [1, 2, 3, 4, 3, 2, 1]); //=> [3, 4, 3, 2, 1]
(*… → Boolean) → (*… → Boolean) → (*… → Boolean)
f a predicate
g another predicate
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.
See also or.
var gt10 = x => x > 10; var even = x => x % 2 === 0; var f = R.either(gt10, even); f(101); //=> true f(8); //=> true
a → a
x 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 <Type>.empty and/or <Type>.prototype.empty.
Dispatches to the empty method of the first argument, if present.
R.empty(Just(42)); //=> Nothing()
R.empty([1, 2, 3]); //=> []
R.empty('unicorns'); //=> ''
R.empty({x: 1, y: 2}); //=> {} (a → b) → a → a → Boolean
f x y 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.
R.eqBy(Math.abs, 5, -5); //=> true
k → {k: v} → {k: v} → Boolean prop The name of the property to compare
obj1 obj2 Reports whether two objects have the same value, in R.equals terms, for the specified property. Useful as a curried predicate.
var o1 = { a: 1, b: 2, c: 3, d: 4 };
var o2 = { a: 10, b: 20, c: 3, d: 40 };
R.eqProps('a', o1, o2); //=> false
R.eqProps('c', o1, o2); //=> true a → b → Boolean
a b Returns true if its arguments are equivalent, false otherwise. Handles cyclical data structures.
Dispatches symmetrically to the equals methods of both arguments, if present.
R.equals(1, 1); //=> true
R.equals(1, '1'); //=> false
R.equals([1, 2, 3], [1, 2, 3]); //=> true
var a = {}; a.v = a;
var b = {}; b.v = b;
R.equals(a, b); //=> true {k: (v → v)} → {k: v} → {k: v} transformations The object specifying transformation functions to apply to the object.
object The object to be transformed.
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.
var tomato = {firstName: ' Tomato ', data: {elapsed: 100, remaining: 1400}, id:123};
var transformations = {
firstName: R.trim,
lastName: R.trim, // Will not get invoked.
data: {elapsed: R.add(1), remaining: R.add(-1)}
};
R.evolve(transformations, tomato); //=> {firstName: 'Tomato', data: {elapsed: 101, remaining: 1399}, id:123} * → Boolean
A function that always returns false. Any passed in parameters are ignored.
R.F(); //=> false
Filterable f => (a → Boolean) → f a → f a
pred filterable 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.
Dispatches to the filter method of the second argument, if present.
Acts as a transducer if a transformer is given in list position.
See also reject, transduce, addIndex.
var isEven = n => n % 2 === 0;
R.filter(isEven, [1, 2, 3, 4]); //=> [2, 4]
R.filter(isEven, {a: 1, b: 2, c: 3, d: 4}); //=> {b: 2, d: 4} (a → Boolean) → [a] → a | undefined
fn The predicate function used to determine if the element is the desired one.
list The array to consider.
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.
See also transduce.
var xs = [{a: 1}, {a: 2}, {a: 3}];
R.find(R.propEq('a', 2))(xs); //=> {a: 2}
R.find(R.propEq('a', 4))(xs); //=> undefined (a → Boolean) → [a] → Number
fn The predicate function used to determine if the element is the desired one.
list The array to consider.
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.
See also transduce.
var xs = [{a: 1}, {a: 2}, {a: 3}];
R.findIndex(R.propEq('a', 2))(xs); //=> 1
R.findIndex(R.propEq('a', 4))(xs); //=> -1 (a → Boolean) → [a] → a | undefined
fn The predicate function used to determine if the element is the desired one.
list The array to consider.
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.
See also transduce.
var xs = [{a: 1, b: 0}, {a:1, b: 1}];
R.findLast(R.propEq('a', 1))(xs); //=> {a: 1, b: 1}
R.findLast(R.propEq('a', 4))(xs); //=> undefined (a → Boolean) → [a] → Number
fn The predicate function used to determine if the element is the desired one.
list The array to consider.
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.
See also transduce.
var xs = [{a: 1, b: 0}, {a:1, b: 1}];
R.findLastIndex(R.propEq('a', 1))(xs); //=> 1
R.findLastIndex(R.propEq('a', 4))(xs); //=> -1 [a] → [b]
list The array to consider.
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.
See also unnest.
R.flatten([1, 2, [3, 4], 5, [6, [7, 8, [9, [10, 11], 12]]]]); //=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
(a → b → c → … → z) → (b → a → c → … → z)
fn The function to invoke with its first two parameters reversed.
Returns a new function much like the supplied one, except that the first two arguments' order is reversed.
var mergeThree = (a, b, c) => [].concat(a, b, c); mergeThree(1, 2, 3); //=> [1, 2, 3] R.flip(mergeThree)(1, 2, 3); //=> [2, 1, 3]
(a → *) → [a] → [a]
fn The function to invoke. Receives one argument, value.
list The list to iterate over.
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.
See also addIndex.
var printXPlusFive = x => console.log(x + 5); R.forEach(printXPlusFive, [1, 2, 3]); //=> [1, 2, 3] // logs 6 // logs 7 // logs 8
((a, String, StrMap a) → Any) → StrMap a → StrMap a
fn The function to invoke. Receives three argument, value, key, obj.
obj The object to iterate over.
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).
var printKeyConcatValue = (value, key) => console.log(key + ':' + value);
R.forEachObjIndexed(printKeyConcatValue, {x: 1, y: 2}); //=> {x: 1, y: 2}
// logs x:1
// logs y:2 [[k,v]] → {k: v} pairs An array of two-element arrays that will be the keys and values of the output object.
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.
R.fromPairs([['a', 1], ['b', 2], ['c', 3]]); //=> {a: 1, b: 2, c: 3} (a → String) → [a] → {String: [a]} fn Function :: a -> String
list The array to group
Splits a list into sub-lists 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.
Dispatches to the groupBy method of the second argument, if present.
Acts as a transducer if a transformer is given in list position.
See also transduce.
var byGrade = R.groupBy(function(student) {
var score = student.score;
return score < 65 ? 'F' :
score < 70 ? 'D' :
score < 80 ? 'C' :
score < 90 ? 'B' : 'A';
});
var students = [{name: 'Abby', score: 84},
{name: 'Eddy', score: 58},
// ...
{name: 'Jack', score: 69}];
byGrade(students);
// {
// 'A': [{name: 'Dianne', score: 99}],
// 'B': [{name: 'Abby', score: 84}]
// // ...,
// 'F': [{name: 'Eddy', score: 58}]
// } ((a, a) → Boolean) → [a] → [[a]]
fn Function for determining whether two given (adjacent) elements should be in the same group
list The array to group. Also accepts a string, which will be treated as a list of characters.
Takes a list and returns a list of lists where each sublist's elements are all "equal" according to the provided equality function.
R.groupWith(R.equals, [0, 1, 1, 2, 3, 5, 8, 13, 21]) //=> [[0], [1, 1], [2], [3], [5], [8], [13], [21]] R.groupWith((a, b) => a % 2 === b % 2, [0, 1, 1, 2, 3, 5, 8, 13, 21]) //=> [[0], [1, 1], [2], [3, 5], [8], [13, 21]] R.groupWith(R.eqBy(isVowel), 'aestiou') //=> ['ae', 'st', 'iou']
Ord a => a → a → Boolean
a b Returns true if the first argument is greater than the second; false otherwise.
See also lt.
R.gt(2, 1); //=> true
R.gt(2, 2); //=> false
R.gt(2, 3); //=> false
R.gt('a', 'z'); //=> false
R.gt('z', 'a'); //=> true Ord a => a → a → Boolean
a b Returns true if the first argument is greater than or equal to the second; false otherwise.
See also lte.
R.gte(2, 1); //=> true
R.gte(2, 2); //=> true
R.gte(2, 3); //=> false
R.gte('a', 'z'); //=> false
R.gte('z', 'a'); //=> true s → {s: x} → Boolean prop The name of the property to check for.
obj The object to query.
Returns whether or not an object has an own property with the specified name
var hasName = R.has('name');
hasName({name: 'alice'}); //=> true
hasName({name: 'bob'}); //=> true
hasName({}); //=> false
var point = {x: 0, y: 0};
var pointHas = R.has(R.__, point);
pointHas('x'); //=> true
pointHas('y'); //=> true
pointHas('z'); //=> false s → {s: x} → Boolean prop The name of the property to check for.
obj The object to query.
Returns whether or not an object or its prototype chain has a property with the specified name
function Rectangle(width, height) {
this.width = width;
this.height = height;
}
Rectangle.prototype.area = function() {
return this.width * this.height;
};
var square = new Rectangle(2, 2);
R.hasIn('width', square); //=> true
R.hasIn('area', square); //=> true [a] → a | Undefined
String → Stringlist Returns the first element of the given list or string. In some libraries this function is named first.
R.head(['fi', 'fo', 'fum']); //=> 'fi'
R.head([]); //=> undefined
R.head('abc'); //=> 'a'
R.head(''); //=> '' a → a → Boolean
a b 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.
var o = {};
R.identical(o, o); //=> true
R.identical(1, 1); //=> true
R.identical(1, '1'); //=> false
R.identical([], []); //=> false
R.identical(0, -0); //=> false
R.identical(NaN, NaN); //=> true a → a
x The value to return.
A function that does nothing but return the parameter supplied to it. Good as a default or placeholder function.
R.identity(1); //=> 1
var obj = {};
R.identity(obj) === obj; //=> true (*… → Boolean) → (*… → *) → (*… → *) → (*… → *)
condition A predicate function
onTrue A function to invoke when the condition evaluates to a truthy value.
onFalse A function to invoke when the condition evaluates to a falsy value.
Creates a function that will process either the onTrue or the onFalse function depending upon the result of the condition predicate.
var incCount = R.ifElse(
R.has('count'),
R.over(R.lensProp('count'), R.inc),
R.assoc('count', 1)
);
incCount({}); //=> { count: 1 }
incCount({ count: 1 }); //=> { count: 2 } Number → Number
n Increments its argument.
See also dec.
R.inc(42); //=> 43
(a → String) → [{k: v}] → {k: {k: v}} fn Function :: a -> String
array The array of objects to index
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.
var list = [{id: 'xyz', title: 'A'}, {id: 'abc', title: 'B'}];
R.indexBy(R.prop('id'), list);
//=> {abc: {id: 'abc', title: 'B'}, xyz: {id: 'xyz', title: 'A'}} a → [a] → Number
target The item to find.
xs The array to search in.
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.
See also lastIndexOf.
R.indexOf(3, [1,2,3,4]); //=> 2 R.indexOf(10, [1,2,3,4]); //=> -1
[a] → [a]
String → Stringlist Returns all but the last element of the given list or string.
R.init([1, 2, 3]); //=> [1, 2]
R.init([1, 2]); //=> [1]
R.init([1]); //=> []
R.init([]); //=> []
R.init('abc'); //=> 'ab'
R.init('ab'); //=> 'a'
R.init('a'); //=> ''
R.init(''); //=> '' Number → a → [a] → [a]
index The position to insert the element
elt The element to insert into the Array
list The list to insert into
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. No lists have been harmed in the application of this function.
R.insert(2, 'x', [1,2,3,4]); //=> [1,2,'x',3,4]
Number → [a] → [a] → [a]
index The position to insert the sub-list
elts The sub-list to insert into the Array
list The list to insert the sub-list into
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. No lists have been harmed in the application of this function.
R.insertAll(2, ['x','y','z'], [1,2,3,4]); //=> [1,2,'x','y','z',3,4]
[*] → [*] → [*]
list1 The first list.
list2 The second list.
Combines two lists into a set (i.e. no duplicates) composed of those elements common to both lists.
See also intersectionWith.
R.intersection([1,2,3,4], [7,6,5,4,3]); //=> [4, 3]
((a, a) → Boolean) → [a] → [a] → [a]
pred A predicate function that determines whether the two supplied elements are equal.
list1 One list of items to compare
list2 A second list of items to compare
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.
See also intersection.
var buffaloSpringfield = [
{id: 824, name: 'Richie Furay'},
{id: 956, name: 'Dewey Martin'},
{id: 313, name: 'Bruce Palmer'},
{id: 456, name: 'Stephen Stills'},
{id: 177, name: 'Neil Young'}
];
var csny = [
{id: 204, name: 'David Crosby'},
{id: 456, name: 'Stephen Stills'},
{id: 539, name: 'Graham Nash'},
{id: 177, name: 'Neil Young'}
];
R.intersectionWith(R.eqBy(R.prop('id')), buffaloSpringfield, csny);
//=> [{id: 456, name: 'Stephen Stills'}, {id: 177, name: 'Neil Young'}] a → [a] → [a]
separator The element to add to the list.
list The list to be interposed.
Creates a new list with the separator interposed between elements.
Dispatches to the intersperse method of the second argument, if present.
R.intersperse('n', ['ba', 'a', 'a']); //=> ['ba', 'n', 'a', 'n', 'a'] a → (b → b) → [c] → a
acc The initial accumulator value.
xf The transducer function. Receives a transformer and returns a transformer.
list The list to iterate over.
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.
var numbers = [1, 2, 3, 4]; var transducer = R.compose(R.map(R.add(1)), R.take(2)); R.into([], transducer, numbers); //=> [2, 3] var intoArray = R.into([]); intoArray(transducer, numbers); //=> [2, 3]
{s: x} → {x: [ s, … ]} obj The object or array to invert
Same as R.invertObj, however this accounts for objects with duplicate values by putting the values into an array.
var raceResultsByFirstName = {
first: 'alice',
second: 'jake',
third: 'alice',
};
R.invert(raceResultsByFirstName);
//=> { 'alice': ['first', 'third'], 'jake':['second'] } {s: x} → {x: s} obj The object or array to invert
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.
var raceResults = {
first: 'alice',
second: 'jake'
};
R.invertObj(raceResults);
//=> { 'alice': 'first', 'jake':'second' }
// Alternatively:
var raceResults = ['alice', 'jake'];
R.invertObj(raceResults);
//=> { 'alice': '0', 'jake':'1' } Number → String → (a → b → … → n → Object → *)
arity Number of arguments the returned function should take before the target object.
method Name of the method to call.
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.
var sliceFrom = R.invoker(1, 'slice'); sliceFrom(6, 'abcdefghijklm'); //=> 'ghijklm' var sliceFrom6 = R.invoker(2, 'slice')(6); sliceFrom6(8, 'abcdefghijklm'); //=> 'gh'
(* → {*}) → a → Boolean ctor A constructor
val The value to test
See if an object (val) is an instance of the supplied constructor. This function will check up the inheritance chain, if any.
R.is(Object, {}); //=> true
R.is(Number, 1); //=> true
R.is(Object, 1); //=> false
R.is(String, 's'); //=> true
R.is(String, new String('')); //=> true
R.is(Object, new String('')); //=> true
R.is(Object, 's'); //=> false
R.is(Number, {}); //=> false * → Booleanx The object to test.
Tests whether or not an object is similar to an array.
R.isArrayLike([]); //=> true
R.isArrayLike(true); //=> false
R.isArrayLike({}); //=> false
R.isArrayLike({length: 10}); //=> false
R.isArrayLike({0: 'zero', 9: 'nine', length: 10}); //=> true a → Boolean
x Returns true if the given value is its type's empty value; false otherwise.
See also empty.
R.isEmpty([1, 2, 3]); //=> false
R.isEmpty([]); //=> true
R.isEmpty(''); //=> true
R.isEmpty(null); //=> false
R.isEmpty({}); //=> true
R.isEmpty({length: 0}); //=> false * → Boolean
x The value to test.
Checks if the input value is null or undefined.
R.isNil(null); //=> true R.isNil(undefined); //=> true R.isNil(0); //=> false R.isNil([]); //=> false
String → [a] → String
separator The string used to separate the elements.
xs The elements to join into a string.
Returns a string made by inserting the separator between each element and concatenating all the elements into a single string.
See also split.
var spacer = R.join(' ');
spacer(['a', 2, 3.4]); //=> 'a 2 3.4'
R.join('|', [1, 2, 3]); //=> '1|2|3' [(a, b, …, m) → n] → ((a, b, …, m) → [n])
fns An array of functions
juxt applies a list of functions to a list of values.
See also applySpec.
var getRange = R.juxt([Math.min, Math.max]); getRange(3, 4, 9, -3); //=> [-3, 9]
{k: v} → [k] obj The object to extract properties from
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.
R.keys({a: 1, b: 2, c: 3}); //=> ['a', 'b', 'c'] {k: v} → [k] obj The object to extract properties from
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.
var F = function() { this.x = 'X'; };
F.prototype.y = 'Y';
var f = new F();
R.keysIn(f); //=> ['x', 'y'] [a] → a | Undefined
String → Stringlist Returns the last element of the given list or string.
R.last(['fi', 'fo', 'fum']); //=> 'fum'
R.last([]); //=> undefined
R.last('abc'); //=> 'c'
R.last(''); //=> '' a → [a] → Number
target The item to find.
xs The array to search in.
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.
See also indexOf.
R.lastIndexOf(3, [-1,3,3,0,1,2,3,4]); //=> 6 R.lastIndexOf(10, [1,2,3,4]); //=> -1
[a] → Number
list The array to inspect.
Returns the number of elements in the array by returning list.length.
R.length([]); //=> 0 R.length([1, 2, 3]); //=> 3
(s → a) → ((a, s) → s) → Lens s a
Lens s a = Functor f => (a → f a) → s → f sgetter setter 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.
See also view, set, over, lensIndex, lensProp.
var xLens = R.lens(R.prop('x'), R.assoc('x'));
R.view(xLens, {x: 1, y: 2}); //=> 1
R.set(xLens, 4, {x: 1, y: 2}); //=> {x: 4, y: 2}
R.over(xLens, R.negate, {x: 1, y: 2}); //=> {x: -1, y: 2} Number → Lens s a
Lens s a = Functor f => (a → f a) → s → f sn Returns a lens whose focus is the specified index.
var headLens = R.lensIndex(0); R.view(headLens, ['a', 'b', 'c']); //=> 'a' R.set(headLens, 'x', ['a', 'b', 'c']); //=> ['x', 'b', 'c'] R.over(headLens, R.toUpper, ['a', 'b', 'c']); //=> ['A', 'b', 'c']
[Idx] → Lens s a
Idx = String | IntLens s a = Functor f => (a → f a) → s → f spath The path to use.
Returns a lens whose focus is the specified path.
var xHeadYLens = R.lensPath(['x', 0, 'y']);
R.view(xHeadYLens, {x: [{y: 2, z: 3}, {y: 4, z: 5}]});
//=> 2
R.set(xHeadYLens, 1, {x: [{y: 2, z: 3}, {y: 4, z: 5}]});
//=> {x: [{y: 1, z: 3}, {y: 4, z: 5}]}
R.over(xHeadYLens, R.negate, {x: [{y: 2, z: 3}, {y: 4, z: 5}]});
//=> {x: [{y: -2, z: 3}, {y: 4, z: 5}]} String → Lens s a
Lens s a = Functor f => (a → f a) → s → f sk Returns a lens whose focus is the specified property.
var xLens = R.lensProp('x');
R.view(xLens, {x: 1, y: 2}); //=> 1
R.set(xLens, 4, {x: 1, y: 2}); //=> {x: 4, y: 2}
R.over(xLens, R.negate, {x: 1, y: 2}); //=> {x: -1, y: 2} (*… → *) → ([*]… → [*])
fn The function to lift into higher context
"lifts" a function of arity > 1 so that it may "map over" a list, Function or other object that satisfies the FantasyLand Apply spec.
See also liftN.
var madd3 = R.lift((a, b, c) => a + b + c); madd3([1,2,3], [1,2,3], [1]); //=> [3, 4, 5, 4, 5, 6, 5, 6, 7] var madd5 = R.lift((a, b, c, d, e) => a + b + c + d + e); madd5([1,2], [3], [4, 5], [6], [7, 8]); //=> [21, 22, 22, 23, 22, 23, 23, 24]
Number → (*… → *) → ([*]… → [*])
fn The function to lift into higher context
"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.
var madd3 = R.liftN(3, (...args) => R.sum(args)); madd3([1,2,3], [1,2,3], [1]); //=> [3, 4, 5, 4, 5, 6, 5, 6, 7]
Ord a => a → a → Boolean
a b Returns true if the first argument is less than the second; false otherwise.
See also gt.
R.lt(2, 1); //=> false
R.lt(2, 2); //=> false
R.lt(2, 3); //=> true
R.lt('a', 'z'); //=> true
R.lt('z', 'a'); //=> false Ord a => a → a → Boolean
a b Returns true if the first argument is less than or equal to the second; false otherwise.
See also gte.
R.lte(2, 1); //=> false
R.lte(2, 2); //=> true
R.lte(2, 3); //=> true
R.lte('a', 'z'); //=> true
R.lte('z', 'a'); //=> false Functor f => (a → b) → f a → f b
fn The function to be called on every element of the input list.
list The list to be iterated over.
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.
var double = x => x * 2;
R.map(double, [1, 2, 3]); //=> [2, 4, 6]
R.map(double, {x: 1, y: 2, z: 3}); //=> {x: 2, y: 4, z: 6} (acc → x → (acc, y)) → acc → [x] → (acc, [y])
fn The function to be called on every element of the input list.
acc The accumulator value.
list The list to iterate over.
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].
See also addIndex, mapAccumRight.
var digits = ['1', '2', '3', '4']; var appender = (a, b) => [a + b, a + b]; R.mapAccum(appender, 0, digits); //=> ['01234', ['01', '012', '0123', '01234']]
(x→ acc → (y, acc)) → acc → [x] → ([y], acc)
fn The function to be called on every element of the input list.
acc The accumulator value.
list The list to iterate over.
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, value and acc, and should return a tuple [value, acc].
var digits = ['1', '2', '3', '4']; var append = (a, b) => [a + b, a + b]; R.mapAccumRight(append, 5, digits); //=> [['12345', '2345', '345', '45'], '12345']
((*, String, Object) → *) → Object → Object
fn obj 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.
See also map.
var values = { x: 1, y: 2, z: 3 };
var prependKeyAndDouble = (num, key, obj) => key + (num * 2);
R.mapObjIndexed(prependKeyAndDouble, values); //=> { x: 'x2', y: 'y4', z: 'z6' } RegExp → String → [String | Undefined]
rx A regular expression.
str The string to match against
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.
See also test.
R.match(/([a-z]a)/g, 'bananas'); //=> ['ba', 'na', 'na'] R.match(/a/, 'b'); //=> [] R.match(/a/, null); //=> TypeError: null does not have a method named "match"
Number → Number → Number
m The dividend.
p the modulus.
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.
R.mathMod(-17, 5); //=> 3 R.mathMod(17, 5); //=> 2 R.mathMod(17, -5); //=> NaN R.mathMod(17, 0); //=> NaN R.mathMod(17.2, 5); //=> NaN R.mathMod(17, 5.3); //=> NaN var clock = R.mathMod(R.__, 12); clock(15); //=> 3 clock(24); //=> 0 var seventeenMod = R.mathMod(17); seventeenMod(3); //=> 2 seventeenMod(4); //=> 1 seventeenMod(10); //=> 7
Ord a => a → a → a
a b Returns the larger of its two arguments.
R.max(789, 123); //=> 789
R.max('a', 'b'); //=> 'b' Ord b => (a → b) → a → a → a
f a b Takes a function and two values, and returns whichever value produces the larger result when passed to the provided function.
// square :: Number -> Number var square = n => n * n; R.maxBy(square, -3, 2); //=> -3 R.reduce(R.maxBy(square), 0, [3, -5, 4, 1, -2]); //=> -5 R.reduce(R.maxBy(square), 0, []); //=> 0
[Number] → Number
list Returns the mean of the given list of numbers.
R.mean([2, 7, 9]); //=> 6 R.mean([]); //=> NaN
[Number] → Number
list Returns the median of the given list of numbers.
R.median([2, 9, 7]); //=> 7 R.median([7, 2, 10, 9]); //=> 8 R.median([]); //=> NaN
(*… → a) → (*… → a)
fn The function to memoize.
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.
var count = 0;
var factorial = R.memoize(n => {
count += 1;
return R.product(R.range(1, n + 1));
});
factorial(5); //=> 120
factorial(5); //=> 120
factorial(5); //=> 120
count; //=> 1 {k: v} → {k: v} → {k: v} l r 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.
See also mergeWith, mergeWithKey.
R.merge({ 'name': 'fred', 'age': 10 }, { 'age': 40 });
//=> { 'name': 'fred', 'age': 40 }
var resetToDefault = R.merge(R.__, {x: 0});
resetToDefault({x: 5, y: 2}); //=> {x: 0, y: 2} [{k: v}] → {k: v} list An array of objects
Merges a list of objects together into one object.
See also reduce.
R.mergeAll([{foo:1},{bar:2},{baz:3}]); //=> {foo:1,bar:2,baz:3}
R.mergeAll([{foo:1},{foo:2},{bar:2}]); //=> {foo:2,bar:2} (a → a → a) → {a} → {a} → {a} fn l r 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.
See also merge, mergeWithKey.
R.mergeWith(R.concat,
{ a: true, values: [10, 20] },
{ b: true, values: [15, 35] });
//=> { a: true, b: true, values: [10, 20, 15, 35] } (String → a → a → a) → {a} → {a} → {a} fn l r 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.
let concatValues = (k, l, r) => k == 'values' ? R.concat(l, r) : r
R.mergeWithKey(concatValues,
{ a: true, thing: 'foo', values: [10, 20] },
{ b: true, thing: 'bar', values: [15, 35] });
//=> { a: true, b: true, thing: 'bar', values: [10, 20, 15, 35] } Ord a => a → a → a
a b Returns the smaller of its two arguments.
R.min(789, 123); //=> 123
R.min('a', 'b'); //=> 'a' Ord b => (a → b) → a → a → a
f a b Takes a function and two values, and returns whichever value produces the smaller result when passed to the provided function.
// square :: Number -> Number var square = n => n * n; R.minBy(square, -3, 2); //=> 2 R.reduce(R.minBy(square), Infinity, [3, -5, 4, 1, -2]); //=> 1 R.reduce(R.minBy(square), Infinity, []); //=> Infinity
Number → Number → Number
a The value to the divide.
b The pseudo-modulus
Divides the first parameter by the second and returns the remainder. Note that this function preserves the JavaScript-style behavior for modulo. For mathematical modulo see mathMod.
See also mathMod.
R.modulo(17, 3); //=> 2 // JS behavior: R.modulo(-17, 3); //=> -2 R.modulo(17, -3); //=> 2 var isOdd = R.modulo(R.__, 2); isOdd(42); //=> 0 isOdd(21); //=> 1
Number → Number → Number
a The first value.
b The second value.
Multiplies two numbers. Equivalent to a * b but curried.
See also divide.
var double = R.multiply(2); var triple = R.multiply(3); double(3); //=> 6 triple(4); //=> 12 R.multiply(2, 5); //=> 10
Number → (* → a) → (* → a)
n The desired arity of the new function.
fn The function to wrap.
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.
var takesTwoArgs = (a, b) => [a, b]; takesTwoArgs.length; //=> 2 takesTwoArgs(1, 2); //=> [1, 2] var takesOneArg = R.nAry(1, takesTwoArgs); takesOneArg.length; //=> 1 // Only `n` arguments are passed to the wrapped function takesOneArg(1, 2); //=> [1, undefined]
Number → Number
n Negates its argument.
R.negate(42); //=> -42
(a → Boolean) → [a] → Boolean
fn The predicate function.
list The array to consider.
Returns true if no elements of the list match the predicate, false otherwise.
Dispatches to the any method of the second argument, if present.
var isEven = n => n % 2 === 0; R.none(isEven, [1, 3, 5, 7, 9, 11]); //=> true R.none(isEven, [1, 3, 5, 7, 8, 11]); //=> false
* → Boolean
a any value
A function that returns the ! of its argument. It will return true when passed false-y value, and false when passed a truth-y one.
See also complement.
R.not(true); //=> false R.not(false); //=> true R.not(0); //=> true R.not(1); //=> false
Number → [a] → a | Undefined
Number → String → Stringoffset list Returns the nth element of the given list or string. If n is negative the element at index length + n is returned.
var list = ['foo', 'bar', 'baz', 'quux']; R.nth(1, list); //=> 'bar' R.nth(-1, list); //=> 'quux' R.nth(-99, list); //=> undefined R.nth(2, 'abc'); //=> 'c' R.nth(3, 'abc'); //=> ''
Number → *… → *
n Returns a function which returns its nth argument.
R.nthArg(1)('a', 'b', 'c'); //=> 'b'
R.nthArg(-1)('a', 'b', 'c'); //=> 'c' String → a → {String:a} key val Creates an object containing a single key:value pair.
See also pair.
var matchPhrases = R.compose(
R.objOf('must'),
R.map(R.objOf('match_phrase'))
);
matchPhrases(['foo', 'bar', 'baz']); //=> {must: [{match_phrase: 'foo'}, {match_phrase: 'bar'}, {match_phrase: 'baz'}]} a → [a]
x any value
Returns a singleton array containing the value provided.
Note this of is different from the ES6 of; See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/of
R.of(null); //=> [null] R.of([42]); //=> [[42]]
[String] → {String: *} → {String: *} names an array of String property names to omit from the new object
obj The object to copy from
Returns a partial copy of an object omitting the keys specified.
See also pick.
R.omit(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {b: 2, c: 3} (a… → b) → (a… → b)
fn The function to wrap in a call-only-once wrapper.
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.
var addOneOnce = R.once(x => x + 1); addOneOnce(10); //=> 11 addOneOnce(addOneOnce(50)); //=> 11
a → b → a | b
a b Returns true if one or both of its arguments are true. Returns false if both arguments are false.
See also either.
R.or(true, true); //=> true R.or(true, false); //=> true R.or(false, true); //=> true R.or(false, false); //=> false
Lens s a → (a → a) → s → s
Lens s a = Functor f => (a → f a) → s → f slens v x Returns the result of "setting" the portion of the given data structure focused by the given lens to the result of applying the given function to the focused value.
See also prop, lensIndex, lensProp.
var headLens = R.lensIndex(0); R.over(headLens, R.toUpper, ['foo', 'bar', 'baz']); //=> ['FOO', 'bar', 'baz']
a → b → (a,b)
fst snd Takes two arguments, fst and snd, and returns [fst, snd].
R.pair('foo', 'bar'); //=> ['foo', 'bar'] ((a, b, c, …, n) → x) → [a, b, c, …] → ((d, e, f, …, n) → x)
f args 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.
See also partialRight.
var multiply2 = (a, b) => a * b;
var double = R.partial(multiply2, [2]);
double(2); //=> 4
var greet = (salutation, title, firstName, lastName) =>
salutation + ', ' + title + ' ' + firstName + ' ' + lastName + '!';
var sayHello = R.partial(greet, ['Hello']);
var sayHelloToMs = R.partial(sayHello, ['Ms.']);
sayHelloToMs('Jane', 'Jones'); //=> 'Hello, Ms. Jane Jones!' ((a, b, c, …, n) → x) → [d, e, f, …, n] → ((a, b, c, …) → x)
f args 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.
See also partial.
var greet = (salutation, title, firstName, lastName) =>
salutation + ', ' + title + ' ' + firstName + ' ' + lastName + '!';
var greetMsJaneJones = R.partialRight(greet, ['Ms.', 'Jane', 'Jones']);
greetMsJaneJones('Hello'); //=> 'Hello, Ms. Jane Jones!' Filterable f => (a → Boolean) → f a → [f a, f a]
pred A predicate to determine which side the element belongs to.
filterable the list (or other filterable) to partition.
Takes a predicate and a list or other "filterable" object and returns the pair of filterable objects of the same type of elements which do and do not satisfy, the predicate, respectively.
R.partition(R.contains('s'), ['sss', 'ttt', 'foo', 'bars']);
// => [ [ 'sss', 'bars' ], [ 'ttt', 'foo' ] ]
R.partition(R.contains('s'), { a: 'sss', b: 'ttt', foo: 'bars' });
// => [ { a: 'sss', foo: 'bars' }, { b: 'ttt' } ] [Idx] → {a} → a | Undefined Idx = String | Intpath The path to use.
obj The object to retrieve the nested property from.
Retrieve the value at a given path.
See also prop.
R.path(['a', 'b'], {a: {b: 2}}); //=> 2
R.path(['a', 'b'], {c: {b: 2}}); //=> undefined [Idx] → a → {a} → Boolean Idx = String | Intpath The path of the nested property to use
val The value to compare the nested property with
obj The object to check the nested property in
Determines whether a nested path on an object has a specific value, in R.equals terms. Most likely used to filter a list.
var user1 = { address: { zipCode: 90210 } };
var user2 = { address: { zipCode: 55555 } };
var user3 = { name: 'Bob' };
var users = [ user1, user2, user3 ];
var isFamous = R.pathEq(['address', 'zipCode'], 90210);
R.filter(isFamous, users); //=> [ user1 ] a → [Idx] → {a} → a Idx = String | Intd The default value.
p The path to use.
obj The object to retrieve the nested property from.
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.
R.pathOr('N/A', ['a', 'b'], {a: {b: 2}}); //=> 2
R.pathOr('N/A', ['a', 'b'], {c: {b: 2}}); //=> "N/A" (a → Boolean) → [Idx] → {a} → Boolean Idx = String | Intpred propPath obj Returns true if the specified object property at given path satisfies the given predicate; false otherwise.
See also propSatisfies, path.
R.pathSatisfies(y => y > 0, ['x', 'y'], {x: {y: 2}}); //=> true [k] → {k: v} → {k: v} names an array of String property names to copy onto a new object
obj The object to copy from
Returns a partial copy of an object containing only the keys specified. If the key does not exist, the property is ignored.
R.pick(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1, d: 4}
R.pick(['a', 'e', 'f'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1} [k] → {k: v} → {k: v} names an array of String property names to copy onto a new object
obj The object to copy from
Similar to pick except that this one includes a key: undefined pair for properties that don't exist.
See also pick.
R.pickAll(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1, d: 4}
R.pickAll(['a', 'e', 'f'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1, e: undefined, f: undefined} (v, k → Boolean) → {k: v} → {k: v} pred A predicate to determine whether or not a key should be included on the output object.
obj The object to copy from
Returns a partial copy of an object containing only the keys that satisfy the supplied predicate.
var isUpperCase = (val, key) => key.toUpperCase() === key;
R.pickBy(isUpperCase, {a: 1, b: 2, A: 3, B: 4}); //=> {A: 3, B: 4} (((a, b, …, n) → o), (o → p), …, (x → y), (y → z)) → ((a, b, …, n) → z)
functions Performs left-to-right function composition. The leftmost function may have any arity; the remaining functions must be unary.
In some libraries this function is named sequence.
Note: The result of pipe is not automatically curried.
See also compose.
var f = R.pipe(Math.pow, R.negate, R.inc); f(3, 4); // -(3^4) + 1
Chain m => ((a → m b), (b → m c), …, (y → m z)) → (a → m z)
Returns the left-to-right Kleisli composition of the provided functions, each of which must return a value of a type supported by chain.
R.pipeK(f, g, h) is equivalent to R.pipe(R.chain(f), R.chain(g), R.chain(h)).
See also composeK.
// parseJson :: String -> Maybe *
// get :: String -> Object -> Maybe *
// getStateCode :: Maybe String -> Maybe String
var getStateCode = R.pipeK(
parseJson,
get('user'),
get('address'),
get('state'),
R.compose(Maybe.of, R.toUpper)
);
getStateCode('{"user":{"address":{"state":"ny"}}}');
//=> Just('NY')
getStateCode('[Invalid JSON]');
//=> Nothing() ((a → Promise b), (b → Promise c), …, (y → Promise z)) → (a → Promise z)
functions Performs left-to-right composition of one or more Promise-returning functions. The leftmost function may have any arity; the remaining functions must be unary.
See also composeP.
// followersForUser :: String -> Promise [User] var followersForUser = R.pipeP(db.getUserById, db.getFollowers);
k → [{k: v}] → [v] key The key name to pluck off of each object.
list The array to consider.
Returns a new list by plucking the same named property off all objects in the list supplied.
See also props.
R.pluck('a')([{a: 1}, {a: 2}]); //=> [1, 2]
R.pluck(0)([[1, 2], [3, 4]]); //=> [1, 3] a → [a] → [a]
el The item to add to the head of the output list.
list The array to add to the tail of the output list.
Returns a new list with the given element at the front, followed by the contents of the list.
See also append.
R.prepend('fee', ['fi', 'fo', 'fum']); //=> ['fee', 'fi', 'fo', 'fum'] [Number] → Number
list An array of numbers
Multiplies together all the elements of a list.
See also reduce.
R.product([2,4,6,8,100,1]); //=> 38400
[k] → [{k: v}] → [{k: v}] props The property names to project
objs The objects to query
Reasonable analog to SQL select statement.
var abby = {name: 'Abby', age: 7, hair: 'blond', grade: 2};
var fred = {name: 'Fred', age: 12, hair: 'brown', grade: 7};
var kids = [abby, fred];
R.project(['name', 'grade'], kids); //=> [{name: 'Abby', grade: 2}, {name: 'Fred', grade: 7}] s → {s: a} → a | Undefined p The property name
obj The object to query
Returns a function that when supplied an object returns the indicated property of that object, if it exists.
See also path.
R.prop('x', {x: 100}); //=> 100
R.prop('x', {}); //=> undefined String → a → Object → Boolean
name val obj Returns true if the specified object property is equal, in R.equals terms, to the given value; false otherwise.
See also equals, propSatisfies.
var abby = {name: 'Abby', age: 7, hair: 'blond'};
var fred = {name: 'Fred', age: 12, hair: 'brown'};
var rusty = {name: 'Rusty', age: 10, hair: 'brown'};
var alois = {name: 'Alois', age: 15, disposition: 'surly'};
var kids = [abby, fred, rusty, alois];
var hasBrownHair = R.propEq('hair', 'brown');
R.filter(hasBrownHair, kids); //=> [fred, rusty] Type → String → Object → Boolean
type name obj Returns true if the specified object property is of the given type; false otherwise.
See also is, propSatisfies.
R.propIs(Number, 'x', {x: 1, y: 2}); //=> true
R.propIs(Number, 'x', {x: 'foo'}); //=> false
R.propIs(Number, 'x', {}); //=> false a → String → Object → a
val The default value.
p The name of the property to return.
obj The object to query.
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.
var alice = {
name: 'ALICE',
age: 101
};
var favorite = R.prop('favoriteLibrary');
var favoriteWithDefault = R.propOr('Ramda', 'favoriteLibrary');
favorite(alice); //=> undefined
favoriteWithDefault(alice); //=> 'Ramda' [k] → {k: v} → [v] ps The property names to fetch
obj The object to query
Acts as multiple prop: array of keys in, array of values out. Preserves order.
R.props(['x', 'y'], {x: 1, y: 2}); //=> [1, 2]
R.props(['c', 'a', 'b'], {b: 2, a: 1}); //=> [undefined, 1, 2]
var fullName = R.compose(R.join(' '), R.props(['first', 'last']));
fullName({last: 'Bullet-Tooth', age: 33, first: 'Tony'}); //=> 'Tony Bullet-Tooth' (a → Boolean) → String → {String: a} → Boolean pred name obj Returns true if the specified object property satisfies the given predicate; false otherwise.
R.propSatisfies(x => x > 0, 'x', {x: 1, y: 2}); //=> true Number → Number → [Number]
from The first number in the list.
to One more than the last number in the list.
Returns a list of numbers from from (inclusive) to to (exclusive).
R.range(1, 5); //=> [1, 2, 3, 4] R.range(50, 53); //=> [50, 51, 52]
((a, b) → a) → a → [b] → a
fn The iterator function. Receives two values, the accumulator and the current element from the array.
acc The accumulator value.
list The list to iterate over.
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.
The iterator function receives two values: (acc, value). It may use R.reduced to shortcut the iteration.
The arguments' order of reduceRight's iterator function is (value, acc).
Note: R.reduce does not skip deleted or unassigned indices (sparse arrays), unlike the native Array.prototype.reduce method. For more details on this behavior, see: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce#Description
Dispatches to the reduce method of the third argument, if present.
See also reduced, addIndex, reduceRight.
R.reduce(R.subtract, 0, [1, 2, 3, 4]) // => ((((0 - 1) - 2) - 3) - 4) = -10
- -10
/ \ / \
- 4 -6 4
/ \ / \
- 3 ==> -3 3
/ \ / \
- 2 -1 2
/ \ / \
0 1 0 1 ((a, b) → a) → a → (b → String) → [b] → {String: a} valueFn The function that reduces the elements of each group to a single value. Receives two values, accumulator for a particular group and the current element.
acc The (initial) accumulator value for each group.
keyFn The function that maps the list's element into a key.
list The array to group.
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.
This function is basically a more general groupBy function.
Acts as a transducer if a transformer is given in list position.
var reduceToNamesBy = R.reduceBy((acc, student) => acc.concat(student.name), []);
var namesByGrade = reduceToNamesBy(function(student) {
var score = student.score;
return score < 65 ? 'F' :
score < 70 ? 'D' :
score < 80 ? 'C' :
score < 90 ? 'B' : 'A';
});
var students = [{name: 'Lucy', score: 92},
{name: 'Drew', score: 85},
// ...
{name: 'Bart', score: 62}];
namesByGrade(students);
// {
// 'A': ['Lucy'],
// 'B': ['Drew']
// // ...,
// 'F': ['Bart']
// } a → *
x The final value of the reduce.
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.
Note: this optimization is unavailable to functions not explicitly listed above. For instance, it is not currently supported by reduceRight.
R.reduce( R.pipe(R.add, R.when(R.gte(R.__, 10), R.reduced)), 0, [1, 2, 3, 4, 5]) // 10
(a, b → b) → b → [a] → b
fn The iterator function. Receives two values, the current element from the array and the accumulator.
acc The accumulator value.
list The list to iterate over.
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.
Similar to reduce, except moves through the input list from the right to the left.
The iterator function receives two values: (value, acc), while the arguments' order of reduce's iterator function is (acc, value).
Note: R.reduceRight does not skip deleted or unassigned indices (sparse arrays), unlike the native Array.prototype.reduce method. For more details on this behavior, see: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduceRight#Description
R.reduceRight(R.subtract, 0, [1, 2, 3, 4]) // => (1 - (2 - (3 - (4 - 0)))) = -2
- -2
/ \ / \
1 - 1 3
/ \ / \
2 - ==> 2 -1
/ \ / \
3 - 3 4
/ \ / \
4 0 4 0 ((a, b) → Boolean) → ((a, b) → a) → a → [b] → a
pred The predicate. It is passed the accumulator and the current element.
fn The iterator function. Receives two values, the accumulator and the current element.
a The accumulator value.
list The list to iterate over.
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.
var isOdd = (acc, x) => x % 2 === 1; var xs = [1, 3, 5, 60, 777, 800]; R.reduceWhile(isOdd, R.add, 0, xs); //=> 9 var ys = [2, 4, 6] R.reduceWhile(isOdd, R.add, 111, ys); //=> 111
Filterable f => (a → Boolean) → f a → f a
pred filterable The complement of filter.
Acts as a transducer if a transformer is given in list position.
See also filter, transduce, addIndex.
var isOdd = (n) => n % 2 === 1;
R.reject(isOdd, [1, 2, 3, 4]); //=> [2, 4]
R.reject(isOdd, {a: 1, b: 2, c: 3, d: 4}); //=> {b: 2, d: 4} Number → Number → [a] → [a]
start The position to start removing elements
count The number of elements to remove
list The list to remove from
Removes the sub-list of list starting at index start and containing count elements. 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.
R.remove(2, 3, [1,2,3,4,5,6,7,8]); //=> [1,2,6,7,8]
a → n → [a]
value The value to repeat.
n The desired size of the output list.
Returns a fixed list of size n containing a specified identical value.
R.repeat('hi', 5); //=> ['hi', 'hi', 'hi', 'hi', 'hi']
var obj = {};
var repeatedObjs = R.repeat(obj, 5); //=> [{}, {}, {}, {}, {}]
repeatedObjs[0] === repeatedObjs[1]; //=> true RegExp|String → String → String → String
pattern A regular expression or a substring to match.
replacement The string to replace the matches with.
str The String to do the search and replacement in.
Replace a substring or regex match in a string with a replacement.
R.replace('foo', 'bar', 'foo foo foo'); //=> 'bar foo foo'
R.replace(/foo/, 'bar', 'foo foo foo'); //=> 'bar foo foo'
// Use the "g" (global) flag to replace all occurrences:
R.replace(/foo/g, 'bar', 'foo foo foo'); //=> 'bar bar bar' [a] → [a]
String → Stringlist Returns a new list or string with the elements or characters in reverse order.
R.reverse([1, 2, 3]); //=> [3, 2, 1]
R.reverse([1, 2]); //=> [2, 1]
R.reverse([1]); //=> [1]
R.reverse([]); //=> []
R.reverse('abc'); //=> 'cba'
R.reverse('ab'); //=> 'ba'
R.reverse('a'); //=> 'a'
R.reverse(''); //=> '' (a,b → a) → a → [b] → [a]
fn The iterator function. Receives two values, the accumulator and the current element from the array
acc The accumulator value.
list The list to iterate over.
Scan is similar to reduce, but returns a list of successively reduced values from the left
var numbers = [1, 2, 3, 4]; var factorials = R.scan(R.multiply, 1, numbers); //=> [1, 1, 2, 6, 24]
(Applicative f, Traversable t) => (a → f a) → t (f a) → f (t a)
of traversable Transforms a Traversable of Applicative into an Applicative of Traversable.
Dispatches to the sequence method of the second argument, if present.
See also traverse.
R.sequence(Maybe.of, [Just(1), Just(2), Just(3)]); //=> Just([1, 2, 3]) R.sequence(Maybe.of, [Just(1), Just(2), Nothing()]); //=> Nothing() R.sequence(R.of, Just([1, 2, 3])); //=> [Just(1), Just(2), Just(3)] R.sequence(R.of, Nothing()); //=> [Nothing()]
Lens s a → a → s → s
Lens s a = Functor f => (a → f a) → s → f slens v x Returns the result of "setting" the portion of the given data structure focused by the given lens to the given value.
See also prop, lensIndex, lensProp.
var xLens = R.lensProp('x');
R.set(xLens, 4, {x: 1, y: 2}); //=> {x: 4, y: 2}
R.set(xLens, 8, {x: 1, y: 2}); //=> {x: 8, y: 2} Number → Number → [a] → [a]
Number → Number → String → StringfromIndex The start index (inclusive).
toIndex The end index (exclusive).
list Returns the elements of the given list or string (or object with a slice method) from fromIndex (inclusive) to toIndex (exclusive).
Dispatches to the slice method of the third argument, if present.
R.slice(1, 3, ['a', 'b', 'c', 'd']); //=> ['b', 'c'] R.slice(1, Infinity, ['a', 'b', 'c', 'd']); //=> ['b', 'c', 'd'] R.slice(0, -1, ['a', 'b', 'c', 'd']); //=> ['a', 'b', 'c'] R.slice(-3, -1, ['a', 'b', 'c', 'd']); //=> ['b', 'c'] R.slice(0, 3, 'ramda'); //=> 'ram'
(a,a → Number) → [a] → [a]
comparator A sorting function :: a -> b -> Int
list The list to sort
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. Please note that this is a copy of the list. It does not modify the original.
var diff = function(a, b) { return a - b; };
R.sort(diff, [4,2,7,5]); //=> [2, 4, 5, 7] Ord b => (a → b) → [a] → [a]
fn list The list to sort.
Sorts the list according to the supplied function.
var sortByFirstItem = R.sortBy(R.prop(0));
var sortByNameCaseInsensitive = R.sortBy(R.compose(R.toLower, R.prop('name')));
var pairs = [[-1, 1], [-2, 2], [-3, 3]];
sortByFirstItem(pairs); //=> [[-3, 3], [-2, 2], [-1, 1]]
var alice = {
name: 'ALICE',
age: 101
};
var bob = {
name: 'Bob',
age: -10
};
var clara = {
name: 'clara',
age: 314.159
};
var people = [clara, bob, alice];
sortByNameCaseInsensitive(people); //=> [alice, bob, clara] [a → a → Number] → [a] → [a]
functions A list of comparator functions.
list The list to sort.
Sorts a list according to a list of comparators.
var alice = {
name: 'alice',
age: 40
};
var bob = {
name: 'bob',
age: 30
};
var clara = {
name: 'clara',
age: 40
};
var people = [clara, bob, alice];
var ageNameSort = R.sortWith([
R.descend(R.prop('age')),
R.ascend(R.prop('name'))
]);
ageNameSort(people); //=> [alice, clara, bob] (String | RegExp) → String → [String]
sep The pattern.
str The string to separate into an array.
Splits a string into an array of strings based on the given separator.
See also join.
var pathComponents = R.split('/');
R.tail(pathComponents('/usr/local/bin/node')); //=> ['usr', 'local', 'bin', 'node']
R.split('.', 'a.b.c.xyz.d'); //=> ['a', 'b', 'c', 'xyz', 'd'] Number → [a] → [[a], [a]]
Number → String → [String, String]index The index where the array/string is split.
array The array/string to be split.
Splits a given list or string at a given index.
R.splitAt(1, [1, 2, 3]); //=> [[1], [2, 3]] R.splitAt(5, 'hello world'); //=> ['hello', ' world'] R.splitAt(-1, 'foobar'); //=> ['fooba', 'r']
Number → [a] → [[a]]
Number → String → [String]n list Splits a collection into slices of the specified length.
R.splitEvery(3, [1, 2, 3, 4, 5, 6, 7]); //=> [[1, 2, 3], [4, 5, 6], [7]] R.splitEvery(3, 'foobarbaz'); //=> ['foo', 'bar', 'baz']
(a → Boolean) → [a] → [[a], [a]]
pred The predicate that determines where the array is split.
list The array to be split.
Takes a list and a predicate and returns a pair of lists with the following properties:
R.splitWhen(R.equals(2), [1, 2, 3, 1, 2, 3]); //=> [[1], [2, 3, 1, 2, 3]]
Number → Number → Number
a The first value.
b The second value.
Subtracts its second argument from its first argument.
See also add.
R.subtract(10, 8); //=> 2 var minus5 = R.subtract(R.__, 5); minus5(17); //=> 12 var complementaryAngle = R.subtract(90); complementaryAngle(30); //=> 60 complementaryAngle(72); //=> 18
[Number] → Number
list An array of numbers
Adds together all the elements of a list.
See also reduce.
R.sum([2,4,6,8,100,1]); //=> 121
[*] → [*] → [*]
list1 The first list.
list2 The second list.
Finds the set (i.e. no duplicates) of all elements contained in the first or second list, but not both.
See also symmetricDifferenceWith, difference, differenceWith.
R.symmetricDifference([1,2,3,4], [7,6,5,4,3]); //=> [1,2,7,6,5] R.symmetricDifference([7,6,5,4,3], [1,2,3,4]); //=> [7,6,5,1,2]
((a, a) → Boolean) → [a] → [a] → [a]
pred A predicate used to test whether two items are equal.
list1 The first list.
list2 The second list.
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.
See also symmetricDifference, difference, differenceWith.
var eqA = R.eqBy(R.prop('a'));
var l1 = [{a: 1}, {a: 2}, {a: 3}, {a: 4}];
var l2 = [{a: 3}, {a: 4}, {a: 5}, {a: 6}];
R.symmetricDifferenceWith(eqA, l1, l2); //=> [{a: 1}, {a: 2}, {a: 5}, {a: 6}] * → Boolean
A function that always returns true. Any passed in parameters are ignored.
R.T(); //=> true
[a] → [a]
String → Stringlist Returns all but the first element of the given list or string (or object with a tail method).
Dispatches to the slice method of the first argument, if present.
R.tail([1, 2, 3]); //=> [2, 3]
R.tail([1, 2]); //=> [2]
R.tail([1]); //=> []
R.tail([]); //=> []
R.tail('abc'); //=> 'bc'
R.tail('ab'); //=> 'b'
R.tail('a'); //=> ''
R.tail(''); //=> '' Number → [a] → [a]
Number → String → Stringn list Returns the first n elements of the given list, string, or transducer/transformer (or object with a take method).
Dispatches to the take method of the second argument, if present.
See also drop.
R.take(1, ['foo', 'bar', 'baz']); //=> ['foo'] R.take(2, ['foo', 'bar', 'baz']); //=> ['foo', 'bar'] R.take(3, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz'] R.take(4, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz'] R.take(3, 'ramda'); //=> 'ram' var personnel = [ 'Dave Brubeck', 'Paul Desmond', 'Eugene Wright', 'Joe Morello', 'Gerry Mulligan', 'Bob Bates', 'Joe Dodge', 'Ron Crotty' ]; var takeFive = R.take(5); takeFive(personnel); //=> ['Dave Brubeck', 'Paul Desmond', 'Eugene Wright', 'Joe Morello', 'Gerry Mulligan']
Number → [a] → [a]
Number → String → Stringn The number of elements to return.
xs The collection to consider.
Returns a new list containing the last n elements of the given list. If n > list.length, returns a list of list.length elements.
See also dropLast.
R.takeLast(1, ['foo', 'bar', 'baz']); //=> ['baz'] R.takeLast(2, ['foo', 'bar', 'baz']); //=> ['bar', 'baz'] R.takeLast(3, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz'] R.takeLast(4, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz'] R.takeLast(3, 'ramda'); //=> 'mda'
(a → Boolean) → [a] → [a]
fn The function called per iteration.
list The collection to iterate over.
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).
See also dropLastWhile, addIndex.
var isNotOne = x => x !== 1; R.takeLastWhile(isNotOne, [1, 2, 3, 4]); //=> [2, 3, 4]
(a → Boolean) → [a] → [a]
fn The function called per iteration.
list The collection to iterate over.
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. Excludes the element that caused the predicate function to fail. The predicate function is passed one argument: (value).
Dispatches to the takeWhile method of the second argument, if present.
Acts as a transducer if a transformer is given in list position.
See also dropWhile, transduce, addIndex.
var isNotFour = x => x !== 4; R.takeWhile(isNotFour, [1, 2, 3, 4, 3, 2, 1]); //=> [1, 2, 3]
(a → *) → a → a
fn The function to call with x. The return value of fn will be thrown away.
x Runs the given function with the supplied object, then returns the object.
var sayX = x => console.log('x is ' + x);
R.tap(sayX, 100); //=> 100
// logs 'x is 100' RegExp → String → Boolean
pattern str Determines whether a given string matches a given regular expression.
See also match.
R.test(/^x/, 'xyz'); //=> true R.test(/^y/, 'xyz'); //=> false
(Number → a) → Number → [a]
fn The function to invoke. Passed one argument, the current value of n.
n A value between 0 and n - 1. Increments after each function call.
Calls an input function n times, returning an array containing the results of those function calls.
fn is passed one argument: The current value of n, which begins at 0 and is gradually incremented to n - 1.
R.times(R.identity, 5); //=> [0, 1, 2, 3, 4]
String → String
str The string to lower case.
The lower case version of a string.
See also toUpper.
R.toLower('XYZ'); //=> 'xyz' {String: *} → [[String,*]] obj The object to extract from
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.
See also fromPairs.
R.toPairs({a: 1, b: 2, c: 3}); //=> [['a', 1], ['b', 2], ['c', 3]] {String: *} → [[String,*]] obj The object to extract from
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.
var F = function() { this.x = 'X'; };
F.prototype.y = 'Y';
var f = new F();
R.toPairsIn(f); //=> [['x','X'], ['y','Y']] * → String
val 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. For example:
function Point(x, y) {
this.x = x;
this.y = y;
}
Point.prototype.toString = function() {
return 'new Point(' + this.x + ', ' + this.y + ')';
};
R.toString(new Point(1, 2)); //=> 'new Point(1, 2)'
R.toString(42); //=> '42'
R.toString('abc'); //=> '"abc"'
R.toString([1, 2, 3]); //=> '[1, 2, 3]'
R.toString({foo: 1, bar: 2, baz: 3}); //=> '{"bar": 2, "baz": 3, "foo": 1}'
R.toString(new Date('2001-02-03T04:05:06Z')); //=> 'new Date("2001-02-03T04:05:06.000Z")' String → String
str The string to upper case.
The upper case version of a string.
See also toLower.
R.toUpper('abc'); //=> 'ABC' (c → c) → (a,b → a) → a → [b] → a
xf The transducer function. Receives a transformer and returns a transformer.
fn The iterator function. Receives two values, the accumulator and the current element from the array. Wrapped as transformer, if necessary, and used to initialize the transducer
acc The initial accumulator value.
list The list to iterate over.
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.
The iterator function receives two values: (acc, value). It will be wrapped as a transformer to initialize the transducer. A transformer can be passed directly in place of an iterator function. In both cases, iteration may be stopped early with the R.reduced function.
A transducer is a function that accepts a transformer and returns a transformer and can be composed directly.
A transformer is an an 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 can be used to provide an initial accumulator, but is ignored by transduce.
The iteration is performed with R.reduce after initializing the transducer.
See also reduce, reduced, into.
var numbers = [1, 2, 3, 4]; var transducer = R.compose(R.map(R.add(1)), R.take(2)); R.transduce(transducer, R.flip(R.append), [], numbers); //=> [2, 3]
[[a]] → [[a]]
list A 2D list
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.
R.transpose([[1, 'a'], [2, 'b'], [3, 'c']]) //=> [[1, 2, 3], ['a', 'b', 'c']] R.transpose([[1, 2, 3], ['a', 'b', 'c']]) //=> [[1, 'a'], [2, 'b'], [3, 'c']] If some of the rows are shorter than the following rows, their elements are skipped: R.transpose([[10, 11], [20], [], [30, 31, 32]]) //=> [[10, 20, 30], [11, 31], [32]]
(Applicative f, Traversable t) => (a → f a) → (a → f b) → t a → f (t b)
of f traversable Maps an Applicative-returning function over a Traversable, then uses sequence to transform the resulting Traversable of Applicative into an Applicative of Traversable.
Dispatches to the sequence method of the third argument, if present.
See also sequence.
// Returns `Nothing` if the given divisor is `0` safeDiv = n => d => d === 0 ? Nothing() : Just(n / d) R.traverse(Maybe.of, safeDiv(10), [2, 4, 5]); //=> Just([5, 2.5, 2]) R.traverse(Maybe.of, safeDiv(10), [2, 0, 5]); //=> Nothing
String → String
str The string to trim.
Removes (strips) whitespace from both ends of the string.
R.trim(' xyz '); //=> 'xyz'
R.map(R.trim, R.split(',', 'x, y, z')); //=> ['x', 'y', 'z'] (…x → a) → ((e, …x) → a) → (…x → a)
tryer The function that may throw.
catcher The function that will be evaluated if tryer throws.
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.
R.tryCatch(R.prop('x'), R.F)({x: true}); //=> true
R.tryCatch(R.prop('x'), R.F)(null); //=> false (* → {*}) → String val The value to test
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'.
R.type({}); //=> "Object"
R.type(1); //=> "Number"
R.type(false); //=> "Boolean"
R.type('s'); //=> "String"
R.type(null); //=> "Null"
R.type([]); //=> "Array"
R.type(/[A-z]/); //=> "RegExp" ([*…] → a) → (*… → a)
fn Takes a function fn, which takes a single array argument, and returns a function which:
fn as an array; andIn other words, R.unapply derives a variadic function from a function which takes an array. R.unapply is the inverse of R.apply.
See also apply.
R.unapply(JSON.stringify)(1, 2, 3); //=> '[1,2,3]'
(* → b) → (a → b)
fn The function to wrap.
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.
var takesTwoArgs = function(a, b) {
return [a, b];
};
takesTwoArgs.length; //=> 2
takesTwoArgs(1, 2); //=> [1, 2]
var takesOneArg = R.unary(takesTwoArgs);
takesOneArg.length; //=> 1
// Only 1 argument is passed to the wrapped function
takesOneArg(1, 2); //=> [1, undefined] Number → (a → b) → (a → c)
length The arity for the returned function.
fn The function to uncurry.
Returns a function of arity n from a (manually) curried function.
See also curry.
var addFour = a => b => c => d => a + b + c + d; var uncurriedAddFour = R.uncurryN(4, addFour); uncurriedAddFour(1, 2, 3, 4); //=> 10
(a → [b]) → * → [b]
fn The iterator function. receives one argument, seed, and returns either false to quit iteration or an array of length two to proceed. The element at index 0 of this array will be added to the resulting array, and the element at index 1 will be passed to the next call to fn.
seed The seed value.
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.
The iterator function receives one argument: (seed).
var f = n => n > 50 ? false : [-n, n + 10]; R.unfold(f, 10); //=> [-10, -20, -30, -40, -50]
[*] → [*] → [*]
as The first list.
bs The second list.
Combines two lists into a set (i.e. no duplicates) composed of the elements of each list.
R.union([1, 2, 3], [2, 3, 4]); //=> [1, 2, 3, 4]
(a → a → Boolean) → [*] → [*] → [*]
pred A predicate used to test whether two items are equal.
list1 The first list.
list2 The second list.
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.
See also union.
var l1 = [{a: 1}, {a: 2}];
var l2 = [{a: 1}, {a: 4}];
R.unionWith(R.eqBy(R.prop('a')), l1, l2); //=> [{a: 1}, {a: 2}, {a: 4}] [a] → [a]
list The array to consider.
Returns a new list containing only one copy of each element in the original list. R.equals is used to determine equality.
R.uniq([1, 1, 2, 1]); //=> [1, 2] R.uniq([1, '1']); //=> [1, '1'] R.uniq([[42], [42]]); //=> [[42]]
(a → b) → [a] → [a]
fn A function used to produce a value to use during comparisons.
list The array to consider.
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.
R.uniqBy(Math.abs, [-1, -5, 2, 10, 1, 2]); //=> [-1, -5, 2, 10]
(a, a → Boolean) → [a] → [a]
pred A predicate used to test whether two items are equal.
list The array to consider.
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. Prefers the first item if two items compare equal based on the predicate.
var strEq = R.eqBy(String);
R.uniqWith(strEq)([1, '1', 2, 1]); //=> [1, 2]
R.uniqWith(strEq)([{}, {}]); //=> [{}]
R.uniqWith(strEq)([1, '1', 1]); //=> [1]
R.uniqWith(strEq)(['1', 1, 1]); //=> ['1'] (a → Boolean) → (a → a) → a → a
pred A predicate function
whenFalseFn A function to invoke when the pred evaluates to a falsy value.
x An object to test with the pred function and pass to whenFalseFn if necessary.
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.
// coerceArray :: (a|[a]) -> [a] var coerceArray = R.unless(R.isArrayLike, R.of); coerceArray([1, 2, 3]); //=> [1, 2, 3] coerceArray(1); //=> [1]
Chain c => c (c a) → c a
list Shorthand for R.chain(R.identity), which removes one level of nesting from any Chain.
R.unnest([1, [2], [[3]]]); //=> [1, 2, [3]] R.unnest([[1, 2], [3, 4], [5, 6]]); //=> [1, 2, 3, 4, 5, 6]
(a → Boolean) → (a → a) → a → a
pred A predicate function
fn The iterator function
init Initial value
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.
R.until(R.gt(R.__, 100), R.multiply(2))(1) // => 128
Number → a → [a] → [a]
idx The index to update.
x The value to exist at the given index of the returned array.
list The source array-like object to be updated.
Returns a new copy of the array with the element at the provided index replaced with the given value.
See also adjust.
R.update(1, 11, [0, 1, 2]); //=> [0, 11, 2] R.update(1)(11)([0, 1, 2]); //=> [0, 11, 2]
(x1 → x2 → … → z) → [(a → x1), (b → x2), …] → (a → b → … → z)
fn The function to wrap.
transformers A list of transformer functions
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.
See also converge.
R.useWith(Math.pow, [R.identity, R.identity])(3, 4); //=> 81 R.useWith(Math.pow, [R.identity, R.identity])(3)(4); //=> 81 R.useWith(Math.pow, [R.dec, R.inc])(3, 4); //=> 32 R.useWith(Math.pow, [R.dec, R.inc])(3)(4); //=> 32
{k: v} → [v] obj The object to extract values from
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.
R.values({a: 1, b: 2, c: 3}); //=> [1, 2, 3] {k: v} → [v] obj The object to extract values from
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.
var F = function() { this.x = 'X'; };
F.prototype.y = 'Y';
var f = new F();
R.valuesIn(f); //=> ['X', 'Y'] Lens s a → s → a
Lens s a = Functor f => (a → f a) → s → f slens x 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.
See also prop, lensIndex, lensProp.
var xLens = R.lensProp('x');
R.view(xLens, {x: 1, y: 2}); //=> 1
R.view(xLens, {x: 4, y: 2}); //=> 4 (a → Boolean) → (a → a) → a → a
pred A predicate function
whenTrueFn A function to invoke when the condition evaluates to a truthy value.
x An object to test with the pred function and pass to whenTrueFn if necessary.
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.
// truncate :: String -> String
var truncate = R.when(
R.propSatisfies(R.gt(R.__, 10), 'length'),
R.pipe(R.take(10), R.append('…'), R.join(''))
);
truncate('12345'); //=> '12345'
truncate('0123456789ABC'); //=> '0123456789…' {String: (* → Boolean)} → {String: *} → Boolean spec testObj Takes a spec object and a test object; returns true if the test satisfies the spec. Each of the spec's own properties must be a predicate function. Each predicate is applied to the value of the corresponding property of the test object. where returns true if all the predicates return true, false otherwise.
where is well suited to declaratively expressing constraints for other functions such as filter and find.
// pred :: Object -> Boolean
var pred = R.where({
a: R.equals('foo'),
b: R.complement(R.equals('bar')),
x: R.gt(__, 10),
y: R.lt(__, 20)
});
pred({a: 'foo', b: 'xxx', x: 11, y: 19}); //=> true
pred({a: 'xxx', b: 'xxx', x: 11, y: 19}); //=> false
pred({a: 'foo', b: 'bar', x: 11, y: 19}); //=> false
pred({a: 'foo', b: 'xxx', x: 10, y: 19}); //=> false
pred({a: 'foo', b: 'xxx', x: 11, y: 20}); //=> false {String: *} → {String: *} → Boolean spec testObj 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.equals terms) as accessing that property of the spec.
whereEq is a specialization of where.
See also where.
// pred :: Object -> Boolean
var pred = R.whereEq({a: 1, b: 2});
pred({a: 1}); //=> false
pred({a: 1, b: 2}); //=> true
pred({a: 1, b: 2, c: 3}); //=> true
pred({a: 1, b: 1}); //=> false [a] → [a] → [a]
list1 The values to be removed from list2.
list2 The array to remove values from.
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.
See also transduce.
R.without([1, 2], [1, 2, 1, 3, 4]); //=> [3, 4]
[a] → [b] → [[a,b]]
as The first list.
bs The second list.
Creates a new list out of the two supplied by creating each possible pair from the lists.
R.xprod([1, 2], ['a', 'b']); //=> [[1, 'a'], [1, 'b'], [2, 'a'], [2, 'b']]
[a] → [b] → [[a,b]]
list1 The first array to consider.
list2 The second array to consider.
Creates a new list out of the two supplied by pairing up equally-positioned items from both lists. The returned list is truncated to the length of the shorter of the two input lists. Note: zip is equivalent to zipWith(function(a, b) { return [a, b] }).
R.zip([1, 2, 3], ['a', 'b', 'c']); //=> [[1, 'a'], [2, 'b'], [3, 'c']]
[String] → [*] → {String: *} keys The array that will be properties on the output object.
values The list of values on the output object.
Creates a new object out of a list of keys and a list of values. Key/value pairing is truncated to the length of the shorter of the two lists. Note: zipObj is equivalent to pipe(zipWith(pair), fromPairs).
R.zipObj(['a', 'b', 'c'], [1, 2, 3]); //=> {a: 1, b: 2, c: 3} (a,b → c) → [a] → [b] → [c]
fn The function used to combine the two elements into one value.
list1 The first array to consider.
list2 The second array to consider.
Creates a new list out of the two supplied by applying the function to each equally-positioned pair in the lists. The returned list is truncated to the length of the shorter of the two input lists.
var f = (x, y) => {
// ...
};
R.zipWith(f, [1, 2, 3], ['a', 'b', 'c']);
//=> [f(1, 'a'), f(2, 'b'), f(3, 'c')]
© 2013–2016 Scott Sauyet and Michael Hurley
Licensed under the MIT License.
http://ramdajs.com/0.23.0/docs/