[
    {
        "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. ",
                "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. ",
                "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. ",
                "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, resultWithDefault, mappend\n",
        "unions": [],
        "aliases": [],
        "values": [
            {
                "name": "bimap",
                "comment": " Treat Result as a bifunctor. ",
                "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. ",
                "type": "Result a b -> Bool"
            },
            {
                "name": "mappend",
                "comment": " Monoidal append - join two Results together as though they were one. ",
                "type": "Result e a -> Result e b -> Result e ( a, b )"
            },
            {
                "name": "resultWithDefault",
                "comment": " Like Maybe.withDefault, for Results.",
                "type": "b -> Result a b -> 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. ",
                "type": "List (Maybe a) -> List a"
            },
            {
                "name": "isJust",
                "comment": " Boolean checks. ",
                "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. ",
                "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. ",
                "type": "b -> (a -> b) -> Maybe a -> b"
            }
        ],
        "binops": []
    },
    {
        "name": "Exts.List",
        "comment": " Extensions to the core List library.\n\n@docs chunk, mergeBy, singleton\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": "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. ",
                "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. ",
                "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\n",
        "unions": [],
        "aliases": [],
        "values": [
            {
                "name": "set",
                "comment": " Encode a set to a JSON array . ",
                "type": "(comparable -> Value) -> Set comparable -> Value"
            }
        ],
        "binops": []
    },
    {
        "name": "Exts.Http",
        "comment": " Extensions to the main Http library.\n\n@docs promoteError, put, postForm\n",
        "unions": [],
        "aliases": [],
        "values": [
            {
                "name": "postForm",
                "comment": " Send a POST request with appropriate headers form-encoding. ",
                "type": "Decoder value -> String -> Body -> Task Error value"
            },
            {
                "name": "promoteError",
                "comment": " Convert an Http.RawError into an Error, using the same rules Http uses internally. ",
                "type": "RawError -> Error"
            },
            {
                "name": "put",
                "comment": " Send a simple PUT request. ",
                "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 rendered as a table. The definition a list of (column-title, column-value-accessor) pairs.\n\n  I find this approach brakes down for all but simple tables, so be\n  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. ",
                "type": "TableDef a -> List a -> Html"
            },
            {
                "name": "simpleTableRow",
                "comment": " Given a table definition, render an element to a <tr> tag. This is lower-level. Usually you will want `simpleTable` instead. ",
                "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. ",
                "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. ",
                "args": [],
                "cases": [
                    [
                        "SixteenByNine",
                        []
                    ],
                    [
                        "FourByThree",
                        []
                    ]
                ]
            }
        ],
        "aliases": [],
        "values": [
            {
                "name": "container",
                "comment": " Bootstrap grid container. ",
                "type": "List Html -> Html"
            },
            {
                "name": "containerFluid",
                "comment": " Bootstrap grid fluid container. ",
                "type": "List Html -> Html"
            },
            {
                "name": "empty",
                "comment": " The minimum markup - an empty span. ",
                "type": "Html"
            },
            {
                "name": "glyphicon",
                "comment": " Glyphicons. Supply the unprefixed glyph name (eg. 'zoom-in'). ",
                "type": "String -> Html"
            },
            {
                "name": "popover",
                "comment": " Interface to the bootstrap popover that does not require bootstrap.js. ",
                "type": "PopoverDirection -> Bool -> List ( String, String ) -> Maybe String -> List Html -> Html"
            },
            {
                "name": "row",
                "comment": " Bootstrap grid row. ",
                "type": "List Html -> Html"
            },
            {
                "name": "twoColumns",
                "comment": " Two evenly-sized columns. Must be used within a row. ",
                "type": "List Html -> List Html -> Html"
            },
            {
                "name": "video",
                "comment": " Embed a responsive video. ",
                "type": "Ratio -> String -> Html"
            }
        ],
        "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. ",
                "type": "Int -> Float -> Float"
            }
        ],
        "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. ",
                "type": "Date -> String"
            }
        ],
        "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. ",
                "args": [
                    "a"
                ],
                "type": "{ entering : List a, continuing : List a, leaving : List a }"
            }
        ],
        "values": [
            {
                "name": "empty",
                "comment": " A default starting state for Deltas. ",
                "type": "Delta a"
            },
            {
                "name": "generation",
                "comment": " Update the delta by inspecting a list of players. ",
                "type": "List a -> Delta a -> Delta a"
            }
        ],
        "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. ",
                "type": "List comparable -> Dict comparable Int"
            },
            {
                "name": "getWithDefault",
                "comment": " Attempt to find a key, if it's not there, return a default value. ",
                "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. ",
                "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": []
    }
]