v0_15_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 (or strings). 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 non-primitives the value\nreturned is a reference to the original value.",
    "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": "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": "Wraps a function of any arity (including nullary) in a function that accepts exactly `n`\nparameters. Unlike `nAry`, which passes only `n` arguments to the wrapped function,\nfunctions produced by `arity` will pass all provided arguments to the wrapped function.",
    "name": "arity",
    "sig": "(Number, (* -> *)) -> (* -> *)",
    "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": "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.\nEach argument to `R.cond` is a [predicate, transform] pair. All of\nthe arguments 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": "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": "Divides two numbers. Equivalent to `a / b`.",
    "name": "divide",
    "sig": "Number -> Number -> Number",
    "category": "Math"
  },
  {
    "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": "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": "Like `filter`, but passes additional parameters to the predicate function. The predicate\nfunction is passed three arguments: *(value, index, list)*.",
    "name": "filterIndexed",
    "sig": "(a, i, [a] -> Boolean) -> [a] -> [a]",
    "category": "List"
  },
  {
    "description": "Like `forEach`, but but passes additional parameters to the predicate function.\n\n`fn` receives three arguments: *(value, index, list)*.\n\nNote: `R.forEachIndexed` does not skip deleted or unassigned indices (sparse arrays),\nunlike the native `Array.prototype.forEach` method. For more details on this behavior,\nsee:\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": "forEachIndexed",
    "sig": "(a, i, [a] -> ) -> [a] -> [a]",
    "category": "List"
  },
  {
    "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 parameter is greater than the second.",
    "name": "gt",
    "sig": "Number -> Number -> Boolean",
    "category": "Math"
  },
  {
    "description": "Returns true if the first parameter is greater than or equal to the second.",
    "name": "gte",
    "sig": "Number -> Number -> Boolean",
    "category": "Math"
  },
  {
    "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": "Increments its argument.",
    "name": "inc",
    "sig": "Number -> Number",
    "category": "Math"
  },
  {
    "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": "Creates a lens. Supply a function to `get` values from inside an object, and a `set`\nfunction to change values on an object. (n.b.: This can, and should, be done without\nmutating the original object!) The lens is a function wrapped around the input `get`\nfunction, with the `set` function attached as a property on the wrapper. A `map`\nfunction is also attached to the returned function that takes a function to operate\non the specified (`get`) property, which is then `set` before returning. The attached\n`set` and `map` functions are curried.",
    "name": "lens",
    "sig": "(k -> v) -> (v -> a -> *) -> (a -> b)",
    "category": "Object"
  },
  {
    "description": "Returns a lens associated with the provided object.",
    "name": "lensOn",
    "sig": "({} -> v) -> (v -> a -> *) -> {} -> (a -> b)",
    "category": "Object"
  },
  {
    "description": "Returns true if the first parameter is less than the second.",
    "name": "lt",
    "sig": "Number -> Number -> Boolean",
    "category": "Math"
  },
  {
    "description": "Returns true if the first parameter is less than or equal to the second.",
    "name": "lte",
    "sig": "Number -> Number -> Boolean",
    "category": "Math"
  },
  {
    "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": "Like `map`, but but passes additional parameters to the mapping function.\n`fn` receives three arguments: *(value, index, list)*.\n\nNote: `R.mapIndexed` does not skip deleted or unassigned indices (sparse arrays), unlike\nthe native `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",
    "name": "mapIndexed",
    "sig": "(a,i,[b] -> b) -> [a] -> [b]",
    "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": "Determines the largest of a list of items as determined by pairwise comparisons from the supplied comparator.\nNote that this will return undefined if supplied an empty list.",
    "name": "maxBy",
    "sig": "(a -> Number) -> [a] -> a",
    "category": "Math"
  },
  {
    "description": "Determines the smallest of a list of items as determined by pairwise comparisons from the supplied comparator\nNote that this will return undefined if supplied an empty list.",
    "name": "minBy",
    "sig": "(a -> Number) -> [a] -> a",
    "category": "Math"
  },
  {
    "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 in a list.\nIf n is negative the element at index length + n is returned.",
    "name": "nth",
    "sig": "Number -> [a] -> a",
    "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": "Retrieve the value at a given path.",
    "name": "path",
    "sig": "[String] -> {*} -> *",
    "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",
    "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": "Acts as multiple `get`: 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": "Like `reduce`, but passes additional parameters to the predicate function.\n\nThe iterator function receives four values: *(acc, value, index, list)*\n\nNote: `R.reduceIndexed` does not skip deleted or unassigned indices (sparse arrays),\nunlike the native `Array.prototype.reduce` method. For more details on this behavior,\nsee:\nhttps://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce#Description",
    "name": "reduceIndexed",
    "sig": "(a,b,i,[b] -> a) -> a -> [b] -> a",
    "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": "Like `reduceRight`, but passes additional parameters to the predicate function. Moves through\nthe input list from the right to the left.\n\nThe iterator function receives four values: *(acc, value, index, list)*.\n\nNote: `R.reduceRightIndexed` does not skip deleted or unassigned indices (sparse arrays),\nunlike the native `Array.prototype.reduce` method. For more details on this behavior,\nsee:\nhttps://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduceRight#Description",
    "name": "reduceRightIndexed",
    "sig": "(a,b,i,[b] -> 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": "Like `reject`, but passes additional parameters to the predicate function. The predicate\nfunction is passed three arguments: *(value, index, list)*.",
    "name": "rejectIndexed",
    "sig": "(a, i, [a] -> Boolean) -> [a] -> [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 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 a key generated by the supplied function.",
    "name": "sortBy",
    "sig": "(a -> String) -> [a] -> [a]",
    "category": "Relation"
  },
  {
    "description": "Finds the first index of a substring in a string, returning -1 if it's not present",
    "name": "strIndexOf",
    "sig": "String -> String -> Number",
    "category": "String"
  },
  {
    "description": "Finds the last index of a substring in a string, returning -1 if it's not present",
    "name": "strLastIndexOf",
    "sig": "String -> String -> Number",
    "category": "String"
  },
  {
    "description": "Subtracts two numbers. Equivalent to `a - b` but curried.",
    "name": "subtract",
    "sig": "Number -> Number -> Number",
    "category": "Math"
  },
  {
    "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": "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": "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": "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": "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": "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": "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": "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": "Creates a new function that runs each of the functions supplied as parameters in turn,\npassing the return value of each function invocation to the next function invocation,\nbeginning with whatever arguments were passed to the initial invocation.\n\nNote that `compose` is a right-associative function, which means the functions provided\nwill be invoked in order from right to left. In the example `var h = compose(f, g)`,\nthe function `h` is equivalent to `f( g(x) )`, where `x` represents the arguments\noriginally passed to `h`.",
    "name": "compose",
    "sig": "((y -> z), (x -> y), ..., (b -> c), (a... -> b)) -> (a... -> z)",
    "category": "Function"
  },
  {
    "description": "Creates a new lens that allows getting and setting values of nested properties, by\nfollowing each given lens in succession.\n\nNote that `composeL` is a right-associative function, which means the lenses provided\nwill be invoked in order from right to left.",
    "name": "composeL",
    "sig": "((y -> z), (x -> y), ..., (b -> c), (a -> b)) -> (a -> z)",
    "category": "Function"
  },
  {
    "description": "Similar to `compose` but with automatic handling of promises (or, more\nprecisely, \"thenables\"). The behavior is identical  to that of\ncompose() if all composed functions return something other than\npromises (i.e., objects with a .then() method). If one of the function\nreturns a promise, however, then the next function in the composition\nis called asynchronously, in the success callback of the promise, using\nthe resolved value as an input. Note that `composeP` is a right-\nassociative function, just like `compose`.",
    "name": "composeP",
    "sig": "((y -> z), (x -> y), ..., (b -> c), (a... -> b)) -> (a... -> z)",
    "category": "Function"
  },
  {
    "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, 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": "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": "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": "`empty` returns an empty list for any argument, except when the argument satisfies the\nFantasy-land Monoid spec. In that case, this function will return the result of invoking\n`empty` on that Monoid.",
    "name": "empty",
    "sig": "* -> []",
    "category": "Function"
  },
  {
    "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": "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 in a list.\nIn some libraries this function is named `first`.",
    "name": "head",
    "sig": "[a] -> a",
    "category": "List"
  },
  {
    "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": "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": "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": "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": "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": "Returns the last element from a list.",
    "name": "last",
    "sig": "[a] -> a",
    "category": "List"
  },
  {
    "description": "Creates a lens that will focus on index `n` of the source array.",
    "name": "lensIndex",
    "sig": "Number -> (a -> b)",
    "category": "List"
  },
  {
    "description": "Creates a lens that will focus on property `k` of the source object.",
    "name": "lensProp",
    "sig": "String -> (a -> b)",
    "category": "Object"
  },
  {
    "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": "Tests a regular expression against a String",
    "name": "match",
    "sig": "RegExp -> String -> [String] | null",
    "category": "String"
  },
  {
    "description": "Determines the largest of a list of numbers (or elements that can be cast to numbers)",
    "name": "max",
    "sig": "[Number] -> Number",
    "category": "Math"
  },
  {
    "description": "Create a new object with the own properties of a\nmerged with the own properties of object b.\nThis function will *not* mutate passed-in objects.",
    "name": "merge",
    "sig": "{k: v} -> {k: v} -> {k: v}",
    "category": "Object"
  },
  {
    "description": "Determines the smallest of a list of numbers (or elements that can be cast to numbers)",
    "name": "min",
    "sig": "[Number] -> Number",
    "category": "Math"
  },
  {
    "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": "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": "Creates a new function that runs each of the functions supplied as parameters in turn,\npassing the return value of each function invocation to the next function invocation,\nbeginning with whatever arguments were passed to the initial invocation.\n\n`pipe` is the mirror version of `compose`. `pipe` is left-associative, which means that\neach of the functions provided is executed in order from left to right.\n\nIn some libraries this function is named `sequence`.",
    "name": "pipe",
    "sig": "((a... -> b), (b -> c), ..., (x -> y), (y -> z)) -> (a... -> z)",
    "category": "Function"
  },
  {
    "description": "Creates a new lens that allows getting and setting values of nested properties, by\nfollowing each given lens in succession.\n\n`pipeL` is the mirror version of `composeL`. `pipeL` is left-associative, which means that\neach of the functions provided is executed in order from left to right.",
    "name": "pipeL",
    "sig": "((a -> b), (b -> c), ..., (x -> y), (y -> z)) -> (a -> z)",
    "category": "Function"
  },
  {
    "description": "Creates a new function that runs each of the functions supplied as parameters in turn,\npassing to the next function invocation either the value returned by the previous\nfunction or the resolved value if the returned value is a promise. In other words,\nif some of the functions in the sequence return promises, `pipeP` pipes the values\nasynchronously. If none of the functions return promises, the behavior is the same as\nthat of `pipe`.\n\n`pipeP` is the mirror version of `composeP`. `pipeP` is left-associative, which means that\neach of the functions provided is executed in order from left to right.",
    "name": "pipeP",
    "sig": "((a... -> b), (b -> c), ..., (x -> y), (y -> z)) -> (a... -> z)",
    "category": "Function"
  },
  {
    "description": "Determines whether the given property of an object has a specific value,\nin `R.equals` terms. Most likely used to filter a list.",
    "name": "propEq",
    "sig": "k -> v -> {k: v} -> Boolean",
    "category": "Relation"
  },
  {
    "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 a list containing the elements of `xs` from `fromIndex` (inclusive)\nto `toIndex` (exclusive).",
    "name": "slice",
    "sig": "Number -> Number -> [a] -> [a]",
    "category": "List"
  },
  {
    "description": "Splits a string into an array of strings based on the given\nseparator.",
    "name": "split",
    "sig": "String -> String -> [String]",
    "category": "String"
  },
  {
    "description": "Returns a string containing the characters of `str` from `fromIndex`\n(inclusive) to `toIndex` (exclusive).",
    "name": "substring",
    "sig": "Number -> Number -> String -> String",
    "category": "String"
  },
  {
    "description": "Returns a string containing the characters of `str` from `fromIndex`\n(inclusive) to the end of `str`.",
    "name": "substringFrom",
    "sig": "Number -> String -> String",
    "category": "String"
  },
  {
    "description": "Returns a string containing the first `toIndex` characters of `str`.",
    "name": "substringTo",
    "sig": "Number -> String -> String",
    "category": "String"
  },
  {
    "description": "Adds together all the elements of a list.",
    "name": "sum",
    "sig": "[Number] -> Number",
    "category": "Math"
  },
  {
    "description": "Returns all but the first element of a list. If the list provided has the `tail` method,\nit will instead return `list.tail()`.",
    "name": "tail",
    "sig": "[a] -> [a]",
    "category": "List"
  },
  {
    "description": "Returns a new list containing the first `n` elements of the given list.\nIf `n > list.length`, returns a list of `list.length` elements.\n\nActs as a transducer if a transformer is given in list position.",
    "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": "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"
  },
  {
    "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": "Returns a function of arity `n` from a (manually) curried function.",
    "name": "uncurryN",
    "sig": "Number -> (a -> b) -> (a -> c)",
    "category": "Function"
  },
  {
    "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 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": "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": "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 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": "ap applies a list of functions to a list of values.",
    "name": "ap",
    "sig": "[f] -> [a] -> [f 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.\n\nNote: `commuteMap` may be more useful to convert a list of non-Array Functors (e.g.\nMaybe, Either, etc.) to Functor of a list.",
    "name": "commuteMap",
    "sig": "(a -> (b -> c)) -> (x -> [x]) -> [[*]...]",
    "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 list containing all but the first `n` elements of the given `list`.\n\nActs as a transducer if a transformer is given in list position.",
    "name": "drop",
    "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 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": "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 a list.",
    "name": "init",
    "sig": "[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": "Returns the result of applying `obj[methodName]` to `args`.",
    "name": "invoke",
    "sig": "String -> [*] -> Object -> *",
    "category": "Object"
  },
  {
    "description": "Returns `true` if all elements are unique, in `R.equals` terms,\notherwise `false`.",
    "name": "isSet",
    "sig": "[a] -> Boolean",
    "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": "\"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": "Returns a partial copy of an object omitting the keys specified.",
    "name": "omit",
    "sig": "[String] -> {String: *} -> {String: *}",
    "category": "Object"
  },
  {
    "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": "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": "Multiplies together all the elements of a list.",
    "name": "product",
    "sig": "[Number] -> Number",
    "category": "Math"
  },
  {
    "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": "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": "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": "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": "Turns a list of Functors into a Functor of a list.\n\nNote: `commute` may be more useful to convert a list of non-Array Functors (e.g.\nMaybe, Either, etc.) to Functor of a list.",
    "name": "commute",
    "sig": "(x -> [x]) -> [[*]...]",
    "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": "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": "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": "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": "\"lifts\" a function of arity > 1 so that it may \"map over\" an Array or\nother Functor.",
    "name": "lift",
    "sig": "(*... -> *) -> ([*]... -> [*])",
    "category": "Function"
  },
  {
    "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": "Reasonable analog to SQL `select` statement.",
    "name": "project",
    "sig": "[k] -> [{k: v}] -> [{k: v}]",
    "category": "Object"
  },
  {
    "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": "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": "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"
  }
]