[
    {
        "name": "Console",
        "comment": "\n\nA library for writing terminal-based scripts in elm.  The IO type\nprovides an interface for constructing \"computations\" that may perform\nIO effects. Something with type `IO a` is a lazy computation that when\nrun will produce an `a`, possibly IO side effects. See Console.Runner for\nhow to run such a computation.\n\n# IO Type\n@docs IO, run\n\n# Stdout\n@docs putChar, putStr, putStrLn\n\n# Stdin\n@docs getChar, getLine, readUntil\n\n# File Operations\n@docs writeFile\n\n# Exit code\n@docs exit\n\n# Plumbing\n@docs map, mapIO, forEach, pure, apply,\n      (<*>), andThen, (>>=), seq, (>>>), forever",
        "unions": [],
        "aliases": [
            {
                "name": "IO",
                "comment": "An `IO a` is a computation that does some I/O and eventually\n    returns an `a`",
                "args": [
                    "a"
                ],
                "type": "IO a"
            }
        ],
        "values": [
            {
                "name": "andThen",
                "comment": "Chain together IO computations",
                "type": "IO a -> (a -> IO b) -> IO b"
            },
            {
                "name": "apply",
                "comment": "Apply an IO function to an IO value",
                "type": "IO (a -> b) -> IO a -> IO b"
            },
            {
                "name": "exit",
                "comment": "Exit the program with the given exit code.",
                "type": "Int -> IO ()"
            },
            {
                "name": "forEach",
                "comment": "Run an IO computation for each element of a list",
                "type": "List a -> (a -> IO ()) -> IO ()"
            },
            {
                "name": "forever",
                "comment": "Run the same computation over and over again forever.",
                "type": "IO a -> IO ()"
            },
            {
                "name": "getChar",
                "comment": "Read a character from stdin",
                "type": "IO Char"
            },
            {
                "name": "getLine",
                "comment": "Read a line from stdin",
                "type": "IO String"
            },
            {
                "name": "map",
                "comment": "Apply a pure function to an IO value",
                "type": "(a -> b) -> IO a -> IO b"
            },
            {
                "name": "mapIO",
                "comment": "Alternative interface to forEach",
                "type": "(a -> IO ()) -> List a -> IO ()"
            },
            {
                "name": "pure",
                "comment": "Use a pure value where an IO computation is expected.",
                "type": "a -> IO a"
            },
            {
                "name": "putChar",
                "comment": "Print a character to stdout",
                "type": "Char -> IO ()"
            },
            {
                "name": "putStr",
                "comment": "Print a string to stdout.",
                "type": "String -> IO ()"
            },
            {
                "name": "putStrLn",
                "comment": "Print a string to stdout, followed by a newline.",
                "type": "String -> IO ()"
            },
            {
                "name": "readUntil",
                "comment": "Read characters from stdin until one matches the given character.",
                "type": "Char -> IO String"
            },
            {
                "name": "run",
                "comment": "Run an IO computation as a Task",
                "type": "IO () -> Signal (Task x ())"
            },
            {
                "name": "seq",
                "comment": "Run one computation and then another, ignoring the first's output",
                "type": "IO a -> IO b -> IO b"
            },
            {
                "name": "writeFile",
                "comment": "Write content to a file",
                "type": "{ file : String, content : String } -> IO ()"
            }
        ],
        "binops": [
            {
                "name": "<*>",
                "comment": "Convenient operator for apply, similar to ~ in the Signal module",
                "type": "IO (a -> b) -> IO a -> IO b",
                "associativity": "left",
                "precedence": 9
            },
            {
                "name": ">>=",
                "comment": "Operator version of andThen",
                "type": "IO a -> (a -> IO b) -> IO b",
                "associativity": "left",
                "precedence": 9
            },
            {
                "name": ">>>",
                "comment": "Operator version of seq",
                "type": "IO a -> IO b -> IO b",
                "associativity": "left",
                "precedence": 9
            }
        ]
    }
]