alwaysEmptyArray Function

a → Array

Always returns a new empty array.

R_.alwaysEmptyArray(); // []

alwaysEmptyObject Function

a → Object

Always returns a new empty object.

R_.alwaysEmptyObject(); // {}

alwaysEmptyString Function

a → String

Always returns empty string.

R_.alwaysEmptyString(); // ''

alwaysNull Function

a → Object

Always returns null.

R_.alwaysNull(); // null

alwaysOne Function

* → Number

Always returns number one.

R_.alwaysOne(); // 1

alwaysZero Function

* → Number

Always returns zero.

R_.alwaysZero(); // 0

applyCompose Function

[(a → b)] → a → b

Applies composition by a list of functions.

R_.applyCompose([multiply(2), add(1)])(3); // 8

applyIfFunction Function

a|(*… → a) → [*] → a
Parameters
  • x

    Function or value

  • args

    Array of arguments

Returns any

If the first argument is a function then we apply the function with args that are passed as the second argument. If the first argument is not a function then we return it as it is.

const ref = { current: null }; const getRef = always(ref); const createRef = current => ({ current }); R_.applyIfFunction(ref, []); // { current: null } R_.applyIfFunction(getRef, []); // { current: null } R_.applyIfFunction(createRef, [document.body]); // {"current": [object HTMLBodyElement]}

applyIfNotNil Function

(*… → a) → [*] → a
Parameters
  • fn

    The function which will be called with args when defined

  • args

    The arguments to call fn with

Returns * result The result, equivalent to `fn(...args)` or null

Call apply on function if the function is defined. Otherwise do nothing and return null.

const nums = [1, 2, 3]; R_.applyIfNotNil(R.sum, nums); // 6 R_.applyIfNotNil(undefined, nums); // null

applyPipe Function

[(a → b)] → a → b

Applies pipe by to a list of functions.

R_.applyPipe([multiply(2), add(1)])(3); // 7

argumentsToList Function

(a, b, c, …) → ([a, b, c, …])

Converts arguments to list.

R.compose( R.sum, R_.argumentsToList )(1, 2, 3); // 6

assocDotPath Object

String → a → b
Parameters
  • path

    the dot path to set

  • val

    The new value

  • obj

    The object to clone

Returns Object A new object equivalent to the original except along the specified path.

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.

R_.assocDotPath("a.b.c", 42, { a: { b: { c: 0 } } }); //=> {a: {b: {c: 42}}} // Any missing or non-object keys in path will be overridden R_.assocDotPath("a.b.c", 42, { a: 5 }); //=> {a: {b: {c: 42}}}

between Type

Parameters
  • a

    Starting value

  • b

    Ending value

  • val

    The value to test

Returns Boolean

See if an number (val) is within an array of two numbers ('list').

R_.between(1, 5, 4); //=> true R_.between(3, 8, 2.1); //=> false R_.between(100.1, 102, 100.1); //=> true

callIfFunction Function

(a|(*… → a),*…) → a
Parameters
  • x

    Function or value

  • args

    Any number of positional arguments.

Returns any

If the first argument x is a function then we return the result of calling x with the remaining arguments. If x is not a function then we return it as it is.

const ref = { current: null }; const getRef = always(ref); const createRef = current => ({ current }); R_.callIfFunction(ref); // { current: null } R_.callIfFunction(getRef); // { current: null } R_.callIfFunction(createRef, document.body); // {"current": [object HTMLBodyElement]}

camelizeKeys Object

Parameters
  • x

    Object to transform

Returns any

Recursively camelize all keys within an object or array

camelizeKeys({ "co-obj": { co_string: "foo" }, "co-array": [0, null, { "f-f": "ff" }], "co-number": 1, "co-string": "1", "co-fn": head }); // { // coArray: [ // 0, // null, // { // fF: 'ff' // } // ], // coFn: [Function], // coNumber: 1, // coObj: { // coString: 'foo' // }, // coString: '1' // }

composeC Function

Creates curried compose. The rightmost function determines the arity of curry.

const appendAndRejectNil = R_.composeC(R.rejectNil, R.append); const appendCAndRejectNil = appendAndRejectNil("c"); appendCAndRejectNil(["a", null]); // ['a', 'c'];

constructRegExp Function

Constructs RegExp.

test(R_.constructRegExp("end$", "gi"), "in the end"); // true

containsAll List

[a] → [a] → Boolean
Parameters
  • List
  • List
Returns Boolean If all items from first array are in the second array.

Resolves to true if all elements in first list are found within the second list

R_.containsAll(["a", "b"], ["a", "b", "c"]); // true R_.containsAll(["a", "b", "d"], ["a", "b", "c"]); // false

containsAny List

[a] → [a] → Boolean
Parameters
  • List
  • List
Returns Boolean If any of the items from first array are in the second array.

Returns true if any of the items from first array are in the second array.

R_.containsAny(["a", "e"], ["a", "b", "c"]); // true R_.containsAny(["e", "f"], ["a", "b", "c"]); // false

containsNone List

[a] → [a] → Boolean
Parameters
  • List
  • List
Returns Boolean If any of the items from first array is not in the second array.

Returns true if any of the items from first array is not the second array.

R_.containsNone(["e", "f"], ["a", "b", "c"]); // true R_.containsNone(["a", "f"], ["a", "b", "c"]); // false

cx String

String | [String] | Object → String

Conditionally joining classNames together.

The cx function takes any number of arguments which can be a string, object even nested arrays of strings and objects.

The argument 'foo' is short for { foo: true }.

If the value associated with a given key is falsy, that key won't be included in the output.

R_.cx("Table", ["MagicTable"], { "Table--active": true }); // 'Table MagicTable Table--active' R_.cx("Table", ["MagicTable"], { "Table--active": false }); // 'Table MagicTable' R_.cx(["Table", ["MagicTable"]]); // 'Table MagicTable'

defaultToEmptyArray Logic

a → a | Array

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

