[
    {
        "name": "Exts.Tuple",
        "comment": "Extensions for tuples.\n\n@docs indexedPair",
        "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`.",
                "type": "(a -> b) -> a -> ( b, a )"
            }
        ],
        "binops": []
    },
    {
        "name": "Exts.Task",
        "comment": "Extensions for Tasks.\n\n@docs asEffect",
        "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",
        "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",
        "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.",
                "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",
        "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",
        "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 function returns 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",
        "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]]`",
                "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.",
                "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",
        "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.",
                "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",
        "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",
        "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",
        "unions": [],
        "aliases": [
            {
                "name": "CellDef",
                "comment": "A table definition looks something like:\n\n  [(text \"Name\", .name >> text)\n  ,(text \"Name\", .age >> toString >> text)]",
                "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])",
                "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",
        "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",
        "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",
        "unions": [],
        "aliases": [],
        "values": [
            {
                "name": "roundTo",
                "comment": "Round a float to a given number of decimal places.",
                "type": "Int -> Float -> Float"
            }
        ],
        "binops": []
    },
    {
        "name": "Exts.Dict",
        "comment": "Extensions to the core Dict library.\n\n@docs indexBy, groupBy, frequency",
        "unions": [],
        "aliases": [],
        "values": [
            {
                "name": "frequency",
                "comment": "Create a frequency-map from the given list.",
                "type": "List comparable -> Dict comparable Int"
            },
            {
                "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.",
                "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.",
                "type": "(v -> comparable) -> List v -> Dict comparable v"
            }
        ],
        "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",
        "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.Effects",
        "comment": "Extensions to the Effects library.\n\n@docs asEffect, noFx",
        "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!",
                "type": "m -> ( m, Effects a )"
            }
        ],
        "binops": []
    },
    {
        "name": "Exts.Date",
        "comment": "Extensions to the core date library.\n\n@docs toISOString",
        "unions": [],
        "aliases": [],
        "values": [
            {
                "name": "toISOString",
                "comment": "Format a Date as an ISO-standard string.",
                "type": "Date -> String"
            }
        ],
        "binops": []
    }
]