[
    {
        "name": "IO.Infix",
        "comment": "Infix notation for `IO`\n@docs (<$>), (>>=), (<*>), (<+>)\n",
        "unions": [],
        "aliases": [],
        "values": [],
        "binops": [
            {
                "name": "<$>",
                "comment": "Infix notation for `IO.map`",
                "type": "IO model a -> (a -> b) -> IO model b",
                "associativity": "left",
                "precedence": 9
            },
            {
                "name": "<*>",
                "comment": "Infix notation for `IO.ap`",
                "type": "IO model (a -> b) -> IO model a -> IO model b",
                "associativity": "left",
                "precedence": 9
            },
            {
                "name": "<+>",
                "comment": "Infix notation for `IO.combine`",
                "type": "IO model a -> IO model a -> IO model a",
                "associativity": "left",
                "precedence": 9
            },
            {
                "name": ">>=",
                "comment": "Infix notation for `IO.bind`",
                "type": "IO model a -> (a -> IO model b) -> IO model b",
                "associativity": "left",
                "precedence": 9
            }
        ]
    },
    {
        "name": "IO",
        "comment": "This module provides a monadic interface for The Elm Architecture.\n\nBasically `IO` is a monad enabing two kinds of effects :\n- model modification (it is a state monad)\n- `Cmd` commands\n@docs IO\n\n# Runing an **Elm** application with `IO`\nThis module port the four main way of running an **Elm** application to `IO`.\n@docs Program, program, vDomProgram, programWithFlags, vDomProgramWithFlags\n\n# Lifting values and commands into `IO`\n@docs pure, lift, liftM, none\n\n# The model as a state\n@docs get, set, modify\n\n# Classic monadic operations\n@docs map, bind, join, ap, traverse, mapM\n\n# Passing from a model to another\n@docs lens, select\n\n# Transform IO into regular **Elm**\n@docs transform, transformWithFlags\n\n# Unsafe operations (You've been warned!)\n@docs batch, combine\n",
        "unions": [
            {
                "name": "IO",
                "comment": "Monadic interface for The Elm Architecture.\n\nA value of type `IO m a` is an effectful\ncomputation that can modify the model `m`,\nperform commands and contains values of type `a`.\n",
                "args": [
                    "model",
                    "a"
                ],
                "cases": []
            }
        ],
        "aliases": [
            {
                "name": "Program",
                "comment": "Program using `IO`.",
                "args": [
                    "flags",
                    "model",
                    "msg"
                ],
                "type": "Program flags model (IO model msg)"
            }
        ],
        "values": [
            {
                "name": "ap",
                "comment": "Transform an `IO` containing functions into functions on `IO`\nIt enable to easily lift functions to `IO`.\n\n*Laws*\n- ap (pure identity) = identity\n- ap (pure (f >> g)) = ap (pure f) >> ap (pure g)\n",
                "type": "IO model (a -> b) -> IO model a -> IO model b"
            },
            {
                "name": "batch",
                "comment": "Combine a list of `IO`. Its use is strongly discouraged!\nUse `mapM` instead!\n",
                "type": "List (IO model a) -> IO model a"
            },
            {
                "name": "bind",
                "comment": "Chains `IO`s.\n\nIf you have an `IO model a` and a function which given\na `a` can give you an `IO model b` depending on the value\nof type `a` given to the function. Then `bind` gives you\nan `IO model b` that will run the first `IO` and then apply\nthe function.\n\n*Laws*\n- bind pure = identity\n- bind (f >> pure) = map f\n- (bind f) >> (bind g) = bind (a -> bind g (f a))\n",
                "type": "(a -> IO model b) -> IO model a -> IO model b"
            },
            {
                "name": "combine",
                "comment": "Combine two `IO`. Its use is strongly discouraged!\nUse `mapM` instead!\n",
                "type": "IO model a -> IO model a -> IO model a"
            },
            {
                "name": "get",
                "comment": "An `IO` that returns the current model",
                "type": "IO model model"
            },
            {
                "name": "join",
                "comment": "Flatten an `IO` containing an `IO` into a simple `IO`.\n*Laws*\n- join (pure m) = m\n",
                "type": "IO model (IO model a) -> IO model a"
            },
            {
                "name": "lens",
                "comment": "Congruence by a `Lens` on an `IO`.\n\nIt would be silly to force users to redefine every `IO`\nfor each application model. Lenses enable to lift an `IO`\naction on a model `a` to the same `IO` but action on a\nmodel `b`.\n\nYou can then define your `IO` on the minimal model and\nlift them to you real application's model when needed.\n",
                "type": "Lens a b -> IO a msg -> IO b msg"
            },
            {
                "name": "lift",
                "comment": "Lift a `Cmd` as an  `IO`",
                "type": "Cmd a -> IO model a"
            },
            {
                "name": "liftM",
                "comment": "Lift a `CmdM` as an `IO`",
                "type": "CmdM a -> IO model a"
            },
            {
                "name": "map",
                "comment": "Map a function over an `IO`.\n*Laws*\n- map (f >> g) = (map f) >> (map g)\n- map identity = identity\n",
                "type": "(a -> b) -> IO model a -> IO model b"
            },
            {
                "name": "mapM",
                "comment": "Transform a list of `IO` into an `IO` of list.",
                "type": "List (IO model a) -> IO model (List a)"
            },
            {
                "name": "modify",
                "comment": "A `IO` that modify the model",
                "type": "(model -> model) -> IO model ()"
            },
            {
                "name": "none",
                "comment": "An `IO` doing nothing (an containing no values!) ",
                "type": "IO model a"
            },
            {
                "name": "program",
                "comment": "Port of Platform.program with `IO`.",
                "type": "{ init : ( model, IO model msg ), update : msg -> IO model msg, subscriptions : model -> Sub (IO model msg) } -> Program Never model msg"
            },
            {
                "name": "programWithFlags",
                "comment": "Port of Platform.programWithFlags with `IO`.",
                "type": "{ init : flags -> ( model, IO model msg ), update : msg -> IO model msg, subscriptions : model -> Sub (IO model msg) } -> Program flags model msg"
            },
            {
                "name": "pure",
                "comment": "Returns an `IO` whose only effect is containing the value given to `pure`.",
                "type": "a -> IO model a"
            },
            {
                "name": "select",
                "comment": "Congruence by a `Select` on an `IO`.\nJust like lenses but with `Select`\n",
                "type": "Select a b -> IO a msg -> IO b msg"
            },
            {
                "name": "set",
                "comment": "An `IO` that sets the model",
                "type": "model -> IO model ()"
            },
            {
                "name": "transform",
                "comment": "Transform a program using `IO` into a normal program.",
                "type": "{ y | init : ( model, IO model msg ), update : msg -> IO model msg } -> { y | init : ( model, Cmd (IO model msg) ), update : IO model msg -> model -> ( model, Cmd (IO model msg) ) }"
            },
            {
                "name": "transformWithFlags",
                "comment": "Transform a program using `IO` into a normal program.",
                "type": "{ y | init : flags -> ( model, IO model msg ), update : msg -> IO model msg } -> { y | init : flags -> ( model, Cmd (IO model msg) ), update : IO model msg -> model -> ( model, Cmd (IO model msg) ) }"
            },
            {
                "name": "traverse",
                "comment": "You can think of traverse like a `map` but with effects.\nIt maps a function performing `IO` effects over a list.\n",
                "type": "(a -> IO model b) -> List a -> IO model (List b)"
            },
            {
                "name": "vDomProgram",
                "comment": "Port of VirtualDom.program with `IO` (also works with HTML).",
                "type": "{ init : ( model, IO model msg ), update : msg -> IO model msg, subscriptions : model -> Sub (IO model msg), view : model -> Node (IO model msg) } -> Program Never model msg"
            },
            {
                "name": "vDomProgramWithFlags",
                "comment": "Port of VirtualDom.programWithFlags with `IO` (also works with HTML).",
                "type": "{ init : flags -> ( model, IO model msg ), update : msg -> IO model msg, subscriptions : model -> Sub (IO model msg), view : model -> Node (IO model msg) } -> Program flags model msg"
            }
        ],
        "binops": []
    },
    {
        "name": "Select.Infix",
        "comment": "Infix notation for `Select`\n@docs (<°>)\n",
        "unions": [],
        "aliases": [],
        "values": [],
        "binops": [
            {
                "name": "<°>",
                "comment": "Infix notation for `Select.compose`",
                "type": "Select a b -> Select b c -> Select a c",
                "associativity": "left",
                "precedence": 9
            }
        ]
    },
    {
        "name": "Select",
        "comment": " Selects are a lot like lenses but in a select\nfrom type `a` to `b`, the `a` part may not exist\nin `b`.\n\n@docs Select, lift, nothing, compose, congruence\n",
        "unions": [],
        "aliases": [
            {
                "name": "Select",
                "comment": " The type of a slects ",
                "args": [
                    "a",
                    "b"
                ],
                "type": "b -> Maybe ( a, a -> b )"
            }
        ],
        "values": [
            {
                "name": "compose",
                "comment": " Compose two selects ",
                "type": "Select a b -> Select b c -> Select a c"
            },
            {
                "name": "congruence",
                "comment": " If you have a lens from `a` to `b` and a function on `a`\nthen you get a function on `b`.\n",
                "type": "Select a b -> (a -> a) -> b -> b"
            },
            {
                "name": "lift",
                "comment": " Build a lens from an equivalence between types `a` and `b` ",
                "type": "Lens a b -> Select a b"
            },
            {
                "name": "nothing",
                "comment": " A select that always fails |",
                "type": "Select a b"
            }
        ],
        "binops": []
    },
    {
        "name": "Lens.Infix",
        "comment": "Infix notation for `Lens`\n@docs (<°>)\n",
        "unions": [],
        "aliases": [],
        "values": [],
        "binops": [
            {
                "name": "<°>",
                "comment": "Infix notation for `Lens.compose`",
                "type": "Lens a b -> Lens b c -> Lens a c",
                "associativity": "left",
                "precedence": 9
            }
        ]
    },
    {
        "name": "CmdM.Infix",
        "comment": "Infix notation for `CmdM`\n@docs (<$>), (>>=), (<*>), (<+>)\n",
        "unions": [],
        "aliases": [],
        "values": [],
        "binops": [
            {
                "name": "<$>",
                "comment": "Infix notation for `CmdM.map`",
                "type": "CmdM a -> (a -> b) -> CmdM b",
                "associativity": "left",
                "precedence": 9
            },
            {
                "name": "<*>",
                "comment": "Infix notation for `CmdM.ap`",
                "type": "CmdM (a -> b) -> CmdM a -> CmdM b",
                "associativity": "left",
                "precedence": 9
            },
            {
                "name": "<+>",
                "comment": "Infix notation for `CmdM.combine`",
                "type": "CmdM a -> CmdM a -> CmdM a",
                "associativity": "left",
                "precedence": 9
            },
            {
                "name": ">>=",
                "comment": "Infix notation for `CmdM.bind`",
                "type": "CmdM a -> (a -> CmdM b) -> CmdM b",
                "associativity": "left",
                "precedence": 9
            }
        ]
    },
    {
        "name": "Lens",
        "comment": " Imagine the type `a = {name: String, age : Int}`.\nIf you want to access the `age` part of this type\nor modify only the `age` this is simple you would use\n**Elm** syntax like `x.age` or `{x | age = 7 }` to ease\nthe process.\n\nNow imagine that the `a` is much much more complex, like\na record whose fields are also records and so on for 10 levels.\n**Elm** does not have buitin syntax to ease this case. That's\nwhere lenses comes in.\n\nA lens is like zooming on a part of a type, enabling to access\nor modify this part with ease. It is strongly related to Huet's\nzipper.\n\nTake the a lens of type `Lens a b`. It enable to access the `a`\npart of `b` and modify it simply. The benefits of lenses is they\ncompose naturally.\n\n@docs Lens, lift, compose, congruence\n",
        "unions": [],
        "aliases": [
            {
                "name": "Lens",
                "comment": " The type of a lens ",
                "args": [
                    "a",
                    "b"
                ],
                "type": "b -> ( a, a -> b )"
            }
        ],
        "values": [
            {
                "name": "compose",
                "comment": " Compose two lenses ",
                "type": "Lens a b -> Lens b c -> Lens a c"
            },
            {
                "name": "congruence",
                "comment": " If you have a lens from `a` to `b` and a function on `a`\nthen you get a function on `b`.\n",
                "type": "Lens a b -> (a -> a) -> b -> b"
            },
            {
                "name": "lift",
                "comment": " Build a lens from an equivalence between types `a` and `b` ",
                "type": "(a -> b) -> (b -> a) -> Lens a b"
            }
        ],
        "binops": []
    },
    {
        "name": "CmdM",
        "comment": "This module provides a monadic interface for commands.\n\nBasically `CmdM` is like `Cmd` but is a monad, which means\nyou can chain effects as you like!\n@docs CmdM\n\n# Runing an **Elm** application with `CmdM`\nThis module port the four main way of running an **Elm** application to `CmdM`.\n@docs Program, program, vDomProgram, programWithFlags, vDomProgramWithFlags\n\n# Lifting values and commands into `CmdM`\n@docs pure, lift, none\n\n# Classic monadic operations\n@docs map, bind, join, ap, traverse, mapM\n\n# Transform IO into regular **Elm**\n@docs transform, transformWithFlags\n\n# Folding\nIf you need to convert `CmdM` to something else,\nthis is the way.\n@docs fold, lazyFold\n\n# Unsafe operations (You've been warned!)\n@docs batch, combine\n",
        "unions": [
            {
                "name": "CmdM",
                "comment": " Monadic interface for commands.\n\nA value of type `CmdM a` is an effectful\ncomputation that can perform commands and\ncontains values of type `a`.\n",
                "args": [
                    "msg"
                ],
                "cases": []
            }
        ],
        "aliases": [
            {
                "name": "Program",
                "comment": "Program using `IO`.",
                "args": [
                    "flags",
                    "model",
                    "msg"
                ],
                "type": "Program flags model (CmdM msg)"
            }
        ],
        "values": [
            {
                "name": "ap",
                "comment": "Transform a `CmdM` containing functions into functions on `CmdM`\nIt enable to easily lift functions to `CmdM`.\n\n*Laws*\n- ap (pure identity) = identity\n- ap (pure (f >> g)) = ap (pure f) >> ap (pure g)\n",
                "type": "CmdM (a -> b) -> CmdM a -> CmdM b"
            },
            {
                "name": "batch",
                "comment": " Group commands in a batch. Its behavior may not be what you expect!\n    I strongly discourage you from using it. Use `mapM` instead.\n",
                "type": "List (CmdM a) -> CmdM a"
            },
            {
                "name": "bind",
                "comment": "Chains `CmdM`s.\n\nIf you have a `CmdM a` and a function which given\na `a` can give you a `CmdM b` depending on the value\nof type `a` given to the function. Then `bind` gives you\na `CmdM b` that will run the first `CmdM` and then apply\nthe function.\n\n*Laws*\n- bind pure = identity\n- bind (f >> pure) = map f\n- (bind f) >> (bind g) = bind (a -> bind g (f a))\n",
                "type": "(a -> CmdM b) -> CmdM a -> CmdM b"
            },
            {
                "name": "combine",
                "comment": " Group commands in a batch. Its behavior may not be what you expect!\n    I strongly discourage you from using it. Use `mapM` instead.\n",
                "type": "CmdM a -> CmdM a -> CmdM a"
            },
            {
                "name": "fold",
                "comment": " Catamorphism for CmdM. Strict version.",
                "type": "(a -> r) -> (Cmd r -> r) -> CmdM a -> r"
            },
            {
                "name": "join",
                "comment": "Flatten a `CmdM` containing a `CmdM` into a simple `CmdM`.\n*Laws*\n- join (pure m) = m\n",
                "type": "CmdM (CmdM a) -> CmdM a"
            },
            {
                "name": "lazyFold",
                "comment": " Catamorphism for CmdM. Lazy version.",
                "type": "(a -> r) -> ((() -> Cmd r) -> r) -> CmdM a -> r"
            },
            {
                "name": "lift",
                "comment": " Transforms an **Elm** command into a monadic command `CmdM`.",
                "type": "Cmd a -> CmdM a"
            },
            {
                "name": "map",
                "comment": "Map a function over an `CmdM`.\n*Laws*\n- map (f >> g) = (map f) >> (map g)\n- map identity = identity\n",
                "type": "(a -> b) -> CmdM a -> CmdM b"
            },
            {
                "name": "mapM",
                "comment": "Transform a list of `CmdM` into an `CmdM` of list.",
                "type": "List (CmdM a) -> CmdM (List a)"
            },
            {
                "name": "none",
                "comment": "A `CmdM` doing nothing (an containing no values!) ",
                "type": "CmdM a"
            },
            {
                "name": "program",
                "comment": "Port of Platform.program with `IO`.",
                "type": "{ init : ( model, CmdM msg ), update : msg -> model -> ( model, CmdM msg ), subscriptions : model -> Sub (CmdM msg) } -> Program Never model msg"
            },
            {
                "name": "programWithFlags",
                "comment": "Port of Platform.programWithFlags with `CmdM`.",
                "type": "{ init : flags -> ( model, CmdM msg ), update : msg -> model -> ( model, CmdM msg ), subscriptions : model -> Sub (CmdM msg) } -> Program flags model msg"
            },
            {
                "name": "pure",
                "comment": "Returns a `CmdM` whose only effect is containing the value given to `pure`.",
                "type": "a -> CmdM a"
            },
            {
                "name": "transform",
                "comment": "Transform a program using `IO` into a normal program.",
                "type": "{ y | init : ( model, CmdM msg ), update : msg -> model -> ( model, CmdM msg ) } -> { y | init : ( model, Cmd (CmdM msg) ), update : CmdM msg -> model -> ( model, Cmd (CmdM msg) ) }"
            },
            {
                "name": "transformWithFlags",
                "comment": "Transform a program using `CmdM` into a normal program.",
                "type": "{ y | init : flags -> ( model, CmdM msg ), update : msg -> model -> ( model, CmdM msg ) } -> { y | init : flags -> ( model, Cmd (CmdM msg) ), update : CmdM msg -> model -> ( model, Cmd (CmdM msg) ) }"
            },
            {
                "name": "traverse",
                "comment": "You can think of traverse like a `map` but with effects.\nIt maps a function performing `CmdM` effects over a list.\n",
                "type": "(a -> CmdM b) -> List a -> CmdM (List b)"
            },
            {
                "name": "vDomProgram",
                "comment": "Port of VirtualDom.program with `CmdM` (also works with HTML).",
                "type": "{ init : ( model, CmdM msg ), update : msg -> model -> ( model, CmdM msg ), subscriptions : model -> Sub (CmdM msg), view : model -> Node (CmdM msg) } -> Program Never model msg"
            },
            {
                "name": "vDomProgramWithFlags",
                "comment": "Port of VirtualDom.programWithFlags with `CmdM` (also works with HTML).",
                "type": "{ init : flags -> ( model, CmdM msg ), update : msg -> model -> ( model, CmdM msg ), subscriptions : model -> Sub (CmdM msg), view : model -> Node (CmdM msg) } -> Program flags model msg"
            }
        ],
        "binops": []
    }
]