R_.defaultToEmptyArray(null); //=> [] R_.defaultToEmptyArray(undefined); //=> [] R_.defaultToEmptyArray("Ramda"); //=> 'Ramda' // parseInt('string') results in NaN R_.defaultToEmptyArray(parseInt("string")); //=> []

defaultToEmptyObject Logic

a → a | Object

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

R_.defaultToEmptyObject(null); //=> {} R_.defaultToEmptyObject(undefined); //=> {} R_.defaultToEmptyObject("Ramda"); //=> 'Ramda' // parseInt('string') results in NaN R_.defaultToEmptyObject(parseInt("string")); //=> {}

defaultToEmptyString Logic

a → a | String

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

R_.defaultToEmptyString(null); //=> "" R_.defaultToEmptyString(undefined); //=> "" R_.defaultToEmptyString("Ramda"); //=> 'Ramda' // parseInt('string') results in NaN R_.defaultToEmptyString(parseInt("string")); //=> ""

defaultToFalse Logic

a → a | Boolean

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

R_.defaultToFalse(null); //=> false R_.defaultToFalse(undefined); //=> false R_.defaultToFalse("Ramda"); //=> 'Ramda' // parseInt('string') results in NaN R_.defaultToFalse(parseInt("string")); //=> false

defaultToOne Logic

a → a | Number

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

R_.defaultToOne(null); //=> 1 R_.defaultToOne(undefined); //=> 1 R_.defaultToOne("Ramda"); //=> 'Ramda' // parseInt('string') results in NaN R_.defaultToOne(parseInt("string")); //=> 1

defaultToTrue Logic

a → a | Boolean

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

R_.defaultToTrue(null); //=> true R_.defaultToTrue(undefined); //=> true R_.defaultToTrue("Ramda"); //=> 'Ramda' // parseInt('string') results in NaN R_.defaultToTrue(parseInt("string")); //=> true

defaultToZero Logic

a → a | Number

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

R_.defaultToZero(null); //=> 0 R_.defaultToZero(undefined); //=> 0 R_.defaultToZero("Ramda"); //=> 'Ramda' // parseInt('string') results in NaN R_.defaultToZero(parseInt("string")); //=> 0

dispatch Function

[a] → b|undefined
Parameters
  • listFns

    List of functions

  • values

    Values applied to functions from listFns

Returns any Returns first not nil result of calling fn from `listFns` with `values`.

Returns first not nil result from evaluation of functions in the list. Returns undefined otherwise.

See also dispatchWith.
const validateName = R_.dispatch([ ifElse(Boolean, R_.noop, always("Name is required.")), ifElse(R_.isString, R_.noop, always("Name must be valid.")) ]); validateName(""); // 'Name is required.' validateName(111); // 'Name must be valid.' validateName("Valid name"); // undefined

dispatchWith Function

[a] → b|undefined
Parameters
  • predicate

    Predicate that is applied to result of calling fn from listFns with values

  • listFns

    List of functions

  • values

    Values applied to functions from listFns

Returns any Returns first result of calling fn from `listFns` with `values` that satisfies `predicate`.

Returns first result from evaluation of functions in the list, that satisfies predicate. Returns undefined otherwise.

See also dispatch.
const firstTruthy = R_.dispatchWith(Boolean)([prop("foo"), prop("bar")]); firstTruthy({ foo: "foo", bar: false }); // "foo" firstTruthy({ foo: false, bar: "bar" }); // "bar"

dissocDotPath Object

Parameters
  • path

    The dot path to the value to omit

  • obj

    The object to clone

Returns Object A new object without the property at path

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

R_.dissocDotPath("a.b.c", { a: { b: { c: 42 } } }); //=> {a: {b: {}}}

dotPath Object

Parameters
  • path

    The dot path to use.

  • obj

    The object to retrieve the nested property from.

Returns * The data at `path`.

Retrieve the value at a given dot path.

R_.dotPath("a.b", { a: { b: 2 } }); //=> 2 R_.dotPath("a.b", { c: { b: 2 } }); //=> undefined

dotPathEq Object

String → a → {a} → Boolean
Parameters
  • path

    The dot path to use.

  • eq

    Value for R.equals.

  • obj

    The object to retrieve the nested property from and compare with eq.

Returns * True if value on dot path equals to `eq`.

Determines whether a dot path on an object has a specific value in R.equals terms.

R_.dotPathEq("a.b", 2, { a: { b: 2 } }); //=> true R_.dotPathEq("a.b", 2, { c: { b: 2 } }); //=> false

dotPathNotEq Object

String → a → {a} → Boolean
Parameters
  • path

    The dot path to use.

  • eq

    Value for R_.notEqual.

  • obj

    The object to retrieve the nested property from and compare with eq.

Returns * True if value on dot path equals to `eq`.

Determines whether a dot path on an object has a specific value in R_.notEqual terms.

R_.dotPathNotEq("a.b", 2, { a: { b: 2 } }); //=> false R_.dotPathNotEq("a.b", 2, { c: { b: 2 } }); //=> true

dotPathNotSatisfies Object

(a → Boolean) → String → {a} → Boolean
Parameters
  • predicate
  • path

    The dot path to use.

  • obj
Returns Boolean

Returns true if the specified object property at given dot path not satisfies the given predicate; false otherwise.

R_.dotPathNotSatisfies(y => y > 0, "a.b", { a: { b: 1 } }); // false R_.dotPathNotSatisfies(y => y > 0, "a.b", { a: { b: -1 } }); // true R_.dotPathNotSatisfies(y => y > 0, "a.b", { a: { c: 1 } }); // true

dotPathOr Object

a → String → {a} → a
Parameters
  • default

    Default value if path does not exist.

  • path

    The dot path to use.

  • obj
Returns * The data at `path` of the supplied object or the default value.

If the given, non-null object has a value at the given dot path, returns the value at that path. Otherwise returns the provided default value.

R_.dotPathOr("N/A", "a.b", { a: { b: 1 } }); // 1 R_.dotPathOr("N/A", "a.b", { a: { c: 1 } }); // "N/A"

dotPathSatisfies Object

