v0_16_0.json

[
  {
    "description": "A special placeholder value used to specify \"gaps\" within curried functions,\nallowing partial application of any combination of arguments,\nregardless of their positions.\n\nIf `g` is a curried ternary function and `_` is `R.__`, the following are equivalent:\n\n  - `g(1, 2, 3)`\n  - `g(_, 2, 3)(1)`\n  - `g(_, _, 3)(1)(2)`\n  - `g(_, _, 3)(1, 2)`\n  - `g(_, 2, _)(1, 3)`\n  - `g(_, 2)(1)(3)`\n  - `g(_, 2)(1, 3)`\n  - `g(_, 2)(_, 3)(1)`",
    "name": "__",
    "sig": "",
    "category": "Function"
  },
  {
    "description": "Adds two numbers. Equivalent to `a + b` but curried.",
    "name": "add",
    "sig": "Number -> Number -> Number",
    "category": "Math"
  },
  {
    "description": "Applies a function to the value at the given index of an array,\nreturning a new copy of the array with the element at the given\nindex replaced with the result of the function application.",
    "name": "adjust",
    "sig": "(a -> a) -> Number -> [a] -> [a]",
    "category": "List"
  },
  {
    "description": "Returns a function that always returns the given value. Note that for\nnon-primitives the value returned is a reference to the original value.\n\nThis function is known as `const`, `constant`, or `K` (for K combinator)\nin other languages and libraries.",
    "name": "always",
    "sig": "a -> (* -> a)",
    "category": "Function"
  },
  {
    "description": "Returns a new list, composed of n-tuples of consecutive elements\nIf `n` is greater than the length of the list, an empty list is returned.",
    "name": "aperture",
    "sig": "Number -> [a] -> [[a]]",
    "category": "List"
  },
  {
    "description": "Returns a new list containing the contents of the given list, followed by the given\nelement.",
    "name": "append",
    "sig": "a -> [a] -> [a]",
    "category": "List"
  },
  {
    "description": "Applies function `fn` to the argument list `args`. This is useful for\ncreating a fixed-arity function from a variadic function. `fn` should\nbe a bound function if context is significant.",
    "name": "apply",
    "sig": "(*... -> a) -> [*] -> a",
    "category": "Function"
  },
  {
    "description": "Makes a shallow clone of an object, setting or overriding the specified\nproperty with the given value.  Note that this copies and flattens\nprototype properties onto the new object as well.  All non-primitive\nproperties are copied by reference.",
    "name": "assoc",
    "sig": "String -> a -> {k: v} -> {k: v}",
    "category": "Object"
  },
  {
    "description": "Makes a shallow clone of an object, setting or overriding the nodes\nrequired to create the given path, and placing the specific value at the\ntail end of that path.  Note that this copies and flattens prototype\nproperties onto the new object as well.  All non-primitive properties\nare copied by reference.",
    "name": "assocPath",
    "sig": "[String] -> a -> {k: v} -> {k: v}",
    "category": "Object"
  },
  {
    "description": "Creates a function that is bound to a context.\nNote: `R.bind` does not provide the additional argument-binding capabilities of\n[Function.prototype.bind](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind).",
    "name": "bind",
    "sig": "(* -> *) -> {*} -> (* -> *)",
    "category": "Function"
  },
  {
    "description": "A function wrapping calls to the two functions in an `&&` operation, returning the result of the first\nfunction if it is false-y and the result of the second function otherwise.  Note that this is\nshort-circuited, meaning that the second function will not be invoked if the first returns a false-y\nvalue.",
    "name": "both",
    "sig": "(*... -> Boolean) -> (*... -> Boolean) -> (*... -> Boolean)",
    "category": "Logic"
  },
  {
    "description": "Makes a comparator function out of a function that reports whether the first element is less than the second.",
    "name": "comparator",
    "sig": "(a, b -> Boolean) -> (a, b -> Number)",
    "category": "Function"
  },
  {
    "description": "Takes a function `f` and returns a function `g` such that:\n\n  - applying `g` to zero or more arguments will give __true__ if applying\n    the same arguments to `f` gives a logical __false__ value; and\n\n  - applying `g` to zero or more arguments will give __false__ if applying\n    the same arguments to `f` gives a logical __true__ value.",
    "name": "complement",
    "sig": "(*... -> *) -> (*... -> Boolean)",
    "category": "Logic"
  },
  {
    "description": "Returns a function, `fn`, which encapsulates if/else-if/else logic.\n`R.cond` takes a list of [predicate, transform] pairs. All of the\narguments to `fn` are applied to each of the predicates in turn\nuntil one returns a \"truthy\" value, at which point `fn` returns the\nresult of applying its arguments to the corresponding transformer.\nIf none of the predicates matches, `fn` returns undefined.",
    "name": "cond",
    "sig": "[[(*... -> Boolean),(*... -> *)]] -> (*... -> *)",
    "category": "Logic"
  },
  {
    "description": "Returns `true` if the `x` is found in the `list`, using `pred` as an\nequality predicate for `x`.",
    "name": "containsWith",
    "sig": "(a, a -> Boolean) -> a -> [a] -> Boolean",
    "category": "List"
  },
  {
    "description": "Counts the elements of a list according to how many match each value\nof a key generated by the supplied function. Returns an object\nmapping the keys produced by `fn` to the number of occurrences in\nthe list. Note that all keys are coerced to strings because of how\nJavaScript objects work.",
    "name": "countBy",
    "sig": "(a -> String) -> [a] -> {*}",
    "category": "Relation"
  },
  {
    "description": "Creates an object containing a single key:value pair.",
    "name": "createMapEntry",
    "sig": "String -> a -> {String:a}",
    "category": "Object"
  },
  {
    "description": "Returns a curried equivalent of the provided function, with the\nspecified arity. The curried function has two unusual capabilities.\nFirst, its arguments needn't be provided one at a time. If `g` is\n`R.curryN(3, f)`, the following are equivalent:\n\n  - `g(1)(2)(3)`\n  - `g(1)(2, 3)`\n  - `g(1, 2)(3)`\n  - `g(1, 2, 3)`\n\nSecondly, the special placeholder value `R.__` may be used to specify\n\"gaps\", allowing partial application of any combination of arguments,\nregardless of their positions. If `g` is as above and `_` is `R.__`,\nthe following are equivalent:\n\n  - `g(1, 2, 3)`\n  - `g(_, 2, 3)(1)`\n  - `g(_, _, 3)(1)(2)`\n  - `g(_, _, 3)(1, 2)`\n  - `g(_, 2)(1)(3)`\n  - `g(_, 2)(1, 3)`\n  - `g(_, 2)(_, 3)(1)`",
    "name": "curryN",
    "sig": "Number -> (* -> a) -> (* -> a)",
    "category": "Function"
  },
  {
    "description": "Decrements its argument.",
    "name": "dec",
    "sig": "Number -> Number",
    "category": "Math"
  },
  {
    "description": "Returns the second argument if it is not null or undefined. If it is null\nor undefined, the first (default) argument is returned.",
    "name": "defaultTo",
    "sig": "a -> b -> a | b",
    "category": "Logic"
  },
  {
    "description": "Finds the set (i.e. no duplicates) of all elements in the first list not contained in the second list.\nDuplication is determined according to the value returned by applying the supplied predicate to two list\nelements.",
    "name": "differenceWith",
    "sig": "(a,a -> Boolean) -> [a] -> [a] -> [a]",
    "category": "Relation"
  },
  {
    "description": "Returns a new object that does not contain a `prop` property.",
    "name": "dissoc",
    "sig": "String -> {k: v} -> {k: v}",
    "category": "Object"
  },
  {
    "description": "Makes a shallow clone of an object, omitting the property at the\ngiven path. Note that this copies and flattens prototype properties\nonto the new object as well.  All non-primitive properties are copied\nby reference.",
    "name": "dissocPath",
    "sig": "[String] -> {k: v} -> {k: v}",
    "category": "Object"
  },
  {
    "description": "Divides two numbers. Equivalent to `a / b`.",
    "name": "divide",
    "sig": "Number -> Number -> Number",
    "category": "Math"
  },
  {
    "description": "Returns a new list containing all but last the`n` elements of a given list,\npassing each value from the right to the supplied predicate function, skipping\nelements while the predicate function returns `true`. The predicate function\nis passed one argument: (value)*.",
    "name": "dropLastWhile",
    "sig": "(a -> Boolean) -> [a] -> [a]",
    "category": "List"
  },
  {
    "description": "A function wrapping calls to the two functions in an `||` operation, returning the result of the first\nfunction if it is truth-y and the result of the second function otherwise.  Note that this is\nshort-circuited, meaning that the second function will not be invoked if the first returns a truth-y\nvalue.",
    "name": "either",
    "sig": "(*... -> Boolean) -> (*... -> Boolean) -> (*... -> Boolean)",
    "category": "Logic"
  },
  {
    "description": "Returns the empty value of its argument's type. Ramda defines the empty\nvalue of Array (`[]`), Object (`{}`), and String (`''`). Other types are\nsupported if they define `<Type>.empty` and/or `<Type>.prototype.empty`.",
    "name": "empty",
    "sig": "a -> a",
    "category": "Function"
  },
  {
    "description": "Creates a new object by recursively evolving a shallow copy of `object`, according to the\n`transformation` functions. All non-primitive properties are copied by reference.\n\nA `tranformation` function will not be invoked if its corresponding key does not exist in\nthe evolved object.",
    "name": "evolve",
    "sig": "{k: (v -> v)} -> {k: v} -> {k: v}",
    "category": "Object"
  },
  {
    "description": "Creates a new object out of a list key-value pairs.",
    "name": "fromPairs",
    "sig": "[[k,v]] -> {k: v}",
    "category": "List"
  },
  {
    "description": "Returns `true` if the first argument is greater than the second;\n`false` otherwise.",
    "name": "gt",
    "sig": "Ord a => a -> a -> Boolean",
    "category": "Relation"
  },
  {
    "description": "Returns `true` if the first argument is greater than or equal to the second;\n`false` otherwise.",
    "name": "gte",
    "sig": "Ord a => a -> a -> Boolean",
    "category": "Relation"
  },
  {
    "description": "Returns whether or not an object has an own property with\nthe specified name",
    "name": "has",
    "sig": "s -> {s: x} -> Boolean",
    "category": "Object"
  },
  {
    "description": "Returns whether or not an object or its prototype chain has\na property with the specified name",
    "name": "hasIn",
    "sig": "s -> {s: x} -> Boolean",
    "category": "Object"
  },
  {
    "description": "Returns true if its arguments are identical, false otherwise. Values are\nidentical if they reference the same memory. `NaN` is identical to `NaN`;\n`0` and `-0` are not identical.",
    "name": "identical",
    "sig": "a -> a -> Boolean",
    "category": "Relation"
  },
  {
    "description": "A function that does nothing but return the parameter supplied to it. Good as a default\nor placeholder function.",
    "name": "identity",
    "sig": "a -> a",
    "category": "Function"
  },
  {
    "description": "Creates a function that will process either the `onTrue` or the `onFalse` function depending\nupon the result of the `condition` predicate.",
    "name": "ifElse",
    "sig": "(*... -> Boolean) -> (*... -> *) -> (*... -> *) -> (*... -> *)",
    "category": "Logic"
  },
  {
    "description": "Increments its argument.",
    "name": "inc",
    "sig": "Number -> Number",
    "category": "Math"
  },
  {
    "description": "Inserts the supplied element into the list, at index `index`.  _Note\nthat this is not destructive_: it returns a copy of the list with the changes.\n<small>No lists have been harmed in the application of this function.</small>",
    "name": "insert",
    "sig": "Number -> a -> [a] -> [a]",
    "category": "List"
  },
  {
    "description": "Inserts the sub-list into the list, at index `index`.  _Note  that this\nis not destructive_: it returns a copy of the list with the changes.\n<small>No lists have been harmed in the application of this function.</small>",
    "name": "insertAll",
    "sig": "Number -> [a] -> [a] -> [a]",
    "category": "List"
  },
  {
    "description": "See if an object (`val`) is an instance of the supplied constructor.\nThis function will check up the inheritance chain, if any.",
    "name": "is",
    "sig": "(* -> {*}) -> a -> Boolean",
    "category": "Type"
  },
  {
    "description": "Tests whether or not an object is similar to an array.",
    "name": "isArrayLike",
    "sig": "* -> Boolean",
    "category": "Type"
  },
  {
    "description": "Reports whether the list has zero elements.",
    "name": "isEmpty",
    "sig": "[a] -> Boolean",
    "category": "Logic"
  },
  {
    "description": "Checks if the input value is `null` or `undefined`.",
    "name": "isNil",
    "sig": "* -> Boolean",
    "category": "Type"
  },
  {
    "description": "Returns a list containing the names of all the enumerable own\nproperties of the supplied object.\nNote that the order of the output array is not guaranteed to be\nconsistent across different JS platforms.",
    "name": "keys",
    "sig": "{k: v} -> [k]",
    "category": "Object"
  },
  {
    "description": "Returns a list containing the names of all the\nproperties of the supplied object, including prototype properties.\nNote that the order of the output array is not guaranteed to be\nconsistent across different JS platforms.",
    "name": "keysIn",
    "sig": "{k: v} -> [k]",
    "category": "Object"
  },
  {
    "description": "Returns the number of elements in the array by returning `list.length`.",
    "name": "length",
    "sig": "[a] -> Number",
    "category": "List"
  },
  {
    "description": "Returns `true` if the first argument is less than the second;\n`false` otherwise.",
    "name": "lt",
    "sig": "Ord a => a -> a -> Boolean",
    "category": "Relation"
  },
  {
    "description": "Returns `true` if the first argument is less than or equal to the second;\n`false` otherwise.",
    "name": "lte",
    "sig": "Ord a => a -> a -> Boolean",
    "category": "Relation"
  },
  {
    "description": "The mapAccum function behaves like a combination of map and reduce; it applies a\nfunction to each element of a list, passing an accumulating parameter from left to\nright, and returning a final value of this accumulator together with the new list.\n\nThe iterator function receives two arguments, *acc* and *value*, and should return\na tuple *[acc, value]*.",
    "name": "mapAccum",
    "sig": "(acc -> x -> (acc, y)) -> acc -> [x] -> (acc, [y])",
    "category": "List"
  },
  {
    "description": "The mapAccumRight function behaves like a combination of map and reduce; it applies a\nfunction to each element of a list, passing an accumulating parameter from right\nto left, and returning a final value of this accumulator together with the new list.\n\nSimilar to `mapAccum`, except moves through the input list from the right to the\nleft.\n\nThe iterator function receives two arguments, *acc* and *value*, and should return\na tuple *[acc, value]*.",
    "name": "mapAccumRight",
    "sig": "(acc -> x -> (acc, y)) -> acc -> [x] -> (acc, [y])",
    "category": "List"
  },
  {
    "description": "mathMod behaves like the modulo operator should mathematically, unlike the `%`\noperator (and by extension, R.modulo). So while \"-17 % 5\" is -2,\nmathMod(-17, 5) is 3. mathMod requires Integer arguments, and returns NaN\nwhen the modulus is zero or negative.",
    "name": "mathMod",
    "sig": "Number -> Number -> Number",
    "category": "Math"
  },
  {
    "description": "Returns the larger of its two arguments.",
    "name": "max",
    "sig": "Ord a => a -> a -> a",
    "category": "Relation"
  },
  {
    "description": "Takes a function and two values, and returns whichever value produces\nthe larger result when passed to the provided function.",
    "name": "maxBy",
    "sig": "Ord b => (a -> b) -> a -> a -> a",
    "category": "Relation"
  },
  {
    "description": "Create a new object with the own properties of `a`\nmerged with the own properties of object `b`.",
    "name": "merge",
    "sig": "{k: v} -> {k: v} -> {k: v}",
    "category": "Object"
  },
  {
    "description": "Returns the smaller of its two arguments.",
    "name": "min",
    "sig": "Ord a => a -> a -> a",
    "category": "Relation"
  },
  {
    "description": "Takes a function and two values, and returns whichever value produces\nthe smaller result when passed to the provided function.",
    "name": "minBy",
    "sig": "Ord b => (a -> b) -> a -> a -> a",
    "category": "Relation"
  },
  {
    "description": "Divides the second parameter by the first and returns the remainder.\nNote that this functions preserves the JavaScript-style behavior for\nmodulo. For mathematical modulo see `mathMod`",
    "name": "modulo",
    "sig": "Number -> Number -> Number",
    "category": "Math"
  },
  {
    "description": "Multiplies two numbers. Equivalent to `a * b` but curried.",
    "name": "multiply",
    "sig": "Number -> Number -> Number",
    "category": "Math"
  },
  {
    "description": "Wraps a function of any arity (including nullary) in a function that accepts exactly `n`\nparameters. Any extraneous parameters will not be passed to the supplied function.",
    "name": "nAry",
    "sig": "Number -> (* -> a) -> (* -> a)",
    "category": "Function"
  },
  {
    "description": "Negates its argument.",
    "name": "negate",
    "sig": "Number -> Number",
    "category": "Math"
  },
  {
    "description": "A function that returns the `!` of its argument. It will return `true` when\npassed false-y value, and `false` when passed a truth-y one.",
    "name": "not",
    "sig": "* -> Boolean",
    "category": "Logic"
  },
  {
    "description": "Returns the nth element of the given list or string.\nIf n is negative the element at index length + n is returned.",
    "name": "nth",
    "sig": "Number -> [a] -> a | Undefined",
    "category": "List"
  },
  {
    "description": "Returns a function which returns its nth argument.",
    "name": "nthArg",
    "sig": "Number -> *... -> *",
    "category": "Function"
  },
  {
    "description": "Returns the nth character of the given string.",
    "name": "nthChar",
    "sig": "Number -> String -> String",
    "category": "String"
  },
  {
    "description": "Returns the character code of the nth character of the given string.",
    "name": "nthCharCode",
    "sig": "Number -> String -> Number",
    "category": "String"
  },
  {
    "description": "Returns a singleton array containing the value provided.\n\nNote this `of` is different from the ES6 `of`; See\nhttps://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/of",
    "name": "of",
    "sig": "a -> [a]",
    "category": "Function"
  },
  {
    "description": "Accepts a function `fn` and returns a function that guards invocation of `fn` such that\n`fn` can only ever be called once, no matter how many times the returned function is\ninvoked.",
    "name": "once",
    "sig": "(a... -> b) -> (a... -> b)",
    "category": "Function"
  },
  {
    "description": "Returns the result of \"setting\" the portion of the given data structure\nfocused by the given lens to the given value.",
    "name": "over",
    "sig": "Lens s a -> (a -> a) -> s -> s",
    "category": "Object"
  },
  {
    "description": "Retrieve the value at a given path.",
    "name": "path",
    "sig": "[String] -> {k: v} -> v | Undefined",
    "category": "Object"
  },
  {
    "description": "Returns a partial copy of an object containing only the keys specified.  If the key does not exist, the\nproperty is ignored.",
    "name": "pick",
    "sig": "[k] -> {k: v} -> {k: v}",
    "category": "Object"
  },
  {
    "description": "Similar to `pick` except that this one includes a `key: undefined` pair for properties that don't exist.",
    "name": "pickAll",
    "sig": "[k] -> {k: v} -> {k: v}",
    "category": "Object"
  },
  {
    "description": "Returns a partial copy of an object containing only the keys that\nsatisfy the supplied predicate.",
    "name": "pickBy",
    "sig": "(v, k -> Boolean) -> {k: v} -> {k: v}",
    "category": "Object"
  },
  {
    "description": "Returns a new list with the given element at the front, followed by the contents of the\nlist.",
    "name": "prepend",
    "sig": "a -> [a] -> [a]",
    "category": "List"
  },
  {
    "description": "Returns a function that when supplied an object returns the indicated property of that object, if it exists.",
    "name": "prop",
    "sig": "s -> {s: a} -> a | Undefined",
    "category": "Object"
  },
  {
    "description": "If the given, non-null object has an own property with the specified name,\nreturns the value of that property.\nOtherwise returns the provided default value.",
    "name": "propOr",
    "sig": "a -> String -> Object -> a",
    "category": "Object"
  },
  {
    "description": "Returns `true` if the specified object property satisfies the given\npredicate; `false` otherwise.",
    "name": "propSatisfies",
    "sig": "(a -> Boolean) -> String -> {String: a} -> Boolean",
    "category": "Logic"
  },
  {
    "description": "Acts as multiple `prop`: array of keys in, array of values out. Preserves order.",
    "name": "props",
    "sig": "[k] -> {k: v} -> [v]",
    "category": "Object"
  },
  {
    "description": "Returns a list of numbers from `from` (inclusive) to `to`\n(exclusive).",
    "name": "range",
    "sig": "Number -> Number -> [Number]",
    "category": "List"
  },
  {
    "description": "Returns a single item by iterating through the list, successively calling the iterator\nfunction and passing it an accumulator value and the current value from the array, and\nthen passing the result to the next call.\n\nSimilar to `reduce`, except moves through the input list from the right to the left.\n\nThe iterator function receives two values: *(acc, value)*\n\nNote: `R.reduceRight` does not skip deleted or unassigned indices (sparse arrays), unlike\nthe native `Array.prototype.reduce` method. For more details on this behavior, see:\nhttps://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduceRight#Description",
    "name": "reduceRight",
    "sig": "(a,b -> a) -> a -> [b] -> a",
    "category": "List"
  },
  {
    "description": "Returns a value wrapped to indicate that it is the final value of the\nreduce and transduce functions.  The returned value\nshould be considered a black box: the internal structure is not\nguaranteed to be stable.\n\nNote: this optimization is unavailable to functions not explicitly listed\nabove.  For instance, it is not currently supported by reduceIndexed,\nreduceRight, or reduceRightIndexed.",
    "name": "reduced",
    "sig": "a -> *",
    "category": "List"
  },
  {
    "description": "Removes the sub-list of `list` starting at index `start` and containing\n`count` elements.  _Note that this is not destructive_: it returns a\ncopy of the list with the changes.\n<small>No lists have been harmed in the application of this function.</small>",
    "name": "remove",
    "sig": "Number -> Number -> [a] -> [a]",
    "category": "List"
  },
  {
    "description": "Replace a substring or regex match in a string with a replacement.",
    "name": "replace",
    "sig": "RegExp|String -> String -> String -> String",
    "category": "String"
  },
  {
    "description": "Returns a new list with the same elements as the original list, just\nin the reverse order.",
    "name": "reverse",
    "sig": "[a] -> [a]",
    "category": "List"
  },
  {
    "description": "Scan is similar to reduce, but returns a list of successively reduced values from the left",
    "name": "scan",
    "sig": "(a,b -> a) -> a -> [b] -> [a]",
    "category": "List"
  },
  {
    "description": "Returns the result of \"setting\" the portion of the given data structure\nfocused by the given lens to the given value.",
    "name": "set",
    "sig": "Lens s a -> a -> s -> s",
    "category": "Object"
  },
  {
    "description": "Returns a copy of the list, sorted according to the comparator function, which should accept two values at a\ntime and return a negative number if the first value is smaller, a positive number if it's larger, and zero\nif they are equal.  Please note that this is a **copy** of the list.  It does not modify the original.",
    "name": "sort",
    "sig": "(a,a -> Number) -> [a] -> [a]",
    "category": "List"
  },
  {
    "description": "Sorts the list according to the supplied function.",
    "name": "sortBy",
    "sig": "Ord b => (a -> b) -> [a] -> [a]",
    "category": "Relation"
  },
  {
    "description": "Subtracts two numbers. Equivalent to `a - b` but curried.",
    "name": "subtract",
    "sig": "Number -> Number -> Number",
    "category": "Math"
  },
  {
    "description": "Returns a new list containing the last `n` elements of a given list, passing each value\nto the supplied predicate function, and terminating when the predicate function returns\n`false`. Excludes the element that caused the predicate function to fail. The predicate\nfunction is passed one argument: *(value)*.",
    "name": "takeLastWhile",
    "sig": "(a -> Boolean) -> [a] -> [a]",
    "category": "List"
  },
  {
    "description": "Runs the given function with the supplied object, then returns the object.",
    "name": "tap",
    "sig": "(a -> *) -> a -> a",
    "category": "Function"
  },
  {
    "description": "Determines whether a given string matches a given regular expression.",
    "name": "test",
    "sig": "RegExp -> String -> Boolean",
    "category": "String"
  },
  {
    "description": "Calls an input function `n` times, returning an array containing the results of those\nfunction calls.\n\n`fn` is passed one argument: The current value of `n`, which begins at `0` and is\ngradually incremented to `n - 1`.",
    "name": "times",
    "sig": "(i -> a) -> i -> [a]",
    "category": "List"
  },
  {
    "description": "Converts an object into an array of key, value arrays.\nOnly the object's own properties are used.\nNote that the order of the output array is not guaranteed to be\nconsistent across different JS platforms.",
    "name": "toPairs",
    "sig": "{String: *} -> [[String,*]]",
    "category": "Object"
  },
  {
    "description": "Converts an object into an array of key, value arrays.\nThe object's own properties and prototype properties are used.\nNote that the order of the output array is not guaranteed to be\nconsistent across different JS platforms.",
    "name": "toPairsIn",
    "sig": "{String: *} -> [[String,*]]",
    "category": "Object"
  },
  {
    "description": "Removes (strips) whitespace from both ends of the string.",
    "name": "trim",
    "sig": "String -> String",
    "category": "String"
  },
  {
    "description": "Gives a single-word string description of the (native) type of a value, returning such\nanswers as 'Object', 'Number', 'Array', or 'Null'.  Does not attempt to distinguish user\nObject types any further, reporting them all as 'Object'.",
    "name": "type",
    "sig": "(* -> {*}) -> String",
    "category": "Type"
  },
  {
    "description": "Takes a function `fn`, which takes a single array argument, and returns\na function which:\n\n  - takes any number of positional arguments;\n  - passes these arguments to `fn` as an array; and\n  - returns the result.\n\nIn other words, R.unapply derives a variadic function from a function\nwhich takes an array. R.unapply is the inverse of R.apply.",
    "name": "unapply",
    "sig": "([*...] -> a) -> (*... -> a)",
    "category": "Function"
  },
  {
    "description": "Wraps a function of any arity (including nullary) in a function that accepts exactly 1\nparameter. Any extraneous parameters will not be passed to the supplied function.",
    "name": "unary",
    "sig": "(* -> b) -> (a -> b)",
    "category": "Function"
  },
  {
    "description": "Returns a function of arity `n` from a (manually) curried function.",
    "name": "uncurryN",
    "sig": "Number -> (a -> b) -> (a -> c)",
    "category": "Function"
  },
  {
    "description": "Builds a list from a seed value. Accepts an iterator function, which returns either false\nto stop iteration or an array of length 2 containing the value to add to the resulting\nlist and the seed to be used in the next call to the iterator function.\n\nThe iterator function receives one argument: *(seed)*.",
    "name": "unfold",
    "sig": "(a -> [b]) -> * -> [b]",
    "category": "List"
  },
  {
    "description": "Returns a new list containing only one copy of each element in the original list, based\nupon the value returned by applying the supplied predicate to two list elements. Prefers\nthe first item if two items compare equal based on the predicate.",
    "name": "uniqWith",
    "sig": "(a, a -> Boolean) -> [a] -> [a]",
    "category": "List"
  },
  {
    "description": "Returns a new copy of the array with the element at the\nprovided index replaced with the given value.",
    "name": "update",
    "sig": "Number -> a -> [a] -> [a]",
    "category": "List"
  },
  {
    "description": "Returns a list of all the enumerable own properties of the supplied object.\nNote that the order of the output array is not guaranteed across\ndifferent JS platforms.",
    "name": "values",
    "sig": "{k: v} -> [v]",
    "category": "Object"
  },
  {
    "description": "Returns a list of all the properties, including prototype properties,\nof the supplied object.\nNote that the order of the output array is not guaranteed to be\nconsistent across different JS platforms.",
    "name": "valuesIn",
    "sig": "{k: v} -> [v]",
    "category": "Object"
  },
  {
    "description": "Returns a \"view\" of the given data structure, determined by the given lens.\nThe lens's focus determines which portion of the data structure is visible.",
    "name": "view",
    "sig": "Lens s a -> s -> a",
    "category": "Object"
  },
  {
    "description": "Takes a spec object and a test object; returns true if the test satisfies\nthe spec. Each of the spec's own properties must be a predicate function.\nEach predicate is applied to the value of the corresponding property of\nthe test object. `where` returns true if all the predicates return true,\nfalse otherwise.\n\n`where` is well suited to declaratively expressing constraints for other\nfunctions such as `filter` and `find`.",
    "name": "where",
    "sig": "{String: (* -> Boolean)} -> {String: *} -> Boolean",
    "category": "Object"
  },
  {
    "description": "Wrap a function inside another to allow you to make adjustments to the parameters, or do\nother processing either before the internal function is called or with its results.",
    "name": "wrap",
    "sig": "(a... -> b) -> ((a... -> b) -> a... -> c) -> (a... -> c)",
    "category": "Function"
  },
  {
    "description": "Creates a new list out of the two supplied by creating each possible\npair from the lists.",
    "name": "xprod",
    "sig": "[a] -> [b] -> [[a,b]]",
    "category": "List"
  },
  {
    "description": "Creates a new list out of the two supplied by pairing up\nequally-positioned items from both lists.  The returned list is\ntruncated to the length of the shorter of the two input lists.\nNote: `zip` is equivalent to `zipWith(function(a, b) { return [a, b] })`.",
    "name": "zip",
    "sig": "[a] -> [b] -> [[a,b]]",
    "category": "List"
  },
  {
    "description": "Creates a new object out of a list of keys and a list of values.",
    "name": "zipObj",
    "sig": "[String] -> [*] -> {String: *}",
    "category": "List"
  },
  {
    "description": "Creates a new list out of the two supplied by applying the function to\neach equally-positioned pair in the lists. The returned list is\ntruncated to the length of the shorter of the two input lists.",
    "name": "zipWith",
    "sig": "(a,b -> c) -> [a] -> [b] -> [c]",
    "category": "List"
  },
  {
    "description": "A function that always returns `false`. Any passed in parameters are ignored.",
    "name": "F",
    "sig": "* -> false",
    "category": "Function"
  },
  {
    "description": "A function that always returns `true`. Any passed in parameters are ignored.",
    "name": "T",
    "sig": "* -> true",
    "category": "Function"
  },
  {
    "description": "Creates a new list iteration function from an existing one by adding two new parameters\nto its callback function: the current index, and the entire list.\n\nThis would turn, for instance, Ramda's simple `map` function into one that more closely\nresembles `Array.prototype.map`.  Note that this will only work for functions in which\nthe iteration callback function is the first parameter, and where the list is the last\nparameter.  (This latter might be unimportant if the list parameter is not used.)",
    "name": "addIndex",
    "sig": "((a ... -> b) ... -> [a] -> *) -> (a ..., Int, [a] -> b) ... -> [a] -> *)",
    "category": "Function"
  },
  {
    "description": "Returns `true` if all elements of the list match the predicate, `false` if there are any\nthat don't.\n\nActs as a transducer if a transformer is given in list position.",
    "name": "all",
    "sig": "(a -> Boolean) -> [a] -> Boolean",
    "category": "List"
  },
  {
    "description": "A function that returns the first argument if it's falsy otherwise the second\nargument. Note that this is NOT short-circuited, meaning that if expressions\nare passed they are both evaluated.\n\nDispatches to the `and` method of the first argument if applicable.",
    "name": "and",
    "sig": "* -> * -> *",
    "category": "Logic"
  },
  {
    "description": "Returns `true` if at least one of elements of the list match the predicate, `false`\notherwise.\n\nActs as a transducer if a transformer is given in list position.",
    "name": "any",
    "sig": "(a -> Boolean) -> [a] -> Boolean",
    "category": "List"
  },
  {
    "description": "Wraps a function of any arity (including nullary) in a function that accepts exactly 2\nparameters. Any extraneous parameters will not be passed to the supplied function.",
    "name": "binary",
    "sig": "(* -> c) -> (a, b -> c)",
    "category": "Function"
  },
  {
    "description": "Creates a deep copy of the value which may contain (nested) `Array`s and\n`Object`s, `Number`s, `String`s, `Boolean`s and `Date`s. `Function`s are\nnot copied, but assigned by their reference.",
    "name": "clone",
    "sig": "{*} -> {*}",
    "category": "Object"
  },
  {
    "description": "Returns a new list consisting of the elements of the first list followed by the elements\nof the second.",
    "name": "concat",
    "sig": "[a] -> [a] -> [a]",
    "category": "List"
  },
  {
    "description": "Returns a curried equivalent of the provided function. The curried\nfunction has two unusual capabilities. First, its arguments needn't\nbe provided one at a time. If `f` is a ternary function and `g` is\n`R.curry(f)`, the following are equivalent:\n\n  - `g(1)(2)(3)`\n  - `g(1)(2, 3)`\n  - `g(1, 2)(3)`\n  - `g(1, 2, 3)`\n\nSecondly, the special placeholder value `R.__` may be used to specify\n\"gaps\", allowing partial application of any combination of arguments,\nregardless of their positions. If `g` is as above and `_` is `R.__`,\nthe following are equivalent:\n\n  - `g(1, 2, 3)`\n  - `g(_, 2, 3)(1)`\n  - `g(_, _, 3)(1)(2)`\n  - `g(_, _, 3)(1, 2)`\n  - `g(_, 2)(1)(3)`\n  - `g(_, 2)(1, 3)`\n  - `g(_, 2)(_, 3)(1)`",
    "name": "curry",
    "sig": "(* -> a) -> (* -> a)",
    "category": "Function"
  },
  {
    "description": "Returns a new list containing the last `n` elements of a given list, passing each value\nto the supplied predicate function, skipping elements while the predicate function returns\n`true`. The predicate function is passed one argument: *(value)*.\n\nActs as a transducer if a transformer is given in list position.",
    "name": "dropWhile",
    "sig": "(a -> Boolean) -> [a] -> [a]",
    "category": "List"
  },
  {
    "description": "Returns `true` if its arguments are equivalent, `false` otherwise.\nDispatches to an `equals` method if present. Handles cyclical data\nstructures.",
    "name": "equals",
    "sig": "a -> b -> Boolean",
    "category": "Relation"
  },
  {
    "description": "Returns a new list containing only those items that match a given predicate function.\nThe predicate function is passed one argument: *(value)*.\n\nNote that `R.filter` does not skip deleted or unassigned indices, unlike the native\n`Array.prototype.filter` method. For more details on this behavior, see:\nhttps://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter#Description\n\nActs as a transducer if a transformer is given in list position.",
    "name": "filter",
    "sig": "(a -> Boolean) -> [a] -> [a]",
    "category": "List"
  },
  {
    "description": "Returns the first element of the list which matches the predicate, or `undefined` if no\nelement matches.\n\nActs as a transducer if a transformer is given in list position.",
    "name": "find",
    "sig": "(a -> Boolean) -> [a] -> a | undefined",
    "category": "List"
  },
  {
    "description": "Returns the index of the first element of the list which matches the predicate, or `-1`\nif no element matches.\n\nActs as a transducer if a transformer is given in list position.",
    "name": "findIndex",
    "sig": "(a -> Boolean) -> [a] -> Number",
    "category": "List"
  },
  {
    "description": "Returns the last element of the list which matches the predicate, or `undefined` if no\nelement matches.\n\nActs as a transducer if a transformer is given in list position.",
    "name": "findLast",
    "sig": "(a -> Boolean) -> [a] -> a | undefined",
    "category": "List"
  },
  {
    "description": "Returns the index of the last element of the list which matches the predicate, or\n`-1` if no element matches.\n\nActs as a transducer if a transformer is given in list position.",
    "name": "findLastIndex",
    "sig": "(a -> Boolean) -> [a] -> Number",
    "category": "List"
  },
  {
    "description": "Returns a new list by pulling every item out of it (and all its sub-arrays) and putting\nthem in a new array, depth-first.",
    "name": "flatten",
    "sig": "[a] -> [b]",
    "category": "List"
  },
  {
    "description": "Returns a new function much like the supplied one, except that the first two arguments'\norder is reversed.",
    "name": "flip",
    "sig": "(a -> b -> c -> ... -> z) -> (b -> a -> c -> ... -> z)",
    "category": "Function"
  },
  {
    "description": "Iterate over an input `list`, calling a provided function `fn` for each element in the\nlist.\n\n`fn` receives one argument: *(value)*.\n\nNote: `R.forEach` does not skip deleted or unassigned indices (sparse arrays), unlike\nthe native `Array.prototype.forEach` method. For more details on this behavior, see:\nhttps://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach#Description\n\nAlso note that, unlike `Array.prototype.forEach`, Ramda's `forEach` returns the original\narray. In some libraries this function is named `each`.",
    "name": "forEach",
    "sig": "(a -> *) -> [a] -> [a]",
    "category": "List"
  },
  {
    "description": "Returns a list of function names of object's own functions",
    "name": "functions",
    "sig": "{*} -> [String]",
    "category": "Object"
  },
  {
    "description": "Returns a list of function names of object's own and prototype functions",
    "name": "functionsIn",
    "sig": "{*} -> [String]",
    "category": "Object"
  },
  {
    "description": "Splits a list into sub-lists stored in an object, based on the result of calling a String-returning function\non each element, and grouping the results according to values returned.\n\nActs as a transducer if a transformer is given in list position.",
    "name": "groupBy",
    "sig": "(a -> String) -> [a] -> {String: [a]}",
    "category": "List"
  },
  {
    "description": "Returns the first element of the given list or string. In some libraries\nthis function is named `first`.",
    "name": "head",
    "sig": "[a] -> a | Undefined",
    "category": "List"
  },
  {
    "description": "Combines two lists into a set (i.e. no duplicates) composed of those\nelements common to both lists.  Duplication is determined according\nto the value returned by applying the supplied predicate to two list\nelements.",
    "name": "intersectionWith",
    "sig": "(a,a -> Boolean) -> [a] -> [a] -> [a]",
    "category": "Relation"
  },
  {
    "description": "Creates a new list with the separator interposed between elements.",
    "name": "intersperse",
    "sig": "a -> [a] -> [a]",
    "category": "List"
  },
  {
    "description": "Transforms the items of the list with the transducer and appends the transformed items to\nthe accumulator using an appropriate iterator function based on the accumulator type.\n\nThe accumulator can be an array, string, object or a transformer. Iterated items will\nbe appended to arrays and concatenated to strings. Objects will be merged directly or 2-item\narrays will be merged as key, value pairs.\n\nThe accumulator can also be a transformer object that provides a 2-arity reducing iterator\nfunction, step, 0-arity initial value function, init, and 1-arity result extraction function\nresult. The step function is used as the iterator function in reduce. The result function is\nused to convert the final accumulator into the return type and in most cases is R.identity.\nThe init function is used to provide the initial accumulator.\n\nThe iteration is performed with R.reduce after initializing the transducer.",
    "name": "into",
    "sig": "a -> (b -> b) -> [c] -> a",
    "category": "List"
  },
  {
    "description": "Same as R.invertObj, however this accounts for objects\nwith duplicate values by putting the values into an\narray.",
    "name": "invert",
    "sig": "{s: x} -> {x: [ s, ... ]}",
    "category": "Object"
  },
  {
    "description": "Returns a new object with the keys of the given object\nas values, and the values of the given object as keys.",
    "name": "invertObj",
    "sig": "{s: x} -> {x: s}",
    "category": "Object"
  },
  {
    "description": "Returns the last element of the given list or string.",
    "name": "last",
    "sig": "[a] -> a | Undefined",
    "category": "List"
  },
  {
    "description": "Returns the position of the last occurrence of an item in\nan array, or -1 if the item is not included in the array.\n`R.equals` is used to determine equality.",
    "name": "lastIndexOf",
    "sig": "a -> [a] -> Number",
    "category": "List"
  },
  {
    "description": "Returns a new list, constructed by applying the supplied function to every element of the\nsupplied list.\n\nNote: `R.map` does not skip deleted or unassigned indices (sparse arrays), unlike the\nnative `Array.prototype.map` method. For more details on this behavior, see:\nhttps://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map#Description\n\nActs as a transducer if a transformer is given in list position.",
    "name": "map",
    "sig": "(a -> b) -> [a] -> [b]",
    "category": "List"
  },
  {
    "description": "Map, but for objects. Creates an object with the same keys as `obj` and values\ngenerated by running each property of `obj` through `fn`. `fn` is passed one argument:\n*(value)*.",
    "name": "mapObj",
    "sig": "(v -> v) -> {k: v} -> {k: v}",
    "category": "Object"
  },
  {
    "description": "Like `mapObj`, but but passes additional arguments to the predicate function. The\npredicate function is passed three arguments: *(value, key, obj)*.",
    "name": "mapObjIndexed",
    "sig": "(v, k, {k: v} -> v) -> {k: v} -> {k: v}",
    "category": "Object"
  },
  {
    "description": "Returns `true` if no elements of the list match the predicate,\n`false` otherwise.",
    "name": "none",
    "sig": "(a -> Boolean) -> [a] -> Boolean",
    "category": "List"
  },
  {
    "description": "A function that returns the first truthy of two arguments otherwise the\nlast argument. Note that this is NOT short-circuited, meaning that if\nexpressions are passed they are both evaluated.\n\nDispatches to the `or` method of the first argument if applicable.",
    "name": "or",
    "sig": "* -> * -> *",
    "category": "Logic"
  },
  {
    "description": "Accepts as its arguments a function and any number of values and returns a function that,\nwhen invoked, calls the original function with all of the values prepended to the\noriginal function's arguments list. In some libraries this function is named `applyLeft`.",
    "name": "partial",
    "sig": "(a -> b -> ... -> i -> j -> ... -> m -> n) -> a -> b-> ... -> i -> (j -> ... -> m -> n)",
    "category": "Function"
  },
  {
    "description": "Accepts as its arguments a function and any number of values and returns a function that,\nwhen invoked, calls the original function with all of the values appended to the original\nfunction's arguments list.\n\nNote that `partialRight` is the opposite of `partial`: `partialRight` fills `fn`'s arguments\nfrom the right to the left.  In some libraries this function is named `applyRight`.",
    "name": "partialRight",
    "sig": "(a -> b-> ... -> i -> j -> ... -> m -> n) -> j -> ... -> m -> n -> (a -> b-> ... -> i)",
    "category": "Function"
  },
  {
    "description": "Takes a predicate and a list and returns the pair of lists of\nelements which do and do not satisfy the predicate, respectively.",
    "name": "partition",
    "sig": "(a -> Boolean) -> [a] -> [[a],[a]]",
    "category": "List"
  },
  {
    "description": "Determines whether a nested path on an object has a specific value,\nin `R.equals` terms. Most likely used to filter a list.",
    "name": "pathEq",
    "sig": "[String] -> * -> {String: *} -> Boolean",
    "category": "Relation"
  },
  {
    "description": "Returns a new list by plucking the same named property off all objects in the list supplied.",
    "name": "pluck",
    "sig": "k -> [{k: v}] -> [v]",
    "category": "List"
  },
  {
    "description": "Returns `true` if the specified object property is equal, in `R.equals`\nterms, to the given value; `false` otherwise.",
    "name": "propEq",
    "sig": "a -> String -> Object -> Boolean",
    "category": "Relation"
  },
  {
    "description": "Returns `true` if the specified object property is of the given type;\n`false` otherwise.",
    "name": "propIs",
    "sig": "Type -> String -> Object -> Boolean",
    "category": "Type"
  },
  {
    "description": "Returns a single item by iterating through the list, successively calling the iterator\nfunction and passing it an accumulator value and the current value from the array, and\nthen passing the result to the next call.\n\nThe iterator function receives two values: *(acc, value)*.  It may use `R.reduced` to\nshortcut the iteration.\n\nNote: `R.reduce` does not skip deleted or unassigned indices (sparse arrays), unlike\nthe native `Array.prototype.reduce` method. For more details on this behavior, see:\nhttps://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce#Description",
    "name": "reduce",
    "sig": "(a,b -> a) -> a -> [b] -> a",
    "category": "List"
  },
  {
    "description": "Similar to `filter`, except that it keeps only values for which the given predicate\nfunction returns falsy. The predicate function is passed one argument: *(value)*.\n\nActs as a transducer if a transformer is given in list position.",
    "name": "reject",
    "sig": "(a -> Boolean) -> [a] -> [a]",
    "category": "List"
  },
  {
    "description": "Returns a fixed list of size `n` containing a specified identical value.",
    "name": "repeat",
    "sig": "a -> n -> [a]",
    "category": "List"
  },
  {
    "description": "Returns the elements of the given list or string (or object with a `slice`\nmethod) from `fromIndex` (inclusive) to `toIndex` (exclusive).",
    "name": "slice",
    "sig": "Number -> Number -> [a] -> [a]",
    "category": "List"
  },
  {
    "description": "Splits a collection into slices of the specified length.",
    "name": "splitEvery",
    "sig": "Number -> [a] -> [[a]]",
    "category": "List"
  },
  {
    "description": "Adds together all the elements of a list.",
    "name": "sum",
    "sig": "[Number] -> Number",
    "category": "Math"
  },
  {
    "description": "Returns all but the first element of the given list or string (or object\nwith a `tail` method).",
    "name": "tail",
    "sig": "[a] -> [a]",
    "category": "List"
  },
  {
    "description": "Returns the first `n` elements of the given list, string, or\ntransducer/transformer (or object with a `take` method).",
    "name": "take",
    "sig": "Number -> [a] -> [a]",
    "category": "List"
  },
  {
    "description": "Returns a new list containing the first `n` elements of a given list, passing each value\nto the supplied predicate function, and terminating when the predicate function returns\n`false`. Excludes the element that caused the predicate function to fail. The predicate\nfunction is passed one argument: *(value)*.\n\nActs as a transducer if a transformer is given in list position.",
    "name": "takeWhile",
    "sig": "(a -> Boolean) -> [a] -> [a]",
    "category": "List"
  },
  {
    "description": "Initializes a transducer using supplied iterator function. Returns a single item by\niterating through the list, successively calling the transformed iterator function and\npassing it an accumulator value and the current value from the array, and then passing\nthe result to the next call.\n\nThe iterator function receives two values: *(acc, value)*. It will be wrapped as a\ntransformer to initialize the transducer. A transformer can be passed directly in place\nof an iterator function.  In both cases, iteration may be stopped early with the\n`R.reduced` function.\n\nA transducer is a function that accepts a transformer and returns a transformer and can\nbe composed directly.\n\nA transformer is an an object that provides a 2-arity reducing iterator function, step,\n0-arity initial value function, init, and 1-arity result extraction function, result.\nThe step function is used as the iterator function in reduce. The result function is used\nto convert the final accumulator into the return type and in most cases is R.identity.\nThe init function can be used to provide an initial accumulator, but is ignored by transduce.\n\nThe iteration is performed with R.reduce after initializing the transducer.",
    "name": "transduce",
    "sig": "(c -> c) -> (a,b -> a) -> a -> [b] -> a",
    "category": "List"
  },
  {
    "description": "Combines two lists into a set (i.e. no duplicates) composed of the elements of each list.  Duplication is\ndetermined according to the value returned by applying the supplied predicate to two list elements.",
    "name": "unionWith",
    "sig": "(a,a -> Boolean) -> [a] -> [a] -> [a]",
    "category": "Relation"
  },
  {
    "description": "Returns a new list containing only one copy of each element in the original list.\n`R.equals` is used to determine equality.",
    "name": "uniq",
    "sig": "[a] -> [a]",
    "category": "List"
  },
  {
    "description": "Returns a new list by pulling every item at the first level of nesting out, and putting\nthem in a new array.",
    "name": "unnest",
    "sig": "[a] -> [b]",
    "category": "List"
  },
  {
    "description": "Accepts a function `fn` and any number of transformer functions and returns a new\nfunction. When the new function is invoked, it calls the function `fn` with parameters\nconsisting of the result of calling each supplied handler on successive arguments to the\nnew function.\n\nIf more arguments are passed to the returned function than transformer functions, those\narguments are passed directly to `fn` as additional parameters. If you expect additional\narguments that don't need to be transformed, although you can ignore them, it's best to\npass an identity function so that the new function reports the correct arity.",
    "name": "useWith",
    "sig": "(x1 -> x2 -> ... -> z) -> ((a -> x1), (b -> x2), ...) -> (a -> b -> ... -> z)",
    "category": "Function"
  },
  {
    "description": "Takes a spec object and a test object; returns true if the test satisfies\nthe spec, false otherwise. An object satisfies the spec if, for each of the\nspec's own properties, accessing that property of the object gives the same\nvalue (in `R.equals` terms) as accessing that property of the spec.\n\n`whereEq` is a specialization of [`where`](#where).",
    "name": "whereEq",
    "sig": "{String: *} -> {String: *} -> Boolean",
    "category": "Object"
  },
  {
    "description": "Given a list of predicates, returns a new predicate that will be true exactly when all of them are.",
    "name": "allPass",
    "sig": "[(*... -> Boolean)] -> (*... -> Boolean)",
    "category": "Logic"
  },
  {
    "description": "Given a list of predicates returns a new predicate that will be true exactly when any one of them is.",
    "name": "anyPass",
    "sig": "[(*... -> Boolean)] -> (*... -> Boolean)",
    "category": "Logic"
  },
  {
    "description": "ap applies a list of functions to a list of values.",
    "name": "ap",
    "sig": "[f] -> [a] -> [f a]",
    "category": "Function"
  },
  {
    "description": "Returns the result of calling its first argument with the remaining\narguments. This is occasionally useful as a converging function for\n`R.converge`: the left branch can produce a function while the right\nbranch produces a value to be passed to that function as an argument.",
    "name": "call",
    "sig": "(*... -> a),*... -> a",
    "category": "Function"
  },
  {
    "description": "`chain` maps a function over a list and concatenates the results.\nThis implementation is compatible with the\nFantasy-land Chain spec, and will work with types that implement that spec.\n`chain` is also known as `flatMap` in some libraries",
    "name": "chain",
    "sig": "(a -> [b]) -> [a] -> [b]",
    "category": "List"
  },
  {
    "description": "Turns a list of Functors into a Functor of a list, applying\na mapping function to the elements of the list along the way.",
    "name": "commuteMap",
    "sig": "Functor f => (f a -> f b) -> (x -> f x) -> [f a] -> f [b]",
    "category": "List"
  },
  {
    "description": "Wraps a constructor function inside a curried function that can be called with the same\narguments and returns the same type. The arity of the function returned is specified\nto allow using variadic constructor functions.",
    "name": "constructN",
    "sig": "Number -> (* -> {*}) -> (* -> {*})",
    "category": "Function"
  },
  {
    "description": "Accepts at least three functions and returns a new function. When invoked, this new\nfunction will invoke the first function, `after`, passing as its arguments the\nresults of invoking the subsequent functions with whatever arguments are passed to\nthe new function.",
    "name": "converge",
    "sig": "(x1 -> x2 -> ... -> z) -> ((a -> b -> ... -> x1), (a -> b -> ... -> x2), ...) -> (a -> b -> ... -> z)",
    "category": "Function"
  },
  {
    "description": "Returns all but the first `n` elements of the given list, string, or\ntransducer/transformer (or object with a `drop` method).",
    "name": "drop",
    "sig": "Number -> [a] -> [a]",
    "category": "List"
  },
  {
    "description": "Returns a list containing all but the last `n` elements of the given `list`.",
    "name": "dropLast",
    "sig": "Number -> [a] -> [a]",
    "category": "List"
  },
  {
    "description": "Returns a new list without any consecutively repeating elements. Equality is\ndetermined by applying the supplied predicate two consecutive elements.\nThe first element in a series of equal element is the one being preserved.\n\nActs as a transducer if a transformer is given in list position.",
    "name": "dropRepeatsWith",
    "sig": "(a, a -> Boolean) -> [a] -> [a]",
    "category": "List"
  },
  {
    "description": "Reports whether two objects have the same value, in `R.equals` terms,\nfor the specified property. Useful as a curried predicate.",
    "name": "eqProps",
    "sig": "k -> {k: v} -> {k: v} -> Boolean",
    "category": "Object"
  },
  {
    "description": "Returns the position of the first occurrence of an item in an array,\nor -1 if the item is not included in the array. `R.equals` is used to\ndetermine equality.",
    "name": "indexOf",
    "sig": "a -> [a] -> Number",
    "category": "List"
  },
  {
    "description": "Returns all but the last element of the given list or string.",
    "name": "init",
    "sig": "[a] -> [a]",
    "category": "List"
  },
  {
    "description": "Returns `true` if all elements are unique, in `R.equals` terms,\notherwise `false`.",
    "name": "isSet",
    "sig": "[a] -> Boolean",
    "category": "List"
  },
  {
    "description": "Returns a lens for the given getter and setter functions. The getter \"gets\"\nthe value of the focus; the setter \"sets\" the value of the focus. The setter\nshould not mutate the data structure.",
    "name": "lens",
    "sig": "(s -> a) -> ((a, s) -> s) -> Lens s a",
    "category": "Object"
  },
  {
    "description": "Returns a lens whose focus is the specified index.",
    "name": "lensIndex",
    "sig": "Number -> Lens s a",
    "category": "Object"
  },
  {
    "description": "Returns a lens whose focus is the specified property.",
    "name": "lensProp",
    "sig": "String -> Lens s a",
    "category": "Object"
  },
  {
    "description": "\"lifts\" a function to be the specified arity, so that it may \"map over\" that many\nlists (or other Functors).",
    "name": "liftN",
    "sig": "Number -> (*... -> *) -> ([*]... -> [*])",
    "category": "Function"
  },
  {
    "description": "Returns the mean of the given list of numbers.",
    "name": "mean",
    "sig": "[Number] -> Number",
    "category": "Math"
  },
  {
    "description": "Returns the median of the given list of numbers.",
    "name": "median",
    "sig": "[Number] -> Number",
    "category": "Math"
  },
  {
    "description": "Merges a list of objects together into one object.",
    "name": "mergeAll",
    "sig": "[{k: v}] -> {k: v}",
    "category": "List"
  },
  {
    "description": "Performs left-to-right function composition. The leftmost function may have\nany arity; the remaining functions must be unary.\n\nIn some libraries this function is named `sequence`.",
    "name": "pipe",
    "sig": "(((a, b, ..., n) -> o), (o -> p), ..., (x -> y), (y -> z)) -> (a -> b -> ... -> n -> z)",
    "category": "Function"
  },
  {
    "description": "Performs left-to-right composition of one or more Promise-returning\nfunctions. The leftmost function may have any arity; the remaining\nfunctions must be unary.",
    "name": "pipeP",
    "sig": "((a -> Promise b), (b -> Promise c), ..., (y -> Promise z)) -> (a -> Promise z)",
    "category": "Function"
  },
  {
    "description": "Multiplies together all the elements of a list.",
    "name": "product",
    "sig": "[Number] -> Number",
    "category": "Math"
  },
  {
    "description": "Reasonable analog to SQL `select` statement.",
    "name": "project",
    "sig": "[k] -> [{k: v}] -> [{k: v}]",
    "category": "Object"
  },
  {
    "description": "Returns a new list containing the last `n` elements of the given list.\nIf `n > list.length`, returns a list of `list.length` elements.",
    "name": "takeLast",
    "sig": "Number -> [a] -> [a]",
    "category": "List"
  },
  {
    "description": "Turns a list of Functors into a Functor of a list.",
    "name": "commute",
    "sig": "Functor f => (x -> f x) -> [f a] -> f [a]",
    "category": "List"
  },
  {
    "description": "Performs right-to-left function composition. The rightmost function may have\nany arity; the remaining functions must be unary.",
    "name": "compose",
    "sig": "((y -> z), (x -> y), ..., (o -> p), ((a, b, ..., n) -> o)) -> (a -> b -> ... -> n -> z)",
    "category": "Function"
  },
  {
    "description": "Returns the right-to-left Kleisli composition of the provided functions,\neach of which must return a value of a type supported by [`chain`](#chain).\n\n`R.composeK(h, g, f)` is equivalent to `R.compose(R.chain(h), R.chain(g), R.chain(f))`.",
    "name": "composeK",
    "sig": "Chain m => ((y -> m z), (x -> m y), ..., (a -> m b)) -> (m a -> m z)",
    "category": "Function"
  },
  {
    "description": "Performs right-to-left composition of one or more Promise-returning\nfunctions. The rightmost function may have any arity; the remaining\nfunctions must be unary.",
    "name": "composeP",
    "sig": "((y -> Promise z), (x -> Promise y), ..., (a -> Promise b)) -> (a -> Promise z)",
    "category": "Function"
  },
  {
    "description": "Wraps a constructor function inside a curried function that can be called with the same\narguments and returns the same type.",
    "name": "construct",
    "sig": "(* -> {*}) -> (* -> {*})",
    "category": "Function"
  },
  {
    "description": "Returns `true` if the specified value is equal, in `R.equals` terms,\nto at least one element of the given list; `false` otherwise.",
    "name": "contains",
    "sig": "a -> [a] -> Boolean",
    "category": "List"
  },
  {
    "description": "Finds the set (i.e. no duplicates) of all elements in the first list not contained in the second list.",
    "name": "difference",
    "sig": "[a] -> [a] -> [a]",
    "category": "Relation"
  },
  {
    "description": "Returns a new list without any consecutively repeating elements.\n`R.equals` is used to determine equality.\n\nActs as a transducer if a transformer is given in list position.",
    "name": "dropRepeats",
    "sig": "[a] -> [a]",
    "category": "List"
  },
  {
    "description": "Combines two lists into a set (i.e. no duplicates) composed of those elements common to both lists.",
    "name": "intersection",
    "sig": "[a] -> [a] -> [a]",
    "category": "Relation"
  },
  {
    "description": "\"lifts\" a function of arity > 1 so that it may \"map over\" an Array or\nother Functor.",
    "name": "lift",
    "sig": "(*... -> *) -> ([*]... -> [*])",
    "category": "Function"
  },
  {
    "description": "Returns a partial copy of an object omitting the keys specified.",
    "name": "omit",
    "sig": "[String] -> {String: *} -> {String: *}",
    "category": "Object"
  },
  {
    "description": "Returns the left-to-right Kleisli composition of the provided functions,\neach of which must return a value of a type supported by [`chain`](#chain).\n\n`R.pipeK(f, g, h)` is equivalent to `R.pipe(R.chain(f), R.chain(g), R.chain(h))`.",
    "name": "pipeK",
    "sig": "Chain m => ((a -> m b), (b -> m c), ..., (y -> m z)) -> (m a -> m z)",
    "category": "Function"
  },
  {
    "description": "Returns the string representation of the given value. `eval`'ing the output\nshould result in a value equivalent to the input value. Many of the built-in\n`toString` methods do not satisfy this requirement.\n\nIf the given value is an `[object Object]` with a `toString` method other\nthan `Object.prototype.toString`, this method is invoked with no arguments\nto produce the return value. This means user-defined constructor functions\ncan provide a suitable `toString` method. For example:\n\n    function Point(x, y) {\n      this.x = x;\n      this.y = y;\n    }\n\n    Point.prototype.toString = function() {\n      return 'new Point(' + this.x + ', ' + this.y + ')';\n    };\n\n    R.toString(new Point(1, 2)); //=> 'new Point(1, 2)'",
    "name": "toString",
    "sig": "* -> String",
    "category": "String"
  },
  {
    "description": "Combines two lists into a set (i.e. no duplicates) composed of the\nelements of each list.",
    "name": "union",
    "sig": "[a] -> [a] -> [a]",
    "category": "Relation"
  },
  {
    "description": "Returns a new list containing only one copy of each element in the\noriginal list, based upon the value returned by applying the supplied\nfunction to each list element. Prefers the first item if the supplied\nfunction produces the same value on two items. `R.equals` is used for\ncomparison.",
    "name": "uniqBy",
    "sig": "(a -> b) -> [a] -> [a]",
    "category": "List"
  },
  {
    "description": "Turns a named method with a specified arity into a function\nthat can be called directly supplied with arguments and a target object.\n\nThe returned function is curried and accepts `arity + 1` parameters where\nthe final parameter is the target object.",
    "name": "invoker",
    "sig": "Number -> String -> (a -> b -> ... -> n -> Object -> *)",
    "category": "Function"
  },
  {
    "description": "Returns a string made by inserting the `separator` between each\nelement and concatenating all the elements into a single string.",
    "name": "join",
    "sig": "String -> [a] -> String",
    "category": "List"
  },
  {
    "description": "Tests a regular expression against a String. Note that this function\nwill return an empty array when there are no matches. This differs\nfrom [`String.prototype.match`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/match)\nwhich returns `null` when there are no matches.",
    "name": "match",
    "sig": "RegExp -> String -> [String | Undefined]",
    "category": "String"
  },
  {
    "description": "Creates a new function that, when invoked, caches the result of calling `fn` for a given\nargument set and returns the result. Subsequent calls to the memoized `fn` with the same\nargument set will not result in an additional call to `fn`; instead, the cached result\nfor that set of arguments will be returned.",
    "name": "memoize",
    "sig": "(*... -> a) -> (*... -> a)",
    "category": "Function"
  },
  {
    "description": "Splits a string into an array of strings based on the given\nseparator.",
    "name": "split",
    "sig": "String -> String -> [String]",
    "category": "String"
  },
  {
    "description": "The lower case version of a string.",
    "name": "toLower",
    "sig": "String -> String",
    "category": "String"
  },
  {
    "description": "The upper case version of a string.",
    "name": "toUpper",
    "sig": "String -> String",
    "category": "String"
  }
]