v0_12_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": "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": "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.",
    "name": "and",
    "sig": "* -> * -> *",
    "category": "Logic"
  },
  {
    "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": "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": "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": "Tests if two items are equal.  Equality is strict here, meaning reference equality for objects and\nnon-coercing equality for primitives.",
    "name": "eq",
    "sig": "a -> b -> Boolean",
    "category": "Relation"
  },
  {
    "description": "Reports whether two objects have the same value for the specified property.  Useful as a curried predicate.",
    "name": "eqProps",
    "sig": "k -> {k: v} -> {k: v} -> Boolean",
    "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": "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": "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": "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": "Returns the position of the first occurrence of an item in an array\n(by strict equality),\nor -1 if the item is not included in the array.",
    "name": "indexOf",
    "sig": "a -> [a] -> Number",
    "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": "",
    "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 `true` if all elements are unique, otherwise `false`.\nUniqueness is determined using strict equality (`===`).",
    "name": "isSet",
    "sig": "[a] -> Boolean",
    "category": "List"
  },
  {
    "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 position of the last occurrence of an item (by strict equality) in\nan array, or -1 if the item is not included in the array.",
    "name": "lastIndexOf",
    "sig": "a -> [a] -> Number",
    "category": "List"
  },
  {
    "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",
    "name": "maxBy",
    "sig": "(a -> Number) -> [a] -> a",
    "category": "Math"
  },
  {
    "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.\n\nNote that this version of `memoize` should not be applied to functions which\ntake objects as arguments.",
    "name": "memoize",
    "sig": "(*... -> a) -> (*... -> a)",
    "category": "Function"
  },
  {
    "description": "Determines the smallest of a list of items as determined by pairwise comparisons from the supplied comparator",
    "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": "Returns a partial copy of an object omitting the keys specified.",
    "name": "omit",
    "sig": "[String] -> {String: *} -> {String: *}",
    "category": "Object"
  },
  {
    "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": "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.",
    "name": "or",
    "sig": "* -> * -> *",
    "category": "Logic"
  },
  {
    "description": "Retrieve the value at a given path.",
    "name": "path",
    "sig": "[String] -> {*} -> *",
    "category": "Object"
  },
  {
    "description": "Determines whether a nested path on an object has a specific value\naccording to strict equality ('==='). Most likely used to filter a list:",
    "name": "pathEq",
    "sig": "[String] -> * -> {String: *} -> Boolean",
    "category": "Relation"
  },
  {
    "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": "[String] -> {String: *} -> {String: *}",
    "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": "Determines whether the given property of an object has a specific\nvalue according to strict equality (`===`).  Most likely used to\nfilter a list:",
    "name": "propEq",
    "sig": "k -> v -> {k: v} -> Boolean",
    "category": "Relation"
  },
  {
    "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": "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": "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 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": "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": "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": "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": "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 `true` if the specified item is somewhere in the list, `false` otherwise.\nEquivalent to `indexOf(a)(list) > -1`. Uses strict (`===`) equality checking.",
    "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": "((*... -> c) -> (((* -> a), (* -> b), ...) -> c)",
    "category": "Function"
  },
  {
    "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": "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": "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 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 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` wraps any object in an array. This implementation is compatible with the\nFantasy-land Monoid spec, and will work with types that implement that spec.",
    "name": "empty",
    "sig": "* -> []",
    "category": "Function"
  },
  {
    "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": "Calls the specified function on the supplied object. Any additional arguments\nafter `fn` and `obj` are passed in to `fn`. If no additional arguments are passed to `func`,\n`fn` is invoked with no arguments.",
    "name": "func",
    "sig": "k -> {k : v} -> v(*)",
    "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": "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": "Returns the result of applying `obj[methodName]` to `args`.",
    "name": "invoke",
    "sig": "String -> Object -> [*] -> *",
    "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 `len + 1` parameters where\nthe final parameter is the target object.",
    "name": "invoker",
    "sig": "(Number, String) -> (a... -> c -> b)",
    "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 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 the last element from a list.",
    "name": "last",
    "sig": "[a] -> a",
    "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": "List"
  },
  {
    "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": "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": "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": "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 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": "Returns a new list by plucking the same named property off all objects in the list supplied.",
    "name": "pluck",
    "sig": "String -> {*} -> [*]",
    "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\nThe iterator function receives two values: *(acc, value)*\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)*.",
    "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": "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": "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.  If\n`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.\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.\nEquality is strict here, meaning reference equality for objects and non-coercing equality\nfor primitives.",
    "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": "((* -> *), (* -> *)...) -> (* -> *)",
    "category": "Function"
  },
  {
    "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": "Takes a spec object and a test object and returns true if the test satisfies the spec.\nAny property on the spec that is not a function is interpreted as an equality\nrelation.\n\nIf the spec has a property mapped to a function, then `where` evaluates the function, passing in\nthe test object's value for the property in question, as well as the whole test object.\n\n`where` is well suited to declaratively expressing constraints for other functions, e.g.,\n`filter`, `find`, `pickBy`, etc.",
    "name": "where",
    "sig": "{k: v} -> {k: v} -> 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": "The character at the nth position in a String:",
    "name": "charAt",
    "sig": "Number -> String -> String",
    "category": "String"
  },
  {
    "description": "The ascii code of the character at the nth position in a String:",
    "name": "charCodeAt",
    "sig": "Number -> String -> Number",
    "category": "String"
  },
  {
    "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": "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": "Performs a deep test on whether two items are equal.\nEquality implies the two items are semmatically equivalent.\nCyclic structures are handled as expected",
    "name": "eqDeep",
    "sig": "a -> b -> Boolean",
    "category": "Relation"
  },
  {
    "description": "Creates a new object by evolving a shallow copy of `object`, according to the\n`transformation` functions.  All non-primitive properties are copied by reference.",
    "name": "evolve",
    "sig": "{k: (v -> v)} -> {k: v} -> {k: v}",
    "category": "Object"
  },
  {
    "description": "Returns a list of function names of object's own functions",
    "name": "functions",
    "sig": "{*} -> [String]",
    "category": "Object"
  },
  {
    "description": "Returns all but the last element of a list.",
    "name": "init",
    "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": "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": "\"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": "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": "Merges a list of objects together into one object.",
    "name": "mergeAll",
    "sig": "[{k: v}] -> {k: v}",
    "category": "List"
  },
  {
    "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": "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": "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.",
    "name": "construct",
    "sig": "(* -> {*}) -> (* -> {*})",
    "category": "Function"
  },
  {
    "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": "\"lifts\" a function of arity > 1 so that it may \"map over\" an Array or\nother Functor.",
    "name": "lift",
    "sig": "(*... -> *) -> ([*]... -> [*])",
    "category": "Function"
  }
]