(a → Boolean) → String → {a} → Boolean
Parameters
  • predicate
  • path

    The dot path to use.

  • obj
Returns Boolean

Returns true if the specified object property at given dot path satisfies the given predicate; false otherwise.

R_.dotPathSatisfies(y => y > 0, "a.b", { a: { b: 1 } }); // true R_.dotPathSatisfies(y => y > 0, "a.b", { a: { b: -1 } }); // false R_.dotPathSatisfies(y => y > 0, "a.b", { a: { c: 1 } }); // false

duplicate List

a → [a]

Creates pair. Every item of pair equals to input parameter.

R_.duplicate(1); // [1, 1]

endsWithSuffix String

a → b → Boolean
Parameters
  • suffix
  • x
Returns boolean True if `x` ends with `suffix`

Testing string if ends with some suffix.

R_.endsWithSuffix("o", "hello"); // true R_.endsWithSuffix("ello", "hello"); // true R_.endsWithSuffix("y", "good bye"); // false

endsWithSuffixIgnoreCase String

a → b → Boolean
Parameters
  • suffix
  • x
Returns boolean True if `x` ends with `suffix` ignore case

Testing string if ends with some suffix ignoring case.

R_.endsWithSuffixIgnoreCase("o", "HELLO"); // true R_.endsWithSuffixIgnoreCase("ELLO", "hello"); // true R_.endsWithSuffixIgnoreCase("hello", "hello"); // true R_.endsWithSuffixIgnoreCase("o", "good bye"); // false

ensureArray List

a → Array

Wraps input in an Array if it's not an Array already.

R_.ensureArray("A string yo."); // ["A string yo."] R_.ensureArray(["an array item yo"]); // ["an array item yo"] R_.ensureArray([{ consoleLog: "yo" }]); // [{ consoleLog: "yo" }]

equalsEmptyString String

Deprecated true
a → Boolean

Alias for equalsToEmptyString.

R_.equalsEmptyString(""); // true R_.equalsEmptyString("hi"); // false

equalsLength List

Number → [a] → Boolean

Returns true if length of array equals first argument

const lengthEqualsOne = R_.equalsLength(1); lengthEqualsOne([{}]); // true lengthEqualsOne([]); // false

equalsStringIgnoreCase String

a → b → Boolean
Parameters
  • x
  • y
Returns boolean True if `x` equals `y` ignore case

Testing string if equals ignoring case.

R_.equalsStringIgnoreCase("hello", "HELLO"); // true R_.equalsStringIgnoreCase("HELLO", "hello"); // true R_.equalsStringIgnoreCase("hello", "hello"); // true R_.equalsStringIgnoreCase("hello", "good bye"); // false

equalsToEmptyArray Relation

a → Boolean
Parameters
  • value
Returns boolean True if `value` is empty array.

Testing if argument equals to empty array.

R_.equalsToEmptyArray([]); // true R_.equalsToEmptyArray([""]); // false

equalsToEmptyObject Relation

a → Boolean
Parameters
  • value
Returns boolean True if `value` is empty object.

Testing if argument equals to empty object.

R_.equalsToEmptyObject({}); // true R_.equalsToEmptyObject(""); // false

equalsToEmptyString Relation

a → Boolean
Parameters
  • value
Returns boolean True if `value` is empty string

Testing if argument equals to ''

R_.equalsToEmptyString(""); // true R_.equalsToEmptyString("hi"); // false

equalsToFalse Relation

a → Boolean
Parameters
  • value
Returns boolean True if `value` is false

Testing if argument equals to false

R_.equalsToFalse(false); // true R_.equalsToFalse(null); // false

equalsToNull Relation

a → Boolean
Parameters
  • value
Returns boolean True if `value` is null

Testing if argument equals to null

R_.equalsToNull(null); // true R_.equalsToNull(undefined); // false

equalsToOne Relation

a → Boolean
Parameters
  • value
Returns boolean True if `value` is 1

Returns true if argument equals to 1.

R_.equalsToOne(3); // false R_.equalsToOne(1); // true R_.equalsToOne(-3); // false

equalsToTrue Relation

a → Boolean
Parameters
  • value
Returns boolean True if `value` is true

Testing if argument equals to true

R_.equalsToTrue(true); // true R_.equalsToTrue(false); // false

equalsToZero Relation

a → Boolean
Parameters
  • value
Returns boolean True if `value` is 0

Returns true if argument equals to 0.

R_.equalsToZero(3); // false R_.equalsToZero(0); // true R_.equalsToZero(-3); // false

findNotNil List

[a] → a

Returns first not nil value

R_.findNotNil([null, undefined, 0, true]); // 0

flattenArgs List

(a, [b, c]…) → [a, b, c]
Parameters
Returns Array flatten array

Applies flatten on array of arguments

R_.flattenArgs("e", "f", "a"); // ['e', 'f', 'a'] R_.flattenArgs("e", ["f", "a"]); // ['e', 'f', 'a'] R_.flattenArgs("e", ["f", ["a"]]); // ['e', 'f', 'a']

flipIncludes List

[a] → b → Boolean
Parameters
  • list
  • item
Returns Boolean Returns `true` if `list` includes `item`.

Returns true if list includes item.

R_.flipIncludes(["e", "f"], "e"); // true R_.flipIncludes(["e", "f"], "a"); // false

get Object

a → [a] → a
Parameters
  • x
Returns any Slice of x

Returns part of the object based on path.

R_.get({ foo: "bar" }, ["foo"]); // "bar"

gteThanLength List

Number → [a] → Boolean

Returns true if length of array is smaller or equals than first argument

const lengthSmallerThanEqualsOne = R_.gteThanLength(1); lengthSmallerThanEqualsTwo([{}, {}]); // false lengthSmallerThanEqualsTwo([{}]); // true lengthSmallerThanEqualsTwo([]); // true

gtThanLength List

Number → [a] → Boolean

Returns true if length of array is smaller than first argument

