[
    {
        "name": "Array",
        "comment": "A library for fast immutable arrays. The elements in an array must have the\nsame type. The arrays are implemented in Relaxed Radix Balanced-Trees for fast\nreads, updates, and appends.\n\n# Creating Arrays\n@docs empty, repeat, initialize, fromList\n\n# Basics\n@docs isEmpty, length, push, append\n\n# Get and Set\n@docs get, set\n\n# Taking Arrays Apart\n@docs slice, toList, toIndexedList\n\n# Mapping, Filtering, and Folding\n@docs map, indexedMap, filter, foldl, foldr",
        "unions": [],
        "aliases": [],
        "values": [
            {
                "name": "append",
                "comment": "Append two arrays to a new one.\n\n    append (repeat 2 42) (repeat 3 81) == fromList [42,42,81,81,81]",
                "type": "Array a -> Array a -> Array a"
            },
            {
                "name": "empty",
                "comment": "Return an empty array.\n\n    length empty == 0",
                "type": "Array a"
            },
            {
                "name": "filter",
                "comment": "Keep only elements that satisfy the predicate:\n\n    filter isEven (fromList [1..6]) == (fromList [2,4,6])",
                "type": "(a -> Bool) -> Array a -> Array a"
            },
            {
                "name": "foldl",
                "comment": "Reduce an array from the left. Read `foldl` as “fold from the left”.\n\n    foldl (::) [] (fromList [1,2,3]) == [3,2,1]",
                "type": "(a -> b -> b) -> b -> Array a -> b"
            },
            {
                "name": "foldr",
                "comment": "Reduce an array from the right. Read `foldr` as “fold from the right”.\n\n    foldr (+) 0 (repeat 3 5) == 15",
                "type": "(a -> b -> b) -> b -> Array a -> b"
            },
            {
                "name": "fromList",
                "comment": "Create an array from a list.",
                "type": "List a -> Array a"
            },
            {
                "name": "get",
                "comment": "Return Just the element at the index or Nothing if the index is out of range.\n\n    get  0 (fromList [0,1,2]) == Just 0\n    get  2 (fromList [0,1,2]) == Just 2\n    get  5 (fromList [0,1,2]) == Nothing\n    get -1 (fromList [0,1,2]) == Nothing",
                "type": "Int -> Array a -> Maybe a"
            },
            {
                "name": "indexedMap",
                "comment": "Apply a function on every element with its index as first argument.\n\n    indexedMap (*) (fromList [5,5,5]) == fromList [0,5,10]",
                "type": "(Int -> a -> b) -> Array a -> Array b"
            },
            {
                "name": "initialize",
                "comment": "Initialize an array. `initialize n f` creates an array of length `n` with\nthe element at index `i` initialized to the result of `(f i)`.\n\n    initialize 4 identity    == fromList [0,1,2,3]\n    initialize 4 (\\n -> n*n) == fromList [0,1,4,9]\n    initialize 4 (always 0)  == fromList [0,0,0,0]",
                "type": "Int -> (Int -> a) -> Array a"
            },
            {
                "name": "isEmpty",
                "comment": "Determine if an array is empty.\n\n    isEmpty empty == True",
                "type": "Array a -> Bool"
            },
            {
                "name": "length",
                "comment": "Return the length of an array.\n\n    length (fromList [1,2,3]) == 3",
                "type": "Array a -> Int"
            },
            {
                "name": "map",
                "comment": "Apply a function on every element in an array.\n\n    map sqrt (fromList [1,4,9]) == fromList [1,2,3]",
                "type": "(a -> b) -> Array a -> Array b"
            },
            {
                "name": "push",
                "comment": "Push an element to the end of an array.\n\n    push 3 (fromList [1,2]) == fromList [1,2,3]",
                "type": "a -> Array a -> Array a"
            },
            {
                "name": "repeat",
                "comment": "Creates an array with a given length, filled with a default element.\n\n    repeat 5 0     == fromList [0,0,0,0,0]\n    repeat 3 \"cat\" == fromList [\"cat\",\"cat\",\"cat\"]\n\nNotice that `repeat 3 x` is the same as `initialize 3 (always x)`.",
                "type": "Int -> a -> Array a"
            },
            {
                "name": "set",
                "comment": "Set the element at a particular index. Returns an updated array.\nIf the index is out of range, the array is unaltered.\n\n    set 1 7 (fromList [1,2,3]) == fromList [1,7,3]",
                "type": "Int -> a -> Array a -> Array a"
            },
            {
                "name": "slice",
                "comment": "Get a sub-section of an array: `(slice start end array)`. The `start` is a\nzero-based index where we will start our slice. The `end` is a zero-based index\nthat indicates the end of the slice. The slice extracts up to but not including\n`end`.\n\n    slice  0  3 (fromList [0,1,2,3,4]) == fromList [0,1,2]\n    slice  1  4 (fromList [0,1,2,3,4]) == fromList [1,2,3]\n\nBoth the `start` and `end` indexes can be negative, indicating an offset from\nthe end of the array.\n\n    slice  1 -1 (fromList [0,1,2,3,4]) == fromList [1,2,3]\n    slice -2  5 (fromList [0,1,2,3,4]) == fromList [3,4]\n\nThis makes it pretty easy to `pop` the last element off of an array: `slice 0 -1 array`",
                "type": "Int -> Int -> Array a -> Array a"
            },
            {
                "name": "toIndexedList",
                "comment": "Create an indexed list from an array. Each element of the array will be\npaired with its index.\n\n    toIndexedList (fromList [\"cat\",\"dog\"]) == [(0,\"cat\"), (1,\"dog\")]",
                "type": "Array a -> List ( Int, a )"
            },
            {
                "name": "toList",
                "comment": "Create a list of elements from an array.\n\n    toList (fromList [3,5,8]) == [3,5,8]",
                "type": "Array a -> List a"
            }
        ],
        "binops": []
    },
    {
        "name": "Basics",
        "comment": "Tons of useful functions that get imported by default.\n\n# Equality\n@docs (==), (/=)\n\n# Comparison\n\nThese functions only work on `comparable` types. This includes numbers,\ncharacters, strings, lists of comparable things, and tuples of comparable\nthings. Note that tuples with 7 or more elements are not comparable; why\nare your tuples so big?\n\n@docs (<), (>), (<=), (>=), max, min, Order, compare\n\n# Booleans\n@docs not, (&&), (||), xor, otherwise\n\n# Mathematics\n@docs (+), (-), (*), (/), (^), (//), rem, (%), negate, abs, sqrt, clamp, logBase, e\n\n# Trigonometry\n@docs pi, cos, sin, tan, acos, asin, atan, atan2\n\n# Number Conversions\n@docs round, floor, ceiling, truncate, toFloat\n\n# Angle Conversions\nAll angle conversions result in &ldquo;standard Elm angles&rdquo;\nwhich happen to be radians.\n\n@docs degrees, radians, turns\n\n# Polar Coordinates\n@docs toPolar, fromPolar\n\n# Floating Point Checks\n@docs isNaN, isInfinite\n\n# Strings and Lists\n@docs toString, (++)\n\n# Tuples\n@docs fst, snd\n\n# Higher-Order Helpers\n@docs identity, always, (<|), (|>), (<<), (>>), flip, curry, uncurry",
        "unions": [
            {
                "name": "Order",
                "comment": "Represents the relative ordering of two things.\nThe relations are less than, equal to, and greater than.",
                "args": [],
                "cases": [
                    [
                        "LT",
                        []
                    ],
                    [
                        "EQ",
                        []
                    ],
                    [
                        "GT",
                        []
                    ]
                ]
            }
        ],
        "aliases": [],
        "values": [
            {
                "name": "abs",
                "comment": "Take the absolute value of a number.",
                "type": "number -> number"
            },
            {
                "name": "acos",
                "comment": "",
                "type": "Float -> Float"
            },
            {
                "name": "always",
                "comment": "Create a [constant function](http://en.wikipedia.org/wiki/Constant_function),\na function that *always* returns the same value regardless of what input you give.\nIt is defined as:\n\n    always a b = a\n\nIt totally ignores the second argument, so `always 42` is a function that always\nreturns 42. When you are dealing with higher-order functions, this comes in\nhandy more often than you might expect. For example, creating a zeroed out list\nof length ten would be:\n\n    map (always 0) [0..9]",
                "type": "a -> b -> a"
            },
            {
                "name": "asin",
                "comment": "",
                "type": "Float -> Float"
            },
            {
                "name": "atan",
                "comment": "You probably do not want to use this. It takes `(y/x)` as the\nargument, so there is no way to know whether the negative signs comes from\nthe `y` or `x`. Thus, the resulting angle is always between &pi;/2 and -&pi;/2\n(in quadrants I and IV). You probably want to use `atan2` instead.",
                "type": "Float -> Float"
            },
            {
                "name": "atan2",
                "comment": "This helps you find the angle of a cartesian coordinate.\nYou will almost certainly want to use this instead of `atan`.\nSo `atan2 y x` computes *atan(y/x)* but also keeps track of which\nquadrant the angle should really be in. The result will be between\n&pi; and -&pi;, giving you the full range of angles.",
                "type": "Float -> Float -> Float"
            },
            {
                "name": "ceiling",
                "comment": "Ceiling function, rounding up.",
                "type": "Float -> Int"
            },
            {
                "name": "clamp",
                "comment": "Clamps a number within a given range. With the expression\n`clamp 100 200 x` the results are as follows:\n\n    100     if x < 100\n     x      if 100 <= x < 200\n    200     if 200 <= x",
                "type": "number -> number -> number -> number"
            },
            {
                "name": "compare",
                "comment": "Compare any two comparable values. Comparable values include `String`, `Char`,\n`Int`, `Float`, `Time`, or a list or tuple containing comparable values.\nThese are also the only values that work as `Dict` keys or `Set` members.",
                "type": "comparable -> comparable -> Order"
            },
            {
                "name": "cos",
                "comment": "",
                "type": "Float -> Float"
            },
            {
                "name": "curry",
                "comment": "Change how arguments are passed to a function.\nThis splits paired arguments into two separate arguments.",
                "type": "(( a, b ) -> c) -> a -> b -> c"
            },
            {
                "name": "degrees",
                "comment": "Convert degrees to standard Elm angles (radians).",
                "type": "Float -> Float"
            },
            {
                "name": "e",
                "comment": "An approximation of e.",
                "type": "Float"
            },
            {
                "name": "flip",
                "comment": "Flip the order of the first two arguments to a function.",
                "type": "(a -> b -> c) -> b -> a -> c"
            },
            {
                "name": "floor",
                "comment": "Floor function, rounding down.",
                "type": "Float -> Int"
            },
            {
                "name": "fromPolar",
                "comment": "Convert polar coordinates (r,&theta;) to cartesian coordinates (x,y).",
                "type": "( Float, Float ) -> ( Float, Float )"
            },
            {
                "name": "fst",
                "comment": "Given a 2-tuple, returns the first value.",
                "type": "( a, b ) -> a"
            },
            {
                "name": "identity",
                "comment": "Given a value, returns exactly the same value. This is called\n[the identity function](http://en.wikipedia.org/wiki/Identity_function).",
                "type": "a -> a"
            },
            {
                "name": "isInfinite",
                "comment": "",
                "type": "Float -> Bool"
            },
            {
                "name": "isNaN",
                "comment": "",
                "type": "Float -> Bool"
            },
            {
                "name": "logBase",
                "comment": "Calculate the logarithm of a number with a given base.\n\n    logBase 10 100 == 2\n    logBase 2 256 == 8",
                "type": "Float -> Float -> Float"
            },
            {
                "name": "max",
                "comment": "Find the larger of two comparables.",
                "type": "comparable -> comparable -> comparable"
            },
            {
                "name": "min",
                "comment": "Find the smaller of two comparables.",
                "type": "comparable -> comparable -> comparable"
            },
            {
                "name": "negate",
                "comment": "Negate a number.\n\n    negate 42 == -42\n    negate -42 == 42\n    negate 0 == 0",
                "type": "number -> number"
            },
            {
                "name": "not",
                "comment": "Negate a boolean value.\n\n    not True == False\n    not False == True",
                "type": "Bool -> Bool"
            },
            {
                "name": "otherwise",
                "comment": "Equal to `True`. Useful as the last case of a multi-way-if.",
                "type": "Bool"
            },
            {
                "name": "pi",
                "comment": "An approximation of pi.",
                "type": "Float"
            },
            {
                "name": "radians",
                "comment": "Convert radians to standard Elm angles (radians).",
                "type": "Float -> Float"
            },
            {
                "name": "rem",
                "comment": "Find the remainder after dividing one number by another.\n\n     7 `rem` 2 == 1\n    -1 `rem` 4 == -1",
                "type": "Int -> Int -> Int"
            },
            {
                "name": "round",
                "comment": "Round a number to the nearest integer.",
                "type": "Float -> Int"
            },
            {
                "name": "sin",
                "comment": "",
                "type": "Float -> Float"
            },
            {
                "name": "snd",
                "comment": "Given a 2-tuple, returns the second value.",
                "type": "( a, b ) -> b"
            },
            {
                "name": "sqrt",
                "comment": "Take the square root of a number.",
                "type": "Float -> Float"
            },
            {
                "name": "tan",
                "comment": "",
                "type": "Float -> Float"
            },
            {
                "name": "toFloat",
                "comment": "Convert an integer into a float.",
                "type": "Int -> Float"
            },
            {
                "name": "toPolar",
                "comment": "Convert cartesian coordinates (x,y) to polar coordinates (r,&theta;).",
                "type": "( Float, Float ) -> ( Float, Float )"
            },
            {
                "name": "toString",
                "comment": "Turn any kind of value into a string. When you view the resulting string\nwith `Text.fromString` it should look just like the value it came from.\n\n    toString 42 == \"42\"\n    toString [1,2] == \"[1,2]\"\n    toString \"he said, \\\"hi\\\"\" == \"\\\"he said, \\\\\\\"hi\\\\\\\"\\\"\"",
                "type": "a -> String"
            },
            {
                "name": "truncate",
                "comment": "Truncate a number, rounding towards zero.",
                "type": "Float -> Int"
            },
            {
                "name": "turns",
                "comment": "Convert turns to standard Elm angles (radians).\nOne turn is equal to 360&deg;.",
                "type": "Float -> Float"
            },
            {
                "name": "uncurry",
                "comment": "Change how arguments are passed to a function.\nThis combines two arguments into a single pair.",
                "type": "(a -> b -> c) -> ( a, b ) -> c"
            },
            {
                "name": "xor",
                "comment": "The exclusive-or operator. `True` if exactly one input is `True`.",
                "type": "Bool -> Bool -> Bool"
            }
        ],
        "binops": [
            {
                "name": "%",
                "comment": "Perform [modular arithmetic](http://en.wikipedia.org/wiki/Modular_arithmetic).\n\n     7 % 2 == 1\n    -1 % 4 == 3",
                "type": "Int -> Int -> Int",
                "associativity": "left",
                "precedence": 7
            },
            {
                "name": "&&",
                "comment": "The logical AND operator. `True` if both inputs are `True`.\nThis operator short-circuits to `False` if the first argument is `False`.",
                "type": "Bool -> Bool -> Bool",
                "associativity": "right",
                "precedence": 3
            },
            {
                "name": "*",
                "comment": "",
                "type": "number -> number -> number",
                "associativity": "left",
                "precedence": 7
            },
            {
                "name": "+",
                "comment": "",
                "type": "number -> number -> number",
                "associativity": "left",
                "precedence": 6
            },
            {
                "name": "++",
                "comment": "Put two appendable things together. This includes strings, lists, and text.\n\n    \"hello\" ++ \"world\" == \"helloworld\"\n    [1,1,2] ++ [3,5,8] == [1,1,2,3,5,8]",
                "type": "appendable -> appendable -> appendable",
                "associativity": "right",
                "precedence": 5
            },
            {
                "name": "-",
                "comment": "",
                "type": "number -> number -> number",
                "associativity": "left",
                "precedence": 6
            },
            {
                "name": "/",
                "comment": "Floating point division.",
                "type": "Float -> Float -> Float",
                "associativity": "left",
                "precedence": 7
            },
            {
                "name": "//",
                "comment": "Integer division. The remainder is discarded.",
                "type": "Int -> Int -> Int",
                "associativity": "left",
                "precedence": 7
            },
            {
                "name": "/=",
                "comment": "",
                "type": "a -> a -> Bool",
                "associativity": "non",
                "precedence": 4
            },
            {
                "name": "<",
                "comment": "",
                "type": "comparable -> comparable -> Bool",
                "associativity": "non",
                "precedence": 4
            },
            {
                "name": "<<",
                "comment": "Function composition, passing results along in the suggested direction. For\nexample, the following code checks if the square root of a number is odd:\n\n    not << isEven << sqrt\n\nYou can think of this operator as equivalent to the following:\n\n    (g << f)  ==  (\\x -> g (f x))\n\nSo our example expands out to something like this:\n\n    \\n -> not (isEven (sqrt n))",
                "type": "(b -> c) -> (a -> b) -> a -> c",
                "associativity": "right",
                "precedence": 9
            },
            {
                "name": "<=",
                "comment": "",
                "type": "comparable -> comparable -> Bool",
                "associativity": "non",
                "precedence": 4
            },
            {
                "name": "<|",
                "comment": "Backward function application `f <| x == f x`. This function is useful for\navoiding parenthesis. Consider the following code to create a text element:\n\n    leftAligned (monospace (fromString \"code\"))\n\nThis can also be written as:\n\n    leftAligned << monospace <| fromString \"code\"",
                "type": "(a -> b) -> a -> b",
                "associativity": "right",
                "precedence": 0
            },
            {
                "name": "==",
                "comment": "",
                "type": "a -> a -> Bool",
                "associativity": "non",
                "precedence": 4
            },
            {
                "name": ">",
                "comment": "",
                "type": "comparable -> comparable -> Bool",
                "associativity": "non",
                "precedence": 4
            },
            {
                "name": ">=",
                "comment": "",
                "type": "comparable -> comparable -> Bool",
                "associativity": "non",
                "precedence": 4
            },
            {
                "name": ">>",
                "comment": "Function composition, passing results along in the suggested direction. For\nexample, the following code checks if the square root of a number is odd:\n\n    sqrt >> isEven >> not\n\nThis direction of function composition seems less pleasant than `(<<)` which\nreads nicely in expressions like: `filter (not << isRegistered) students`",
                "type": "(a -> b) -> (b -> c) -> a -> c",
                "associativity": "left",
                "precedence": 9
            },
            {
                "name": "^",
                "comment": "Exponentiation\n\n    3^2 == 9",
                "type": "number -> number -> number",
                "associativity": "right",
                "precedence": 8
            },
            {
                "name": "|>",
                "comment": "Forward function application `x |> f == f x`. This function is useful\nfor avoiding parenthesis and writing code in a more natural way.\nConsider the following code to create a pentagon:\n\n    scale 2 (move (10,10) (filled blue (ngon 5 30)))\n\nThis can also be written as:\n\n    ngon 5 30\n      |> filled blue\n      |> move (10,10)\n      |> scale 2",
                "type": "a -> (a -> b) -> b",
                "associativity": "left",
                "precedence": 0
            },
            {
                "name": "||",
                "comment": "The logical OR operator. `True` if one or both inputs are `True`.\nThis operator short-circuits to `True` if the first argument is `True`.",
                "type": "Bool -> Bool -> Bool",
                "associativity": "right",
                "precedence": 2
            }
        ]
    },
    {
        "name": "Bitwise",
        "comment": "Library for [bitwise operations](http://en.wikipedia.org/wiki/Bitwise_operation).\n\n# Basic Operations\n\n@docs and, or, xor, complement\n\n# Bit Shifts\n\n@docs shiftLeft, shiftRight, shiftRightLogical",
        "unions": [],
        "aliases": [],
        "values": [
            {
                "name": "and",
                "comment": "Bitwise AND",
                "type": "Int -> Int -> Int"
            },
            {
                "name": "complement",
                "comment": "Flip each bit individually, often called bitwise NOT",
                "type": "Int -> Int"
            },
            {
                "name": "or",
                "comment": "Bitwise OR",
                "type": "Int -> Int -> Int"
            },
            {
                "name": "shiftLeft",
                "comment": "Shift bits to the left by a given offset, filling new bits with zeros.\nThis can be used to multiply numbers by powers of two.\n\n    8 `shiftLeft` 1 == 16\n    8 `shiftLeft` 2 == 32",
                "type": "Int -> Int -> Int"
            },
            {
                "name": "shiftRight",
                "comment": "Shift bits to the right by a given offset, filling new bits with\nwhatever is the topmost bit. This can be used to divide numbers by powers of two.\n\n     32 `shiftRight` 1 == 16\n     32 `shiftRight` 2 == 8\n    -32 `shiftRight` 1 == -16\n\nThis is called an [arithmatic right\nshift](http://en.wikipedia.org/wiki/Bitwise_operation#Arithmetic_shift),\noften written (>>), and sometimes called a sign-propagating\nright shift because it fills empty spots with copies of the highest bit.",
                "type": "Int -> Int -> Int"
            },
            {
                "name": "shiftRightLogical",
                "comment": "Shift bits to the right by a given offset, filling new bits with\nzeros.\n\n     32 `shiftRightLogical` 1 == 16\n     32 `shiftRightLogical` 2 == 8\n    -32 `shiftRightLogical` 1 == 2147483632\n\nThis is called an [logical right\nshift](http://en.wikipedia.org/wiki/Bitwise_operation#Logical_shift), often written (>>>),\nand sometimes called a zero-fill right shift because it fills empty spots\nwith zeros.",
                "type": "Int -> Int -> Int"
            },
            {
                "name": "xor",
                "comment": "Bitwise XOR",
                "type": "Int -> Int -> Int"
            }
        ],
        "binops": []
    },
    {
        "name": "Char",
        "comment": "Functions for working with characters. Character literals are enclosed in\n`'a'` pair of single quotes.\n\n# Classification\n@docs isUpper, isLower, isDigit, isOctDigit, isHexDigit\n\n# Conversion\n@docs toUpper, toLower, toLocaleUpper, toLocaleLower, toCode, fromCode",
        "unions": [],
        "aliases": [
            {
                "name": "KeyCode",
                "comment": "",
                "args": [],
                "type": "Int"
            }
        ],
        "values": [
            {
                "name": "fromCode",
                "comment": "Convert from unicode.",
                "type": "KeyCode -> Char"
            },
            {
                "name": "isDigit",
                "comment": "True for ASCII digits `[0-9]`.",
                "type": "Char -> Bool"
            },
            {
                "name": "isHexDigit",
                "comment": "True for ASCII hexadecimal digits `[0-9a-fA-F]`.",
                "type": "Char -> Bool"
            },
            {
                "name": "isLower",
                "comment": "True for lower case letters.",
                "type": "Char -> Bool"
            },
            {
                "name": "isOctDigit",
                "comment": "True for ASCII octal digits `[0-7]`.",
                "type": "Char -> Bool"
            },
            {
                "name": "isUpper",
                "comment": "True for upper case letters.",
                "type": "Char -> Bool"
            },
            {
                "name": "toCode",
                "comment": "Convert to unicode. Used with the `Keyboard` library, which expects the\ninput to be uppercase.",
                "type": "Char -> KeyCode"
            },
            {
                "name": "toLocaleLower",
                "comment": "Convert to lower case, according to any locale-specific case mappings.",
                "type": "Char -> Char"
            },
            {
                "name": "toLocaleUpper",
                "comment": "Convert to upper case, according to any locale-specific case mappings.",
                "type": "Char -> Char"
            },
            {
                "name": "toLower",
                "comment": "Convert to lower case.",
                "type": "Char -> Char"
            },
            {
                "name": "toUpper",
                "comment": "Convert to upper case.",
                "type": "Char -> Char"
            }
        ],
        "binops": []
    },
    {
        "name": "Color",
        "comment": "Library for working with colors. Includes\n[RGB](https://en.wikipedia.org/wiki/RGB_color_model) and\n[HSL](http://en.wikipedia.org/wiki/HSL_and_HSV) creation, gradients, and\nbuilt-in names.\n\n# Creation\n@docs rgb, rgba, hsl, hsla, greyscale, grayscale, complement\n\n# Gradients\n@docs linear, radial\n\n# Extracting Colors\n@docs toRgb, toHsl\n\n# Built-in Colors\nThese colors come from the [Tango\npalette](http://tango.freedesktop.org/Tango_Icon_Theme_Guidelines)\nwhich provides aesthetically reasonable defaults for colors. Each color also\ncomes with a light and dark version.\n\n### Standard\n@docs red, orange, yellow, green, blue, purple, brown\n\n### Light\n@docs lightRed, lightOrange, lightYellow, lightGreen, lightBlue, lightPurple, lightBrown\n\n### Dark\n@docs darkRed, darkOrange, darkYellow, darkGreen, darkBlue, darkPurple, darkBrown\n\n### Eight Shades of Grey\nThese colors are a compatible series of shades of grey, fitting nicely\nwith the Tango palette.\n@docs white, lightGrey, grey, darkGrey, lightCharcoal, charcoal, darkCharcoal, black\n\nThese are identical to the *grey* versions. It seems the spelling is regional, but\nthat has never helped me remember which one I should be writing.\n@docs lightGray, gray, darkGray",
        "unions": [],
        "aliases": [],
        "values": [
            {
                "name": "black",
                "comment": "",
                "type": "Color"
            },
            {
                "name": "blue",
                "comment": "",
                "type": "Color"
            },
            {
                "name": "brown",
                "comment": "",
                "type": "Color"
            },
            {
                "name": "charcoal",
                "comment": "",
                "type": "Color"
            },
            {
                "name": "complement",
                "comment": "Produce a &ldquo;complementary color&rdquo;. The two colors will\naccent each other. This is the same as rotating the hue by 180&deg;.",
                "type": "Color -> Color"
            },
            {
                "name": "darkBlue",
                "comment": "",
                "type": "Color"
            },
            {
                "name": "darkBrown",
                "comment": "",
                "type": "Color"
            },
            {
                "name": "darkCharcoal",
                "comment": "",
                "type": "Color"
            },
            {
                "name": "darkGray",
                "comment": "",
                "type": "Color"
            },
            {
                "name": "darkGreen",
                "comment": "",
                "type": "Color"
            },
            {
                "name": "darkGrey",
                "comment": "",
                "type": "Color"
            },
            {
                "name": "darkOrange",
                "comment": "",
                "type": "Color"
            },
            {
                "name": "darkPurple",
                "comment": "",
                "type": "Color"
            },
            {
                "name": "darkRed",
                "comment": "",
                "type": "Color"
            },
            {
                "name": "darkYellow",
                "comment": "",
                "type": "Color"
            },
            {
                "name": "gray",
                "comment": "",
                "type": "Color"
            },
            {
                "name": "grayscale",
                "comment": "Produce a gray based on the input. 0 is white, 1 is black.",
                "type": "Float -> Color"
            },
            {
                "name": "green",
                "comment": "",
                "type": "Color"
            },
            {
                "name": "grey",
                "comment": "",
                "type": "Color"
            },
            {
                "name": "greyscale",
                "comment": "",
                "type": "Float -> Color"
            },
            {
                "name": "hsl",
                "comment": "Create [HSL colors](http://en.wikipedia.org/wiki/HSL_and_HSV). This gives\nyou access to colors more like a color wheel, where all hues are aranged in a\ncircle that you specify with standard Elm angles (radians).\n\n    red   = hsl (degrees   0) 1 0.5\n    green = hsl (degrees 120) 1 0.5\n    blue  = hsl (degrees 240) 1 0.5\n\n    pastelRed = hsl (degrees 0) 0.7 0.7\n\nTo cycle through all colors, just cycle through degrees. The saturation level\nis how vibrant the color is, like a dial between grey and bright colors. The\nlightness level is a dial between white and black.",
                "type": "Float -> Float -> Float -> Color"
            },
            {
                "name": "hsla",
                "comment": "Create [HSL colors](http://en.wikipedia.org/wiki/HSL_and_HSV)\nwith an alpha component for transparency.",
                "type": "Float -> Float -> Float -> Float -> Color"
            },
            {
                "name": "lightBlue",
                "comment": "",
                "type": "Color"
            },
            {
                "name": "lightBrown",
                "comment": "",
                "type": "Color"
            },
            {
                "name": "lightCharcoal",
                "comment": "",
                "type": "Color"
            },
            {
                "name": "lightGray",
                "comment": "",
                "type": "Color"
            },
            {
                "name": "lightGreen",
                "comment": "",
                "type": "Color"
            },
            {
                "name": "lightGrey",
                "comment": "",
                "type": "Color"
            },
            {
                "name": "lightOrange",
                "comment": "",
                "type": "Color"
            },
            {
                "name": "lightPurple",
                "comment": "",
                "type": "Color"
            },
            {
                "name": "lightRed",
                "comment": "",
                "type": "Color"
            },
            {
                "name": "lightYellow",
                "comment": "",
                "type": "Color"
            },
            {
                "name": "linear",
                "comment": "Create a linear gradient. Takes a start and end point and then a series of\n&ldquo;color stops&rdquo; that indicate how to interpolate between the start and\nend points. See [this example](http://elm-lang.org/edit/examples/Elements/LinearGradient.elm) for a\nmore visual explanation.",
                "type": "( number, number ) -> ( number, number ) -> List ( Float, Color ) -> Gradient"
            },
            {
                "name": "orange",
                "comment": "",
                "type": "Color"
            },
            {
                "name": "purple",
                "comment": "",
                "type": "Color"
            },
            {
                "name": "radial",
                "comment": "Create a radial gradient. First takes a start point and inner radius.  Then\ntakes an end point and outer radius. It then takes a series of &ldquo;color\nstops&rdquo; that indicate how to interpolate between the inner and outer\ncircles. See [this example](http://elm-lang.org/edit/examples/Elements/RadialGradient.elm) for a\nmore visual explanation.",
                "type": "( number, number ) -> number -> ( number, number ) -> number -> List ( Float, Color ) -> Gradient"
            },
            {
                "name": "red",
                "comment": "",
                "type": "Color"
            },
            {
                "name": "rgb",
                "comment": "Create RGB colors from numbers between 0 and 255 inclusive.",
                "type": "Int -> Int -> Int -> Color"
            },
            {
                "name": "rgba",
                "comment": "Create RGB colors with an alpha component for transparency.\nThe alpha component is specified with numbers between 0 and 1.",
                "type": "Int -> Int -> Int -> Float -> Color"
            },
            {
                "name": "toHsl",
                "comment": "Extract the components of a color in the HSL format.",
                "type": "Color -> { hue : Float, saturation : Float, lightness : Float, alpha : Float }"
            },
            {
                "name": "toRgb",
                "comment": "Extract the components of a color in the RGB format.",
                "type": "Color -> { red : Int, green : Int, blue : Int, alpha : Float }"
            },
            {
                "name": "white",
                "comment": "",
                "type": "Color"
            },
            {
                "name": "yellow",
                "comment": "",
                "type": "Color"
            }
        ],
        "binops": []
    },
    {
        "name": "Date",
        "comment": "Library for working with dates. Email the mailing list if you encounter\nissues with internationalization or locale formatting.\n\n# Conversions\n@docs fromString, toTime, fromTime\n\n# Extractions\n@docs year, month, Month, day, dayOfWeek, Day, hour, minute, second, millisecond",
        "unions": [
            {
                "name": "Day",
                "comment": "Represents the days of the week.",
                "args": [],
                "cases": [
                    [
                        "Mon",
                        []
                    ],
                    [
                        "Tue",
                        []
                    ],
                    [
                        "Wed",
                        []
                    ],
                    [
                        "Thu",
                        []
                    ],
                    [
                        "Fri",
                        []
                    ],
                    [
                        "Sat",
                        []
                    ],
                    [
                        "Sun",
                        []
                    ]
                ]
            },
            {
                "name": "Month",
                "comment": "Represents the month of the year.",
                "args": [],
                "cases": [
                    [
                        "Jan",
                        []
                    ],
                    [
                        "Feb",
                        []
                    ],
                    [
                        "Mar",
                        []
                    ],
                    [
                        "Apr",
                        []
                    ],
                    [
                        "May",
                        []
                    ],
                    [
                        "Jun",
                        []
                    ],
                    [
                        "Jul",
                        []
                    ],
                    [
                        "Aug",
                        []
                    ],
                    [
                        "Sep",
                        []
                    ],
                    [
                        "Oct",
                        []
                    ],
                    [
                        "Nov",
                        []
                    ],
                    [
                        "Dec",
                        []
                    ]
                ]
            }
        ],
        "aliases": [],
        "values": [
            {
                "name": "day",
                "comment": "Extract the day of a given date. Given the date 23 June 1990 at 11:45AM\nthis returns the integer `23`.",
                "type": "Date -> Int"
            },
            {
                "name": "dayOfWeek",
                "comment": "Extract the day of the week for a given date. Given the date 23 June\n1990 at 11:45AM this returns the Day `Thu` as defined below.",
                "type": "Date -> Day"
            },
            {
                "name": "fromString",
                "comment": "Attempt to read a date from a string.",
                "type": "String -> Result String Date"
            },
            {
                "name": "fromTime",
                "comment": "Take a UNIX time and convert it to a `Date`.",
                "type": "Time -> Date"
            },
            {
                "name": "hour",
                "comment": "Extract the hour of a given date. Given the date 23 June 1990 at 11:45AM\nthis returns the integer `11`.",
                "type": "Date -> Int"
            },
            {
                "name": "millisecond",
                "comment": "Extract the millisecond of a given date. Given the date 23 June 1990 at 11:45:30.123AM\nthis returns the integer `123`.",
                "type": "Date -> Int"
            },
            {
                "name": "minute",
                "comment": "Extract the minute of a given date. Given the date 23 June 1990 at 11:45AM\nthis returns the integer `45`.",
                "type": "Date -> Int"
            },
            {
                "name": "month",
                "comment": "Extract the month of a given date. Given the date 23 June 1990 at 11:45AM\nthis returns the Month `Jun` as defined below.",
                "type": "Date -> Month"
            },
            {
                "name": "second",
                "comment": "Extract the second of a given date. Given the date 23 June 1990 at 11:45AM\nthis returns the integer `0`.",
                "type": "Date -> Int"
            },
            {
                "name": "toTime",
                "comment": "Convert a date into a time since midnight (UTC) of 1 January 1990 (i.e.\n[UNIX time](http://en.wikipedia.org/wiki/Unix_time)). Given the date 23 June\n1990 at 11:45AM this returns the corresponding time.",
                "type": "Date -> Time"
            },
            {
                "name": "year",
                "comment": "Extract the year of a given date. Given the date 23 June 1990 at 11:45AM\nthis returns the integer `1990`.",
                "type": "Date -> Int"
            }
        ],
        "binops": []
    },
    {
        "name": "Debug",
        "comment": "This library is for investigating bugs or performance problems. It should\n*not* be used in production code.\n\n# Console Debugging\n@docs log, crash\n\n# Time-Travel Debugging\n@docs watch, watchSummary, trace",
        "unions": [],
        "aliases": [],
        "values": [
            {
                "name": "crash",
                "comment": "Crash the program with an error message. This is an uncatchable error,\nintended for code that is soon-to-be-implemented. For example, if you are\nworking with a large ADT and have partially completed a case expression, it may\nmake sense to do this:\n\n    data Entity = Ship | Fish | Captain | Seagull\n\n    drawEntity entity =\n        case entity of\n          Ship -> ...\n          Fish -> ...\n          _ -> Debug.crash (\"drawEntity not implemented for \" ++ toString entity ++ \" yet!\")\n\nNote that incomplete pattern matches are *very* bad practice! They are one of\nthe very few ways to crash an Elm program, and they are completely avoidable.\nProduction code should not have incomplete pattern matches!\n\n**Use this if** you want to do some testing while you are partway through\nwriting a function.\n\n**Do not use this if** you want to do some typical try-catch exception handling.\nUse the `Maybe` or `Either` libraries instead.",
                "type": "String -> a"
            },
            {
                "name": "log",
                "comment": "Log a tagged value on the developer console, and then return the value.\n\n    1 + log \"number\" 1        -- equals 2, logs \"number: 1\"\n    length (log \"start\" [])   -- equals 0, logs \"start: []\"\n\nNotice that `log` is not a pure function! It should *only* be used for\ninvestigating bugs or performance problems.",
                "type": "String -> a -> a"
            },
            {
                "name": "trace",
                "comment": "Trace all past positions of a `Form` in the debugger. Add this to a `Form`\nand you will see a line tracing its entire history.",
                "type": "String -> Form -> Form"
            },
            {
                "name": "watch",
                "comment": "Watch a particular value in the debugger. Say we want to know the value of\na variable called `velocity` because it may not be updated correctly. Adding\n`Debug.watch` allows us to name the value and show it with the debugger.\n\n\t  Debug.watch \"velocity\" velocity == velocity\n\nNotice that the result of evaluating this expression is exactly the same as\nnot having the expression at all. That means it's easy to add to any value.",
                "type": "String -> a -> a"
            },
            {
                "name": "watchSummary",
                "comment": "Watch a summary of a particular value in the debugger. This function is\npretty much the same as `watch` but it lets you specify a way to summarize\nthe value you are interested in. For example, maybe you only want to see part\nof a record:\n\n\t  Debug.watchSummary \"velocity\" .velocity object\n\nThis is the same as just writing `object`, but it creates a watch that *only*\nlooks at the value of `object.velocity`. You can also show summary statistics\nlike length of a list:\n\n\t  Debug.watchSummary \"Number of clicks\" length clicks\n\nAgain, this evaluates to `clicks` but we get to see how long that list is in\nthe debugger.",
                "type": "String -> (a -> b) -> a -> a"
            }
        ],
        "binops": []
    },
    {
        "name": "Dict",
        "comment": "A dictionary mapping unique keys to values. The keys can be any comparable\ntype. This includes `Int`, `Float`, `Time`, `Char`, `String`, and tuples or\nlists of comparable types.\n\nInsert, remove, and query operations all take *O(log n)* time. Dictionary\nequality with `(==)` is unreliable and should not be used.\n\n# Build\n@docs empty, singleton, insert, update, remove\n\n# Query\n@docs isEmpty, member, get\n\n# Combine\n@docs union, intersect, diff\n\n# Lists\n@docs keys, values, toList, fromList\n\n# Transform\n@docs map, foldl, foldr, filter, partition",
        "unions": [],
        "aliases": [],
        "values": [
            {
                "name": "diff",
                "comment": "Keep a key-value pair when its key does not appear in the second dictionary.",
                "type": "Dict comparable v -> Dict comparable v -> Dict comparable v"
            },
            {
                "name": "empty",
                "comment": "Create an empty dictionary.",
                "type": "Dict comparable v"
            },
            {
                "name": "filter",
                "comment": "Keep a key-value pair when it satisfies a predicate.",
                "type": "(comparable -> v -> Bool) -> Dict comparable v -> Dict comparable v"
            },
            {
                "name": "foldl",
                "comment": "Fold over the key-value pairs in a dictionary, in order from lowest\nkey to highest key.",
                "type": "(comparable -> v -> b -> b) -> b -> Dict comparable v -> b"
            },
            {
                "name": "foldr",
                "comment": "Fold over the key-value pairs in a dictionary, in order from highest\nkey to lowest key.",
                "type": "(comparable -> v -> b -> b) -> b -> Dict comparable v -> b"
            },
            {
                "name": "fromList",
                "comment": "Convert an association list into a dictionary.",
                "type": "List ( comparable, v ) -> Dict comparable v"
            },
            {
                "name": "get",
                "comment": "Get the value associated with a key. If the key is not found, return\n`Nothing`. This is useful when you are not sure if a key will be in the\ndictionary.\n\n    animals = fromList [ (\"Tom\", Cat), (\"Jerry\", Mouse) ]\n\n    get \"Tom\"   animals == Just Cat\n    get \"Mouse\" animals == Just Mouse\n    get \"Spike\" animals == Nothing",
                "type": "comparable -> Dict comparable v -> Maybe v"
            },
            {
                "name": "insert",
                "comment": "Insert a key-value pair into a dictionary. Replaces value when there is\na collision.",
                "type": "comparable -> v -> Dict comparable v -> Dict comparable v"
            },
            {
                "name": "intersect",
                "comment": "Keep a key-value pair when its key appears in the second dictionary.\nPreference is given to values in the first dictionary.",
                "type": "Dict comparable v -> Dict comparable v -> Dict comparable v"
            },
            {
                "name": "isEmpty",
                "comment": "Determine if a dictionary is empty.\n\n    isEmpty empty == True",
                "type": "Dict comparable v -> Bool"
            },
            {
                "name": "keys",
                "comment": "Get all of the keys in a dictionary.",
                "type": "Dict comparable v -> List comparable"
            },
            {
                "name": "map",
                "comment": "Apply a function to all values in a dictionary.",
                "type": "(comparable -> a -> b) -> Dict comparable a -> Dict comparable b"
            },
            {
                "name": "member",
                "comment": "Determine if a key is in a dictionary.",
                "type": "comparable -> Dict comparable v -> Bool"
            },
            {
                "name": "partition",
                "comment": "Partition a dictionary according to a predicate. The first dictionary\ncontains all key-value pairs which satisfy the predicate, and the second\ncontains the rest.",
                "type": "(comparable -> v -> Bool) -> Dict comparable v -> ( Dict comparable v, Dict comparable v )"
            },
            {
                "name": "remove",
                "comment": "Remove a key-value pair from a dictionary. If the key is not found,\nno changes are made.",
                "type": "comparable -> Dict comparable v -> Dict comparable v"
            },
            {
                "name": "singleton",
                "comment": "Create a dictionary with one key-value pair.",
                "type": "comparable -> v -> Dict comparable v"
            },
            {
                "name": "toList",
                "comment": "Convert a dictionary into an association list of key-value pairs.",
                "type": "Dict comparable v -> List ( comparable, v )"
            },
            {
                "name": "union",
                "comment": "Combine two dictionaries. If there is a collision, preference is given\nto the first dictionary.",
                "type": "Dict comparable v -> Dict comparable v -> Dict comparable v"
            },
            {
                "name": "update",
                "comment": "Update the value of a dictionary for a specific key with a given function.",
                "type": "comparable -> (Maybe v -> Maybe v) -> Dict comparable v -> Dict comparable v"
            },
            {
                "name": "values",
                "comment": "Get all of the values in a dictionary.",
                "type": "Dict comparable v -> List v"
            }
        ],
        "binops": []
    },
    {
        "name": "Graphics.Element",
        "comment": "Graphical elements that snap together to build complex widgets and layouts.\nEach Element is a rectangle with a known width and height, making them easy to\ncombine and position.\n\n# Show Anything\n@docs show\n\n# Images\n@docs image, fittedImage, croppedImage, tiledImage\n\n# Text\nEach of the following functions places [`Text`](Text) into a box. The function\nyou use determines the alignment of the text.\n\n@docs leftAligned, rightAligned, centered, justified\n\n# Styling\n@docs width, height, size, color, opacity, link, tag\n\n# Inspection\n@docs widthOf, heightOf, sizeOf\n\n# Layout\n@docs flow, up, down, left, right, inward, outward\n\n## Layout Aliases\nThere are also some convenience functions for working\nwith `flow` in specific cases:\n\n@docs layers, above, below, beside\n\n# Positioning\n@docs empty, spacer, container\n\n## Specific Positions\n\nTo create a `Position` you can use any of the built-in positions\nwhich cover nine common positions.\n@docs middle, midTop, midBottom, midLeft, midRight, topLeft, topRight,\n      bottomLeft, bottomRight\n\nIf you need more precision, you can create custom positions.\n\n@docs absolute, relative, middleAt, midTopAt, midBottomAt, midLeftAt,\n      midRightAt, topLeftAt, topRightAt, bottomLeftAt, bottomRightAt",
        "unions": [],
        "aliases": [
            {
                "name": "Element",
                "comment": "",
                "args": [],
                "type": "{ props : Properties, element : ElementPrim }"
            },
            {
                "name": "Position",
                "comment": "",
                "args": [],
                "type": "{ horizontal : Three, vertical : Three, x : Pos, y : Pos }"
            }
        ],
        "values": [
            {
                "name": "above",
                "comment": "Stack elements vertically.\nTo put `a` above `b` you would say: ``a `above` b``",
                "type": "Element -> Element -> Element"
            },
            {
                "name": "absolute",
                "comment": "",
                "type": "Int -> Pos"
            },
            {
                "name": "below",
                "comment": "Stack elements vertically.\nTo put `a` below `b` you would say: ``a `below` b``",
                "type": "Element -> Element -> Element"
            },
            {
                "name": "beside",
                "comment": "Put elements beside each other horizontally.\nTo put `a` beside `b` you would say: ``a `beside` b``",
                "type": "Element -> Element -> Element"
            },
            {
                "name": "bottomLeft",
                "comment": "",
                "type": "Position"
            },
            {
                "name": "bottomLeftAt",
                "comment": "",
                "type": "Pos -> Pos -> Position"
            },
            {
                "name": "bottomRight",
                "comment": "",
                "type": "Position"
            },
            {
                "name": "bottomRightAt",
                "comment": "",
                "type": "Pos -> Pos -> Position"
            },
            {
                "name": "centered",
                "comment": "Center text in the text block. There is equal spacing on either side of a\nline of text.",
                "type": "Text -> Element"
            },
            {
                "name": "color",
                "comment": "Create an `Element` with a given background color.",
                "type": "Color -> Element -> Element"
            },
            {
                "name": "container",
                "comment": "Put an element in a container. This lets you position the element really\neasily, and there are tons of ways to set the `Position`.\nTo center `element` exactly in a 300-by-300 square you would say:\n\n    container 300 300 middle element\n\nBy setting the color of the container, you can create borders.",
                "type": "Int -> Int -> Position -> Element -> Element"
            },
            {
                "name": "croppedImage",
                "comment": "Create a cropped image. Take a rectangle out of the picture starting\nat the given top left coordinate. If you have a 140-by-140 image,\nthe following will cut a 100-by-100 square out of the middle of it.\n\n    croppedImage (20,20) 100 100 \"yogi.jpg\"",
                "type": "( Int, Int ) -> Int -> Int -> String -> Element"
            },
            {
                "name": "down",
                "comment": "",
                "type": "Direction"
            },
            {
                "name": "empty",
                "comment": "An Element that takes up no space. Good for things that appear conditionally:\n\n    flow down [ img1, if showMore then img2 else empty ]",
                "type": "Element"
            },
            {
                "name": "fittedImage",
                "comment": "Create a fitted image given a width, height, and image source.\nThis will crop the picture to best fill the given dimensions.",
                "type": "Int -> Int -> String -> Element"
            },
            {
                "name": "flow",
                "comment": "Have a list of elements flow in a particular direction.\nThe `Direction` starts from the first element in the list.\n\n    flow right [a,b,c]\n\n        +---+---+---+\n        | a | b | c |\n        +---+---+---+",
                "type": "Direction -> List Element -> Element"
            },
            {
                "name": "height",
                "comment": "Create an `Element` with a given height.",
                "type": "Int -> Element -> Element"
            },
            {
                "name": "heightOf",
                "comment": "Get the height of an Element",
                "type": "Element -> Int"
            },
            {
                "name": "image",
                "comment": "Create an image given a width, height, and image source.",
                "type": "Int -> Int -> String -> Element"
            },
            {
                "name": "inward",
                "comment": "",
                "type": "Direction"
            },
            {
                "name": "justified",
                "comment": "Align text along the left and right sides of the text block. Word spacing is\nadjusted to make this possible.",
                "type": "Text -> Element"
            },
            {
                "name": "layers",
                "comment": "Layer elements on top of each other, starting from the bottom:\n`layers == flow outward`",
                "type": "List Element -> Element"
            },
            {
                "name": "left",
                "comment": "",
                "type": "Direction"
            },
            {
                "name": "leftAligned",
                "comment": "Align text along the left side of the text block. This is sometimes known as\n*ragged right*.",
                "type": "Text -> Element"
            },
            {
                "name": "link",
                "comment": "Create an `Element` that is a hyper-link.",
                "type": "String -> Element -> Element"
            },
            {
                "name": "midBottom",
                "comment": "",
                "type": "Position"
            },
            {
                "name": "midBottomAt",
                "comment": "",
                "type": "Pos -> Pos -> Position"
            },
            {
                "name": "midLeft",
                "comment": "",
                "type": "Position"
            },
            {
                "name": "midLeftAt",
                "comment": "",
                "type": "Pos -> Pos -> Position"
            },
            {
                "name": "midRight",
                "comment": "",
                "type": "Position"
            },
            {
                "name": "midRightAt",
                "comment": "",
                "type": "Pos -> Pos -> Position"
            },
            {
                "name": "midTop",
                "comment": "",
                "type": "Position"
            },
            {
                "name": "midTopAt",
                "comment": "",
                "type": "Pos -> Pos -> Position"
            },
            {
                "name": "middle",
                "comment": "",
                "type": "Position"
            },
            {
                "name": "middleAt",
                "comment": "",
                "type": "Pos -> Pos -> Position"
            },
            {
                "name": "opacity",
                "comment": "Create an `Element` with a given opacity. Opacity is a number between 0 and 1\nwhere 0 means totally clear.",
                "type": "Float -> Element -> Element"
            },
            {
                "name": "outward",
                "comment": "",
                "type": "Direction"
            },
            {
                "name": "relative",
                "comment": "",
                "type": "Float -> Pos"
            },
            {
                "name": "right",
                "comment": "",
                "type": "Direction"
            },
            {
                "name": "rightAligned",
                "comment": "Align text along the right side of the text block. This is sometimes known\nas *ragged left*.",
                "type": "Text -> Element"
            },
            {
                "name": "show",
                "comment": "Convert anything to its textual representation and make it displayable in\nthe browser. Excellent for debugging.\n\n    main : Element\n    main =\n      show \"Hello World!\"\n\n    show value =\n        leftAligned (Text.monospace (Text.fromString (toString value)))",
                "type": "a -> Element"
            },
            {
                "name": "size",
                "comment": "Create an `Element` with a new width and height.",
                "type": "Int -> Int -> Element -> Element"
            },
            {
                "name": "sizeOf",
                "comment": "Get the width and height of an Element",
                "type": "Element -> ( Int, Int )"
            },
            {
                "name": "spacer",
                "comment": "Create an empty box. This is useful for getting your spacing right and\nfor making borders.",
                "type": "Int -> Int -> Element"
            },
            {
                "name": "tag",
                "comment": "Create an `Element` with a tag. This lets you link directly to it.\nThe element `(tag \"all-about-badgers\" thirdParagraph)` can be reached\nwith a link like this: `/facts-about-animals.elm#all-about-badgers`",
                "type": "String -> Element -> Element"
            },
            {
                "name": "tiledImage",
                "comment": "",
                "type": "Int -> Int -> String -> Element"
            },
            {
                "name": "topLeft",
                "comment": "",
                "type": "Position"
            },
            {
                "name": "topLeftAt",
                "comment": "",
                "type": "Pos -> Pos -> Position"
            },
            {
                "name": "topRight",
                "comment": "",
                "type": "Position"
            },
            {
                "name": "topRightAt",
                "comment": "",
                "type": "Pos -> Pos -> Position"
            },
            {
                "name": "up",
                "comment": "",
                "type": "Direction"
            },
            {
                "name": "width",
                "comment": "Create an `Element` with a given width.",
                "type": "Int -> Element -> Element"
            },
            {
                "name": "widthOf",
                "comment": "Get the width of an Element",
                "type": "Element -> Int"
            }
        ],
        "binops": []
    },
    {
        "name": "Graphics.Collage",
        "comment": "The collage API is for freeform graphics. You can move, rotate, scale, etc.\nall sorts of forms including lines, shapes, images, and elements.\n\nCollages use the same coordinate system you might see in an algebra or physics\nproblem. The origin (0,0) is at the center of the collage, not the top left\ncorner as in some other graphics libraries. Furthermore, the y-axis points up,\nso moving a form 10 units in the y-axis will move it up on screen.\n\n# Unstructured Graphics\n@docs collage\n\n# Creating Forms\n@docs toForm, filled, textured, gradient, outlined, traced, text, outlinedText\n\n# Transforming Forms\n@docs move, moveX, moveY, scale, rotate, alpha\n\n# Grouping Forms\nGrouping forms makes it easier to write modular graphics code. You can create\na form that is a composite of many subforms. From there it is easy to transform\nit as a single unit.\n\n@docs group, groupTransform\n\n# Shapes\n@docs rect, oval, square, circle, ngon, polygon\n\n# Paths\n@docs segment, path\n\n# Line Styles\n@docs solid, dashed, dotted, LineStyle, LineCap, LineJoin, defaultLine",
        "unions": [
            {
                "name": "LineCap",
                "comment": "The shape of the ends of a line.",
                "args": [],
                "cases": [
                    [
                        "Flat",
                        []
                    ],
                    [
                        "Round",
                        []
                    ],
                    [
                        "Padded",
                        []
                    ]
                ]
            },
            {
                "name": "LineJoin",
                "comment": "The shape of the &ldquo;joints&rdquo; of a line, where each line segment\nmeets. `Sharp` takes an argument to limit the length of the joint. This\ndefaults to 10.",
                "args": [],
                "cases": [
                    [
                        "Smooth",
                        []
                    ],
                    [
                        "Sharp",
                        [
                            "Float"
                        ]
                    ],
                    [
                        "Clipped",
                        []
                    ]
                ]
            }
        ],
        "aliases": [
            {
                "name": "Form",
                "comment": "",
                "args": [],
                "type": "{ theta : Float, scale : Float, x : Float, y : Float, alpha : Float, form : BasicForm }"
            },
            {
                "name": "LineStyle",
                "comment": "All of the attributes of a line style. This lets you build up a line style\nhowever you want. You can also update existing line styles with record updates.",
                "args": [],
                "type": "{ color : Color, width : Float, cap : LineCap, join : LineJoin, dashing : List Int, dashOffset : Int }"
            },
            {
                "name": "Path",
                "comment": "",
                "args": [],
                "type": "List ( Float, Float )"
            },
            {
                "name": "Shape",
                "comment": "",
                "args": [],
                "type": "List ( Float, Float )"
            }
        ],
        "values": [
            {
                "name": "alpha",
                "comment": "Set the alpha of a `Form`. The default is 1, and 0 is totally transparent.",
                "type": "Float -> Form -> Form"
            },
            {
                "name": "circle",
                "comment": "A circle with a given radius.",
                "type": "Float -> Shape"
            },
            {
                "name": "collage",
                "comment": "A collage is a collection of 2D forms. There are no strict positioning\nrelationships between forms, so you are free to do all kinds of 2D graphics.",
                "type": "Int -> Int -> List Form -> Element"
            },
            {
                "name": "dashed",
                "comment": "Create a dashed line style with a given color. Dashing equals `[8,4]`.",
                "type": "Color -> LineStyle"
            },
            {
                "name": "defaultLine",
                "comment": "The default line style, which is solid black with flat caps and sharp joints.\nYou can use record updates to build the line style you\nwant. For example, to make a thicker line, you could say:\n\n    { defaultLine | width <- 10 }",
                "type": "LineStyle"
            },
            {
                "name": "dotted",
                "comment": "Create a dotted line style with a given color. Dashing equals `[3,3]`.",
                "type": "Color -> LineStyle"
            },
            {
                "name": "filled",
                "comment": "Create a filled in shape.",
                "type": "Color -> Shape -> Form"
            },
            {
                "name": "gradient",
                "comment": "Fill a shape with a [gradient](Color#linear).",
                "type": "Gradient -> Shape -> Form"
            },
            {
                "name": "group",
                "comment": "Flatten many forms into a single `Form`. This lets you move and rotate them\nas a single unit, making it possible to build small, modular components.",
                "type": "List Form -> Form"
            },
            {
                "name": "groupTransform",
                "comment": "Flatten many forms into a single `Form` and then apply a matrix\ntransformation.",
                "type": "Transform2D -> List Form -> Form"
            },
            {
                "name": "move",
                "comment": "Move a form by the given amount. This is a relative translation so\n`(move (10,10) form)` would move `form` ten pixels up and ten pixels to the\nright.",
                "type": "( Float, Float ) -> Form -> Form"
            },
            {
                "name": "moveX",
                "comment": "Move a shape in the x direction. This is relative so `(moveX 10 form)` moves\n`form` 10 pixels to the right.",
                "type": "Float -> Form -> Form"
            },
            {
                "name": "moveY",
                "comment": "Move a shape in the y direction. This is relative so `(moveY 10 form)` moves\n`form` upwards by 10 pixels.",
                "type": "Float -> Form -> Form"
            },
            {
                "name": "ngon",
                "comment": "A regular polygon with N sides. The first argument specifies the number\nof sides and the second is the radius. So to create a pentagon with radius\n30 you would say:\n\n    ngon 5 30",
                "type": "Int -> Float -> Shape"
            },
            {
                "name": "outlined",
                "comment": "Outline a shape with a given line style.",
                "type": "LineStyle -> Shape -> Form"
            },
            {
                "name": "outlinedText",
                "comment": "Create some outlined text. Since we are just outlining the text, the color\nis taken from the `LineStyle` attribute instead of the `Text`.",
                "type": "LineStyle -> Text -> Form"
            },
            {
                "name": "oval",
                "comment": "An oval with a given width and height.",
                "type": "Float -> Float -> Shape"
            },
            {
                "name": "path",
                "comment": "Create a path that follows a sequence of points.",
                "type": "List ( Float, Float ) -> Path"
            },
            {
                "name": "polygon",
                "comment": "Create an arbitrary polygon by specifying its corners in order.\n`polygon` will automatically close all shapes, so the given list\nof points does not need to start and end with the same position.",
                "type": "List ( Float, Float ) -> Shape"
            },
            {
                "name": "rect",
                "comment": "A rectangle with a given width and height.",
                "type": "Float -> Float -> Shape"
            },
            {
                "name": "rotate",
                "comment": "Rotate a form by a given angle. Rotate takes standard Elm angles (radians)\nand turns things counterclockwise. So to turn `form` 30&deg; to the left\nyou would say, `(rotate (degrees 30) form)`.",
                "type": "Float -> Form -> Form"
            },
            {
                "name": "scale",
                "comment": "Scale a form by a given factor. Scaling by 2 doubles both dimensions,\nand quadruples the area.",
                "type": "Float -> Form -> Form"
            },
            {
                "name": "segment",
                "comment": "Create a path along a given line segment.",
                "type": "( Float, Float ) -> ( Float, Float ) -> Path"
            },
            {
                "name": "solid",
                "comment": "Create a solid line style with a given color.",
                "type": "Color -> LineStyle"
            },
            {
                "name": "square",
                "comment": "A square with a given edge length.",
                "type": "Float -> Shape"
            },
            {
                "name": "text",
                "comment": "Create some text. Details like size and color are part of the `Text` value\nitself, so you can mix colors and sizes and fonts easily.",
                "type": "Text -> Form"
            },
            {
                "name": "textured",
                "comment": "Create a textured shape. The texture is described by some url and is\ntiled to fill the entire shape.",
                "type": "String -> Shape -> Form"
            },
            {
                "name": "toForm",
                "comment": "Turn any `Element` into a `Form`. This lets you use text, gifs, and video\nin your collage. This means you can move, rotate, and scale\nan `Element` however you want.",
                "type": "Element -> Form"
            },
            {
                "name": "traced",
                "comment": "Trace a path with a given line style.",
                "type": "LineStyle -> Path -> Form"
            }
        ],
        "binops": []
    },
    {
        "name": "Graphics.Input",
        "comment": "This module is for creating input widgets such as buttons and text fields.\nAll functions in this library report to a [`Signal.Mailbox`](Signal#message).\n\n# Basic Input Elements\n\nTo learn about text fields, see the\n[`Graphics.Input.Field`](Graphics-Input-Field) library.\n\n@docs button, customButton, checkbox, dropDown\n\n# Clicks and Hovers\n@docs clickable, hoverable",
        "unions": [],
        "aliases": [],
        "values": [
            {
                "name": "button",
                "comment": "Create a standard button. The following example begins making a basic\ncalculator:\n\n    type Keys = Number Int | Plus | Minus | Clear\n\n    keys : Signal.Mailbox Keys\n    keys = Signal.mailbox Clear\n\n    calculator : Element\n    calculator =\n        flow right\n          [ button (Signal.message keys.address (Number 1)) \"1\"\n          , button (Signal.message keys.address (Number 2)) \"2\"\n          , button (Signal.message keys.address    Plus   ) \"+\"\n          ]\n\nIf the user presses the \"+\" button, `keys.signal` will update to `Plus`. If the\nusers presses \"2\", `keys.signal` will update to `(Number 2)`.",
                "type": "Message -> String -> Element"
            },
            {
                "name": "checkbox",
                "comment": "Create a checkbox. The following example creates three synced checkboxes:\n\n    check : Signal.Mailbox Bool\n    check = Signal.mailbox False\n\n    boxes : Bool -> Element\n    boxes checked =\n        let box = container 40 40 middle (checkbox (Signal.message check.address) checked)\n        in\n            flow right [ box, box, box ]\n\n    main : Signal Element\n    main = boxes <~ check.signal",
                "type": "(Bool -> Message) -> Bool -> Element"
            },
            {
                "name": "clickable",
                "comment": "Detect mouse clicks on a specific `Element`. In the following example,\nwe will create a clickable picture called `cat`.\n\n    type Picture = Cat | Hat\n\n    picture : Signal.Mailbox Picture\n    picture = Signal.mailbox Cat\n\n    cat : Element\n    cat =\n      image 30 30 \"/cat.jpg\"\n        |> clickable (Signal.message picture.address Cat)\n\n    hat : Element\n    hat =\n      image 30 30 \"/hat.jpg\"\n        |> clickable (Signal.message picture.address Hat)\n\nWhen the user clicks on the `cat` element, `picture.signal` receives\nan update containing the value `Cat`. When the user clicks on the `hat` element,\n`picture.signal` receives an update containing the value `Hat`. This lets you\ndistinguish which element was clicked. In a more complex example, they could be\ndistinguished with IDs or more complex data structures.",
                "type": "Message -> Element -> Element"
            },
            {
                "name": "customButton",
                "comment": "Same as `button` but lets you customize buttons to look however you want.\n\n    click : Signal.Mailbox ()\n    click = Signal.mailbox ()\n\n    prettyButton : Element\n    prettyButton =\n        customButton (Signal.message click.address ())\n            (image 100 40 \"/button_up.jpg\")\n            (image 100 40 \"/button_hover.jpg\")\n            (image 100 40 \"/button_down.jpg\")",
                "type": "Message -> Element -> Element -> Element -> Element"
            },
            {
                "name": "dropDown",
                "comment": "Create a drop-down menu.  The following drop-down lets you choose your\nfavorite British sport:\n\n    type Sport = Football | Cricket | Snooker\n\n    sport : Signal.Mailbox (Maybe Sport)\n    sport = Signal.mailbox Nothing\n\n    sportDropDown : Element\n    sportDropDown =\n        dropDown (Signal.message sport.address)\n          [ (\"\"        , Nothing)\n          , (\"Football\", Just Football)\n          , (\"Cricket\" , Just Cricket)\n          , (\"Snooker\" , Just Snooker)\n          ]\n\nIf the user selects \"Football\" from the drop down menue, `sport.signal`\nwill update to `Just Football`.",
                "type": "(a -> Message) -> List ( String, a ) -> Element"
            },
            {
                "name": "hoverable",
                "comment": "Detect mouse hovers over a specific `Element`. In the following example,\nwe will create a hoverable picture called `cat`.\n\n    hover : Signal.Mailbox Bool\n    hover = Signal.mailbox False\n\n    cat : Element\n    cat =\n      image 30 30 \"/cat.jpg\"\n        |> hoverable (Signal.message hover.address)\n\nWhen the mouse hovers above the `cat` element, `hover.signal` will become\n`True`. When the mouse leaves it, `hover.signal` will become `False`.",
                "type": "(Bool -> Message) -> Element -> Element"
            }
        ],
        "binops": []
    },
    {
        "name": "Graphics.Input.Field",
        "comment": "This library provides an API for creating and updating text fields.\nText fields use exactly the same approach as [`Graphics.Input`](Graphics-Input)\nfor modelling user input, allowing you to keep track of new events and update\ntext fields programmatically.\n\n# Create Fields\n@docs field, password, email\n\n# Field Content\n@docs Content, Selection, Direction, noContent\n\n# Field Style\n@docs defaultStyle, Style, Outline, noOutline, Highlight, noHighlight, Dimensions, uniformly",
        "unions": [
            {
                "name": "Direction",
                "comment": "The direction of selection. When the user highlights a selection in a text\nfield, they must do it in a particular direction. This determines which end of\nthe selection moves when they change the selection by pressing Shift-Left or\nShift-Right.",
                "args": [],
                "cases": [
                    [
                        "Forward",
                        []
                    ],
                    [
                        "Backward",
                        []
                    ]
                ]
            }
        ],
        "aliases": [
            {
                "name": "Content",
                "comment": "Represents the current content of a text field. For example:\n\n    content = Content \"She sells sea shells\" (Selection 0 3 Backward)\n\nThis means the user highlighted the substring `\"She\"` backwards. The value of\n`content.string` is `\"She sells sea shells\"`.",
                "args": [],
                "type": "{ string : String, selection : Selection }"
            },
            {
                "name": "Dimensions",
                "comment": "For setting dimensions of a field's padding or outline. The left, right,\ntop, and bottom may all have different sizes. The following example creates\ndimensions such that the left and right are twice as wide as the top and bottom:\n\n    myDimensions : Int -> Dimensions\n    myDimensions n =\n        { left = 2 * n\n        , right = 2 * n\n        , top = n\n        , bottom = n\n        }",
                "args": [],
                "type": "{ left : Int, right : Int, top : Int, bottom : Int }"
            },
            {
                "name": "Highlight",
                "comment": "When a field has focus, it has a blue highlight around it by default. The\n`Highlight` lets you set the `color` and `width` of this highlight. Set the\n`width` to zero to turn the highlight off. Here is an example highlight that\nis blue and thin:\n\n    { color = blue, width = 1 }",
                "args": [],
                "type": "{ color : Color, width : Int }"
            },
            {
                "name": "Outline",
                "comment": "A field can have a outline around it. This lets you set its color, width,\nand radius. The radius allows you to round the corners of your field. Set the\nwidth to zero to make it invisible. Here is an example outline that is grey\nand thin with slightly rounded corners:\n\n    { color = grey, width = uniformly 1, radius = 4 }",
                "args": [],
                "type": "{ color : Color, width : Dimensions, radius : Int }"
            },
            {
                "name": "Selection",
                "comment": "The selection within a text field. `start` is never greater than `end`:\n\n    Selection 0 0 Forward  -- cursor precedes all characters\n\n    Selection 5 9 Backward -- highlighting characters starting after\n                           -- the 5th and ending after the 9th",
                "args": [],
                "type": "{ start : Int, end : Int, direction : Direction }"
            },
            {
                "name": "Style",
                "comment": "Describe the style of a text box. `style` describes the style of the text\nitself using [`Text.Style`](/Text#Style). `highlight` describes the glowing blue\nhighlight that shows up when the field has focus. `outline` describes the line\nsurrounding the text field, and `padding` adds whitespace between the `outline`\nand the text.\n\nThe width and height of the text box *includes* the `padding` and `outline`.\nSay we have a text box that is 40 pixels tall. It has a uniform outline of\n1 pixel and a uniform padding of 5 pixels. Both of these must be subtracted\nfrom the total height to determine how much room there is for text. The\n`padding` and `outline` appear on the top and bottom, so there will be 28\nvertical pixels remaining for the text (40 - 1 - 5 - 5 - 1).",
                "args": [],
                "type": "{ padding : Dimensions, outline : Outline, highlight : Highlight, style : Style }"
            }
        ],
        "values": [
            {
                "name": "defaultStyle",
                "comment": "The default style for a text field. The outline is `Color.grey` with width\n1 and radius 2. The highlight is `Color.blue` with width 1, and the default\ntext color is black.",
                "type": "Style"
            },
            {
                "name": "email",
                "comment": "Same as `field` but it adds an annotation that this field is for email\naddresses. This is helpful for auto-complete and for mobile users who may\nget a custom keyboard with an `@` and `.com` button.",
                "type": "Style -> (Content -> Message) -> String -> Content -> Element"
            },
            {
                "name": "field",
                "comment": "Create a text field. The following example creates a time-varying element\ncalled `nameField`. As the user types their name, the field will be updated\nto match what they have entered.\n\n    name : Signal.Mailbox Content\n    name = Signal.mailbox noContent\n\n    nameField : Signal Element\n    nameField =\n        field defaultStyle (Signal.message name.address) \"Name\" <~ name.signal\n\nWhen we use the `field` function, we first give it a visual style. This is\nthe first argument so that it is easier to define your own custom field\n(`myField = field myStyle`). The next two arguments are a `Handle` and a\nhandler function that processes or augments events before sending them along\nto the associated `Input`. In the example above we use the `identity` function to\npass events along unchanged to the `name` `Input`. We then provide the\nplace-holder message to use when no input has been provided yet. Finally,\nwe give the current `Content` of the field. This argument is last because\nit is most likely to change frequently, making function composition easier.",
                "type": "Style -> (Content -> Message) -> String -> Content -> Element"
            },
            {
                "name": "noContent",
                "comment": "A field with no content:\n\n    Content \"\" (Selection 0 0 Forward)",
                "type": "Content"
            },
            {
                "name": "noHighlight",
                "comment": "A highlight with zero width, so you cannot see it.",
                "type": "Highlight"
            },
            {
                "name": "noOutline",
                "comment": "An outline with zero width, so you cannot see it.",
                "type": "Outline"
            },
            {
                "name": "password",
                "comment": "Same as `field` but the UI element blocks out each characters.",
                "type": "Style -> (Content -> Message) -> String -> Content -> Element"
            },
            {
                "name": "uniformly",
                "comment": "Create uniform dimensions:\n\n    uniformly 4 == { left=4, right=4, top=4, bottom=4 }\n\nThe following example creates an outline where the left, right, top, and bottom\nedges all have width 1:\n\n    Outline grey (uniformly 1) 4",
                "type": "Int -> Dimensions"
            }
        ],
        "binops": []
    },
    {
        "name": "Json.Decode",
        "comment": "A way to turn Json values into Elm values. A `Decoder a` represents a\ndecoding operation that will either produce a value of type `a`, or fail.\n\n# Run a Decoder\n@docs decodeString, decodeValue\n\n# Primitives\n@docs string, int, float, bool, null\n\n# Arrays\n@docs list, array,\n  tuple1, tuple2, tuple3, tuple4, tuple5, tuple6, tuple7, tuple8\n\n# Objects\n@docs (:=), at,\n  object1, object2, object3, object4, object5, object6, object7, object8,\n  keyValuePairs, dict\n\n# Oddly Shaped Values\n@docs maybe, oneOf, map, fail, succeed, andThen\n\n# \"Creative\" Values\n@docs value, customDecoder",
        "unions": [
            {
                "name": "Decoder",
                "comment": "",
                "args": [
                    "a"
                ],
                "cases": [
                    [
                        "Decoder",
                        []
                    ]
                ]
            }
        ],
        "aliases": [
            {
                "name": "Value",
                "comment": "",
                "args": [],
                "type": "Value"
            }
        ],
        "values": [
            {
                "name": "andThen",
                "comment": "Helpful when one field will determine the shape of a bunch of other fields.\n\n    type Shape\n        = Rectangle Float Float\n        | Circle Float\n\n    shape : Decoder Shape\n    shape =\n      (\"tag\" := string) `andThen` shapeInfo\n\n    shapeInfo : String -> Decoder Shape\n    shapeInfo tag =\n      case tag of\n        \"rectangle\" ->\n            object2 Rectangle\n              (\"width\" := float)\n              (\"height\" := float)\n\n        \"circle\" ->\n            object1 Circle\n              (\"radius\" := float)\n\n        _ ->\n            fail (tag ++ \" is not a recognized tag for shapes\")",
                "type": "Decoder a -> (a -> Decoder b) -> Decoder b"
            },
            {
                "name": "array",
                "comment": "Extract an Array from a JS array.\n\n    -- [1,2,3,4]\n\n    numbers : Decoder (Array Int)\n    numbers =\n        array int",
                "type": "Decoder a -> Decoder (Array a)"
            },
            {
                "name": "at",
                "comment": "Access a nested field, making it easy to dive into big structures. This is\nreally a helper function so you do not need to write `(:=)` so many times.\n\n    -- object.target.value = 'hello'\n    value : Decoder String\n    value =\n        at [\"target\", \"value\"] string\n\nIt is defined as\n\n    at fields decoder =\n        List.foldr (:=) decoder fields",
                "type": "List String -> Decoder a -> Decoder a"
            },
            {
                "name": "bool",
                "comment": "Extract a boolean.\n\n    -- { ... checked: true ... }\n\n    checked : Decoder Bool\n    checked =\n        \"checked\" := true",
                "type": "Decoder Bool"
            },
            {
                "name": "customDecoder",
                "comment": "",
                "type": "Decoder a -> (a -> Result String b) -> Decoder b"
            },
            {
                "name": "decodeString",
                "comment": "",
                "type": "Decoder a -> String -> Result String a"
            },
            {
                "name": "decodeValue",
                "comment": "",
                "type": "Decoder a -> Value -> Result String a"
            },
            {
                "name": "dict",
                "comment": "Turn any object into a dictionary of key-value pairs.\n\n    -- { mercury: 0.33, venus: 4.87, earth: 5.97, ... }\n    planetMasses : Decoder (Dict String Int)\n    planetMasses =\n        dict float",
                "type": "Decoder a -> Decoder (Dict String a)"
            },
            {
                "name": "fail",
                "comment": "A decoder that always fails. Useful when paired with `andThen` or `oneOf`\nto improve error messages when things go wrong. For example, the following\ndecoder is able to provide a much more specific error message when `fail` is\nthe last option.\n\n    point : Decoder (Float,Float)\n    point =\n        oneOf\n        [ tuple2 (,) float float\n        , object2 (,) (\"x\" := float) (\"y\" := float)\n        , fail \"expecting some kind of point\"\n        ]",
                "type": "String -> Decoder a"
            },
            {
                "name": "float",
                "comment": "Extract a float.\n\n    -- [ 6.022, 3.1415, 1.618 ]\n\n    numbers : Decoder (List Float)\n    numbers =\n        list float",
                "type": "Decoder Float"
            },
            {
                "name": "int",
                "comment": "Extract an integer.\n\n    -- { ... age: 42 ... }\n\n    age : Decoder Int\n    age =\n        \"age\" := int",
                "type": "Decoder Int"
            },
            {
                "name": "keyValuePairs",
                "comment": "Turn any object into a list of key-value pairs. Fails if _any_ key can't be\ndecoded with the given decoder.\n\n    -- { tom: 89, sue: 92, bill: 97, ... }\n    grades : Decoder (List (String, Int))\n    grades =\n        keyValuePairs int",
                "type": "Decoder a -> Decoder (List ( String, a ))"
            },
            {
                "name": "list",
                "comment": "Extract a List from a JS array.\n\n    -- [1,2,3,4]\n\n    numbers : Decoder [Int]\n    numbers =\n        list int",
                "type": "Decoder a -> Decoder (List a)"
            },
            {
                "name": "map",
                "comment": "Transform the value returned by a decoder. Most useful when paired with\nthe `oneOf` function.\n\n    nullOr : Decoder a -> Decoder (Maybe a)\n    nullOr decoder =\n        oneOf\n          [ null Nothing\n          , map Just decoder\n          ]\n\n    type UserID = OldID Int | NewID String\n\n    -- 1234 or \"1234abc\"\n    userID : Decoder UserID\n    userID =\n        oneOf\n          [ map OldID int\n          , map NewID string\n          ]",
                "type": "(a -> b) -> Decoder a -> Decoder b"
            },
            {
                "name": "maybe",
                "comment": "Extract a Maybe value, wrapping successes with `Just` and turning any\nfailure in `Nothing`. If you are expecting that a field can sometimes be `null`,\nit's better to check for it [explictly](#null), as this function will swallow\nerros from ill-formed JSON.\n\nThe following code decodes JSON objects that may not have a profession field.\n\n    -- profession: Just \"plumber\"\n    -- { name: \"Tom\", age: 31, profession: \"plumber\" }\n    -- profession: Nothing\n    -- { name: \"Sue\", age: 42 }\n    -- { name: \"Amy\", age: 27, profession: null }\n    -- { name: \"Joe\", age: 36, profession: [\"something\", \"unexpected\"] }\n\n    type alias Person =\n        { name : String\n        , age : Int\n        , profession : Maybe String\n        }\n\n    person : Decoder Person\n    person =\n        object3 Person\n          (\"name\" := string)\n          (\"age\" := int)\n          (maybe (\"profession\" := string))",
                "type": "Decoder a -> Decoder (Maybe a)"
            },
            {
                "name": "null",
                "comment": "Decode null as the value given, and fail otherwise. Primarily useful for\ncreating *other* decoders.\n\n    numbers : Decoder [Int]\n    numbers =\n        list (oneOf [ int, null 0 ])\n\nThis decoder treats `null` as `Nothing`, and otherwise tries to produce a\n`Just`.\n\n    nullOr : Decoder a -> Decoder (Maybe a)\n    nullOr decoder =\n        oneOf\n        [ null Nothing\n        , map Just decoder\n        ]",
                "type": "a -> Decoder a"
            },
            {
                "name": "object1",
                "comment": "",
                "type": "(a -> value) -> Decoder a -> Decoder value"
            },
            {
                "name": "object2",
                "comment": "Use two different decoders on a JS value. This is nice for extracting\nmultiple fields from an object.\n\n    point : Decoder (Float,Float)\n    point =\n        object2 (,)\n          (\"x\" := float)\n          (\"y\" := float)",
                "type": "(a -> b -> value) -> Decoder a -> Decoder b -> Decoder value"
            },
            {
                "name": "object3",
                "comment": "Use three different decoders on a JS value. This is nice for extracting\nmultiple fields from an object.\n\n    type alias Job = { name : String, id : Int, completed : Bool }\n\n    point : Decoder Job\n    point =\n        object3 Job\n          (\"name\" := string)\n          (\"id\" := int)\n          (\"completed\" := bool)",
                "type": "(a -> b -> c -> value) -> Decoder a -> Decoder b -> Decoder c -> Decoder value"
            },
            {
                "name": "object4",
                "comment": "",
                "type": "(a -> b -> c -> d -> value) -> Decoder a -> Decoder b -> Decoder c -> Decoder d -> Decoder value"
            },
            {
                "name": "object5",
                "comment": "",
                "type": "(a -> b -> c -> d -> e -> value) -> Decoder a -> Decoder b -> Decoder c -> Decoder d -> Decoder e -> Decoder value"
            },
            {
                "name": "object6",
                "comment": "",
                "type": "(a -> b -> c -> d -> e -> f -> value) -> Decoder a -> Decoder b -> Decoder c -> Decoder d -> Decoder e -> Decoder f -> Decoder value"
            },
            {
                "name": "object7",
                "comment": "",
                "type": "(a -> b -> c -> d -> e -> f -> g -> value) -> Decoder a -> Decoder b -> Decoder c -> Decoder d -> Decoder e -> Decoder f -> Decoder g -> Decoder value"
            },
            {
                "name": "object8",
                "comment": "",
                "type": "(a -> b -> c -> d -> e -> f -> g -> h -> value) -> Decoder a -> Decoder b -> Decoder c -> Decoder d -> Decoder e -> Decoder f -> Decoder g -> Decoder h -> Decoder value"
            },
            {
                "name": "oneOf",
                "comment": "Try out multiple different decoders. This is helpful when you are dealing\nwith something with a very strange shape and when `andThen` does not help\nnarrow things down so you can be more targeted.\n\n    -- [ [3,4], { x:0, y:0 }, [5,12] ]\n\n    points : Decoder (List (Float,Float))\n    points =\n        list point\n\n    point : Decoder (Float,Float)\n    point =\n        oneOf\n        [ tuple2 (,) float float\n        , object2 (,) (\"x\" := float) (\"y\" := float)\n        ]",
                "type": "List (Decoder a) -> Decoder a"
            },
            {
                "name": "string",
                "comment": "Extract a string.\n\n    -- [\"John\",\"Doe\"]\n\n    name : Decoder (String, String)\n    name =\n        tuple2 (,) string string",
                "type": "Decoder String"
            },
            {
                "name": "succeed",
                "comment": "A decoder that always succeeds. Useful when paired with `andThen` or\n`oneOf` but everything is supposed to work out at the end. For example,\nmaybe you have an optional field that can have a default value when it is\nmissing.\n\n    -- { x:3, y:4 } or { x:3, y:4, z:5 }\n\n    point3D : Decoder (Float,Float,Float)\n    point3D =\n        object (,,)\n          (\"x\" := float)\n          (\"y\" := float)\n          (oneOf [ \"z\" := float, succeed 0 ])",
                "type": "a -> Decoder a"
            },
            {
                "name": "tuple1",
                "comment": "Handle an array with exactly one element.\n\n    authorship : Decoder String\n    authorship =\n        oneOf\n          [ tuple1 (\\author -> \"Author: \" ++ author) string\n          , list string |> map (\\authors -> \"Co-authors: \" ++ String.join \", \" authors)\n          ]",
                "type": "(a -> value) -> Decoder a -> Decoder value"
            },
            {
                "name": "tuple2",
                "comment": "Handle an array with exactly two elements. Useful for points and simple\npairs.\n\n    -- [3,4] or [0,0]\n    point : Decoder (Float,Float)\n    point =\n        tuple2 (,) float float\n\n    -- [\"John\",\"Doe\"] or [\"Hermann\",\"Hesse\"]\n    name : Decoder Name\n    name =\n        tuple2 Name string string\n\n    type alias Name = { first : String, last : String }",
                "type": "(a -> b -> value) -> Decoder a -> Decoder b -> Decoder value"
            },
            {
                "name": "tuple3",
                "comment": "Handle an array with exactly three elements.\n\n    -- [3,4,5] or [0,0,0]\n    point3D : Decoder (Float,Float,Float)\n    point3D =\n        tuple3 (,,) float float float",
                "type": "(a -> b -> c -> value) -> Decoder a -> Decoder b -> Decoder c -> Decoder value"
            },
            {
                "name": "tuple4",
                "comment": "",
                "type": "(a -> b -> c -> d -> value) -> Decoder a -> Decoder b -> Decoder c -> Decoder d -> Decoder value"
            },
            {
                "name": "tuple5",
                "comment": "",
                "type": "(a -> b -> c -> d -> e -> value) -> Decoder a -> Decoder b -> Decoder c -> Decoder d -> Decoder e -> Decoder value"
            },
            {
                "name": "tuple6",
                "comment": "",
                "type": "(a -> b -> c -> d -> e -> f -> value) -> Decoder a -> Decoder b -> Decoder c -> Decoder d -> Decoder e -> Decoder f -> Decoder value"
            },
            {
                "name": "tuple7",
                "comment": "",
                "type": "(a -> b -> c -> d -> e -> f -> g -> value) -> Decoder a -> Decoder b -> Decoder c -> Decoder d -> Decoder e -> Decoder f -> Decoder g -> Decoder value"
            },
            {
                "name": "tuple8",
                "comment": "",
                "type": "(a -> b -> c -> d -> e -> f -> g -> h -> value) -> Decoder a -> Decoder b -> Decoder c -> Decoder d -> Decoder e -> Decoder f -> Decoder g -> Decoder h -> Decoder value"
            },
            {
                "name": "value",
                "comment": "Bring in an arbitrary JSON value. Useful if you need to work with crazily\nformatted data. For example, this lets you create a parser for \"variadic\" lists\nwhere the first few types are different, followed by 0 or more of the same\ntype.\n\n    variadic2 : (a -> b -> List c -> value) -> Decoder a -> Decoder b -> Decoder (List c) -> Decoder value\n    variadic2 f a b cs =\n        customDecoder (list value) \\jsonList ->\n            case jsonList of\n              one :: two :: rest ->\n                  Result.map3 f\n                    (decodeValue a one)\n                    (decodeValue b two)\n                    (decodeValue cs rest)\n\n              _ -> Result.Err \"expecting at least two elements in the array\"",
                "type": "Decoder Value"
            }
        ],
        "binops": [
            {
                "name": ":=",
                "comment": "Decode an object if it has a certain field.\n\n    nameAndAge : Decoder (String,Int)\n    nameAndAge =\n        object2 (,)\n          (\"name\" := string)\n          (\"age\" := int)\n\n    optionalProfession : Decoder (Maybe String)\n    optionalProfession =\n        maybe (\"profession\" := string)",
                "type": "String -> Decoder a -> Decoder a",
                "associativity": "left",
                "precedence": 9
            }
        ]
    },
    {
        "name": "Json.Encode",
        "comment": "Library for turning Elm values into Json values.\n\n# Encoding\n@docs encode\n\n# Primitives\n@docs string, int, float, bool, null\n\n# Arrays\n@docs list, array\n\n# Objects\n@docs object",
        "unions": [
            {
                "name": "Value",
                "comment": "",
                "args": [],
                "cases": [
                    [
                        "Value",
                        []
                    ]
                ]
            }
        ],
        "aliases": [],
        "values": [
            {
                "name": "array",
                "comment": "",
                "type": "Array Value -> Value"
            },
            {
                "name": "bool",
                "comment": "",
                "type": "Bool -> Value"
            },
            {
                "name": "encode",
                "comment": "Convert a `Value` into a prettified string. The first argument specifies\nthe amount of indentation in the resulting string.\n\n    person =\n        object\n          [ (\"name\", string \"Tom\")\n          , (\"age\", int 42)\n          ]\n\n    compact = encode 0 person\n    -- {\"name\":\"Tom\",\"age\":42}\n\n    readable = encode 4 person\n    -- {\n    --     \"name\": \"Tom\",\n    --     \"age\": 42\n    -- }",
                "type": "Int -> Value -> String"
            },
            {
                "name": "float",
                "comment": "Encode a Float. `Infinity` and `NaN` are encoded as `null`.",
                "type": "Float -> Value"
            },
            {
                "name": "int",
                "comment": "",
                "type": "Int -> Value"
            },
            {
                "name": "list",
                "comment": "",
                "type": "List Value -> Value"
            },
            {
                "name": "null",
                "comment": "",
                "type": "Value"
            },
            {
                "name": "object",
                "comment": "",
                "type": "List ( String, Value ) -> Value"
            },
            {
                "name": "string",
                "comment": "",
                "type": "String -> Value"
            }
        ],
        "binops": []
    },
    {
        "name": "Keyboard",
        "comment": "Library for working with keyboard input.\n\n# Representing Keys\n@docs KeyCode\n\n# Directions\n@docs arrows, wasd\n\n# Specific Keys\nThe following signals are `True` when the particular key is pressed and `False`\notherwise.\n\n@docs enter, space, ctrl, shift, alt, meta\n\n# General Keypresses\n@docs isDown, keysDown, presses",
        "unions": [],
        "aliases": [
            {
                "name": "KeyCode",
                "comment": "Type alias to make it clearer what integers are supposed to represent\nin this library. Use `Char.toCode` and `Char.fromCode` to convert key codes\nto characters. Use the uppercase character with `toCode`.",
                "args": [],
                "type": "Int"
            }
        ],
        "values": [
            {
                "name": "alt",
                "comment": "",
                "type": "Signal Bool"
            },
            {
                "name": "arrows",
                "comment": "A signal of records indicating which arrow keys are pressed.\n\n  * `{ x = 0, y = 0 }` when pressing no arrows.\n  * `{ x =-1, y = 0 }` when pressing the left arrow.\n  * `{ x = 1, y = 1 }` when pressing the up and right arrows.\n  * `{ x = 0, y =-1 }` when pressing the down, left, and right arrows.",
                "type": "Signal { x : Int, y : Int }"
            },
            {
                "name": "ctrl",
                "comment": "",
                "type": "Signal Bool"
            },
            {
                "name": "enter",
                "comment": "",
                "type": "Signal Bool"
            },
            {
                "name": "isDown",
                "comment": "Whether an arbitrary key is pressed.",
                "type": "KeyCode -> Signal Bool"
            },
            {
                "name": "keysDown",
                "comment": "Set of keys that are currently down.",
                "type": "Signal (Set KeyCode)"
            },
            {
                "name": "meta",
                "comment": "The meta key is the Windows key on Windows and the Command key on Mac.",
                "type": "Signal Bool"
            },
            {
                "name": "presses",
                "comment": "The latest key that has been pressed.",
                "type": "Signal KeyCode"
            },
            {
                "name": "shift",
                "comment": "",
                "type": "Signal Bool"
            },
            {
                "name": "space",
                "comment": "",
                "type": "Signal Bool"
            },
            {
                "name": "wasd",
                "comment": "Just like the arrows signal, but this uses keys w, a, s, and d,\nwhich are common controls for many computer games.",
                "type": "Signal { x : Int, y : Int }"
            }
        ],
        "binops": []
    },
    {
        "name": "List",
        "comment": "A library for manipulating lists of values. Every value in a\nlist must have the same type.\n\n# Basics\n@docs isEmpty, length, reverse, member\n\n# Sub-lists\n@docs head, tail, filter, take, drop\n\n# Putting Lists Together\n@docs repeat, (::), append, concat, intersperse\n\n# Taking Lists Apart\n@docs partition, unzip\n\n# Mapping\n@docs map, map2, map3, map4, map5\n\nIf you can think of a legitimate use of `mapN` where `N` is 6 or more, please\nlet us know on [the list](https://groups.google.com/forum/#!forum/elm-discuss).\nThe current sentiment is that it is already quite error prone once you get to\n4 and possibly should be approached another way.\n\n# Special Maps\n@docs filterMap, concatMap, indexedMap\n\n# Folding\n@docs foldr, foldl\n\n# Special Folds\n@docs sum, product, maximum, minimum, all, any, scanl\n\n# Sorting\n@docs sort, sortBy, sortWith",
        "unions": [],
        "aliases": [],
        "values": [
            {
                "name": "all",
                "comment": "Determine if all elements satisfy the predicate.\n\n    all isEven [2,4] == True\n    all isEven [2,3] == False\n    all isEven [] == True",
                "type": "(a -> Bool) -> List a -> Bool"
            },
            {
                "name": "any",
                "comment": "Determine if any elements satisfy the predicate.\n\n    any isEven [2,3] == True\n    any isEven [1,3] == False\n    any isEven [] == False",
                "type": "(a -> Bool) -> List a -> Bool"
            },
            {
                "name": "append",
                "comment": "Put two lists together.\n\n    append [1,1,2] [3,5,8] == [1,1,2,3,5,8]\n    append ['a','b'] ['c'] == ['a','b','c']",
                "type": "List a -> List a -> List a"
            },
            {
                "name": "concat",
                "comment": "Concatenate a bunch of lists into a single list:\n\n    concat [[1,2],[3],[4,5]] == [1,2,3,4,5]",
                "type": "List (List a) -> List a"
            },
            {
                "name": "concatMap",
                "comment": "Map a given function onto a list and flatten the resulting lists.\n\n    concatMap f xs == concat (map f xs)",
                "type": "(a -> List b) -> List a -> List b"
            },
            {
                "name": "drop",
                "comment": "Drop the first *n* members of a list.\n\n    drop 2 [1,2,3,4] == [3,4]",
                "type": "Int -> List a -> List a"
            },
            {
                "name": "filter",
                "comment": "Keep only elements that satisfy the predicate.\n\n    filter isEven [1..6] == [2,4,6]",
                "type": "(a -> Bool) -> List a -> List a"
            },
            {
                "name": "filterMap",
                "comment": "Apply a function that may succeed to all values in the list, but only keep\nthe successes.\n\n    String.toInt : String -> Maybe Int\n\n    filterMap String.toInt [\"3\", \"4.0\", \"5\", \"hats\"] == [3,5]",
                "type": "(a -> Maybe b) -> List a -> List b"
            },
            {
                "name": "foldl",
                "comment": "Reduce a list from the left.\n\n    foldl (::) [] [1,2,3] == [3,2,1]",
                "type": "(a -> b -> b) -> b -> List a -> b"
            },
            {
                "name": "foldr",
                "comment": "Reduce a list from the right.\n\n    foldr (+) 0 [1,2,3] == 6",
                "type": "(a -> b -> b) -> b -> List a -> b"
            },
            {
                "name": "head",
                "comment": "Extract the first element of a list.\n\n    head [1,2,3] == Just 1\n    head [] == Nothing",
                "type": "List a -> Maybe a"
            },
            {
                "name": "indexedMap",
                "comment": "Same as `map` but the function is also applied to the index of each\nelement (starting at zero).\n\n    indexedMap (,) [\"Tom\",\"Sue\",\"Bob\"] == [ (0,\"Tom\"), (1,\"Sue\"), (2,\"Bob\") ]",
                "type": "(Int -> a -> b) -> List a -> List b"
            },
            {
                "name": "intersperse",
                "comment": "Places the given value between all members of the given list.\n\n    intersperse \"on\" [\"turtles\",\"turtles\",\"turtles\"] == [\"turtles\",\"on\",\"turtles\",\"on\",\"turtles\"]",
                "type": "a -> List a -> List a"
            },
            {
                "name": "isEmpty",
                "comment": "Determine if a list is empty.\n\n    isEmpty [] == True",
                "type": "List a -> Bool"
            },
            {
                "name": "length",
                "comment": "Determine the length of a list.\n\n    length [1,2,3] == 3",
                "type": "List a -> Int"
            },
            {
                "name": "map",
                "comment": "Apply a function to every element of a list.\n\n    map sqrt [1,4,9] == [1,2,3]\n\n    map not [True,False,True] == [False,True,False]",
                "type": "(a -> b) -> List a -> List b"
            },
            {
                "name": "map2",
                "comment": "Combine two lists, combining them with the given function.\nIf one list is longer, the extra elements are dropped.\n\n    map2 (+) [1,2,3] [1,2,3,4] == [2,4,6]\n\n    map2 (,) [1,2,3] ['a','b'] == [ (1,'a'), (2,'b') ]\n\n    pairs : List a -> List b -> List (a,b)\n    pairs lefts rights =\n        map2 (,) lefts rights",
                "type": "(a -> b -> result) -> List a -> List b -> List result"
            },
            {
                "name": "map3",
                "comment": "",
                "type": "(a -> b -> c -> result) -> List a -> List b -> List c -> List result"
            },
            {
                "name": "map4",
                "comment": "",
                "type": "(a -> b -> c -> d -> result) -> List a -> List b -> List c -> List d -> List result"
            },
            {
                "name": "map5",
                "comment": "",
                "type": "(a -> b -> c -> d -> e -> result) -> List a -> List b -> List c -> List d -> List e -> List result"
            },
            {
                "name": "maximum",
                "comment": "Find the maximum element in a non-empty list.\n\n    maximum [1,4,2] == Just 4\n    maximum []      == Nothing",
                "type": "List comparable -> Maybe comparable"
            },
            {
                "name": "member",
                "comment": "",
                "type": "a -> List a -> Bool"
            },
            {
                "name": "minimum",
                "comment": "Find the minimum element in a non-empty list.\n\n    minimum [3,2,1] == Just 1\n    minimum []      == Nothing",
                "type": "List comparable -> Maybe comparable"
            },
            {
                "name": "partition",
                "comment": "Partition a list based on a predicate. The first list contains all values\nthat satisfy the predicate, and the second list contains all the value that do\nnot.\n\n    partition (\\x -> x < 3) [0..5] == ([0,1,2], [3,4,5])\n    partition isEven        [0..5] == ([0,2,4], [1,3,5])",
                "type": "(a -> Bool) -> List a -> ( List a, List a )"
            },
            {
                "name": "product",
                "comment": "Get the product of the list elements.\n\n    product [1..4] == 24",
                "type": "List number -> number"
            },
            {
                "name": "repeat",
                "comment": "Create a list with *n* copies of a value:\n\n    repeat 3 (0,0) == [(0,0),(0,0),(0,0)]",
                "type": "Int -> a -> List a"
            },
            {
                "name": "reverse",
                "comment": "Reverse a list.\n\n    reverse [1..4] == [4,3,2,1]",
                "type": "List a -> List a"
            },
            {
                "name": "scanl",
                "comment": "Reduce a list from the left, building up all of the intermediate results into a list.\n\n    scanl (+) 0 [1,2,3,4] == [0,1,3,6,10]",
                "type": "(a -> b -> b) -> b -> List a -> List b"
            },
            {
                "name": "sort",
                "comment": "Sort values from lowest to highest\n\n    sort [3,1,5] == [1,3,5]",
                "type": "List comparable -> List comparable"
            },
            {
                "name": "sortBy",
                "comment": "Sort values by a derived property.\n\n    alice = { name=\"Alice\", height=1.62 }\n    bob   = { name=\"Bob\"  , height=1.85 }\n    chuck = { name=\"Chuck\", height=1.76 }\n\n    sortBy .name   [chuck,alice,bob] == [alice,bob,chuck]\n    sortBy .height [chuck,alice,bob] == [alice,chuck,bob]\n\n    sortBy String.length [\"mouse\",\"cat\"] == [\"cat\",\"mouse\"]",
                "type": "(a -> comparable) -> List a -> List a"
            },
            {
                "name": "sortWith",
                "comment": "Sort values with a custom comparison function.\n\n    sortWith flippedComparison [1..5] == [5,4,3,2,1]\n\n    flippedComparison a b =\n        case compare a b of\n          LT -> GT\n          EQ -> EQ\n          GT -> LT\n\nThis is also the most general sort function, allowing you\nto define any other: `sort == sortWith compare`",
                "type": "(a -> a -> Order) -> List a -> List a"
            },
            {
                "name": "sum",
                "comment": "Get the sum of the list elements.\n\n    sum [1..4] == 10",
                "type": "List number -> number"
            },
            {
                "name": "tail",
                "comment": "Extract the rest of the list.\n\n    tail [1,2,3] == Just [2,3]\n    tail [] == Nothing",
                "type": "List a -> Maybe (List a)"
            },
            {
                "name": "take",
                "comment": "Take the first *n* members of a list.\n\n    take 2 [1,2,3,4] == [1,2]",
                "type": "Int -> List a -> List a"
            },
            {
                "name": "unzip",
                "comment": "Decompose a list of tuples into a tuple of lists.\n\n    unzip [(0, True), (17, False), (1337, True)] == ([0,17,1337], [True,False,True])",
                "type": "List ( a, b ) -> ( List a, List b )"
            }
        ],
        "binops": [
            {
                "name": "::",
                "comment": "Add an element to the front of a list. Pronounced *cons*.\n\n    1 :: [2,3] == [1,2,3]\n    1 :: [] == [1]",
                "type": "a -> List a -> List a",
                "associativity": "right",
                "precedence": 5
            }
        ]
    },
    {
        "name": "Maybe",
        "comment": "This library fills a bunch of important niches in Elm. A `Maybe` can help\nyou with optional arguments, error handling, and records with optional fields.\n\n# Definition\n@docs Maybe\n\n# Common Helpers\n@docs map, withDefault, oneOf\n\n# Chaining Maybes\n@docs andThen",
        "unions": [
            {
                "name": "Maybe",
                "comment": "Represent values that may or may not exist. It can be useful if you have a\nrecord field that is only filled in sometimes. Or if a function takes a value\nsometimes, but does not absolutely need it.\n\n    -- A person, but maybe we do not know their age.\n    type alias Person =\n        { name : String\n        , age : Maybe Int\n        }\n\n    tom = { name = \"Tom\", age = Just 42 }\n    sue = { name = \"Sue\", age = Nothing }",
                "args": [
                    "a"
                ],
                "cases": [
                    [
                        "Just",
                        [
                            "a"
                        ]
                    ],
                    [
                        "Nothing",
                        []
                    ]
                ]
            }
        ],
        "aliases": [],
        "values": [
            {
                "name": "andThen",
                "comment": "Chain together many computations that may fail. It is helpful to see its\ndefinition:\n\n    andThen : Maybe a -> (a -> Maybe b) -> Maybe b\n    andThen maybe callback =\n        case maybe of\n          Just value -> callback value\n          Nothing -> Nothing\n\nThis means we only continue with the callback if things are going well. For\nexample, say you need to use (`toInt : String -> Maybe Int`) to parse a month\nand make sure it is between 1 and 12:\n\n    toValidMonth : Int -> Maybe Int\n    toValidMonth month =\n        if month >= 1 && month <= 12\n            then Just month\n            else Nothing\n\n    toMonth : String -> Maybe Int\n    toMonth rawString =\n        toInt rawString `andThen` toValidMonth\n\nIf `toInt` fails and results in `Nothing` this entire chain of operations will\nshort-circuit and result in `Nothing`. If `toValidMonth` results in `Nothing`,\nagain the chain of computations will result in `Nothing`.",
                "type": "Maybe a -> (a -> Maybe b) -> Maybe b"
            },
            {
                "name": "map",
                "comment": "Transform an `Maybe` value with a given function:\n\n    map sqrt (Just 9) == Just 3\n    map sqrt Nothing == Nothing",
                "type": "(a -> b) -> Maybe a -> Maybe b"
            },
            {
                "name": "oneOf",
                "comment": "Pick the first `Maybe` that actually has a value. Useful when you want to\ntry a couple different things, but there is no default value.\n\n    oneOf [ Nothing, Just 42, Just 71 ] == Just 42\n    oneOf [ Nothing, Nothing, Just 71 ] == Just 71\n    oneOf [ Nothing, Nothing, Nothing ] == Nothing",
                "type": "List (Maybe a) -> Maybe a"
            },
            {
                "name": "withDefault",
                "comment": "Provide a default value, turning an optional value into a normal value.\nThis comes in handy when paired with functions like `Dict.get` which gives back\na `Maybe`.\n\n    withDefault 100 (Just 42)   -- 42\n    withDefault 100 Nothing     -- 100\n\n    withDefault \"unknown\" (Dict.get \"Tom\" Dict.empty)   -- \"unknown\"",
                "type": "a -> Maybe a -> a"
            }
        ],
        "binops": []
    },
    {
        "name": "Mouse",
        "comment": "Library for working with mouse input.\n\n# Position\n@docs position, x, y\n\n# Button Status\n@docs isDown, clicks",
        "unions": [],
        "aliases": [],
        "values": [
            {
                "name": "clicks",
                "comment": "Always equal to unit. Event triggers on every mouse click.",
                "type": "Signal ()"
            },
            {
                "name": "isDown",
                "comment": "The current state of the left mouse-button.\nTrue when the button is down, and false otherwise.",
                "type": "Signal Bool"
            },
            {
                "name": "position",
                "comment": "The current mouse position.",
                "type": "Signal ( Int, Int )"
            },
            {
                "name": "x",
                "comment": "The current x-coordinate of the mouse.",
                "type": "Signal Int"
            },
            {
                "name": "y",
                "comment": "The current y-coordinate of the mouse.",
                "type": "Signal Int"
            }
        ],
        "binops": []
    },
    {
        "name": "Random",
        "comment": "This library helps you generate pseudo-random values.\n\nThe general pattern is to define a `Generator` which can produce certain kinds\nof random values. You actually produce random values by feeding a fresh `Seed`\nto your `Generator`.\n\nSince you need a fresh `Seed` to produce more random values, you should\nprobably store a `Seed` in your application's state. This will allow you to\nkeep updating it as you generate random values and fresh seeds.\n\nThe following example models a bunch of bad guys that randomly appear. The\n`possiblyAddBadGuy` function uses the random seed to see if we should add a bad\nguy, and if so, it places a bad guy at a randomly generated point.\n\n    type alias Model =\n        { badGuys : List (Float,Float)\n        , seed : Seed\n        }\n\n    possiblyAddBadGuy : Model -> Model\n    possiblyAddBadGuy model =\n        let (addProbability, seed') =\n              generate (float 0 1) model.seed\n        in\n            if addProbability < 0.9\n              then\n                { model |\n                    seed <- seed'\n                }\n              else\n                let (position, seed'') =\n                      generate (pair (float 0 100) (float 0 100)) seed'\n                in\n                    { model |\n                        badGuys <- position :: model.badGuys\n                        seed <- seed''\n                    }\n\nDetails: This is an implemenation of the Portable Combined Generator of\nL'Ecuyer for 32-bit computers. It is almost a direct translation from the\n[System.Random](http://hackage.haskell.org/package/random-1.0.1.1/docs/System-Random.html)\nmodule. It has a period of roughly 2.30584e18.\n\n# Generators\n\n@docs int, float, pair, list\n\n# Running a Generator\n\n@docs generate, initialSeed\n\n# Constants\n\n@docs maxInt, minInt\n\n# Custom Generators\n\n@docs customGenerator",
        "unions": [],
        "aliases": [
            {
                "name": "Seed",
                "comment": "",
                "args": [],
                "type": "{ state : State, next : State -> ( Int, State ), split : State -> ( State, State ), range : State -> ( Int, Int ) }"
            }
        ],
        "values": [
            {
                "name": "customGenerator",
                "comment": "Create a custom generator. You provide a function that takes a seed, and\nreturns a random value and a new seed. You can use this to create custom\ngenerators not covered by the basic functions in this library.\n\n    pairOf : Generator a -> Generator (a,a)\n    pairOf generator =\n      customGenerator <| \\seed ->\n        let (left , seed' ) = generate generator seed\n            (right, seed'') = generate generator seed'\n        in\n            ((left,right), seed'')",
                "type": "(Seed -> ( a, Seed )) -> Generator a"
            },
            {
                "name": "float",
                "comment": "Create a generator that produces floats in a given range.\n\n    probability : Generator Float\n    probability =\n        float 0 1\n\n    -- generate probability seed0 ==> (0.51, seed1)\n    -- generate probability seed1 ==> (0.04, seed2)",
                "type": "Float -> Float -> Generator Float"
            },
            {
                "name": "generate",
                "comment": "Run a random value generator with a given seed. It will give you back a\nrandom value and a new seed.\n\n    seed0 = initialSeed 31415\n\n    -- generate (int 0 100) seed0 ==> (42, seed1)\n    -- generate (int 0 100) seed1 ==> (31, seed2)\n    -- generate (int 0 100) seed2 ==> (99, seed3)\n\nNotice that we use different seeds on each line. This is important! If you use\nthe same seed, you get the same results.\n\n    -- generate (int 0 100) seed0 ==> (42, seed1)\n    -- generate (int 0 100) seed0 ==> (42, seed1)\n    -- generate (int 0 100) seed0 ==> (42, seed1)",
                "type": "Generator a -> Seed -> ( a, Seed )"
            },
            {
                "name": "initialSeed",
                "comment": "Create a &ldquo;seed&rdquo; of randomness which makes it possible to\ngenerate random values. If you use the same seed many times, it will result\nin the same thing every time! A good way to get an unexpected seed is to use\nthe current time.",
                "type": "Int -> Seed"
            },
            {
                "name": "int",
                "comment": "Create a generator that produces 32-bit integers in a given range. This\nfunction *can* produce values outside of the range [minInt, maxInt] but\nsufficient randomness is not guaranteed.\n\n    int 0 10   -- an integer between zero and ten\n    int -5 5   -- an integer between -5 and 5\n\n    int minInt maxInt  -- an integer in the widest range feasible",
                "type": "Int -> Int -> Generator Int"
            },
            {
                "name": "list",
                "comment": "Create a list of random values.\n\n    floatList : Generator (List Float)\n    floatList =\n        list 10 (float 0 1)\n\n    intList : Generator (List Int)\n    intList =\n        list 5 (int 0 100)\n\n    intPairs : Generator (List (Int, Int))\n    intPairs =\n        list 10 (pair int int)",
                "type": "Int -> Generator a -> Generator (List a)"
            },
            {
                "name": "maxInt",
                "comment": "The maximum value for randomly generated 32-bit ints.",
                "type": "Int"
            },
            {
                "name": "minInt",
                "comment": "The minimum value for randomly generated 32-bit ints.",
                "type": "Int"
            },
            {
                "name": "pair",
                "comment": "Create a pair of random values. A common use of this might be to generate\na point in a certain 2D space. Imagine we have a collage that is 400 pixels\nwide and 200 pixels tall.\n\n    randomPoint : Generator (Int,Int)\n    randomPoint =\n        pair (int -200 200) (int -100 100)",
                "type": "Generator a -> Generator b -> Generator ( a, b )"
            }
        ],
        "binops": []
    },
    {
        "name": "Regex",
        "comment": "A library for working with regular expressions. It uses [the\nsame kind of regular expressions accepted by JavaScript](https://developer.mozilla.org/en/docs/Web/JavaScript/Guide/Regular_Expressions).\n\n# Create\n@docs regex, escape, caseInsensitive\n\n# Helpful Data Structures\n\nThese data structures are needed to help define functions like [`find`](#find)\nand [`replace`](#replace).\n\n@docs HowMany, Match\n\n# Use\n@docs contains, find, replace, split",
        "unions": [
            {
                "name": "HowMany",
                "comment": "`HowMany` is used to specify how many matches you want to make. So\n`replace All` would replace every match, but `replace (AtMost 2)` would\nreplace at most two matches (i.e. zero, one, two, but never three or more).",
                "args": [],
                "cases": [
                    [
                        "All",
                        []
                    ],
                    [
                        "AtMost",
                        [
                            "Int"
                        ]
                    ]
                ]
            }
        ],
        "aliases": [
            {
                "name": "Match",
                "comment": "A `Match` represents all of the details about a particular match in a string.\nHere are details on each field:\n\n  * `match` &mdash; the full string of the match.\n  * `submatches` &mdash; a regex might have [subpatterns, surrounded by\n    parentheses](https://developer.mozilla.org/en/docs/Web/JavaScript/Guide/Regular_Expressions#Using_Parenthesized_Substring_Matches).\n    If there are N subpatterns, there will be N elements in the `submatches` list.\n    Each submatch in this list is a `Maybe` because not all subpatterns may trigger.\n    For example, `(regex \"(a+)|(b+)\")` will either match many `a`&rsquo;s or\n    many `b`&rsquo;s, but never both.\n  * `index` &mdash; the index of the match in the original string.\n  * `number` &mdash; if you find many matches, you can think of each one\n    as being labeled with a `number` starting at one. So the first time you\n    find a match, that is match `number` one. Second time is match `number` two.\n    This is useful when paired with `replace All` if replacement is dependent on how\n    many times a pattern has appeared before.",
                "args": [],
                "type": "{ match : String, submatches : List (Maybe String), index : Int, number : Int }"
            }
        ],
        "values": [
            {
                "name": "caseInsensitive",
                "comment": "Make a regex case insensitive",
                "type": "Regex -> Regex"
            },
            {
                "name": "contains",
                "comment": "Check to see if a Regex is contained in a string.\n\n    contains (regex \"123\") \"12345\" == True\n    contains (regex \"b+\") \"aabbcc\" == True\n\n    contains (regex \"789\") \"12345\" == False\n    contains (regex \"z+\") \"aabbcc\" == False",
                "type": "Regex -> String -> Bool"
            },
            {
                "name": "escape",
                "comment": "Escape strings to be regular expressions, making all special characters\nsafe. So `regex (escape \"^a+\")` will match exactly `\"^a+\"` instead of a series\nof `a`&rsquo;s that start at the beginning of the line.",
                "type": "String -> String"
            },
            {
                "name": "find",
                "comment": "Find matches in a string:\n\n    findTwoCommas = find (AtMost 2) (regex \",\")\n\n      -- map .index (findTwoCommas \"a,b,c,d,e\") == [1,3]\n      -- map .index (findTwoCommas \"a b c d e\") == []\n\n    places = find All (regex \"[oi]n a (\\\\w+)\") \"I am on a boat in a lake.\"\n\n      -- map .match places == [\"on a boat\", \"in a lake\"]\n      -- map .submatches places == [ [Just \"boat\"], [Just \"lake\"] ]",
                "type": "HowMany -> Regex -> String -> List Match"
            },
            {
                "name": "regex",
                "comment": "Create a Regex that matches patterns [as specified in JavaScript](https://developer.mozilla.org/en/docs/Web/JavaScript/Guide/Regular_Expressions#Writing_a_Regular_Expression_Pattern).\n\nBe careful to escape backslashes properly! For example, `\"\\w\"` is escaping the\nletter `w` which is probably not what you want. You probably want `\"\\\\w\"`\ninstead, which escapes the backslash.",
                "type": "String -> Regex"
            },
            {
                "name": "replace",
                "comment": "Replace matches. The function from `Match` to `String` lets\nyou use the details of a specific match when making replacements.\n\n    devowel = replace All (regex \"[aeiou]\") (\\_ -> \"\")\n\n      -- devowel \"The quick brown fox\" == \"Th qck brwn fx\"\n\n    reverseWords = replace All (regex \"\\\\w+\") (\\{match} -> String.reverse match)\n\n      -- reverseWords \"deliver mined parts\" == \"reviled denim strap\"",
                "type": "HowMany -> Regex -> (Match -> String) -> String -> String"
            },
            {
                "name": "split",
                "comment": "Split a string, using the regex as the separator.\n\n    split (AtMost 1) (regex \",\") \"tom,99,90,85\" == [\"tom\",\"99,90,85\"]\n\n    split All (regex \",\") \"a,b,c,d\" == [\"a\",\"b\",\"c\",\"d\"]",
                "type": "HowMany -> Regex -> String -> List String"
            }
        ],
        "binops": []
    },
    {
        "name": "Result",
        "comment": "A `Result` is the result of a computation that may fail. This is a great\nway to manage errors in Elm.\n\n# Type and Constructors\n@docs Result\n\n# Mapping\n@docs map, map2, map3, map4, map5\n\n# Chaining\n@docs andThen\n\n# Formatting Errors\n@docs toMaybe, fromMaybe, formatError",
        "unions": [
            {
                "name": "Result",
                "comment": "A `Result` is either `Ok` meaning the computation succeeded, or it is an\n`Err` meaning that there was some failure.",
                "args": [
                    "error",
                    "value"
                ],
                "cases": [
                    [
                        "Ok",
                        [
                            "value"
                        ]
                    ],
                    [
                        "Err",
                        [
                            "error"
                        ]
                    ]
                ]
            }
        ],
        "aliases": [],
        "values": [
            {
                "name": "andThen",
                "comment": "Chain together a sequence of computations that may fail. It is helpful\nto see its definition:\n\n    andThen : Result e a -> (a -> Result e b) -> Result e b\n    andThen result callback =\n        case result of\n          Ok value -> callback value\n          Err msg -> Err msg\n\nThis means we only continue with the callback if things are going well. For\nexample, say you need to use (`toInt : String -> Result String Int`) to parse\na month and make sure it is between 1 and 12:\n\n    toValidMonth : Int -> Result String Int\n    toValidMonth month =\n        if month >= 1 && month <= 12\n            then Ok month\n            else Err \"months must be between 1 and 12\"\n\n    toMonth : String -> Result String Int\n    toMonth rawString =\n        toInt rawString `andThen` toValidMonth\n\n    -- toMonth \"4\" == Ok 4\n    -- toMonth \"9\" == Ok 9\n    -- toMonth \"a\" == Err \"cannot parse to an Int\"\n    -- toMonth \"0\" == Err \"months must be between 1 and 12\"\n\nThis allows us to come out of a chain of operations with quite a specific error\nmessage. It is often best to create a custom type that explicitly represents\nthe exact ways your computation may fail. This way it is easy to handle in your\ncode.",
                "type": "Result x a -> (a -> Result x b) -> Result x b"
            },
            {
                "name": "formatError",
                "comment": "Format the error value of a result. If the result is `Ok`, it stays exactly\nthe same, but if the result is an `Err` we will format the error. For example,\nsay the errors we get have too much information:\n\n    parseInt : String -> Result ParseError Int\n\n    type ParseError =\n        { message : String\n        , code : Int\n        , position : (Int,Int)\n        }\n\n    formatError .message (parseInt \"123\") == Ok 123\n    formatError .message (parseInt \"abc\") == Err \"char 'a' is not a number\"",
                "type": "(error -> error_) -> Result error a -> Result error_ a"
            },
            {
                "name": "fromMaybe",
                "comment": "Convert from a simple `Maybe` to interact with some code that primarily\nuses `Results`.\n\n    parseInt : String -> Maybe Int\n\n    resultParseInt : String -> Result String Int\n    resultParseInt string =\n        fromMaybe (\"error parsing string: \" ++ toString string) (parseInt string)",
                "type": "x -> Maybe a -> Result x a"
            },
            {
                "name": "map",
                "comment": "Apply a function to a result. If the result is `Ok`, it will be converted.\nIf the result is an `Err`, the same error value will propagate through.\n\n    map sqrt (Ok 4.0)          == Ok 2.0\n    map sqrt (Err \"bad input\") == Err \"bad input\"",
                "type": "(a -> value) -> Result x a -> Result x value"
            },
            {
                "name": "map2",
                "comment": "Apply a function to two results, if both results are `Ok`. If not,\nthe first argument which is an `Err` will propagate through.\n\n    map2 (+) (String.toInt \"1\") (String.toInt \"2\") == Ok 3\n    map2 (+) (String.toInt \"1\") (String.toInt \"y\") == Err \"could not convert string 'y' to an Int\"\n    map2 (+) (String.toInt \"x\") (String.toInt \"y\") == Err \"could not convert string 'x' to an Int\"",
                "type": "(a -> b -> value) -> Result x a -> Result x b -> Result x value"
            },
            {
                "name": "map3",
                "comment": "",
                "type": "(a -> b -> c -> value) -> Result x a -> Result x b -> Result x c -> Result x value"
            },
            {
                "name": "map4",
                "comment": "",
                "type": "(a -> b -> c -> d -> value) -> Result x a -> Result x b -> Result x c -> Result x d -> Result x value"
            },
            {
                "name": "map5",
                "comment": "",
                "type": "(a -> b -> c -> d -> e -> value) -> Result x a -> Result x b -> Result x c -> Result x d -> Result x e -> Result x value"
            },
            {
                "name": "toMaybe",
                "comment": "Convert to a simpler `Maybe` if the actual error message is not needed or\nyou need to interact with some code that primarily uses maybes.\n\n    parseInt : String -> Result ParseError Int\n\n    maybeParseInt : String -> Maybe Int\n    maybeParseInt string =\n        toMaybe (parseInt string)",
                "type": "Result x a -> Maybe a"
            }
        ],
        "binops": []
    },
    {
        "name": "Set",
        "comment": "A set of unique values. The values can be any comparable type. This\nincludes `Int`, `Float`, `Time`, `Char`, `String`, and tuples or lists\nof comparable types.\n\nInsert, remove, and query operations all take *O(log n)* time. Set equality with\n`(==)` is unreliable and should not be used.\n\n# Build\n@docs empty, singleton, insert, remove\n\n# Query\n@docs isEmpty, member\n\n# Combine\n@docs union, intersect, diff\n\n# Lists\n@docs toList, fromList\n\n# Transform\n@docs map, foldl, foldr, filter, partition",
        "unions": [],
        "aliases": [
            {
                "name": "Set",
                "comment": "",
                "args": [
                    "t"
                ],
                "type": "Dict t ()"
            }
        ],
        "values": [
            {
                "name": "diff",
                "comment": "Get the difference between the first set and the second. Keeps values\nthat do not appear in the second set.",
                "type": "Set comparable -> Set comparable -> Set comparable"
            },
            {
                "name": "empty",
                "comment": "Create an empty set.",
                "type": "Set comparable"
            },
            {
                "name": "filter",
                "comment": "Create a new set consisting only of elements which satisfy a predicate.",
                "type": "(comparable -> Bool) -> Set comparable -> Set comparable"
            },
            {
                "name": "foldl",
                "comment": "Fold over the values in a set, in order from lowest to highest.",
                "type": "(comparable -> b -> b) -> b -> Set comparable -> b"
            },
            {
                "name": "foldr",
                "comment": "Fold over the values in a set, in order from highest to lowest.",
                "type": "(comparable -> b -> b) -> b -> Set comparable -> b"
            },
            {
                "name": "fromList",
                "comment": "Convert a list into a set, removing any duplicates.",
                "type": "List comparable -> Set comparable"
            },
            {
                "name": "insert",
                "comment": "Insert a value into a set.",
                "type": "comparable -> Set comparable -> Set comparable"
            },
            {
                "name": "intersect",
                "comment": "Get the intersection of two sets. Keeps values that appear in both sets.",
                "type": "Set comparable -> Set comparable -> Set comparable"
            },
            {
                "name": "isEmpty",
                "comment": "Determine if a set is empty.",
                "type": "Set comparable -> Bool"
            },
            {
                "name": "map",
                "comment": "Map a function onto a set, creating a new set with no duplicates.",
                "type": "(comparable -> comparable_) -> Set comparable -> Set comparable_"
            },
            {
                "name": "member",
                "comment": "Determine if a value is in a set.",
                "type": "comparable -> Set comparable -> Bool"
            },
            {
                "name": "partition",
                "comment": "Create two new sets; the first consisting of elements which satisfy a\npredicate, the second consisting of elements which do not.",
                "type": "(comparable -> Bool) -> Set comparable -> ( Set comparable, Set comparable )"
            },
            {
                "name": "remove",
                "comment": "Remove a value from a set. If the value is not found, no changes are made.",
                "type": "comparable -> Set comparable -> Set comparable"
            },
            {
                "name": "singleton",
                "comment": "Create a set with one value.",
                "type": "comparable -> Set comparable"
            },
            {
                "name": "toList",
                "comment": "Convert a set into a list.",
                "type": "Set comparable -> List comparable"
            },
            {
                "name": "union",
                "comment": "Get the union of two sets. Keep all values.",
                "type": "Set comparable -> Set comparable -> Set comparable"
            }
        ],
        "binops": []
    },
    {
        "name": "Signal",
        "comment": "A *signal* is a value that changes over time. For example, we can\nthink of the mouse position as a pair of numbers that is changing over time,\nwhenever the user moves the mouse.\n\n    Mouse.position : Signal (Int,Int)\n\nAnother signal is the `Element` or `Html` we want to show on screen.\n\n    main : Signal Html\n\nAs the `Html` changes, the user sees different things on screen automatically.\n\nSome useful functions for working with time (e.g. setting FPS) and combining\nsignals and time (e.g. timestamps) can be found in the [`Time`](Time) library.\n\n# Merging\n@docs merge, mergeMany\n\n# Mapping\n@docs map, map2, map3, map4, map5\n\n# Fancy Mapping\n@docs (<~), (~)\n\n# Past-Dependence\n@docs foldp\n\n# Filters\n@docs filter, filterMap, dropRepeats, sampleOn\n\n# Mailboxes\n@docs Mailbox, mailbox, message, forwardTo, send\n\n# Constants\n@docs constant",
        "unions": [],
        "aliases": [
            {
                "name": "Mailbox",
                "comment": "An `Mailbox` is a communication hub. It is made up of\n\n  * an `Address` that you can send messages to\n  * a `Signal` of messages sent to the mailbox",
                "args": [
                    "a"
                ],
                "type": "{ address : Address a, signal : Signal a }"
            }
        ],
        "values": [
            {
                "name": "constant",
                "comment": "Create a signal that never changes. This can be useful if you need\nto pass a combination of signals and normal values to a function:\n\n    map3 view Window.dimensions Mouse.position (constant initialModel)",
                "type": "a -> Signal a"
            },
            {
                "name": "dropRepeats",
                "comment": "Drop updates that repeat the current value of the signal.\n\n    numbers : Signal Int\n\n    noDups : Signal Int\n    noDups =\n        dropRepeats numbers\n\n    --  numbers => 0 0 3 3 5 5 5 4 ...\n    --  noDups  => 0   3   5     4 ...\n\nThe signal should not be a signal of functions, or a record that contains a\nfunction (you'll get a runtime error since functions cannot be equated).",
                "type": "Signal a -> Signal a"
            },
            {
                "name": "filter",
                "comment": "Filter out some updates. The given function decides whether we should\n*keep* an update. If no updates ever flow through, we use the default value\nprovided. The following example only keeps even numbers and has an initial\nvalue of zero.\n\n    numbers : Signal Int\n\n    isEven : Int -> Bool\n\n    evens : Signal Int\n    evens =\n        filter isEven 0 numbers",
                "type": "(a -> Bool) -> a -> Signal a -> Signal a"
            },
            {
                "name": "filterMap",
                "comment": "Filter out some updates. When the filter function gives back `Just` a\nvalue, we send that value along. When it returns `Nothing` we drop it.\nIf the initial value of the incoming signal turns into `Nothing`, we use the\ndefault value provided. The following example keeps only strings that can be\nread as integers.\n\n    userInput : Signal String\n\n    toInt : String -> Maybe Int\n\n    numbers : Signal Int\n    numbers =\n        filterMap toInt 0 userInput",
                "type": "(a -> Maybe b) -> b -> Signal a -> Signal b"
            },
            {
                "name": "foldp",
                "comment": "Create a past-dependent signal. Each update from the incoming signals will\nbe used to step the state forward. The outgoing signal represents the current\nstate.\n\n    clickCount : Signal Int\n    clickCount =\n        foldp (\\click total -> total + 1) 0 Mouse.clicks\n\n    timeSoFar : Signal Time\n    timeSoFar =\n        foldp (+) 0 (fps 40)\n\nSo `clickCount` updates on each mouse click, incrementing by one. `timeSoFar`\nis the time the program has been running, updated 40 times a second.",
                "type": "(a -> state -> state) -> state -> Signal a -> Signal state"
            },
            {
                "name": "forwardTo",
                "comment": "Create a new address. This address will tag each message it receives\nand then forward it along to some other address.\n\n    type Action = Undo | Remove Int\n\n    port actions : Mailbox Action\n\n    removeAddress : Address Int\n    removeAddress =\n        forwardTo actions.address Remove\n\nIn this case we have a general `address` that many people may send\nmessages to. The new `removeAddress` tags all messages with the `Remove` tag\nbefore forwarding them along to the more general `address`. This means\nsome parts of our application can know *only* about `removeAddress` and not\ncare what other kinds of `Actions` are possible.",
                "type": "Address b -> (a -> b) -> Address a"
            },
            {
                "name": "mailbox",
                "comment": "Create a mailbox you can send messages to. The primary use case is\nreceiving updates from tasks and UI elements. The argument is a default value\nfor the custom signal.\n\nNote: Creating new signals is inherently impure, so `(mailbox ())` and\n`(mailbox ())` produce two different mailboxes.",
                "type": "a -> Mailbox a"
            },
            {
                "name": "map",
                "comment": "Apply a function to a signal.\n\n    mouseIsUp : Signal Bool\n    mouseIsUp =\n        map not Mouse.isDown\n\n    main : Signal Element\n    main =\n        map toElement Mouse.position",
                "type": "(a -> result) -> Signal a -> Signal result"
            },
            {
                "name": "map2",
                "comment": "Apply a function to the current value of two signals. The function\nis reevaluated whenever *either* signal changes. In the following example, we\nfigure out the `aspectRatio` of the window by combining the current width and\nheight.\n\n    ratio : Int -> Int -> Float\n    ratio width height =\n        toFloat width / toFloat height\n\n    aspectRatio : Signal Float\n    aspectRatio =\n        map2 ratio Window.width Window.height",
                "type": "(a -> b -> result) -> Signal a -> Signal b -> Signal result"
            },
            {
                "name": "map3",
                "comment": "",
                "type": "(a -> b -> c -> result) -> Signal a -> Signal b -> Signal c -> Signal result"
            },
            {
                "name": "map4",
                "comment": "",
                "type": "(a -> b -> c -> d -> result) -> Signal a -> Signal b -> Signal c -> Signal d -> Signal result"
            },
            {
                "name": "map5",
                "comment": "",
                "type": "(a -> b -> c -> d -> e -> result) -> Signal a -> Signal b -> Signal c -> Signal d -> Signal e -> Signal result"
            },
            {
                "name": "merge",
                "comment": "Merge two signals into one. This function is extremely useful for bringing\ntogether lots of different signals to feed into a `foldp`.\n\n    type Update = MouseMove (Int,Int) | TimeDelta Float\n\n    updates : Signal Update\n    updates =\n        merge\n            (map MouseMove Mouse.position)\n            (map TimeDelta (fps 40))\n\nIf an update comes from either of the incoming signals, it updates the outgoing\nsignal. If an update comes on both signals at the same time, the left update\nwins (i.e., the right update is discarded).",
                "type": "Signal a -> Signal a -> Signal a"
            },
            {
                "name": "mergeMany",
                "comment": "Merge many signals into one. This is useful when you are merging more than\ntwo signals. When multiple updates come in at the same time, the left-most\nupdate wins, just like with `merge`.\n\n    type Update = MouseMove (Int,Int) | TimeDelta Float | Click\n\n    updates : Signal Update\n    updates =\n        mergeMany\n            [ map MouseMove Mouse.position\n            , map TimeDelta (fps 40)\n            , map (always Click) Mouse.clicks\n            ]",
                "type": "List (Signal a) -> Signal a"
            },
            {
                "name": "message",
                "comment": "Create a message that may be sent to a `Mailbox` at a later time.\n\nMost importantly, this lets us create APIs that can send values to ports\n*without* allowing people to run arbitrary tasks.",
                "type": "Address a -> a -> Message"
            },
            {
                "name": "sampleOn",
                "comment": "Sample from the second input every time an event occurs on the first input.\nFor example, `(sampleOn Mouse.clicks (Time.every Time.second))` will give the\napproximate time of the latest click.",
                "type": "Signal a -> Signal b -> Signal b"
            },
            {
                "name": "send",
                "comment": "Send a message to an `Address`.\n\n    type Action = Undo | Remove Int\n\n    address : Address Action\n\n    requestUndo : Task x ()\n    requestUndo =\n        send address Undo\n\nThe `Signal` associated with `address` will receive the `Undo` message\nand push it through the Elm program.",
                "type": "Address a -> a -> Task x ()"
            }
        ],
        "binops": [
            {
                "name": "<~",
                "comment": "An alias for `map`. A prettier way to apply a function to the current value\nof a signal.\n\n    main : Signal Html\n    main =\n      view <~ model\n\n    model : Signal Model\n\n    view : Model -> Html",
                "type": "(a -> b) -> Signal a -> Signal b",
                "associativity": "left",
                "precedence": 4
            },
            {
                "name": "~",
                "comment": "Intended to be paired with the `(<~)` operator, this makes it possible for\nmany signals to flow into a function. Think of it as a fancy alias for\n`mapN`. For example, the following declarations are equivalent:\n\n    main : Signal Element\n    main =\n      scene <~ Window.dimensions ~ Mouse.position\n\n    main : Signal Element\n    main =\n      map2 scene Window.dimensions Mouse.position\n\nYou can use this pattern for as many signals as you want by using `(~)` a bunch\nof times, so you can go higher than `map5` if you need to.",
                "type": "Signal (a -> b) -> Signal a -> Signal b",
                "associativity": "left",
                "precedence": 4
            }
        ]
    },
    {
        "name": "String",
        "comment": "A built-in representation for efficient string manipulation. String literals\nare enclosed in `\"double quotes\"`. Strings are *not* lists of characters.\n\n# Basics\n@docs isEmpty, length, reverse, repeat\n\n# Building and Splitting\n@docs cons, uncons, fromChar, append, concat, split, join, words, lines\n\n# Get Substrings\n@docs slice, left, right, dropLeft, dropRight\n\n# Check for Substrings\n@docs contains, startsWith, endsWith, indexes, indices\n\n# Conversions\n@docs toInt, toFloat, toList, fromList\n\n# Formatting\nCosmetic operations such as padding with extra characters or trimming whitespace.\n\n@docs toUpper, toLower,\n      pad, padLeft, padRight,\n      trim, trimLeft, trimRight\n\n# Higher-Order Functions\n@docs map, filter, foldl, foldr, any, all",
        "unions": [],
        "aliases": [],
        "values": [
            {
                "name": "all",
                "comment": "Determine whether *all* characters satisfy a predicate.\n\n    all isDigit \"90210\" == True\n    all isDigit \"R2-D2\" == False\n    all isDigit \"heart\" == False",
                "type": "(Char -> Bool) -> String -> Bool"
            },
            {
                "name": "any",
                "comment": "Determine whether *any* characters satisfy a predicate.\n\n    any isDigit \"90210\" == True\n    any isDigit \"R2-D2\" == True\n    any isDigit \"heart\" == False",
                "type": "(Char -> Bool) -> String -> Bool"
            },
            {
                "name": "append",
                "comment": "Append two strings. You can also use [the `(++)` operator](Basics#++)\nto do this.\n\n    append \"butter\" \"fly\" == \"butterfly\"",
                "type": "String -> String -> String"
            },
            {
                "name": "concat",
                "comment": "Concatenate many strings into one.\n\n    concat [\"never\",\"the\",\"less\"] == \"nevertheless\"",
                "type": "List String -> String"
            },
            {
                "name": "cons",
                "comment": "Add a character to the beginning of a string.",
                "type": "Char -> String -> String"
            },
            {
                "name": "contains",
                "comment": "See if the second string contains the first one.\n\n    contains \"the\" \"theory\" == True\n    contains \"hat\" \"theory\" == False\n    contains \"THE\" \"theory\" == False\n\nUse `Regex.contains` if you need something more flexible.",
                "type": "String -> String -> Bool"
            },
            {
                "name": "dropLeft",
                "comment": "Drop *n* characters from the left side of a string.",
                "type": "Int -> String -> String"
            },
            {
                "name": "dropRight",
                "comment": "Drop *n* characters from the right side of a string.",
                "type": "Int -> String -> String"
            },
            {
                "name": "endsWith",
                "comment": "See if the second string ends with the first one.\n\n    endsWith \"the\" \"theory\" == False\n    endsWith \"ory\" \"theory\" == True",
                "type": "String -> String -> Bool"
            },
            {
                "name": "filter",
                "comment": "Keep only the characters that satisfy the predicate.\n\n    filter isDigit \"R2-D2\" == \"22\"",
                "type": "(Char -> Bool) -> String -> String"
            },
            {
                "name": "foldl",
                "comment": "Reduce a string from the left.\n\n    foldl cons \"\" \"time\" == \"emit\"",
                "type": "(Char -> b -> b) -> b -> String -> b"
            },
            {
                "name": "foldr",
                "comment": "Reduce a string from the right.\n\n    foldr cons \"\" \"time\" == \"time\"",
                "type": "(Char -> b -> b) -> b -> String -> b"
            },
            {
                "name": "fromChar",
                "comment": "Create a string from a given character.\n\n    fromChar 'a' == \"a\"",
                "type": "Char -> String"
            },
            {
                "name": "fromList",
                "comment": "Convert a list of characters into a String. Can be useful if you\nwant to create a string primarly by consing, perhaps for decoding\nsomething.\n\n    fromList ['a','b','c'] == \"abc\"",
                "type": "List Char -> String"
            },
            {
                "name": "indexes",
                "comment": "Get all of the indexes for a substring in another string.\n\n    indexes \"i\" \"Mississippi\"   == [1,4,7,10]\n    indexes \"ss\" \"Mississippi\"  == [2,5]\n    indexes \"needle\" \"haystack\" == []",
                "type": "String -> String -> List Int"
            },
            {
                "name": "indices",
                "comment": "Alias for `indexes`.",
                "type": "String -> String -> List Int"
            },
            {
                "name": "isEmpty",
                "comment": "Determine if a string is empty.\n\n    isEmpty \"\" == True\n    isEmpty \"the world\" == False",
                "type": "String -> Bool"
            },
            {
                "name": "join",
                "comment": "Put many strings together with a given separator.\n\n    join \"a\" [\"H\",\"w\",\"ii\",\"n\"]        == \"Hawaiian\"\n    join \" \" [\"cat\",\"dog\",\"cow\"]       == \"cat dog cow\"\n    join \"/\" [\"home\",\"evan\",\"Desktop\"] == \"home/evan/Desktop\"",
                "type": "String -> List String -> String"
            },
            {
                "name": "left",
                "comment": "Take *n* characters from the left side of a string.",
                "type": "Int -> String -> String"
            },
            {
                "name": "length",
                "comment": "Get the length of a string.\n\n    length \"innumerable\" == 11\n    length \"\" == 0",
                "type": "String -> Int"
            },
            {
                "name": "lines",
                "comment": "Break a string into lines, splitting on newlines.\n\n    lines \"How are you?\\nGood?\" == [\"How are you?\", \"Good?\"]",
                "type": "String -> List String"
            },
            {
                "name": "map",
                "comment": "Transform every character in a string\n\n    map (\\c -> if c == '/' then '.' else c) \"a/b/c\" == \"a.b.c\"",
                "type": "(Char -> Char) -> String -> String"
            },
            {
                "name": "pad",
                "comment": "Pad a string on both sides until it has a given length.\n\n    pad 5 ' ' \"1\"   == \"  1  \"\n    pad 5 ' ' \"11\"  == \"  11 \"\n    pad 5 ' ' \"121\" == \" 121 \"",
                "type": "Int -> Char -> String -> String"
            },
            {
                "name": "padLeft",
                "comment": "Pad a string on the left until it has a given length.\n\n    padLeft 5 '.' \"1\"   == \"....1\"\n    padLeft 5 '.' \"11\"  == \"...11\"\n    padLeft 5 '.' \"121\" == \"..121\"",
                "type": "Int -> Char -> String -> String"
            },
            {
                "name": "padRight",
                "comment": "Pad a string on the right until it has a given length.\n\n    padRight 5 '.' \"1\"   == \"1....\"\n    padRight 5 '.' \"11\"  == \"11...\"\n    padRight 5 '.' \"121\" == \"121..\"",
                "type": "Int -> Char -> String -> String"
            },
            {
                "name": "repeat",
                "comment": "Repeat a string *n* times.\n\n    repeat 3 \"ha\" == \"hahaha\"",
                "type": "Int -> String -> String"
            },
            {
                "name": "reverse",
                "comment": "Reverse a string.\n\n    reverse \"stressed\" == \"desserts\"",
                "type": "String -> String"
            },
            {
                "name": "right",
                "comment": "Take *n* characters from the right side of a string.",
                "type": "Int -> String -> String"
            },
            {
                "name": "slice",
                "comment": "Take a substring given a start and end index. Negative indexes\nare taken starting from the *end* of the list.\n\n    slice  7  9 \"snakes on a plane!\" == \"on\"\n    slice  0  6 \"snakes on a plane!\" == \"snakes\"\n    slice  0 -7 \"snakes on a plane!\" == \"snakes on a\"\n    slice -6 -1 \"snakes on a plane!\" == \"plane\"",
                "type": "Int -> Int -> String -> String"
            },
            {
                "name": "split",
                "comment": "Split a string using a given separator.\n\n    split \",\" \"cat,dog,cow\"        == [\"cat\",\"dog\",\"cow\"]\n    split \"/\" \"home/evan/Desktop/\" == [\"home\",\"evan\",\"Desktop\", \"\"]\n\nUse `Regex.split` if you need something more flexible.",
                "type": "String -> String -> List String"
            },
            {
                "name": "startsWith",
                "comment": "See if the second string starts with the first one.\n\n    startsWith \"the\" \"theory\" == True\n    startsWith \"ory\" \"theory\" == False",
                "type": "String -> String -> Bool"
            },
            {
                "name": "toFloat",
                "comment": "Try to convert a string into a float, failing on improperly formatted strings.\n\n    toFloat \"123\" == Ok 123.0\n    toFloat \"-42\" == Ok -42.0\n    toFloat \"3.1\" == Ok 3.1\n    toFloat \"31a\" == Err \"could not convert string '31a' to a Float\"",
                "type": "String -> Result String Float"
            },
            {
                "name": "toInt",
                "comment": "Try to convert a string into an int, failing on improperly formatted strings.\n\n    toInt \"123\" == Ok 123\n    toInt \"-42\" == Ok -42\n    toInt \"3.1\" == Err \"could not convert string '3.1' to an Int\"\n    toInt \"31a\" == Err \"could not convert string '31a' to an Int\"",
                "type": "String -> Result String Int"
            },
            {
                "name": "toList",
                "comment": "Convert a string to a list of characters.\n\n    toList \"abc\" == ['a','b','c']",
                "type": "String -> List Char"
            },
            {
                "name": "toLower",
                "comment": "Convert a string to all lower case. Useful for case-insensitive comparisons.",
                "type": "String -> String"
            },
            {
                "name": "toUpper",
                "comment": "Convert a string to all upper case. Useful for case-insensitive comparisons\nand VIRTUAL YELLING.",
                "type": "String -> String"
            },
            {
                "name": "trim",
                "comment": "Get rid of whitespace on both sides of a string.\n\n    trim \"  hats  \\n\" == \"hats\"",
                "type": "String -> String"
            },
            {
                "name": "trimLeft",
                "comment": "Get rid of whitespace on the left of a string.\n\n    trimLeft \"  hats  \\n\" == \"hats  \\n\"",
                "type": "String -> String"
            },
            {
                "name": "trimRight",
                "comment": "Get rid of whitespace on the right of a string.\n\n    trimRight \"  hats  \\n\" == \"  hats\"",
                "type": "String -> String"
            },
            {
                "name": "uncons",
                "comment": "Split a non-empty string into its head and tail. This lets you\npattern match on strings exactly as you would with lists.\n\n    uncons \"abc\" == Just ('a',\"bc\")\n    uncons \"\"    == Nothing",
                "type": "String -> Maybe ( Char, String )"
            },
            {
                "name": "words",
                "comment": "Break a string into words, splitting on chunks of whitespace.\n\n    words \"How are \\t you? \\n Good?\" == [\"How\",\"are\",\"you?\",\"Good?\"]",
                "type": "String -> List String"
            }
        ],
        "binops": []
    },
    {
        "name": "Task",
        "comment": "\n\n# Basics\n@docs succeed, fail\n\n# Mapping\n@docs map, map2, map3, map4, map5, andMap\n\n# Chaining\n@docs andThen, sequence\n\n# Errors\n@docs onError, mapError, toMaybe, fromMaybe, toResult, fromResult\n\n# Threads\n@docs spawn, sleep",
        "unions": [],
        "aliases": [],
        "values": [
            {
                "name": "andMap",
                "comment": "",
                "type": "Task x (a -> b) -> Task x a -> Task x b"
            },
            {
                "name": "andThen",
                "comment": "",
                "type": "Task x a -> (a -> Task x b) -> Task x b"
            },
            {
                "name": "fail",
                "comment": "",
                "type": "x -> Task x a"
            },
            {
                "name": "fromMaybe",
                "comment": "",
                "type": "x -> Maybe a -> Task x a"
            },
            {
                "name": "fromResult",
                "comment": "",
                "type": "Result x a -> Task x a"
            },
            {
                "name": "map",
                "comment": "",
                "type": "(a -> b) -> Task x a -> Task x b"
            },
            {
                "name": "map2",
                "comment": "",
                "type": "(a -> b -> result) -> Task x a -> Task x b -> Task x result"
            },
            {
                "name": "map3",
                "comment": "",
                "type": "(a -> b -> c -> result) -> Task x a -> Task x b -> Task x c -> Task x result"
            },
            {
                "name": "map4",
                "comment": "",
                "type": "(a -> b -> c -> d -> result) -> Task x a -> Task x b -> Task x c -> Task x d -> Task x result"
            },
            {
                "name": "map5",
                "comment": "",
                "type": "(a -> b -> c -> d -> e -> result) -> Task x a -> Task x b -> Task x c -> Task x d -> Task x e -> Task x result"
            },
            {
                "name": "mapError",
                "comment": "",
                "type": "(x -> y) -> Task x a -> Task y a"
            },
            {
                "name": "onError",
                "comment": "",
                "type": "Task x a -> (x -> Task y a) -> Task y a"
            },
            {
                "name": "sequence",
                "comment": "",
                "type": "List (Task x a) -> Task x (List a)"
            },
            {
                "name": "sleep",
                "comment": "",
                "type": "Time -> Task x ()"
            },
            {
                "name": "spawn",
                "comment": "",
                "type": "Task x a -> Task y ThreadID"
            },
            {
                "name": "succeed",
                "comment": "",
                "type": "a -> Task x a"
            },
            {
                "name": "toMaybe",
                "comment": "",
                "type": "Task x a -> Task y (Maybe a)"
            },
            {
                "name": "toResult",
                "comment": "",
                "type": "Task x a -> Task y (Result x a)"
            }
        ],
        "binops": []
    },
    {
        "name": "Text",
        "comment": "A library for styling and displaying text. While the `String` library\nfocuses on representing and manipulating strings of character strings, the\n`Text` library focuses on how those strings should look on screen. It lets\nyou make text bold or italic, set the typeface, set the text size, etc.\n\n# Creating Text\n@docs fromString, empty, append, concat, join\n\n# Links and Style\n@docs link, typeface, monospace, height, color, bold, italic, line, Line,\n    style, Style, defaultStyle",
        "unions": [
            {
                "name": "Line",
                "comment": "Styles for lines on text. This allows you to add an underline, an overline,\nor a strike out text:\n\n    line Under   (fromString \"underline\")\n    line Over    (fromString \"overline\")\n    line Through (fromString \"strike out\")",
                "args": [],
                "cases": [
                    [
                        "Under",
                        []
                    ],
                    [
                        "Over",
                        []
                    ],
                    [
                        "Through",
                        []
                    ]
                ]
            }
        ],
        "aliases": [
            {
                "name": "Style",
                "comment": "Represents all the ways you can style `Text`. If the `typeface` list is\nempty or the `height` is `Nothing`, the users will fall back on their browser's\ndefault settings. The following `Style` is black, 16 pixel tall, underlined, and\nTimes New Roman (assuming that typeface is available on the user's computer):\n\n    { typeface = [ \"Times New Roman\", \"serif\" ]\n    , height   = Just 16\n    , color    = black\n    , bold     = False\n    , italic   = False\n    , line     = Just Under\n    }",
                "args": [],
                "type": "{ typeface : List String, height : Maybe Float, color : Color, bold : Bool, italic : Bool, line : Maybe Line }"
            }
        ],
        "values": [
            {
                "name": "append",
                "comment": "Put two chunks of text together.\n\n    append (fromString \"hello \") (fromString \"world\") == fromString \"hello world\"",
                "type": "Text -> Text -> Text"
            },
            {
                "name": "bold",
                "comment": "Make text bold.\n\n    fromString \"sometimes you want \" ++ bold (fromString \"emphasis\")",
                "type": "Text -> Text"
            },
            {
                "name": "color",
                "comment": "Set the color of some text.\n\n    color red (fromString \"Red\")",
                "type": "Color -> Text -> Text"
            },
            {
                "name": "concat",
                "comment": "Put many chunks of text together.\n\n    concat\n      [ fromString \"type \"\n      , bold (fromString \"Maybe\")\n      , fromString \" = Just a | Nothing\"\n      ]",
                "type": "List Text -> Text"
            },
            {
                "name": "defaultStyle",
                "comment": "Plain black text. It uses the browsers default typeface and text height.\nNo decorations are used.\n\n    { typeface = []\n    , height = Nothing\n    , color = black\n    , bold = False\n    , italic = False\n    , line = Nothing\n    }",
                "type": "Style"
            },
            {
                "name": "empty",
                "comment": "Text with nothing in it.\n\n    empty = fromString \"\"",
                "type": "Text"
            },
            {
                "name": "fromString",
                "comment": "Convert a string into text which can be styled and displayed. To show the\nstring `\"Hello World!\"` on screen in italics, you could say:\n\n    main = leftAligned (italic (fromString \"Hello World!\"))",
                "type": "String -> Text"
            },
            {
                "name": "height",
                "comment": "Set the height of some text.\n\n    height 40 (fromString \"Title\")",
                "type": "Float -> Text -> Text"
            },
            {
                "name": "italic",
                "comment": "Make text italic.\n\n    fromString \"make it \" ++ italic (fromString \"important\")",
                "type": "Text -> Text"
            },
            {
                "name": "join",
                "comment": "Put many chunks of text together with a separator.\n\n    chunks : List Text\n    chunks = List.map fromString [\"lions\",\"tigers\",\"bears\"]\n\n    join (fromString \", \") chunks == fromString \"lions, tigers, bears\"",
                "type": "Text -> List Text -> Text"
            },
            {
                "name": "line",
                "comment": "Put lines on text.\n\n    line Under   (fromString \"underlined\")\n    line Over    (fromString \"overlined\")\n    line Through (fromString \"strike out\")",
                "type": "Line -> Text -> Text"
            },
            {
                "name": "link",
                "comment": "Create a link by providing a URL and the text of the link.\n\n    link \"http://elm-lang.org\" (fromString \"Elm Website\")",
                "type": "String -> Text -> Text"
            },
            {
                "name": "monospace",
                "comment": "Switch to a monospace typeface. Good for code snippets.\n\n    monospace (fromString \"foldl (+) 0 [1,2,3]\")",
                "type": "Text -> Text"
            },
            {
                "name": "style",
                "comment": "Set the style of some text. For example, if you design a `Style` called\n`footerStyle` that is specifically for the bottom of your page, you could apply\nit to text like this:\n\n    style footerStyle (fromString \"the old prince / 2007\")",
                "type": "Style -> Text -> Text"
            },
            {
                "name": "typeface",
                "comment": "Provide a list of preferred typefaces for some text.\n\n    [\"helvetica\",\"arial\",\"sans-serif\"]\n\nNot every browser has access to the same typefaces, so rendering will use the\nfirst typeface in the list that is found on the user's computer. If there are\nno matches, it will use their default typeface. This works the same as the CSS\nfont-family property.",
                "type": "List String -> Text -> Text"
            }
        ],
        "binops": []
    },
    {
        "name": "Time",
        "comment": "Library for working with time.\n\n# Units\n@docs Time, millisecond, second, minute, hour,\n      inMilliseconds, inSeconds, inMinutes, inHours\n\n# Tickers\n@docs fps, fpsWhen, every\n\n# Timing\n@docs timestamp, delay, since",
        "unions": [],
        "aliases": [
            {
                "name": "Time",
                "comment": "Type alias to make it clearer when you are working with time values.\nUsing the `Time` constants instead of raw numbers is very highly recommended.",
                "args": [],
                "type": "Float"
            }
        ],
        "values": [
            {
                "name": "delay",
                "comment": "Delay a signal by a certain amount of time. So `(delay second Mouse.clicks)`\nwill update one second later than any mouse click.",
                "type": "Time -> Signal a -> Signal a"
            },
            {
                "name": "every",
                "comment": "Takes a time interval `t`. The resulting signal is the current time, updated\nevery `t`.\n\nNote: Calling `every 100` twice gives two independently running timers.",
                "type": "Time -> Signal Time"
            },
            {
                "name": "fps",
                "comment": "Takes desired number of frames per second (FPS). The resulting signal\ngives a sequence of time deltas as quickly as possible until it reaches\nthe desired FPS. A time delta is the time between the last frame and the\ncurrent frame.\n\nNote: Calling `fps 30` twice gives two independently running timers.",
                "type": "number -> Signal Time"
            },
            {
                "name": "fpsWhen",
                "comment": "Same as the `fps` function, but you can turn it on and off. Allows you\nto do brief animations based on user input without major inefficiencies.\nThe first time delta after a pause is always zero, no matter how long\nthe pause was. This way summing the deltas will actually give the amount\nof time that the output signal has been running.",
                "type": "number -> Signal Bool -> Signal Time"
            },
            {
                "name": "hour",
                "comment": "",
                "type": "Time"
            },
            {
                "name": "inHours",
                "comment": "",
                "type": "Time -> Float"
            },
            {
                "name": "inMilliseconds",
                "comment": "",
                "type": "Time -> Float"
            },
            {
                "name": "inMinutes",
                "comment": "",
                "type": "Time -> Float"
            },
            {
                "name": "inSeconds",
                "comment": "",
                "type": "Time -> Float"
            },
            {
                "name": "millisecond",
                "comment": "Units of time, making it easier to specify things like a half-second\n`(500 * milliseconds)` without remembering Elm&rsquo;s underlying units of time.",
                "type": "Time"
            },
            {
                "name": "minute",
                "comment": "",
                "type": "Time"
            },
            {
                "name": "second",
                "comment": "",
                "type": "Time"
            },
            {
                "name": "since",
                "comment": "Takes a time `t` and any signal. The resulting boolean signal is true for\ntime `t` after every event on the input signal. So ``(second `since`\nMouse.clicks)`` would result in a signal that is true for one second after\neach mouse click and false otherwise.",
                "type": "Time -> Signal a -> Signal Bool"
            },
            {
                "name": "timestamp",
                "comment": "Add a timestamp to any signal. Timestamps increase monotonically. When you\ncreate `(timestamp Mouse.x)`, an initial timestamp is produced. The timestamp\nupdates whenever `Mouse.x` updates.\n\nTimestamp updates are tied to individual events, so `(timestamp Mouse.x)` and\n`(timestamp Mouse.y)` will always have the same timestamp because they rely on\nthe same underlying event (`Mouse.position`).",
                "type": "Signal a -> Signal ( Time, a )"
            }
        ],
        "binops": []
    },
    {
        "name": "Touch",
        "comment": "This is an early version of the touch library. It will likely grow to\ninclude gestures that would be useful for both games and web-pages.\n\n# Touches\n@docs Touch, touches\n\n# Gestures\n@docs taps",
        "unions": [],
        "aliases": [
            {
                "name": "Touch",
                "comment": "Every `Touch` has `xy` coordinates. It also has an identifier\n`id` to distinguish one touch from another.\n\nA touch also keeps info about the initial point and time of contact:\n`x0`, `y0`, and `t0`. This helps compute more complicated gestures\nlike taps, drags, and swipes which need to know about timing or direction.",
                "args": [],
                "type": "{ x : Int, y : Int, id : Int, x0 : Int, y0 : Int, t0 : Time }"
            }
        ],
        "values": [
            {
                "name": "taps",
                "comment": "The last position that was tapped. Default value is `{x=0,y=0}`.\nUpdates whenever the user taps the screen.",
                "type": "Signal { x : Int, y : Int }"
            },
            {
                "name": "touches",
                "comment": "A list of ongoing touches.",
                "type": "Signal (List Touch)"
            }
        ],
        "binops": []
    },
    {
        "name": "Trampoline",
        "comment": "A [trampoline](http://en.wikipedia.org/wiki/Tail-recursive_function#Through_trampolining)\nmakes it possible to recursively call a function without growing the stack.\n\nPopular JavaScript implementations do not perform any tail-call elimination, so\nrecursive functions can cause a stack overflow if they go too deep. Trampolines\npermit unbounded recursion despite limitations in JavaScript.\n\nThis strategy may create many intermediate closures, which is very expensive in\nJavaScript, so use this library only when it is essential that you recurse deeply.\n\n# Trampolines\n@docs trampoline, Trampoline",
        "unions": [
            {
                "name": "Trampoline",
                "comment": "A way to build computations that may be deeply recursive. We will take an\nexample of a tail-recursive function and rewrite it in a way that lets us use\na trampoline:\n\n    length : List a -> Int\n    length list = length' 0 list\n\n    length' : Int -> List a -> Int\n    length' accum list =\n        case list of\n          []     -> accum\n          hd::tl -> length' (accum+1) tl\n\nThis finds the length of a list, but if the list is too long, it may cause a\nstack overflow. We can rewrite it as follows:\n\n    length : List a -> Int\n    length list = trampoline (length' 0 list)\n\n    length' : Int -> List a -> Trampoline Int\n    length' accum list =\n        case list of\n          []     -> Done accum\n          hd::tl -> Continue (\\() -> length' (accum+1) tl)\n\nNow it uses a trampoline and can recurse without growing the stack!",
                "args": [
                    "a"
                ],
                "cases": [
                    [
                        "Done",
                        [
                            "a"
                        ]
                    ],
                    [
                        "Continue",
                        [
                            "() -> Trampoline a"
                        ]
                    ]
                ]
            }
        ],
        "aliases": [],
        "values": [
            {
                "name": "trampoline",
                "comment": "Evaluate a trampolined value in constant space.",
                "type": "Trampoline a -> a"
            }
        ],
        "binops": []
    },
    {
        "name": "Transform2D",
        "comment": "A library for performing [2D matrix transformations][affine].\nIt is used primarily with the `groupTransform` function from `Graphics.Collage` and\nallows you to do things like rotation, scaling, translation, shearing, and reflection.\n\nNote that all the matrices in this library are 3x3 matrices of homogeneous\ncoordinates, used for [affine transformations][affine]. Since the bottom row as\nalways `0 0 1` in these matrices, it is omitted in the diagrams below.\n\n [affine]: http://en.wikipedia.org/wiki/Transformation_matrix#Affine_transformations\n\n# Transforms\n@docs identity, matrix, rotation, translation, scale, scaleX, scaleY\n\n# Multiplication\n@docs multiply",
        "unions": [],
        "aliases": [],
        "values": [
            {
                "name": "identity",
                "comment": "Create an identity transform. Transforming by the identity does\nnot change anything, but it can come in handy as a default or\nbase case.\n\n        / 1 0 0 \\\n        \\ 0 1 0 /",
                "type": "Transform2D"
            },
            {
                "name": "matrix",
                "comment": "Create a transformation matrix. This lets you create transforms\nsuch as scales, shears, reflections, and translations.\n\n    matrix a b c d x y\n\n        / a b x \\\n        \\ c d y /\n\nNote that `x` and `y` are the translation values.",
                "type": "Float -> Float -> Float -> Float -> Float -> Float -> Transform2D"
            },
            {
                "name": "multiply",
                "comment": "Multiply two transforms together.\n\n    multiply m n\n\n        / ma mb mx \\     / na nb nx \\\n        | mc md my |  .  | nc nd ny |\n        \\  0  0  1 /     \\  0  0  1 /",
                "type": "Transform2D -> Transform2D -> Transform2D"
            },
            {
                "name": "rotation",
                "comment": "Create a [rotation matrix](http://en.wikipedia.org/wiki/Rotation_matrix).\nGiven an angle t, it creates a counterclockwise rotation matrix:\n\n    rotation t\n\n        / cos t  -sin t  0 \\\n        \\ sin t   cos t  0 /",
                "type": "Float -> Transform2D"
            },
            {
                "name": "scale",
                "comment": "Creates a transformation matrix for scaling by a all directions.\n\n    scale s\n\n      / s 0 0 \\\n      \\ 0 s 0 /",
                "type": "Float -> Transform2D"
            },
            {
                "name": "scaleX",
                "comment": "Create a transformation for horizontal scaling.",
                "type": "Float -> Transform2D"
            },
            {
                "name": "scaleY",
                "comment": "Create a transformation for vertical scaling.",
                "type": "Float -> Transform2D"
            },
            {
                "name": "translation",
                "comment": "Create a transformation matrix for translation.\n\n    translation x y\n\n        / 1 0 x \\\n        \\ 0 1 y /",
                "type": "Float -> Float -> Transform2D"
            }
        ],
        "binops": []
    },
    {
        "name": "Window",
        "comment": "Provides information about the container that your Elm program lives in.\nWhen you embed Elm in a `<div>` it gives the dimensions of the container, not\nthe whole window.\n\n# Dimensions\n@docs dimensions, width, height",
        "unions": [],
        "aliases": [],
        "values": [
            {
                "name": "dimensions",
                "comment": "The current width and height of the window (i.e. the area viewable to the\nuser, not including scroll bars).",
                "type": "Signal ( Int, Int )"
            },
            {
                "name": "height",
                "comment": "The current height of the window.",
                "type": "Signal Int"
            },
            {
                "name": "width",
                "comment": "The current width of the window.",
                "type": "Signal Int"
            }
        ],
        "binops": []
    }
]