[
    {
        "name": "Exts.Validation",
        "comment": " Simple tools for validation. See also [Richard Feldman's elm-validate](http://package.elm-lang.org/packages/rtfeldman/elm-validate/latest)\n\n@docs apply, (|:), required, notBlank, emailRegex\n",
        "unions": [],
        "aliases": [],
        "values": [
            {
                "name": "apply",
                "comment": " A validator is a function that takes a possibly-invalid form, and\neither returns an error message, or a form that is definitely valid. For example:\n\n    type alias Form =\n      { email : Maybe String\n      , age : Maybe Int\n      }\n\n    type alias ValidForm =\n      { email : String\n      , age : Int\n      }\n\n    validateForm : Form -> Result String ValidForm\n    validateForm form =\n      Ok ValidForm\n        |: (notBlank \"Email is required and may not be blank.\" form.email)\n        |: (required \"Age is required\" form.age)\n\nAn error message is typically a `String`, but may be any type you choose.\n\n(Hat tip to CircuitHub, who inspired the syntax and guided the code with their [elm-json-extra](http://package.elm-lang.org/packages/circuithub/elm-json-extra/latest) library.)\n",
                "type": "Result e (a -> b) -> Result e a -> Result e b"
            },
            {
                "name": "emailRegex",
                "comment": " A basic email regex. This is incredibly simplistic, but is\nincluded for convenience.\n\nRemember that the only real way to validate an email address is to\nsend something to it and get a reply.\n",
                "type": "Regex"
            },
            {
                "name": "notBlank",
                "comment": " A field that might be `Nothing`, but is only valid if it is a non-empty `String`.\n",
                "type": "e -> Maybe String -> Result e String"
            },
            {
                "name": "required",
                "comment": " A field that might be `Nothing`, but is only valid if it is `Just a`.\n",
                "type": "e -> Maybe a -> Result e a"
            }
        ],
        "binops": [
            {
                "name": "|:",
                "comment": " Convenient synonym for `apply`.\n",
                "type": "Result e (a -> b) -> Result e a -> Result e b",
                "associativity": "left",
                "precedence": 9
            }
        ]
    },
    {
        "name": "Exts.Tuple",
        "comment": " Extensions for tuples.\n\n@docs indexedPair\n\n",
        "unions": [],
        "aliases": [],
        "values": [
            {
                "name": "indexedPair",
                "comment": " Turn a items into a key-value pair.\n\n  See also `Exts.Dict.indexBy` and `Exts.Dict.groupBy`.\n",
                "type": "(a -> b) -> a -> ( b, a )"
            }
        ],
        "binops": []
    },
    {
        "name": "Exts.Task",
        "comment": " Extensions for Tasks.\n\n@docs asEffect\n",
        "unions": [],
        "aliases": [],
        "values": [
            {
                "name": "asEffect",
                "comment": " Convert a `Task` to an `Effect` which conveys success or failure.\n",
                "type": "Task a b -> Effects (Result a b)"
            }
        ],
        "binops": []
    },
    {
        "name": "Exts.String",
        "comment": " Extensions to the core String library.\n\n@docs removePrefix\n\n",
        "unions": [],
        "aliases": [],
        "values": [
            {
                "name": "removePrefix",
                "comment": " Strip a leading string from a `String`.\n",
                "type": "String -> String -> String"
            }
        ],
        "binops": []
    },
    {
        "name": "Exts.Set",
        "comment": " Extensions to the core Set library.\n\n@docs select, uniqueItems\n\n",
        "unions": [],
        "aliases": [],
        "values": [
            {
                "name": "select",
                "comment": " Pull any items from a list where (f x) is in the given set.\n",
                "type": "(a -> comparable) -> Set comparable -> List a -> List a"
            },
            {
                "name": "uniqueItems",
                "comment": " Dive into a `List` to get a set of values.\n\n  For example, pulling a `Set` of countries from a `List` of users.\n",
                "type": "(a -> Maybe comparable) -> List a -> Set comparable"
            }
        ],
        "binops": []
    },
    {
        "name": "Exts.Result",
        "comment": " Extensions to the core Result library.\n\n@docs bimap, isOk, isErr, mappend\n",
        "unions": [],
        "aliases": [],
        "values": [
            {
                "name": "bimap",
                "comment": " Treat `Result` as a bifunctor, applying the first function to `Err` values and the second to `Ok` ones.\n",
                "type": "(e -> f) -> (a -> b) -> Result e a -> Result f b"
            },
            {
                "name": "isErr",
                "comment": " ",
                "type": "Result a b -> Bool"
            },
            {
                "name": "isOk",
                "comment": " Boolean checks for success/failure.\n",
                "type": "Result a b -> Bool"
            },
            {
                "name": "mappend",
                "comment": " Monoidal append - join two Results together as though they were one.\n",
                "type": "Result e a -> Result e b -> Result e ( a, b )"
            }
        ],
        "binops": []
    },
    {
        "name": "Exts.Maybe",
        "comment": " Extensions to the core Maybe library.\n\n@docs isJust, isNothing, maybe, mappend, catMaybes\n",
        "unions": [],
        "aliases": [],
        "values": [
            {
                "name": "catMaybes",
                "comment": " Extract all the `Just` values from a List of Maybes.\n",
                "type": "List (Maybe a) -> List a"
            },
            {
                "name": "isJust",
                "comment": " Boolean checks.\n",
                "type": "Maybe a -> Bool"
            },
            {
                "name": "isNothing",
                "comment": " ",
                "type": "Maybe a -> Bool"
            },
            {
                "name": "mappend",
                "comment": " Monoidal append - join two Maybes together as though they were one.\n",
                "type": "Maybe a -> Maybe b -> Maybe ( a, b )"
            },
            {
                "name": "maybe",
                "comment": " Apply a function to a value, returning the default if the value is `Nothing`.\n",
                "type": "b -> (a -> b) -> Maybe a -> b"
            }
        ],
        "binops": []
    },
    {
        "name": "Exts.List",
        "comment": " Extensions to the core List library.\n\n@docs chunk, mergeBy, singleton, maybeSingleton\n",
        "unions": [],
        "aliases": [],
        "values": [
            {
                "name": "chunk",
                "comment": " Split a list into chunks of length n.\n\n  Be aware that the last sub-list may be smaller than n-items long.\n\n  For example `chunk 3 [1..10] => [[1,2,3], [4,5,6], [7,8,9], [10]]`\n",
                "type": "Int -> List a -> List (List a)"
            },
            {
                "name": "maybeSingleton",
                "comment": " Wrap a maybe item into a list. If the item is `Nothing`, the `List` is empty.\n",
                "type": "Maybe a -> List a"
            },
            {
                "name": "mergeBy",
                "comment": " Merge two lists. The first argument is a function which returns\nthe unique ID of each element. Where an element appears more than\nonce, the last won wins.\n",
                "type": "(a -> comparable) -> List a -> List a -> List a"
            },
            {
                "name": "singleton",
                "comment": " Wrap a single item into a `List`.\n",
                "type": "a -> List a"
            }
        ],
        "binops": []
    },
    {
        "name": "Exts.LatLng",
        "comment": " Calculations between points on the earth.\n\n@docs distanceBetween, bearingTo\n",
        "unions": [],
        "aliases": [],
        "values": [
            {
                "name": "bearingTo",
                "comment": " Calculate the heading you'd need to travel on to get from point a to point b.\n",
                "type": "{ a | latitude : Float, longitude : Float } -> { b | latitude : Float, longitude : Float } -> Float"
            },
            {
                "name": "distanceBetween",
                "comment": " Calculate the distance in kilometers between two points.\n\n  Note that this assumes the earth is spherical, which is not true, but may be true enough for your purposes.\n",
                "type": "{ a | latitude : Float, longitude : Float } -> { b | latitude : Float, longitude : Float } -> Float"
            }
        ],
        "binops": []
    },
    {
        "name": "Exts.Json.Encode",
        "comment": " Extensions to the core Json Encode library.\n\n@docs set, dict, tuple2\n",
        "unions": [],
        "aliases": [],
        "values": [
            {
                "name": "dict",
                "comment": " Encode a dict to a JSON array .\n",
                "type": "(comparable -> Value) -> (v -> Value) -> Dict comparable v -> Value"
            },
            {
                "name": "set",
                "comment": " Encode a set to a JSON array .\n",
                "type": "(comparable -> Value) -> Set comparable -> Value"
            },
            {
                "name": "tuple2",
                "comment": " Encode a 2-tuple to a JSON array .\n",
                "type": "(a -> Value) -> (b -> Value) -> ( a, b ) -> Value"
            }
        ],
        "binops": []
    },
    {
        "name": "Exts.Http",
        "comment": " Extensions to the main Http library.\n\n@docs handleError, put, postContent, postForm, postJson\n",
        "unions": [],
        "aliases": [],
        "values": [
            {
                "name": "handleError",
                "comment": " Lift a raw Http response into a 'Task Error Response', using the same rules `Http` uses internally.\n",
                "type": "Task RawError Response -> Task Error Response"
            },
            {
                "name": "postContent",
                "comment": " Send a `POST` request with the given content-type.\n",
                "type": "String -> Decoder value -> String -> Body -> Task Error value"
            },
            {
                "name": "postForm",
                "comment": " Send a `POST` request with appropriate headers form-encoding.\n",
                "type": "Decoder value -> String -> Body -> Task Error value"
            },
            {
                "name": "postJson",
                "comment": " Send a `POST` request with appropriate headers form-encoding.\n",
                "type": "Decoder value -> String -> Body -> Task Error value"
            },
            {
                "name": "put",
                "comment": " Send a simple `PUT` request.\n",
                "type": "Decoder value -> String -> Body -> Task Error value"
            }
        ],
        "binops": []
    },
    {
        "name": "Exts.Html.Table",
        "comment": " Helpers for simple data tables. Define how a list of items can be\nrendered as a table. The definition is a `List` of `(column-title,\ncolumn-value-accessor)` pairs.\n\n  I find this approach works well for simple tables, but breaks down\n  as soon as you need much customisation. Use it to get you started\n  quickly, but be ready to rewrite when this 80% case no longer suits.\n\n@docs CellDef, TableDef, simpleTable, simpleTableRow, titleGroup, valueGroup\n",
        "unions": [],
        "aliases": [
            {
                "name": "CellDef",
                "comment": " A table definition looks something like:\n\n    [(text \"Name\", .name >> text)\n    ,(text \"Name\", .age >> toString >> text)]\n\n",
                "args": [
                    "a"
                ],
                "type": "( Html, a -> Html )"
            },
            {
                "name": "TableDef",
                "comment": " ",
                "args": [
                    "a"
                ],
                "type": "List (CellDef a)"
            }
        ],
        "values": [
            {
                "name": "simpleTable",
                "comment": " Given a table definition, render a list of elements as HTML.\n",
                "type": "TableDef a -> List a -> Html"
            },
            {
                "name": "simpleTableRow",
                "comment": " Given a table definition, render an element to a <tr> tag. This is\nlower-level. Usually you will want `simpleTable` instead.\n",
                "type": "TableDef a -> a -> Html"
            },
            {
                "name": "titleGroup",
                "comment": " titleGroup and valueGroup are used to create columns that stack multiple pairs. For example:\n\n    [(titleGroup [\"Latitude\", \"Longitude\"]\n     ,valueGroup [.location >> .lat >> toString >> text\n                 ,.location >> .lng >> toString >> text])\n\n",
                "type": "List String -> Html"
            },
            {
                "name": "valueGroup",
                "comment": " ",
                "type": "List (a -> Html) -> a -> Html"
            }
        ],
        "binops": []
    },
    {
        "name": "Exts.Html.Events",
        "comment": " Extensions to the Html.Events library.\n\n@docs onEnter\n",
        "unions": [],
        "aliases": [],
        "values": [
            {
                "name": "onEnter",
                "comment": " Send a message when the user hits enter.\n",
                "type": "Message -> Attribute"
            }
        ],
        "binops": []
    },
    {
        "name": "Exts.Html.Bootstrap",
        "comment": " Base classes for Twitter Bootstrap 3 users.\n\n@docs container, containerFluid, row, empty, twoColumns, Ratio, video, glyphicon, popover, PopoverDirection\n",
        "unions": [
            {
                "name": "PopoverDirection",
                "comment": " ",
                "args": [],
                "cases": [
                    [
                        "Top",
                        []
                    ],
                    [
                        "Right",
                        []
                    ],
                    [
                        "Bottom",
                        []
                    ],
                    [
                        "Left",
                        []
                    ]
                ]
            },
            {
                "name": "Ratio",
                "comment": " Aspect ratios for responsive video embedding.\n",
                "args": [],
                "cases": [
                    [
                        "SixteenByNine",
                        []
                    ],
                    [
                        "FourByThree",
                        []
                    ]
                ]
            }
        ],
        "aliases": [],
        "values": [
            {
                "name": "container",
                "comment": " Bootstrap grid container.\n",
                "type": "List Html -> Html"
            },
            {
                "name": "containerFluid",
                "comment": " Bootstrap grid fluid container.\n",
                "type": "List Html -> Html"
            },
            {
                "name": "empty",
                "comment": " The minimum markup - an empty span.\n",
                "type": "Html"
            },
            {
                "name": "glyphicon",
                "comment": " Glyphicons. Supply the unprefixed glyph name (eg. `\"zoom-in\"' will\ngive you `glyphicon-zoom-in`).\n",
                "type": "String -> Html"
            },
            {
                "name": "popover",
                "comment": " Interface to the bootstrap popover that does not require bootstrap.js.\n",
                "type": "PopoverDirection -> Bool -> List ( String, String ) -> Maybe String -> List Html -> Html"
            },
            {
                "name": "row",
                "comment": " Bootstrap grid row.\n",
                "type": "List Html -> Html"
            },
            {
                "name": "twoColumns",
                "comment": " Two evenly-sized columns. Must be used within a row.\n",
                "type": "List Html -> List Html -> Html"
            },
            {
                "name": "video",
                "comment": " Embed a responsive video.\n",
                "type": "Ratio -> String -> Html"
            }
        ],
        "binops": []
    },
    {
        "name": "Exts.Html.Attributes",
        "comment": " Extensions to the Html.Attributes library.\n\n@docs defaultValue, defaultString, defaultInt, defaultFloat\n",
        "unions": [],
        "aliases": [],
        "values": [
            {
                "name": "defaultFloat",
                "comment": " Convenience version of defaultValue, for `Float`s.\n",
                "type": "Float -> Attribute"
            },
            {
                "name": "defaultInt",
                "comment": " Convenience version of defaultValue, for `Int`s.\n",
                "type": "Int -> Attribute"
            },
            {
                "name": "defaultString",
                "comment": " Convenience version of defaultValue, for `String`s.\n",
                "type": "String -> Attribute"
            },
            {
                "name": "defaultValue",
                "comment": " Set a default value for an input field.\n",
                "type": "Value -> Attribute"
            }
        ],
        "binops": []
    },
    {
        "name": "Exts.Float",
        "comment": " Extensions to the core Float library.\n\n@docs roundTo\n",
        "unions": [],
        "aliases": [],
        "values": [
            {
                "name": "roundTo",
                "comment": " Round a float to a given number of decimal places.\n",
                "type": "Int -> Float -> Float"
            }
        ],
        "binops": []
    },
    {
        "name": "Exts.Delta",
        "comment": " A system for tracking players that enter and leave a stage, a-la D3.\n\nImplementation detail: This code is hampered by the lack of Elm's type classes. Note the following:\n1. Performance may degrade badly as the number of elements increases.\n2. It is up to you to ensure (a) implments Eq correctly.\n\n@docs Delta, empty, generation\n",
        "unions": [],
        "aliases": [
            {
                "name": "Delta",
                "comment": " A data-structure that maintains the difference list of entering, continuing and leaving players.\n",
                "args": [
                    "a"
                ],
                "type": "{ entering : List a, continuing : List a, leaving : List a }"
            }
        ],
        "values": [
            {
                "name": "empty",
                "comment": " A default starting state for Deltas.\n",
                "type": "Delta a"
            },
            {
                "name": "generation",
                "comment": " Update the delta by inspecting a list of players.\n",
                "type": "List a -> Delta a -> Delta a"
            }
        ],
        "binops": []
    },
    {
        "name": "Exts.Date",
        "comment": " Extensions to the core date library.\n\n@docs toISOString\n",
        "unions": [],
        "aliases": [],
        "values": [
            {
                "name": "toISOString",
                "comment": " Format a Date as an ISO-standard string.\n",
                "type": "Date -> String"
            }
        ],
        "binops": []
    },
    {
        "name": "Exts.Dict",
        "comment": " Extensions to the core Dict library.\n\n@docs indexBy, groupBy, frequency, getWithDefault\n\n",
        "unions": [],
        "aliases": [],
        "values": [
            {
                "name": "frequency",
                "comment": " Create a frequency-map from the given list.\n",
                "type": "List comparable -> Dict comparable Int"
            },
            {
                "name": "getWithDefault",
                "comment": " Attempt to find a key, if it's not there, return a default value.\n",
                "type": "a -> comparable -> Dict comparable a -> a"
            },
            {
                "name": "groupBy",
                "comment": " Group a list of items by a key.\n\n  Supply an indexing function (eg. `.id`) and a list of\n  items. `groupBy` returns a dictionary of group-key/list-of-items.\n\n  If the indexing function returns a unique key for every item, consider `indexBy` instead.\n",
                "type": "(v -> comparable) -> List v -> Dict comparable (List v)"
            },
            {
                "name": "indexBy",
                "comment": " Turn a list of items into an indexed dictionary.\n\n  Supply an indexing function (eg. `.id`) and a list of\n  items. `indexBy` returns a dictionary with each item stored under\n  its index.\n\n  This code assumes each index is unique. If that is not the case, you\n  should use `groupBy` instead.\n",
                "type": "(v -> comparable) -> List v -> Dict comparable v"
            }
        ],
        "binops": []
    },
    {
        "name": "Exts.Effects",
        "comment": " Extensions to the Effects library.\n\n@docs asEffect, noFx\n\n",
        "unions": [],
        "aliases": [],
        "values": [
            {
                "name": "asEffect",
                "comment": " Turn a Task into a Result Effect.\n",
                "type": "Task e a -> Effects (Result e a)"
            },
            {
                "name": "noFx",
                "comment": " Wrap a plain model as a (model, no-effects) pair.\n\nThis is taken from the [Effects Documentation](http://package.elm-lang.org/packages/evancz/elm-effects/1.0.0/Effects),\nwhich rightly suggests it might be useful!\n",
                "type": "m -> ( m, Effects a )"
            }
        ],
        "binops": []
    }
]