const lengthSmallerThanTwo = R_.gtThanLength(2); lengthSmallerThanTwo([{}]); // true lengthSmallerThanTwo([{}, {}]); // false

headArg Function

Takes first argument from the arguments

R_.headArg("a", "b", "c"); // a

includes List

Deprecated true
[a] → b → Boolean
Parameters
  • list
  • item
Returns Boolean Returns `true` if `list` includes `item`.

Returns true if if list includes item.

Deprecated due to breaking change in Ramda. Use R_.flipIncludes instead.

R_.includes(["e", "f"], "e"); // true R_.includes(["a", "f"], "a"); // false

isArray Type

a → Boolean

Returns true if argument is type of Array.

R_.isArray([]); // true R_.isArray(""); // false

isBoolean Type

a → Boolean

Returns true if argument is type of Boolean.

R_.isBoolean(true); // true R_.isBoolean(false); // true R_.isBoolean(1); // false R_.isBoolean(""); // false R_.isBoolean("true"); // false R_.isBoolean({}); // false R_.isBoolean([]); // false R_.isBoolean(NaN); // false R_.isBoolean(null); // false R_.isBoolean(undefined); // false

isError Type

a → Boolean

Returns true if the argument is an instance of Error.

R_.isError(new Error()); // true R_.isError(null); // false

isFalsy Logic

a → Boolean
Parameters
  • input
Returns Boolean `true` if `input` is falsy

Returns true for falsy values. Complement of R_.falsy.

R_.isFalsy(true); // false R_.isFalsy({}); // false R_.isFalsy([]); // false R_.isFalsy(1); // false R_.isFalsy("hello"); // false R_.isFalsy(false); // true R_.isFalsy(0); // true R_.isFalsy(""); // true

isFunction Type

a → Boolean

Returns true if argument is type of Function.

R_.isFunction(() => {}); // true R_.isFunction({}); // false R_.isFunction([]); // false R_.isFunction(""); // false R_.isFunction(0); // false

isNegative Math

Number → Boolean

Returns true if argument is lower than 0.

R_.isNegative(3); // false R_.isNegative(0); // false R_.isNegative(-3); // true

isNilOrEmpty Logic

a → Boolean
Parameters
  • input
Returns Boolean

Returns true if input is empty or nil.

R_.isNilOrEmpty(null); // true R_.isNilOrEmpty({}); // true R_.isNilOrEmpty(false); // false R_.isNilOrEmpty(0); // false

isNilOrEmptyString Logic

a → Boolean

Returns true if argument is null, undefined or ''.

R_.isNilOrEmptyString(null); // true R_.isNilOrEmptyString(undefined); // true R_.isNilOrEmptyString(""); // true R_.isNilOrEmptyString(false); // false R_.isNilOrEmptyString(0); // false R_.isNilOrEmptyString([]); // false R_.isNilOrEmptyString({}); // false

isNotEmpty Logic

a → Boolean

Returns true if the given value is not its type's empty value

R_.isNotEmpty([1, 2, 3]); // true R_.isNotEmpty([]); // false R_.isNotEmpty(""); // false R_.isNotEmpty(null); // true R_.isNotEmpty({}); // false R_.isNotEmpty({ length: 0 }); // true

isNotNaN Logic

a → Boolean

Return negation of native isNaN function.

R_.isNotNaN(0); // true R_.isNotNaN(""); // true R_.isNotNaN([]); // true R_.isNotNaN(null); // true R_.isNotNaN({}); // false R_.isNotNaN(NaN); // false R_.isNotNaN(undefined); // false

isNotNil Logic

a → Boolean

Returns true if argument is neither null or undefined.

R_.isNotNil(null); // false R_.isNotNil(undefined); // false R_.isNotNil(""); // true R_.isNotNil(false); // true R_.isNotNil(0); // true R_.isNotNil([]); // true R_.isNotNil({}); // true

isNotNilObject Logic

a → Boolean

Returns true if argument is not nil object.

R_.isNotNilObject({}); // true R_.isNotNilObject([]); // true R_.isNotNilObject(() => {}); // true R_.isNotNilObject(null); // false R_.isNotNilObject(); // false R_.isNotNilObject(1); // false R_.isNotNilObject(""); // false

isNotNumeric Logic

a → Boolean

Returns true if argument is not finite numeric value.

R_.isNotNumeric(-1); // false R_.isNotNumeric(0); // false R_.isNotNumeric(1); // false R_.isNotNumeric(1.1); // false R_.isNotNumeric(Infinity); // true R_.isNotNumeric(NaN); // true R_.isNotNumeric(""); // true R_.isNotNumeric(() => {}); // true R_.isNotNumeric(false); // true R_.isNotNumeric(null); // true R_.isNotNumeric(undefined); // true R_.isNotNumeric({}); // true R_.isNotNumeric([]); // true

isNotRegExp Type

a → Boolean

Returns true if argument is not RegExp.

R_.isNotRegExp(/foo/); // false R_.isNotRegExp(0); // true

isNumber Type

a → Boolean
Parameters
  • x

    Value to test

Returns any True, if value is type of Number

Returns true if value is type of Number.

R_.isNumber(NaN); // true R_.isNumber(Infinite); // true R_.isNumber(1); // true R_.isNumber(false); // false R_.isNumber({}); // false R_.isNumber("1"); // false

isNumeric Logic

a → Boolean

Returns true if argument is finite numeric value.

R_.isNumeric(-1); // true R_.isNumeric(0); // true R_.isNumeric(1); // true R_.isNumeric(1.1); // true R_.isNumeric(Infinity); // false R_.isNumeric(NaN); // false R_.isNumeric(""); // false R_.isNumeric(() => {}); // false R_.isNumeric(false); // false R_.isNumeric(null); // false R_.isNumeric(undefined); // false R_.isNumeric({}); // false R_.isNumeric([]); // false

isObject Type

a → Boolean

Returns true if argument is type of Object.

R_.isObject({}); // true R_.isObject([]); // true R_.isObject(""); // false

isPlainObject Type

a → Boolean
Parameters
  • x

    value to test

