[{"name":"Parser","comment":" Intuitive and easy to use parser library.\n\n\n# Basic usage\n\n@docs Parser, Error, parse, into, take, drop\n\n\n# Matching characters\n\n@docs anyChar, char, charNoCase, digit, digits, letter, letters, lowercase, uppercase, alphanumeric, space, spaces\n\n\n# Text operations\n\n@docs text, textNoCase, textOf, line\n\n\n# List operations\n\n@docs sequence, concat, oneOf, maybe, zeroOrOne, zeroOrMore, oneOrMore, repeat, atLeast, atMost, between, until, while\n\n\n# Chaining\n\n@docs succeed, fail, end, andThen, andThen2, orElse, withError\n\n\n# Mapping\n\n@docs map, map2, map3, map4, map5, mapList\n\n","unions":[],"aliases":[{"name":"Error","comment":" Contains the description of an error.\nThis includes an error message, the position, and the context stack.\n","args":[],"type":"{ message : String.String, input : String.String, row : Basics.Int, col : Basics.Int, context : List.List Parser.Context }"},{"name":"Parser","comment":" A `Parser` is defined as a function that takes an input state,\nincluding an input text, and returns either an [`Error`](#Error),\nor a value with the next state.\n","args":["a"],"type":"Parser.State -> Result.Result Parser.Error ( a, Parser.State )"}],"values":[{"name":"alphanumeric","comment":" Matches a letter or digit character.\nThis is case insensitive.\n\n> ℹ️ Equivalent regular expression: `[a-zA-Z0-9]`\n\n    parse \"abc\" alphanumeric --> Ok 'a'\n\n    parse \"ABC\" alphanumeric --> Ok 'A'\n\n    parse \"123\" alphanumeric --> Ok '1'\n\n    alphanumeric\n        |> parse \"_abc\"\n        |> Result.mapError .message\n    --> Err \"expected a letter or digit [a-zA-Z0-9], but got '_' instead\"\n\n","type":"Parser.Parser Char.Char"},{"name":"andThen","comment":" Parse one value `andThen` do something with that value,\nwhich results in another parser.\n\nThis can be used to validate the last thing we parsed,\nor transform the last value,\nor to use the last value for the next parser like a backreference.\n\n    textOf (oneOrMore anyChar)\n        |> andThen\n            (\\chars ->\n                case String.toInt chars of\n                    Just n -> succeed n\n                    Nothing -> fail \"better use Parser.Common.int\"\n            )\n        |> parse \"123\"\n    --> Ok 123\n\n    textOf (oneOrMore anyChar)\n        |> andThen\n            (\\chars ->\n                case String.toInt chars of\n                    Just n -> succeed n\n                    Nothing -> fail \"better use Parser.Common.int\"\n            )\n        |> parse \"abc\"\n        |> Result.mapError .message\n    --> Err \"better use Parser.Common.int\"\n\n","type":"(a -> Parser.Parser b) -> Parser.Parser a -> Parser.State -> Result.Result Parser.Error ( b, Parser.State )"},{"name":"andThen2","comment":" Parse two values `andThen2` do something with those values,\nwhich results in another parser.\n\nThis can be used to validate the last things we parsed,\nor transform the last values,\nor to ignore eiher of the values,\nor to use the last values for the next parser like a backreference.\n\n    andThen2\n        (\\_ chars ->\n            case String.toInt chars of\n                Just n -> succeed n\n                Nothing -> fail \"failed to parse a number\"\n        )\n        (char '=')\n        digits\n        |> parse \"=123\"\n    --> Ok 123\n\n    andThen2\n        (\\_ chars ->\n            case String.toInt chars of\n                Just n -> succeed n\n                Nothing -> fail \"failed to parse a number\"\n        )\n        (char '=')\n        digits\n        |> parse \"_123\"\n        |> Result.mapError .message\n    --> Err \"expected the character '=', but got '_' instead\"\n\n","type":"(a -> b -> Parser.Parser c) -> Parser.Parser a -> Parser.Parser b -> Parser.Parser c"},{"name":"anyChar","comment":" Matches any single character.\n\n> ℹ️ Equivalent regular expression: `.`\n\n    parse \"abc\" anyChar --> Ok 'a'\n\n    anyChar\n        |> parse \"\"\n        |> Result.mapError .message\n    --> Err \"expected a character, but reached the end of the input text\"\n\n","type":"Parser.State -> Result.Result Parser.Error ( Char.Char, Parser.State )"},{"name":"atLeast","comment":" Parses a value at least a number of times and returns them as a `List`.\n\n> ℹ️ Equivalent regular expression: `{min,}`\n\n    parse \"abcdef\" (atLeast 3 letter) --> Ok [ 'a', 'b', 'c', 'd', 'e', 'f' ]\n\n    atLeast 3 letter\n        |> parse \"ab_def\"\n        |> Result.mapError .message\n    --> Err \"expected a letter [a-zA-Z], but got '_' instead\"\n\n","type":"Basics.Int -> Parser.Parser a -> Parser.Parser (List.List a)"},{"name":"atMost","comment":" Parses a value at most a number of times and returns them as a `List`.\n\n> ℹ️ Equivalent regular expression: `{0,max}`\n\n    parse \"abcdef\" (atMost 3 letter) --> Ok [ 'a', 'b', 'c' ]\n\n    parse \"ab_def\" (atMost 3 letter) --> Ok [ 'a', 'b' ]\n\n    parse \"_bcdef\" (atMost 3 letter) --> Ok []\n\n","type":"Basics.Int -> Parser.Parser a -> Parser.Parser (List.List a)"},{"name":"between","comment":" Parses a value between a range of times and returns them as a `List`.\n\n> ℹ️ Equivalent regular expression: `{min,max}`\n\n    parse \"abcdef\" (between 2 3 letter) --> Ok [ 'a', 'b', 'c' ]\n\n    parse \"ab_def\" (between 2 3 letter) --> Ok [ 'a', 'b' ]\n\n    between 2 3 letter\n        |> parse \"a_cdef\"\n        |> Result.mapError .message\n    --> Err \"expected a letter [a-zA-Z], but got '_' instead\"\n\n","type":"Basics.Int -> Basics.Int -> Parser.Parser a -> Parser.Parser (List.List a)"},{"name":"char","comment":" Matches a specific single character.\nThis is case sensitive.\n\n    parse \"abc\" (char 'a') --> Ok 'a'\n\n    char 'a'\n        |> parse \"ABC\"\n        |> Result.mapError .message\n    --> Err \"expected the character 'a', but got 'A' instead\"\n\n","type":"Char.Char -> Parser.Parser Char.Char"},{"name":"charNoCase","comment":" Matches a specific single character.\nThis is case insensitive.\n\n    parse \"abc\" (charNoCase 'a') --> Ok 'a'\n\n    parse \"ABC\" (charNoCase 'a') --> Ok 'A'\n\n    charNoCase 'a'\n        |> parse \"123\"\n        |> Result.mapError .message\n    --> Err \"expected the character 'a' or 'A', but got '1' instead\"\n\n","type":"Char.Char -> Parser.Parser Char.Char"},{"name":"concat","comment":" Concatenates the parsed values from all the parsers into a single list with\nall the values.\n\n    concat\n        [ oneOrMore digit       -- [ '3' ]\n        , zeroOrOne (char '.')  -- [ '.' ]\n        , zeroOrMore digit      -- [ '1', '4' ]\n        ]\n        |> parse \"3.14\"\n    --> Ok [ '3', '.', '1', '4' ]\n\n","type":"List.List (Parser.Parser (List.List a)) -> Parser.Parser (List.List a)"},{"name":"digit","comment":" Matches a digit character.\n\n> ℹ️ Equivalent regular expression: `[0-9]` or `\\d`\n\n    parse \"123\" digit --> Ok '1'\n\n    digit\n        |> parse \"abc\"\n        |> Result.mapError .message\n    --> Err \"expected a digit [0-9], but got 'a' instead\"\n\n","type":"Parser.Parser Char.Char"},{"name":"digits","comment":" Matches one or more digit.\n\n> ℹ️ Equivalent regular expression: `[0-9]+` or `\\d+`\n\n    parse \"123abc\" digits --> Ok \"123\"\n\n    digits\n        |> parse \"abc123\"\n        |> Result.mapError .message\n    --> Err \"expected a digit [0-9], but got 'a' instead\"\n\n","type":"Parser.Parser String.String"},{"name":"drop","comment":" Ignores a parsed value, but it still must match to continue.\n","type":"Parser.Parser a -> Parser.Parser b -> Parser.Parser b"},{"name":"end","comment":" Succeeds only if there are no more remaining characters in the input text.\n\n> ℹ️ Equivalent regular expression: `$`\n\n    letters\n        |> end\n        |> parse \"abc\"\n    --> Ok \"abc\"\n\n    letters\n        |> end\n        |> parse \"abc123\"\n        |> Result.mapError .message\n    --> Err \"expected the end of the input text, but 3 characters are still remaining\"\n\n","type":"Parser.Parser a -> Parser.State -> Result.Result Parser.Error ( a, Parser.State )"},{"name":"fail","comment":" A parser that always fails with the given error message.\n\n    fail \"something went wrong :(\"\n        |> parse \"\"\n        |> Result.mapError .message\n    --> Err \"something went wrong :(\"\n\n","type":"String.String -> Parser.State -> Result.Result Parser.Error ( a, Parser.State )"},{"name":"into","comment":" Starts a parsing pipeline to parse into a data type.\n\nYou should also specify a name for the context,\nthis helps to give better error messages.\n\n    import Parser.Common exposing (number)\n\n    type alias Point =\n        { x : Float\n        , y : Float\n        }\n\n    point : Parser Point\n    point =\n        into \"Point\"\n            (succeed Point\n                |> drop (char '(')\n                |> take number\n                |> drop (char ',')\n                |> take number\n                |> drop (char ')')\n            )\n\n    parse \"(12,34)\" point --> Ok {x = 12, y = 34}\n\n","type":"String.String -> Parser.Parser a -> Parser.State -> Result.Result Parser.Error ( a, Parser.State )"},{"name":"letter","comment":" Matches a letter character.\nThis is case insensitive.\n\n> ℹ️ Equivalent regular expression: `[a-zA-Z]`\n\n    parse \"abc\" letter --> Ok 'a'\n\n    parse \"ABC\" letter --> Ok 'A'\n\n    letter\n        |> parse \"123\"\n        |> Result.mapError .message\n    --> Err \"expected a letter [a-zA-Z], but got '1' instead\"\n\n","type":"Parser.Parser Char.Char"},{"name":"letters","comment":" Matches one or more letter.\nThis is case insensitive.\n\n> ℹ️ Equivalent regular expression: `[a-zA-Z]+`\n\n    parse \"abc123\" letters --> Ok \"abc\"\n\n    parse \"ABC123\" letters --> Ok \"ABC\"\n\n    letters\n        |> parse \"123abc\"\n        |> Result.mapError .message\n    --> Err \"expected a letter [a-zA-Z], but got '1' instead\"\n\n","type":"Parser.Parser String.String"},{"name":"line","comment":" Gets a line from the input text, delimited by '\\\\n'.\n\n    parse \"abc\\ndef\" line --> Ok \"abc\"\n\n","type":"Parser.Parser String.String"},{"name":"lowercase","comment":" Matches a lowercase letter character.\nThis is case sensitive.\n\n> ℹ️ Equivalent regular expression: `[a-z]`\n\n    parse \"abc\" lowercase --> Ok 'a'\n\n    lowercase\n        |> parse \"ABC\"\n        |> Result.mapError .message\n    --> Err \"expected a lowercase letter [a-z], but got 'A' instead\"\n\n","type":"Parser.Parser Char.Char"},{"name":"map","comment":" Transform the result of a parser.\n\n    letters\n        |> map String.toLower\n        |> parse \"ABC\"\n    --> Ok \"abc\"\n\n","type":"(a -> b) -> Parser.Parser a -> Parser.Parser b"},{"name":"map2","comment":" Transform the result of two parsers.\n\n    import Parser.Common exposing (int)\n\n    map2\n        (\\op x ->\n            if op == '-' then\n                -x\n            else\n                x\n        )\n        (oneOf [char '+', char '-'])\n        int\n        |> parse \"-123\"\n    --> Ok -123\n\n","type":"(a -> b -> c) -> Parser.Parser a -> Parser.Parser b -> Parser.Parser c"},{"name":"map3","comment":" Transform the result of three parsers.\n\n    import Parser.Common exposing (int)\n\n    map3\n        (\\x op y ->\n            if op == '+' then\n                x + y\n            else\n                x - y\n        )\n        int\n        (oneOf [char '+', char '-'])\n        int\n        |> parse \"5+2\"\n    --> Ok 7\n\n","type":"(a -> b -> c -> d) -> Parser.Parser a -> Parser.Parser b -> Parser.Parser c -> Parser.Parser d"},{"name":"map4","comment":" Transform the result of four parsers.\n","type":"(a -> b -> c -> d -> e) -> Parser.Parser a -> Parser.Parser b -> Parser.Parser c -> Parser.Parser d -> Parser.Parser e"},{"name":"map5","comment":" Transform the result of five parsers.\n","type":"(a -> b -> c -> d -> e -> f) -> Parser.Parser a -> Parser.Parser b -> Parser.Parser c -> Parser.Parser d -> Parser.Parser e -> Parser.Parser f"},{"name":"mapList","comment":" Transform the result of a list of parsers.\nNote that all parsers must be of the same type, unlike `map2`..`map5`.\n\n    mapList (String.join \",\")\n        [ text \"ab\"\n        , text \"cd\"\n        , letters\n        ]\n        |> parse \"abcdefg\"\n    --> Ok \"ab,cd,efg\"\n\n","type":"(List.List a -> b) -> List.List (Parser.Parser a) -> Parser.Parser b"},{"name":"maybe","comment":" Parses an optional value and returns it as a `Maybe`.\n\n> ℹ️ Equivalent regular expression: `?`\n\n    parse \"abc\" (maybe letter) --> Ok (Just 'a')\n\n    parse \"_abc\" (maybe letter) --> Ok Nothing\n\n","type":"Parser.Parser a -> Parser.Parser (Maybe.Maybe a)"},{"name":"oneOf","comment":" Returns the value of the first parser that matches.\nIt tries to match the parsers in order.\n\nIf none of the parsers match, it keeps the error message from the last parser.\nTo give a more descriptive error message, you can use [`withError`](#withError).\n\n> ℹ️ Equivalent regular expression: `|`\n\n    oneOf [ char '_', letter ]\n        |> parse \"_abc\"\n    --> Ok '_'\n\n    oneOf [ char '_', letter ]\n        |> parse \"abc\"\n    --> Ok 'a'\n\n    oneOf [ char '_', letter ]\n        |> parse \"123\"\n        |> Result.mapError .message\n    --> Err \"expected a letter [a-zA-Z], but got '1' instead\"\n\n","type":"List.List (Parser.Parser a) -> Parser.Parser a"},{"name":"oneOrMore","comment":" Parses one or more values and returns them as a `List`.\n\n> ℹ️ Equivalent regular expression: `+`\n\n    parse \"abc\" (oneOrMore letter) --> Ok [ 'a', 'b', 'c' ]\n\n    oneOrMore letter\n        |> parse \"_abc\"\n        |> Result.mapError .message\n    --> Err \"expected a letter [a-zA-Z], but got '_' instead\"\n\n","type":"Parser.Parser a -> Parser.Parser (List.List a)"},{"name":"orElse","comment":" If the previous parser failed, try a fallback parser.\n\n    letters\n        |> orElse digits\n        |> parse \"abc\"\n    --> Ok \"abc\"\n\n    letters\n        |> orElse digits\n        |> parse \"123\"\n    --> Ok \"123\"\n\n    letters\n        |> orElse digits\n        |> parse \"_\"\n        |> Result.mapError .message\n    --> Err \"expected a digit [0-9], but got '_' instead\"\n\n","type":"Parser.Parser a -> Parser.Parser a -> Parser.State -> Result.Result Parser.Error ( a, Parser.State )"},{"name":"parse","comment":" Parse an input text, and get either an [`Error`](#Error)\nor the parsed value as a result.\n\n    parse \"abc\" letter --> Ok 'a'\n\n    letter\n        |> parse \"123\"\n        |> Result.mapError .message\n    --> Err \"expected a letter [a-zA-Z], but got '1' instead\"\n\n","type":"String.String -> Parser.Parser a -> Result.Result Parser.Error a"},{"name":"repeat","comment":" Parses a value exactly a number of times and returns them as a `List`.\n\n> ℹ️ Equivalent regular expression: `{n}`\n\n    parse \"abcdef\" (repeat 3 letter) --> Ok [ 'a', 'b', 'c' ]\n\n    repeat 3 letter\n        |> parse \"ab_def\"\n        |> Result.mapError .message\n    --> Err \"expected a letter [a-zA-Z], but got '_' instead\"\n\n","type":"Basics.Int -> Parser.Parser a -> Parser.Parser (List.List a)"},{"name":"sequence","comment":" Matches a sequence of parsers in order, and gets the result as a `List`.\n\n    sequence [ char '_', letter, digit ]\n        |> parse \"_A5\" --> Ok [ '_', 'A', '5' ]\n\n","type":"List.List (Parser.Parser a) -> Parser.State -> Result.Result Parser.Error ( List.List a, Parser.State )"},{"name":"space","comment":" Matches a blank space character.\nA blank space can be a\nregular space `' '`,\ntab `'\\t'`,\nnew line `'\\n'`,\ncarriage return `'\\r'`,\nform feed `'\\f'`,\nor vertical tab `'\\v'`.\n\n> ℹ️ Equivalent regular expression: `[ \\t\\n\\r\\f\\v]` or `\\s`\n\n    parse \"    abc\" space --> Ok ' '\n\n    parse \"\\tabc\" space --> Ok '\\t'\n\n    space\n        |> parse \"abc\"\n        |> Result.mapError .message\n    --> Err \"expected a blank space character, but got 'a' instead\"\n\n","type":"Parser.Parser Char.Char"},{"name":"spaces","comment":" Matches zero or more spaces.\n\n> ℹ️ Equivalent regular expression: `[ \\t\\n\\r\\f\\v]*` or `\\s*`\n\n    parse \"    abc\" spaces --> Ok \"    \"\n\n    parse \"\\tabc\" spaces --> Ok \"\\t\"\n\n    parse \"abc\" spaces --> Ok \"\"\n\n","type":"Parser.Parser String.String"},{"name":"succeed","comment":" A parser that always succeeds with the given value.\n\n    parse \"\" (succeed \"abc\") --> Ok \"abc\"\n\n","type":"a -> Parser.State -> Result.Result Parser.Error ( a, Parser.State )"},{"name":"take","comment":" Takes a parsed value and feeds it to the return value of the parser.\n","type":"Parser.Parser a -> Parser.Parser (a -> b) -> Parser.Parser b"},{"name":"text","comment":" Matches a specific text string.\nThis is case sensitive.\n\n    parse \"abcdef\" (text \"abc\") --> Ok \"abc\"\n\n    text \"abc\"\n        |> parse \"ABCDEF\"\n        |> Result.mapError .message\n    --> Err \"expected the character 'a', but got 'A' instead\"\n\n","type":"String.String -> Parser.Parser String.String"},{"name":"textNoCase","comment":" Matches a specific text string.\nThis is case insensitive.\n\n    parse \"abcdef\" (textNoCase \"abc\") --> Ok \"abc\"\n\n    parse \"ABCDEF\" (textNoCase \"abc\") --> Ok \"ABC\"\n\n    textNoCase \"abc\"\n        |> parse \"123\"\n        |> Result.mapError .message\n    --> Err \"expected the character 'a' or 'A', but got '1' instead\"\n\n","type":"String.String -> Parser.Parser String.String"},{"name":"textOf","comment":" Gets a string from a list of characters.\n\n    textOf (oneOrMore letter) -- letters\n        |> parse \"abc123\" --> Ok \"abc\"\n\n","type":"Parser.Parser (List.List Char.Char) -> Parser.Parser String.String"},{"name":"until","comment":" Parses a values repeatedly until a delimiter parser matches.\nThe delimiter marks the end of the sequence, but is not consumed.\n\nIf the delimiter is not found, it parses until it stops matching\nor until the end of the input text.\n\nThis could be used as a lookahead.\n\n    until (char 'd') letter\n        |> parse \"abcdef\"\n    --> Ok [ 'a', 'b', 'c' ]\n\n    until (char 'd') letter\n        |> parse \"abc123\"\n    --> Ok [ 'a', 'b', 'c' ]\n\n    until (char 'd') letter\n        |> parse \"abc\"\n    --> Ok [ 'a', 'b', 'c' ]\n\n","type":"Parser.Parser stop -> Parser.Parser a -> Parser.Parser (List.List a)"},{"name":"uppercase","comment":" Matches an uppercase letter character.\nThis is case sensitive.\n\n> ℹ️ Equivalent regular expression: `[A-Z]`\n\n    parse \"ABC\" uppercase --> Ok 'A'\n\n    uppercase\n        |> parse \"abc\"\n        |> Result.mapError .message\n    --> Err \"expected an uppercase letter [A-Z], but got 'a' instead\"\n\n","type":"Parser.Parser Char.Char"},{"name":"while","comment":" Parses values while a condition is still `True`.\nOnce the condition is `False`, the sequence stops and the current value is not consumed.\n\nIf the condition never gets to `False`, it parses until it stops matching\nor until the end of the input text.\n\nThe condition function takes two inputs:\na list of all the previously matched values,\nand the current value matched.\n\n    while (\\_ value -> value /= 'd') letter\n        |> parse \"abcdef\"\n    --> Ok [ 'a', 'b', 'c' ]\n\n    while (\\values _ -> List.length values < 3) letter\n        |> parse \"abcdef\"\n    --> Ok [ 'a', 'b', 'c' ]\n\n    while (\\_ value -> value /= 'd') letter\n        |> parse \"abc123\"\n    --> Ok [ 'a', 'b', 'c' ]\n\n    while (\\_ value -> value /= 'd') letter\n        |> parse \"abc\"\n    --> Ok [ 'a', 'b', 'c' ]\n\n","type":"(List.List a -> a -> Basics.Bool) -> Parser.Parser a -> Parser.Parser (List.List a)"},{"name":"withError","comment":" If there is an error, this replaces the error message.\nThis helps create more descriptive error messages instead of the more generic\nones.\n\nIf you want to use the value that failed some validation in the error message,\nconsider using a more relaxed parser and using [`andThen`](#andThen) to do the\nvalidation.\nIt's a little longer, but that way you get access to the potentially invalid\nparsed value.\n\n    letters\n        |> withError \"a name can only consist of letters\"\n        |> parse \"123\"\n        |> Result.mapError .message\n    --> Err \"a name can only consist of letters\"\n\n    -- Alternatively, if you want even better error messages.\n    textOf (oneOrMore anyChar)\n        |> andThen\n            (\\txt ->\n                if String.all Char.isAlpha txt then\n                    succeed txt\n                else\n                    fail\n                        ( \"a name can only consist of letters, got '\"\n                        ++ txt\n                        ++ \"'\"\n                        )\n            )\n        |> parse \"123\"\n        |> Result.mapError .message\n    --> Err \"a name can only consist of letters, got '123'\"\n\n","type":"String.String -> Parser.Parser a -> Parser.State -> Result.Result Parser.Error ( a, Parser.State )"},{"name":"zeroOrMore","comment":" Parses zero or more values and returns them as a `List`.\n\n> ℹ️ Equivalent regular expression: `*`\n\n    parse \"abc\" (zeroOrMore letter) --> Ok [ 'a', 'b', 'c' ]\n\n    parse \"_abc\" (zeroOrMore letter) --> Ok []\n\n","type":"Parser.Parser a -> Parser.Parser (List.List a)"},{"name":"zeroOrOne","comment":" Parses an optional value and returns it as a `List`.\n\n> ℹ️ Equivalent regular expression: `?`\n\n    parse \"abc\" (zeroOrOne letter) --> Ok [ 'a' ]\n\n    parse \"_abc\" (zeroOrOne letter) --> Ok []\n\n","type":"Parser.Parser a -> Parser.Parser (List.List a)"}],"binops":[]},{"name":"Parser.Common","comment":" Common and other useful parsers.\n\n\n# Common\n\n@docs int, number\n\n","unions":[],"aliases":[],"values":[{"name":"int","comment":" Gets an integer value as an `Int`.\n\n    import Parser exposing (parse)\n\n    parse \"123\" int --> Ok 123\n\n    parse \"-123\" int --> Ok -123\n\n    parse \"abc\" int\n        |> Result.mapError .message\n    --> Err \"expected a digit [0-9], but got 'a' instead\"\n\n","type":"Parser.Parser Basics.Int"},{"name":"number","comment":" Gets a decimal value as a `Float`.\n\n    import Parser exposing (parse)\n\n    parse \"12\" number --> Ok 12.0\n\n    parse \"12.\" number --> Ok 12.0\n\n    parse \"12.34\" number --> Ok 12.34\n\n    parse \".12\" number --> Ok 0.12\n\n    parse \"-12.34\" number --> Ok -12.34\n\n    parse \"-.12\" number --> Ok -0.12\n\n    parse \".\" number\n        |> Result.mapError .message\n    --> Err \"expected a digit [0-9], but got '.' instead\"\n\n    parse \"abc\" number\n        |> Result.mapError .message\n    --> Err \"expected a digit [0-9], but got 'a' instead\"\n\n","type":"Parser.Parser Basics.Float"}],"binops":[]}]