[
    {
        "name": "Toolkit.List",
        "comment": "\n\nHelpers for working with lists\n\n# General\n@docs isOneOf, getNth, unique\n\n# List-Tuple conversions\n@docs take2Tuple, take3Tuple, take4Tuple, from2Tuple, from3Tuple, from4Tuple\n\n# Zipping and unzipping\n@docs zip, zip3, zip4, unzip3, unzip4\n\n",
        "unions": [],
        "aliases": [],
        "values": [
            {
                "name": "from2Tuple",
                "comment": " Given a 2-tuple where both values are of the same type, return a list\ncontaining those values\n\n    (1,2)\n      |> Toolkit.List.from2Tuple\n\n    --> Just [1,2]\n\n",
                "type": "( a, a ) -> List a"
            },
            {
                "name": "from3Tuple",
                "comment": " Given a 3-tuple where all three values are of the same type, return a list\ncontaining those values\n",
                "type": "( a, a, a ) -> List a"
            },
            {
                "name": "from4Tuple",
                "comment": " Given a 4-tuple where all four values are of the same type, return a list\ncontaining those values\n",
                "type": "( a, a, a, a ) -> List a"
            },
            {
                "name": "getNth",
                "comment": " Get the value at the nth place of a list without converting the list to an\narray; returns `Nothing` if the list contains fewer than `n + 1` items, or if\n`n` is negative\n\n    [1, 3, 9, 27]\n      |> Toolkit.List.getNth 0\n\n    --> Just 1\n\n    [1, 3, 9, 27]\n      |> Toolkit.List.getNth 3\n\n    --> Just 27\n\n    [1, 3, 9, 27]\n      |> Toolkit.List.getNth 4\n\n    --> Nothing\n\n    [1, 3, 9, 27]\n      |> Toolkit.List.getNth -1\n\n    --> Nothing\n\n",
                "type": "Int -> List a -> Maybe a"
            },
            {
                "name": "isOneOf",
                "comment": " Given a list and a test value, returns `True` if the list contains a value\nequal to the test value.\n\n    \"apple\"\n      |> Toolkit.List.isOneOf\n        [ \"apple\"\n        , \"banana\"\n        , \"cherry\"\n        ]\n\n    --> True\n\nEquivalent to\n[List.member](http://package.elm-lang.org/packages/elm-lang/core/latest/List#member)\nwith the arguments flipped\n\n",
                "type": "List a -> a -> Bool"
            },
            {
                "name": "take2Tuple",
                "comment": " Returns the first two items in a list as a 2-tuple, or `Nothing` if the list\ncontains fewer than two items\n\n    [1,2]\n      |> Toolkit.List.take2Tuple\n\n    --> Just (1,2)\n\n    [1,2,3]\n      |> Toolkit.List.take2Tuple\n\n    --> Just (1,2)\n\n    [1]\n      |> Toolkit.List.take2Tuple\n\n    --> Nothing\n\n",
                "type": "List a -> Maybe ( a, a )"
            },
            {
                "name": "take3Tuple",
                "comment": " Returns the first three items in a list as a 3-tuple, or `Nothing` if the\nlist contains fewer than three items\n",
                "type": "List a -> Maybe ( a, a, a )"
            },
            {
                "name": "take4Tuple",
                "comment": " Returns the first four items in a list as a 4-tuple, or `Nothing` if the\nlist contains fewer than four items\n",
                "type": "List a -> Maybe ( a, a, a, a )"
            },
            {
                "name": "unique",
                "comment": " Given a list of values, returns the unique values as a list sorted from\nhighest to lowest\n\n    [ \"banana\"\n    , \"cherry\"\n    , \"apple\"\n    , \"apple\"\n    ]\n      |> Toolkit.List.unique\n\n    --> [\"apple\", \"banana\", \"cherry\"]\n\n",
                "type": "List comparable -> List comparable"
            },
            {
                "name": "unzip3",
                "comment": " Convert a 3-tuple of lists to a list of 3-tuples (see\n[List.unzip](package.elm-lang.org/packages/elm-lang/core/latest/List#unzip))\n",
                "type": "List ( a, b, c ) -> ( List a, List b, List c )"
            },
            {
                "name": "unzip4",
                "comment": " Convert a 4-tuple of lists to a list of 4-tuples\n",
                "type": "List ( a, b, c, d ) -> ( List a, List b, List c, List d )"
            },
            {
                "name": "zip",
                "comment": " Convert a 2-tuple of lists to a list of 2-tuples\n\n    ( [ 0\n      , 17\n      , 1337\n      ]\n\n    , [ True\n      , False\n      , True\n      ]\n\n    )\n      |> Toolkit.List.zip\n\n    --> [(0, True), (17, False), (1337, True)]\n\n",
                "type": "( List a, List b ) -> List ( a, b )"
            },
            {
                "name": "zip3",
                "comment": " Convert a 3-tuple of lists to a list of 3-tuples\n",
                "type": "( List a, List b, List c ) -> List ( a, b, c )"
            },
            {
                "name": "zip4",
                "comment": " Convert a 4-tuple of lists to a list of 4-tuples\n",
                "type": "( List a, List b, List c, List d ) -> List ( a, b, c, d )"
            }
        ],
        "binops": []
    },
    {
        "name": "Toolkit.Tuple4",
        "comment": "\n\nHelpers for working with 4-tuples\n\n# Getting values\n@docs first, second, third, fourth\n\n# Mapping functions\n@docs map\n\n",
        "unions": [],
        "aliases": [],
        "values": [
            {
                "name": "first",
                "comment": " Return the first value of a 4-tuple\n",
                "type": "( a, b, c, d ) -> a"
            },
            {
                "name": "fourth",
                "comment": " Return the fourth value of a 4-tuple\n",
                "type": "( a, b, c, d ) -> d"
            },
            {
                "name": "map",
                "comment": " Apply a function to all 4 values in a 4-tuple and return the results as a\n4-tuple\n",
                "type": "(a -> b) -> ( a, a, a, a ) -> ( b, b, b, b )"
            },
            {
                "name": "second",
                "comment": " Return the second value of a 4-tuple\n",
                "type": "( a, b, c, d ) -> b"
            },
            {
                "name": "third",
                "comment": " Return the third value of a 4-tuple\n",
                "type": "( a, b, c, d ) -> c"
            }
        ],
        "binops": []
    },
    {
        "name": "Toolkit.Compare",
        "comment": "\n\nHelpers for comparing values\n\n# Intervals\n@docs isInRange, isBetween\n\n",
        "unions": [],
        "aliases": [],
        "values": [
            {
                "name": "isBetween",
                "comment": " Given an interval and a test value, returns `True` if the test value falls\nstrictly *between* the endpoints of the interval, such that a test value equal\nto one of the endpoints will return `False`\n\n    10\n      |> Toolkit.Compare.isBetween (10, 20)\n\n    --> False\n\n",
                "type": "( comparable, comparable ) -> comparable -> Bool"
            },
            {
                "name": "isInRange",
                "comment": " Given an interval and a test value, returns `True` if the test value falls\nwithin the interval, *including* its endpoints\n\n    10\n      |> Toolkit.Compare.isInRange (10, 20)\n\n    --> True\n\n",
                "type": "( comparable, comparable ) -> comparable -> Bool"
            }
        ],
        "binops": []
    },
    {
        "name": "Toolkit.Tuple.Operators",
        "comment": "\n\nSome experimental operators for working with 2-tuples\n\n@docs (..|>)\n\n",
        "unions": [],
        "aliases": [],
        "values": [],
        "binops": [
            {
                "name": "..|>",
                "comment": " Forward operator for\n[Toolkit.Tuple.map](http://package.elm-lang.org/packages/danielnarey/elm-toolkit/latest/Toolkit-Tuple#map)\n\n    (1,2)\n    ..|> (+) 1\n\n    --> (2,3)\n\n",
                "type": "( a, a ) -> (a -> b) -> ( b, b )",
                "associativity": "left",
                "precedence": 0
            }
        ]
    },
    {
        "name": "Toolkit.Tuple3",
        "comment": "\n\nHelpers for working with 3-tuples\n\n# Getting values\n@docs first, second, third\n\n# Mapping functions\n@docs map\n\n",
        "unions": [],
        "aliases": [],
        "values": [
            {
                "name": "first",
                "comment": " Return the first value of a 3-tuple\n",
                "type": "( a, b, c ) -> a"
            },
            {
                "name": "map",
                "comment": " Apply a function to all 3 values in a 3-tuple and return the results as a\n3-tuple\n",
                "type": "(a -> b) -> ( a, a, a ) -> ( b, b, b )"
            },
            {
                "name": "second",
                "comment": " Return the second value of a 3-tuple\n",
                "type": "( a, b, c ) -> b"
            },
            {
                "name": "third",
                "comment": " Return the third value of a 3-tuple\n",
                "type": "( a, b, c ) -> c"
            }
        ],
        "binops": []
    },
    {
        "name": "Toolkit.String",
        "comment": "\n\nHelpers for working with strings\n\n# Conversions\n@docs toBool\n\n",
        "unions": [],
        "aliases": [],
        "values": [
            {
                "name": "toBool",
                "comment": " Convert a boolean string to a `Bool`, ignoring case\n\n    toBool \"true\"     --> Ok True\n    toBool \"True\"     --> Ok True\n    toBool \"false\"    --> Ok False\n    toBool \"FALSE\"    --> Ok False\n    toBool \"blah\"     --> Err \"String argument must be 'true' or 'false' (case ignored)\"\n\n",
                "type": "String -> Result String Bool"
            }
        ],
        "binops": []
    },
    {
        "name": "Toolkit.Tuple",
        "comment": "\n\nHelpers for working with 2-tuples\n\n# Mapping functions\n@docs map\n\n",
        "unions": [],
        "aliases": [],
        "values": [
            {
                "name": "map",
                "comment": " Apply a function to both values in a 2-tuple and return the results as a\n2-tuple\n",
                "type": "(a -> b) -> ( a, a ) -> ( b, b )"
            }
        ],
        "binops": []
    },
    {
        "name": "Toolkit.Result.Operators",
        "comment": "\n\nSome experimental operators for error handling with `Result` values\n\n@docs (!=), (!|>), (!+>)\n\n",
        "unions": [],
        "aliases": [],
        "values": [],
        "binops": [
            {
                "name": "!+>",
                "comment": " Forward operator for `Result.andThen`\n\n    String.toInt \"1\"\n      !+> always (Err \"ERROR\")\n\n    --> Err \"ERROR\"\n    \n",
                "type": "Result x a -> (a -> Result x b) -> Result x b",
                "associativity": "left",
                "precedence": 0
            },
            {
                "name": "!=",
                "comment": " Forward operator for `Result.withDefault`\n\n    String.toInt \"123\" != 0\n\n    --> 123\n\n    String.toInt \"abc\" != 0\n\n    --> 0\n\n",
                "type": "Result x a -> a -> a",
                "associativity": "left",
                "precedence": 0
            },
            {
                "name": "!|>",
                "comment": " Forward operator for `Result.map`\n\n    Ok 4.0\n      !|> sqrt\n\n    --> Ok 2.0\n\n    Err \"bad input\"\n      !|> sqrt\n\n    --> Err \"bad input\"\n\n",
                "type": "Result x a -> (a -> value) -> Result x value",
                "associativity": "left",
                "precedence": 0
            }
        ]
    },
    {
        "name": "Toolkit.Result",
        "comment": "\n\nHelpers for error handling with multiple `Result` values\n\n# Implicit default value\n@docs try\n\n# Zipping\n@docs zip, zip3, zip4, zipList\n\n# Filtering\n@docs filter\n\n",
        "unions": [],
        "aliases": [],
        "values": [
            {
                "name": "filter",
                "comment": " Given a list of `Result` values, return a list containing only the success\nvalues.\n\n    [ Ok 1\n    , Ok 2\n    , Err \"..\"\n    ]\n      |> Toolkit.Result.filter\n\n    --> [1, 2]\n\n",
                "type": "List (Result x a) -> List a"
            },
            {
                "name": "try",
                "comment": " Apply a function that returns a `Result` value, with the initial value as\nthe default (equivalent to `f x |> Result.withDefault x`). Note that the type\nreturned in an `Ok` result must match the type of the initial value.\n",
                "type": "(a -> Result x a) -> a -> a"
            },
            {
                "name": "zip",
                "comment": " Given a 2-tuple of `Result` values, if both values are `Ok`, return an `Ok`\nresult containing the 2-tuple of values; otherwise, return an `Err` value.\n\n    (Ok 1, Ok 2)\n      |> Toolkit.Result.zip \"ERROR\"\n\n    --> Ok (1,2)\n\n    (Ok 1, Err \"..\")\n      |> Toolkit.Result.zip \"ERROR\"\n\n    --> Err \"ERROR\"\n\n",
                "type": "x -> ( Result x a, Result x b ) -> Result x ( a, b )"
            },
            {
                "name": "zip3",
                "comment": " Given a 3-tuple of `Result` values, if all three values are `Ok`, return an\n`Ok` result containing the 3-tuple of values; otherwise, return an `Err`\nvalue.\n",
                "type": "x -> ( Result x a, Result x b, Result x c ) -> Result x ( a, b, c )"
            },
            {
                "name": "zip4",
                "comment": " Given a 4-tuple of `Result` values, if all three values are `Ok`, return an\n`Ok` result containing the 4-tuple of values; otherwise, return an `Err`\nvalue.\n",
                "type": "x -> ( Result x a, Result x b, Result x c, Result x d ) -> Result x ( a, b, c, d )"
            },
            {
                "name": "zipList",
                "comment": " Given a list of `Result` values, if all values are `Ok`, return an `Ok`\nresult containing the list of values; otherwise, return an error message. When\npassed an empty list, returns `Ok []`.\n\n    [Ok 1, Ok 2]\n      |> Toolkit.Result.zipList \"ERROR\"\n\n    --> Ok [1,2]\n\n    [Ok 1, Err \"..\"]\n      |> Toolkit.Result.zipList \"ERROR\"\n\n    --> Err \"ERROR\"\n\n    []\n      |> Toolkit.Result.zipList \"ERROR\"\n\n    --> Ok []\n\n",
                "type": "x -> List (Result x a) -> Result x (List a)"
            }
        ],
        "binops": []
    },
    {
        "name": "Toolkit.Maybe.Operators",
        "comment": "\n\nSome experimental operators for error handling with `Maybe` values\n\n@docs (?=), (?|>), (?+>)\n\n",
        "unions": [],
        "aliases": [],
        "values": [],
        "binops": [
            {
                "name": "?+>",
                "comment": " Forward operator for `Maybe.andThen`\n\n    List.head [1]\n      ?+> always Nothing\n\n    --> Nothing\n\n",
                "type": "Maybe a -> (a -> Maybe b) -> Maybe b",
                "associativity": "left",
                "precedence": 0
            },
            {
                "name": "?=",
                "comment": " Forward operator for `Maybe.withDefault`\n\n    Just 42 ?= 100\n\n    --> 42\n\n    Nothing ?= 100\n\n    --> 100\n\n",
                "type": "Maybe a -> a -> a",
                "associativity": "left",
                "precedence": 0
            },
            {
                "name": "?|>",
                "comment": " Forward operator for `Maybe.map`\n\n    Just 9\n      ?|> sqrt\n\n    --> Just 3\n\n    Nothing\n      ?|> sqrt\n\n    --> Nothing\n\n",
                "type": "Maybe a -> (a -> b) -> Maybe b",
                "associativity": "left",
                "precedence": 0
            }
        ]
    },
    {
        "name": "Toolkit.Maybe",
        "comment": "\n\nHelpers for error handling with multiple `Maybe` values\n\n# Zipping\n@docs zip, zip3, zip4, zipList\n\n# Filtering\n@docs filter\n\n",
        "unions": [],
        "aliases": [],
        "values": [
            {
                "name": "filter",
                "comment": " Given a list of `Maybe` values, return a list containing only the defined\nvalues.\n\n    [ Just 1\n    , Just 2\n    , Nothing\n    ]\n      |> Toolkit.Maybe.filter\n\n    --> [1, 2]\n\n",
                "type": "List (Maybe a) -> List a"
            },
            {
                "name": "zip",
                "comment": " Given a 2-tuple of `Maybe` values, if both values are defined, return `Just`\nthe 2-tuple of values; otherwise, return `Nothing`\n\n    (Just 1, Just 2)\n      |> Toolkit.Maybe.zip\n\n    --> Just (1,2)\n\n    (Just 1, Nothing)\n      |> Toolkit.Maybe.zip\n\n    --> Nothing\n\n",
                "type": "( Maybe a, Maybe b ) -> Maybe ( a, b )"
            },
            {
                "name": "zip3",
                "comment": " Given a 3-tuple of `Maybe` values, if all three values are defined, return\n`Just` the 3-tuple of values; otherwise, return `Nothing`\n",
                "type": "( Maybe a, Maybe b, Maybe c ) -> Maybe ( a, b, c )"
            },
            {
                "name": "zip4",
                "comment": " Given a 4-tuple of `Maybe` values, if all four values are defined, return\n`Just` the 4-tuple of values; otherwise, return `Nothing`\n",
                "type": "( Maybe a, Maybe b, Maybe c, Maybe d ) -> Maybe ( a, b, c, d )"
            },
            {
                "name": "zipList",
                "comment": " Given a list of `Maybe` values, if all values are defined, return\n`Just` the list of values; otherwise, return `Nothing`. When passed an empty\nlist, returns `Just` an empty list.\n\n    [Just 1, Just 2]\n      |> Toolkit.Maybe.zipList\n\n    --> Just [1,2]\n\n    [Just 1, Nothing]\n      |> Toolkit.Maybe.zipList\n\n    --> Nothing\n\n    []\n      |> Toolkit.Maybe.zipList\n\n    --> Just []\n\n",
                "type": "List (Maybe a) -> Maybe (List a)"
            }
        ],
        "binops": []
    },
    {
        "name": "Toolkit.List.Operators",
        "comment": "\n\nSome experimental operators for working with lists\n\n# Appending lists and single elements\n@docs (|++), (|::), (:|++), (:|::)\n\n# Mapping functions\n@docs (.|>)\n\n# Wrapping a single element and applying a list function\n@docs (:|>)\n\n",
        "unions": [],
        "aliases": [],
        "values": [],
        "binops": [
            {
                "name": ".|>",
                "comment": " Forward operator for List.map\n\n    [ 1\n    , 4\n    , 9\n    ]\n     .|> sqrt\n\n    --> [1,2,3]\n\n",
                "type": "List a -> (a -> b) -> List b",
                "associativity": "left",
                "precedence": 0
            },
            {
                "name": ":|++",
                "comment": " Wrap LHS in a list, then append RHS list to it; equivalent to `::`, but\nleft-associative with precedence set to `0` (same as `|>`)\n\n    (\"a\" ++ \"b\")\n      :: [\"cd\",\"ef\"]\n\n    --> [\"ab\",\"cd\",\"ef\"]\n\n    \"a\" ++ \"b\"\n      :: [\"cd\",\"ef\"]\n\n    --> ERROR\n\n    \"a\" ++ \"b\"\n     :|++ [\"cd\",\"ef\"]\n\n    --> [\"ab\",\"cd\",\"ef\"]\n\n",
                "type": "a -> List a -> List a",
                "associativity": "left",
                "precedence": 0
            },
            {
                "name": ":|::",
                "comment": " Wrap LHS in a list, then append the item on RHS to the list\n\n    1\n     :|:: 2\n\n    --> [1,2]\n\n",
                "type": "a -> a -> List a",
                "associativity": "left",
                "precedence": 0
            },
            {
                "name": ":|>",
                "comment": " Wrap LHS in a list, then apply RHS function\n\n    1\n     :|> List.head\n\n    --> Just 1\n\n",
                "type": "a -> (List a -> b) -> b",
                "associativity": "left",
                "precedence": 0
            },
            {
                "name": "|++",
                "comment": " Append the RHS to the end of the LHS; equivalent to `++`, but\nleft-associative with precedence set to `0` (same as `|>`)\n\n    (\"ba\" |> String.reverse) ++ \"c\"\n\n    --> \"abc\"\n\n    \"ba\"\n      |> String.reverse\n      ++ \"c\"\n\n    --> ERROR\n\n    \"ba\"\n      |> String.reverse\n      |++ \"c\"\n\n    --> \"abc\"\n\n",
                "type": "appendable -> appendable -> appendable",
                "associativity": "left",
                "precedence": 0
            },
            {
                "name": "|::",
                "comment": " Append the item on the RHS to the end of the list on the LHS\n\n    [1]\n      |:: 2\n\n    --> [1,2]\n\n    [1]\n      |:: 2\n      |:: 3\n\n    --> [1,2,3]\n\n",
                "type": "List a -> a -> List a",
                "associativity": "left",
                "precedence": 0
            }
        ]
    },
    {
        "name": "Toolkit.Function.Operators",
        "comment": "\n\nSome experimental operators for function application\n\n# Apply List\n@docs (|>.)\n\n# Uncurrying\n@docs (@@|>)\n\n# Flipping arguments\n@docs (#)\n\n# Precedence\n@docs (||>)\n\n",
        "unions": [],
        "aliases": [],
        "values": [],
        "binops": [
            {
                "name": "#",
                "comment": " An operator for\n[`flip`](http://package.elm-lang.org/packages/elm-lang/core/latest/Basics#flip).\nThink of the `#` symbol as appearing where the missing argument would go.\n\n    4\n      |> (/) 2\n\n    --> 0.5\n\n    4\n      |> flip (/) 2\n\n    --> 2\n\n    4\n      |> (/) # 2\n\n    --> 2\n\n\n",
                "type": "(a -> b -> c) -> b -> a -> c",
                "associativity": "left",
                "precedence": 9
            },
            {
                "name": "@@|>",
                "comment": " Forward operator for\n[`uncurry`](http://package.elm-lang.org/packages/elm-lang/core/latest/Basics#uncurry)\nwith 2 parameters\n\n    (1,2)\n    @@|> (+)\n\n    --> 3\n\n",
                "type": "( a, b ) -> (a -> b -> c) -> c",
                "associativity": "left",
                "precedence": 0
            },
            {
                "name": "|>.",
                "comment": " Alias for `Toolkit.Function.applyList`\n\nGiven a list containing any number of functions and a value accepted by\nevery function in the list, return a list containing all of the results. Note\nthat to use this operator, all of the results must be of the same type.\n\n    \"a\"\n      |>.\n        [ flip (++) \"b\"\n        , flip (++) \"c\"\n        , flip (++) \"d\"\n        ]\n\n    --> [\"ab\", \"ac\", \"ad\"]\n\n",
                "type": "a -> List (a -> b) -> List b",
                "associativity": "left",
                "precedence": 0
            },
            {
                "name": "||>",
                "comment": " Forward function application with precedence set to 9. Allows you to avoid\nparentheses when you want the argument to appear before the function name in an\ninline expression.\n\n    1 ||> toString ++ 2 ||> toString\n\n    --> \"12\"\n\n",
                "type": "a -> (a -> b) -> b",
                "associativity": "left",
                "precedence": 9
            }
        ]
    },
    {
        "name": "Toolkit.Function",
        "comment": "\n\nHelpers to do more with functions\n\n# Apply multiple function to data\n@docs apply2, apply3, apply4, applyList, applyWithArgs\n\n# Compose multiple functions\n@docs compose, compose3, compose4, composeList, composeWithArgs\n\n# Curry and uncurry with more than two arguments\n@docs curry3, curry4, uncurry3, uncurry4\n\n",
        "unions": [],
        "aliases": [],
        "values": [
            {
                "name": "apply2",
                "comment": " Given a tuple containing two functions and a value accepted by both\nfunctions, return a tuple containing the two results\n\n    \"1\"\n      |> Toolkit.Function.apply2\n        ( flip (++) \"2\"\n        , String.toInt\n        )\n\n    --> (\"12\", Ok 1)\n\n",
                "type": "( a -> b, a -> c ) -> a -> ( b, c )"
            },
            {
                "name": "apply3",
                "comment": " Given a tuple containing three functions and a value accepted by all three\nfunctions, return a tuple containing the three results\n",
                "type": "( a -> b, a -> c, a -> d ) -> a -> ( b, c, d )"
            },
            {
                "name": "apply4",
                "comment": " Given a tuple containing four functions and a value accepted by all four\nfunctions, return a tuple containing the four results\n",
                "type": "( a -> b, a -> c, a -> d, a -> e ) -> a -> ( b, c, d, e )"
            },
            {
                "name": "applyList",
                "comment": " Given a list containing any number of functions and a value accepted by\nevery function in the list, return a list containing all of the results. Note\nthat to use `applyList`, all of the results must be of the same type, which is\nnot the case for the apply functions that return tuples.\n\n    \"a\"\n      |> Toolkit.Function.applyList\n        [ flip (++) \"b\"\n        , flip (++) \"c\"\n        , flip (++) \"d\"\n        ]\n\n    --> [\"ab\", \"ac\", \"ad\"]\n\n",
                "type": "List (a -> b) -> a -> List b"
            },
            {
                "name": "applyWithArgs",
                "comment": " Apply a series of functions that vary by the value of the first argument,\nreturning the results as a list.\n\n    \"a\"\n      |> Toolkit.Function.applyWithArgs (flip (++))\n        [ \"b\"\n        , \"c\"\n        , \"d\"\n        ]\n\n    --> [\"ab\", \"ac\", \"ad\"]\n\n",
                "type": "(a -> b -> b) -> List a -> b -> List b"
            },
            {
                "name": "compose",
                "comment": " Compose 2 functions, given as a 2-tuple\n\n    \"1\"\n      |> Toolkit.Function.compose\n        ( flip (++) \"1\"\n        , String.toInt\n        )\n\n    --> Ok 11\n\n",
                "type": "( a -> b, b -> c ) -> a -> c"
            },
            {
                "name": "compose3",
                "comment": " Compose 3 functions, given as a 3-tuple\n",
                "type": "( a -> b, b -> c, c -> d ) -> a -> d"
            },
            {
                "name": "compose4",
                "comment": " Compose 4 functions, given as a 4-tuple\n",
                "type": "( a -> b, b -> c, c -> d, d -> e ) -> a -> e"
            },
            {
                "name": "composeList",
                "comment": " Compose a list of functions of arbitrary length; each function must take an\nargument of the same type, with a result also of the same type.\n\n    \"a\"\n      |> Toolkit.Function.composeList\n        [ flip (++) \"b\"\n        , flip (++) \"c\"\n        ]\n\n    --> \"abc\"\n\n",
                "type": "List (a -> a) -> a -> a"
            },
            {
                "name": "composeWithArgs",
                "comment": " Compose a series of functions that vary by the value of the first argument.\n\n    \"a\"\n      |> Toolkit.Function.composeWithArgs (flip (++))\n        [ \"b\"\n        , \"c\"\n        , \"d\"\n        ]\n\n    --> \"abcd\"\n\n",
                "type": "(a -> b -> b) -> List a -> b -> b"
            },
            {
                "name": "curry3",
                "comment": " [`curry`](http://package.elm-lang.org/packages/elm-lang/core/latest/Basics#curry)\nwith 3 parameters\n",
                "type": "(( a, b, c ) -> d) -> a -> b -> c -> d"
            },
            {
                "name": "curry4",
                "comment": " [`curry`](http://package.elm-lang.org/packages/elm-lang/core/latest/Basics#curry)\nwith 4 parameters\n",
                "type": "(( a, b, c, d ) -> e) -> a -> b -> c -> d -> e"
            },
            {
                "name": "uncurry3",
                "comment": " [`uncurry`](http://package.elm-lang.org/packages/elm-lang/core/latest/Basics#uncurry)\nwith 3 parameters\n",
                "type": "(a -> b -> c -> d) -> ( a, b, c ) -> d"
            },
            {
                "name": "uncurry4",
                "comment": " [`uncurry`](http://package.elm-lang.org/packages/elm-lang/core/latest/Basics#uncurry)\nwith 4 parameters\n",
                "type": "(a -> b -> c -> d -> e) -> ( a, b, c, d ) -> e"
            }
        ],
        "binops": []
    },
    {
        "name": "Toolkit.Float",
        "comment": "\n\nHelpers for working with `Float` values\n\n# Rounding\n@docs roundTo\n\n",
        "unions": [],
        "aliases": [],
        "values": [
            {
                "name": "roundTo",
                "comment": " Round a `Float` to a given number of decimal places\n\n    pi\n      |> roundTo 2\n\n    --> 3.14\n\n    pi\n      |> roundTo 0\n\n    --> 3\n\n    1234\n      |> roundTo -2\n\n    --> 1200\n\n",
                "type": "Int -> Float -> Float"
            }
        ],
        "binops": []
    }
]