Returns boolean whether the argument is a plain object

Returns true if the argument is a plain object.

R_.isPlainObject({}); // true R_.isPlainObject([]); // false R_.isPlainObject(null); // false

isPositive Math

Number → Boolean

Returns true if argument is greater than 0.

R_.isPositive(3); // true R_.isPositive(0); // false R_.isPositive(-3); // false

isPromise Type

a → Boolean

Returns true if argument is Promise.

R_.isPromise(Promise.resolve()); // true R_.isPromise(0); // false

isRegExp Type

a → Boolean

Returns true if argument is RegExp.

R_.isRegExp(/foo/); // true R_.isRegExp(0); // false

isString Type

a → Boolean

Returns true if argument is type of String.

R_.isString({}); // false R_.isString([]); // false R_.isString(""); // true

isTruthy Logic

a → Boolean
Parameters
  • input
Returns Boolean `true` if `input` is truthy

Alias for Boolean constructor. Returns 'true' for truthy values.

R_.isTruthy(true); // true R_.isTruthy({}); // true R_.isTruthy([]); // true R_.isTruthy(1); // true R_.isTruthy("hello"); // true R_.isTruthy(false); // false R_.isTruthy(0); // false R_.isTruthy(""); // false

joinWithDash String

[String] → String

Joins array of string with dash (hyphen) determiner.

R_.joinWithDash(["a", "b", "c"]); // 'a-b-c'

joinWithDot String

[String] → String

Joins array of string with dot determiner.

R_.joinWithDot(["a", "b", "c"]); // 'a.b.c'

joinWithSpace String

[String] → String

Joins array of string with space determiner.

R_.joinWithSpace(["a", "b", "c"]); // 'a b c'

joinWithUnderscore String

[String] → String

Joins array of string with underscore determiner.

R_.joinWithUnderscore(["a", "b", "c"]); // 'a_b_c'

keyMirror Object

Object → Object
Parameters
  • Object

    where should be keys copied as values.

Returns Object

Copies keys of object to appropriate values.

const actionTypes = R_.keyMirror({ ITEM_REQUEST: null, ITEM_SUCCESS: null, ITEM_ERROR: null }); const action = { type: actionTypes.ITEM_REQUEST }; action.type === actionTypes.ITEM_REQUEST; // true

lastArg Function

Takes last argument from the arguments

R_.lastArg("a", "b", "c"); // c

listToString List

[String] → String

Converts list of strings to string.

R_.listToString(["h", "e", "l", "l", "o"]); // 'hello'

log Debugging

a → a

Function with side-effect. Logs input to console and returns that input. Should be used only in development.

R_.log("hello"); // logs 'hello' compose( R_.log, R.sum )([1, 3]); // logs 4

lteThanLength List

Number → [a] → Boolean

Returns true if length of array is bigger or equals than first argument

const lengthBiggerThanEqualsOne = R_.lteThanLength(1); lengthBiggerThanEqualsOne([{}, {}]); // true lengthBiggerThanEqualsOne([{}]); // true lengthBiggerThanEqualsOne([]); // false

ltThanLength List

Number → [a] → Boolean

Returns true if length of array is bigger than first argument

const lengthBiggerThanZero = R_.ltThanLength(0); lengthBiggerThanZero([{}]); // true lengthBiggerThanZero([]); // false

mapIndexed Object

(a → Number → a) → [a] → a
Parameters
  • fn

    The function to be called on every element of the list and its index.

  • list

    The list to be iterated over.

Returns Array The new list.

Map using function that is provided with each value of the list and its index in the list.

R_.mapIndexed((value, index) => `${value}-${index}`)([1, 2, 3]); // ['1-0', '2-1', '3-2']

mapKeys Object

Parameters
  • fn

    The function to be called on every key of the input object.

  • obj

    The object to be iterated over.

Returns Array The new object with mapped keys.

Use map function over the keys of the given object

R_.mapKeys(R_.toUpperFirst, { x: 1, y: 2, z: 3 }); //=> {X: 2, Y: 4, Z: 6}

mapKeysAndValues Object

([a] → [b]) → Object → Object

Always returns null.

R_.mapKeysAndValues(([a, b]) => [b, a], { foo: "bar", baz: "boo" }); // { bar: "foo", boo: "baz" }

mapKeysWithValue Object

((String, a) → b) → Object → Object

Map object keys. Mapping functions have both key and value as arguments.

R_.mapKeysWithValue((key, value) => value)({ foo: "bar" }); // { bar: "bar" }

memoizeWithIdentity Function

Creates a new function that, when invoked, caches the result of calling fn for a given argument and returns the result. Subsequent calls to the memoized fn with the same argument will not result in an additional call to fn; instead, the cached result for that argument will be returned

let count = 0; const factorial = R_.memoizeWithIdentity(n => { count += 1; return R.product(R.range(1, n + 1)); }); factorial(5); // 120 factorial(5); // 120 factorial(5); // 120 count; // 1

mergeDeepAllWith Object

((a, a) → a) → [{a}] → {a}
Parameters
  • reducer

    Function that resolves merging between two same keys

  • objects

    Array of objects to be merged with

Returns Object Returns merged object

Creates a new object with the own properties of the list of provided objects. List of objects is reduced from first object to the last. If a key exists in both compared objects:

  • and both associated values are also objects then the values will be recursively merged.
  • otherwise the provided function is applied to associated values using the resulting value as the new value associated with the key. If a key only exists in one object, the value will be associated with the key of the resulting object.
R_.mergeDeepAllWith(R.concat, [ { a: { b: [1] } }, { a: { b: [2] } }, { a: { b: [3] } } ]); // { a: { b: [1, 2, 3] } }

mergeDeepAllWithKey Object

((String, a, a) → a) → [{a}] → {a}
Parameters
  • reducer

    Function that resolves merging between two same keys

  • objects

    Array of objects to be merged with

Returns Object Returns merged object

Creates a new object with the own properties of the list of provided objects. List of objects is reduced from first object to the last. If a key exists in both compared objects:

  • and both associated values are also objects then the values will be recursively merged.
  • otherwise the provided function is applied to the key and associated values using the resulting value as the new value associated with the key. If a key only exists in one object, the value will be associated with the key of the resulting object.
R_.mergeDeepAllWith((key, l, r) => (key === "b" ? R.concat(l, r) : r), [ { a: { b: [1], c: [1] } }, { a: { b: [2], c: [2] } }, { a: { b: [3], c: [3] } } ]); // { a: { b: [1, 2, 3], c: [3] } }

mergeDeepLeftAll Object

[{a}] → {a}
Parameters
  • list

    Array of objects

Returns object Merged object

Returns deeply merged object by merging all objects in a passed list. Merging is applied from the left. See mergeDeepLeft from Ramda.

const a = { fooA: { bar: "a" }, shared: { baz: 1 } }; const b = { fooB: { bar: "b" }, shared: { baz: 2 } }; const c = { fooC: { bar: "c" }, shared: { baz: 3 } }; R_.mergeDeepLeftAll([a, b, c]); // { // fooA: { bar: 'a' }, // fooB: { bar: 'b' }, // fooC: { bar: 'c' }, // shared: { baz: 1 }, // }

mergeDeepRightAll Object

[{a}] → {a}
Parameters
  • list

    Array of objects

Returns object Merged object

Returns deeply merged object by merging all objects in a passed list. Merging is applied from the right. See mergeDeepRight from Ramda.

const a = { fooA: { bar: "a" }, shared: { baz: 1 } }; const b = { fooB: { bar: "b" }, shared: { baz: 2 } }; const c = { fooC: { bar: "c" }, shared: { baz: 3 } }; R_.mergeDeepRightAll([a, b, c]); // { // fooA: { bar: 'a' }, // fooB: { bar: 'b' }, // fooC: { bar: 'c' }, // shared: { baz: 3 }, // }

mergeWithDotPath Object

Parameters
  • path

    The dot path to the value

  • mergeFn

    The merging function

  • value

    Value to merge

  • obj

    The object to clone

Returns Object A new object with merge data

Merge data in object using custom merge fn.

R_.mergeWithDotPath("a.b", R.merge, { d: 30 }, { a: { b: { c: 20 } } }); //=> {a: {b: { c: 20, d: 30 }}}

noop Function

a → Object

Alias for alwaysNull

R_.noop(); // null

notEmpty Logic

Deprecated true
a → Boolean

Alias for isNotEmpty

See also isNotEmpty.
R_.notEmpty([1, 2, 3]); // true R_.notEmpty([]); // false R_.notEmpty(""); // false R_.notEmpty(null); // true R_.notEmpty({}); // false R_.notEmpty({ length: 0 }); // true

notEqual Logic

a → b → Boolean

Returns true if the arguments are not equal

R_.notEqual(1, 2); // true R_.notEqual(1, 1); // false

notEqualToEmptyArray Relation

a → Boolean
Parameters
  • value
Returns Boolean Returns `true` if `value` is not an empty array.

Returns true if value is not equal to empty array.

R_.notEqualToEmptyArray([]); // false R_.notEqualToEmptyArray([{ ramda: true }]); // true

notEqualToEmptyObject Relation

a → Boolean
Parameters
  • value
Returns Boolean Returns `true` if `value` is not an empty object.

Returns true if value is not equal to empty object.

R_.notEqualToEmptyObject({}); // false R_.notEqualToEmptyObject({ ramda: true }); // true

notEqualToEmptyString Relation

a → Boolean
Parameters
  • value
Returns Boolean Returns `true` if `value` is not an empty string.

Returns true if value is not equal to empty string.

R_.notEqualToEmptyString(""); // false R_.notEqualToEmptyString("Ramda"); // true

notEqualToFalse Relation

a → Boolean
Parameters
  • value
Returns Boolean Returns `true` if `value` is not false.

Returns true if value is not equal to false.

R_.notEqualToFalse(false); // false R_.notEqualToFalse(true); // true

notEqualToNull Relation

a → Boolean
Parameters
  • value
Returns Boolean Returns `true` if `value` is not null.

Returns true if value is not equal to null.

R_.notEqualToNull(null); // false R_.notEqualToNull(false); // true

notEqualToOne Relation

a → Boolean
Parameters
  • value
Returns Boolean Returns `true` if `value` is not number one.

Returns true if value is not equal to number one.

R_.notEqualToOne(1); // false R_.notEqualToOne(0); // true

notEqualToTrue Relation

a → Boolean
Parameters
  • value
Returns Boolean Returns `true` if `value` is not true.

Returns true if value is not equal to true.

R_.notEqualToTrue(true); // false R_.notEqualToTrue(false); // true

notEqualToZero Relation

a → Boolean
Parameters
  • value
Returns Boolean Returns `true` if `value` is not zero.

Returns true if value is not equal to zero.

R_.notEqualToZero(0); // false R_.notEqualToZero(1); // true

notFlipInclude List

[a] → b → Boolean
Parameters
  • list
  • item
Returns Boolean Returns `false` if `list` includes `item`.

Returns false if any of the items from list includes item.

R_.notFlipInclude(["e", "f"], "e"); // false R_.notFlipInclude(["e", "f"], "a"); // true

notInclude List

Deprecated true
[a] → b → Boolean
Parameters
  • list
  • item
Returns Boolean Returns `false` if `list` flipIncludes `item`.

Returns false if any of the items from list flipIncludes item.

Deprecated due to breaking change in Ramda. Use R_.notFlipInclude.

R_.notInclude(["e", "f"], "e"); // false R_.notInclude(["a", "f"], "a"); // true

notNaN Logic

Deprecated [description]
a → Boolean

Alias for isNotNaN.

See also isNotNaN.
R_.notNaN(0); // true R_.notNaN(""); // true R_.notNaN([]); // true R_.notNaN(null); // true R_.notNaN({}); // false R_.notNaN(NaN); // false R_.notNaN(undefined); // false

notNil Logic

Deprecated true
a → Boolean

Alias for isNotNil

See also isNotNil.
R_.notNil(null); // false R_.notNil(undefined); // false R_.notNil(""); // true R_.notNil(false); // true R_.notNil(0); // true R_.notNil([]); // true R_.notNil({}); // true

notNumeric Logic

Deprecated true
a → Boolean

Alias for isNotNumeric.

See also isNotNumeric.
R_.notNumeric(-1); // false R_.notNumeric(0); // false R_.notNumeric(1); // false R_.notNumeric(1.1); // false R_.notNumeric(Infinity); // true R_.notNumeric(NaN); // true R_.notNumeric(""); // true R_.notNumeric(() => {}); // true R_.notNumeric(false); // true R_.notNumeric(null); // true R_.notNumeric(undefined); // true R_.notNumeric({}); // true R_.notNumeric([]); // true

objOfOver Object

Parameters
  • lens

    Lens

  • tranformation

    Transformation function

  • input
Returns Object Firstly applies transformation on `input` according to `lens` (`R.over`) and than returning value is made by the "setting" (`R.set`) the portion of previous result focused by the given `lens`.

Firstly applies transformation on input data structure according to provided "lens". Returning value is made by the "setting" the portion of the result focused by the given lens.

R_.objOfOver(R.lensPath(["a", "b"]), x => "Hello " + x, { a: { b: "foo" }, c: "bar" }); // { a: { b: "Hello foo" } }

overHead List

Parameters
  • v
  • x
Returns *

Returns an over lens to the first index of list.

R_.overHead(R.toUpper, ["foo", "bar", "baz"]); //=> ['FOO', 'bar', 'baz']

padLeft String

Number → a → a

Length of the output string, padString and initial value. padString is repeatedly concated to init until the length of the string is equal to lengthString.

R_.padLeft(10, "0")("1"); // '00000000001' R_.padLeft(-9, "0")("1"); // '1' R_.padLeft(1, "0")("1"); // '1'

padLeftUntil String

(a → Boolean) → a → a

Takes a predicate, string padString and initial value. padString is contacted to the output string everytime pred returns falsy value.

R_.padLeftUntil(x => x.length === 10, "0")("1"); // '0000000001'

padRight String

Number → a → a

Length of the output string, padString and initial value. padString is repeatedly appended to the init until the length of the string is equal to lengthString.

R_.padRight(10, "0")("1"); // '10000000000' R_.padRight(-9, "0")("1"); // '1' R_.padRight(1, "0")("1"); // '1'

padRightUntil String

(a → Boolean) → a → a

Takes a predicate, string padString and initial value. padString is append to the output string everytime pred returns falsy value.

R_.padRightUntil(x => x.length === 10, "0")("1"); // '1000000000'

pathNotEq Relation

[String | Int] → a → {a} → Boolean

Returns true if nested path of object literal does not contains given value.

R_.pathNotEq(["a", "b"], 1, { a: { b: 1 } }); // false R_.pathNotEq(["a", "b"], 1, { a: { b: 2 } }); // true R_.pathNotEq(["a", "b"], 1, {}); // true R_.pathNotEq(["a", "b"], 1, { a: {} }); // true

pathNotSatisfies Object

(a → Boolean) → String → {a} → Boolean
Parameters
  • predicate
  • path

    The path to use.

  • obj
Returns Boolean

Returns true if the specified object property at given path not satisfies the given predicate; false otherwise.

const positive = x => x > 0; R_.pathNotSatisfies(positive, ["a", "b"], {}); // true R_.pathNotSatisfies(positive, ["a", "b"], { a: { b: -1 } }); // true R_.pathNotSatisfies(positive, ["a", "b"], { a: { b: 3 } }); // false

pipeC Function

Creates curried pipe. The leftmost function determines the arity of curry.

const appendAndRejectNil = R_.pipeC(R.append, R.rejectNil); const appendCAndRejectNil = appendAndRejectNil("c"); appendCAndRejectNil(["a", null]); // ['a', 'c'];

propNotEq Relation

String → a → Object → Boolean

Returns true if property of object literal does not equals the given value.

R_.propNotEq("a", 1, { a: 1 }); // false R_.propNotEq("a", 1, { a: 2 }); // true R_.propNotEq("a", 1, {}); // true

propNotSatisfies Object

(a → Boolean) → String → {a} → Boolean
Parameters
  • predicate
  • prop

    The prop to use.

  • obj
Returns Boolean

Returns true if the specified object property at given prop not satisfies the given predicate; false otherwise.

const positive = x => x > 0; R_.propNotSatisfies(positive, "a", {}); // true R_.propNotSatisfies(positive, "a", { a: -1 }); // true R_.propNotSatisfies(positive, "a", { a: 3 }); // false

reduceCallable Function

(a → … → b) → [a, …, b] → c

Call function passed as first argument with arguments determined by second parameter in order.

const f = a => b => a + b; R_.reduceCallable(f, [1, 2]); // 3

reduceSource List

((a, b, a, [b]) → a) → a → [b] → a
Parameters
  • fn

    The iterator function. Receives four arguments, the accumulator, the current element, the source accumulator and the source list.

  • acc

    The initial accumulator value and value passed as the source accumulator value in the iterator function.

  • list

    The list to iterator over and value passed as the source list in the iterator function.

Returns * The reduced result.

Extends the reduce functionality by adding the original accumulator value as a third argument and the original list as a fourth argument to the iterator function.

R_.reduceSource((acc, v, sAcc) => v + acc + sAcc, 1, [1, 2, 3]); // 10 R_.reduceSource( R.pipe( R.unapply(R.flatten), R.sum ), 0, [1, 2] ); // 9

rejectEq List

a → [b] → [c]

Filters out every value in a list that equals to first argument.

R_.rejectEq("foo", ["foo", "bar", "foo", "bar"]); // ['bar', 'bar']

rejectNil List

[a] → [a]

Filters out every nil value in a list.

R_.rejectNil([null, undefined, ""]); // ['']

replicate List

Number → a → [a]

Creates list of length n. Every item in list equals to input parameter.

R_.replicate(1, 6); // [6] R_.replicate(2, 6); // [6, 6] R_.replicate(3, 6); // [6, 6, 6]

splitByDot String

String → [String]

Splits string by dot into list.

R_.splitByDot("a.b.c"); // ['a', 'b', 'c']

splitByNonAlphaNumeric String

String → [String]

Splits string into list. Delimiter is every sequence of non-alphanumerical values.

R_.splitByNonAlphaNumeric("Hello world/1"); // ['Hello', 'world', '1']

startsWithPrefix String

a → b → Boolean
Parameters
  • prefix
  • x
Returns boolean True if `x` starts with `prefix`

Testing string if starts with some prefix.

R_.startsWithPrefix("h", "hello"); // true R_.startsWithPrefix("hell", "hello"); // true R_.startsWithPrefix("h", "good bye"); // false

startsWithPrefixIgnoreCase String

a → b → Boolean
Parameters
  • prefix
  • x
Returns boolean True if `x` starts with `prefix` ignore case

Testing string if starts with some prefix ignoring case.

R_.startsWithPrefixIgnoreCase("h", "HELLO"); // true R_.startsWithPrefixIgnoreCase("HELL", "hello"); // true R_.startsWithPrefixIgnoreCase("hello", "hello"); // true R_.startsWithPrefixIgnoreCase("h", "good bye"); // false

toCamelCase String

String → String

Converts string into camelCase.

R_.toCamelCase("hello-world"); // 'helloWorld' R_.toCamelCase("hello- world"); // 'helloWorld' R_.toCamelCase(" hello-/ world/ "); // 'helloWorld'

toDotCase String

String → String

Converts string into dot.case.

R_.toDotCase("hello-world"); // 'hello.world' R_.toDotCase("hello/*? world"); // 'hello.world' R_.toDotCase(" hello -/ world/ "); // 'hello.world'

toEntries Object

{String: a, …} → [{String: a}]

Creates array of entries from object.

R_.toEntries({ a: "b", c: "d" }); // [{ a: "b" }, { c: "d" }]

toggle Function

Parameters
  • options

    must be array of two items

  • val
Returns * opposite of options

Returns the opposite value comparing against a given set of two values.

R_.toggle("on", "off")("on"); // 'off' R_.toggle("active", "inactive")("inactive"); // 'active' R_.toggle(10, 100)(10); // 100 R_.toggle("on", "off")("other"); // 'other'

toKebabCase String

String → String

Converts string into kebab-case.

R_.toKebabCase("hello-world"); // 'hello-world' R_.toKebabCase("hello- world"); // 'hello-world' R_.toKebabCase(" hello-/ world/ "); // 'hello-world'

toLowerFirst String

String → String

Decapitalize first letter.

R_.toLowerFirst("HELLO WORLD"); // 'hELLO WORLD'

toPascalCase String

String → String

Converts string into PascalCase.

R_.toPascalCase("hello-world"); // 'HelloWorld' R_.toPascalCase("hello- world"); // 'HelloWorld' R_.toPascalCase(" hello-/ world/ "); // 'HelloWorld'

toScreamingSnakeCase String

String → String

Converts string into SCREAMING_SNAKE_CASE.

R_.toScreamingSnakeCase("hello-world"); // 'HELLO_WORLD' R_.toScreamingSnakeCase("hello- world"); // 'HELLO_WORLD' R_.toScreamingSnakeCase(" hello-/ world/ "); // 'HELLO_WORLD'

toSnakeCase String

String → String

Converts string into snake_case.

R_.toSnakeCase("hello-world"); // 'hello_world' R_.toSnakeCase("hello- world"); // 'hello_world' R_.toSnakeCase(" hello-/ world/ "); // 'hello_world'

toUpperFirst String

String → String

Capitalize first letter.

R_.toUpperFirst("hello world"); // 'Hello world'

trace Debugging

a → b → b

Function with side-effect. Logs input to console and returns that input. Similar to "log" but allows to label logged value. Should be used only in development.

compose( calculation2, R_.trace("Page A"), calculation1 ); // logs "Page A" and result of calculation1

unfoldObjectDots Object

Object → Object

Unfolds input object by dot delimetered path inside its keys.

R_.unfoldObjectDots({ "a.b.c": 1, "d.e.f": 2, g: 3 }); // {a: {b: {c: 1}}, d: {e: {f: 2}}, g: 3}

valueMirror Object

[String] → Object
Parameters
  • keyList

    List of values representing the keys and values of resulting object.

Returns Object Object, where keys and appropriate values equals to value in `keyList`.

Creates object mirror from list of keys.

const actionTypes = R_.valueMirror([ "ITEM_REQUEST", "ITEM_SUCCESS", "ITEM_ERROR" ]); const action = { type: actionTypes.ITEM_REQUEST }; action.type === actionTypes.ITEM_REQUEST; // true actionTypes.ITEM_SUCCESS; // "ITEM_SUCCESS"

viewEq Object

Parameters
  • lens
  • v

    value to equal

  • x
Returns *

Returns true if the given lens equals to given value

R_.viewEq(R.lensIndex(0), "foo", ["foo", "bar", "baz"]); //=> true

viewWith Object

Parameters
  • lens
  • v

    view function

  • x
Returns *

Applies custom view function on the given lens

R_.viewWith(R.lensIndex(0), R.pathEq(["foo"], "boo"), [{ foo: "boo" }]); //=> true R_.viewWith(R.lensIndex(0), R.divide(R.__, 2), [4]); //=> 2

xPairs List

a → [b] → [[a, b]]

Creates pairs from value and list of values. Value is always prepended to the pair.

See also xPairsRight.
R_.xPairs(1, [2, 3]); // [[1, 2], [1, 3]]

xPairsRight List

a → [b] → [[b, a]]

Creates pairs from value and list of values. Value is always appended as the last item to the pair.

See also xPairs.
R_.xPairsRight(1, [2, 3]); // [[2, 1], [3, 1]]