String

Parse a Str using a Parser.

color : Parser(Utf8, [Red, Green, Blue])
color = {
    one_of(
        [
            Parser.const(Red).skip(string("red")),
            Parser.const(Green).skip(string("green")),
            Parser.const(Blue).skip(string("blue")),
        ]
    )
}

expect parse_str(color, "green") == Ok(Green)

Runs a parser against the start of a string, allowing the parser to consume it only partially.

- If the parser succeeds, returns the resulting value as well as the leftover input. - If the parser fails, returns Err (ParsingFailure msg)

at_sign : Parser(Utf8, [AtSign])
at_sign = Parser.const(AtSign).skip(codeunit('@'))

expect parse_str(at_sign, "@") == Ok(AtSign)
expect at_sign->parse_str_partial("@").map_ok(|r| { r.val }) == Ok(AtSign)
expect at_sign->parse_str_partial("$").is_err()

Runs a parser against a string, requiring the parser to consume it fully.

- If the parser succeeds, returns Ok a - If the parser fails, returns Err (ParsingFailure Str) - If the parser succeeds but does not consume the full string, returns Err (ParsingIncomplete (List U8))

Runs a parser against the start of a list of scalars, allowing the parser to consume it only partially.

Match one UTF-8 code unit when it satisfies the given predicate.

is_digit : U8 -> Bool
is_digit = |b| { b >= '0' and b <= '9' }

expect codeunit_satisfies->parse_str(is_digit, "0") == Ok('0')
expect codeunit_satisfies->parse_str(is_digit, "*").is_err()

Match one exact UTF-8 code unit.

at_sign : Parser(Utf8, [AtSign])
at_sign = Parser.const(AtSign).skip(codeunit('@'))

expect at_sign->parse_str("@") == Ok(AtSign)
expect at_sign->parse_str_partial("$").is_err()

Parse an exact sequence of utf8

Parse the given Str

expect string("Foo")->parse_str("Foo") == Ok("Foo")
expect string("Foo")->parse_str("Bar").is_err()

Matches any U8 codeunit

expect parse_str(any_codeunit, "a") == Ok('a')
expect parse_str(any_codeunit, "$") == Ok('$')

Matches any Utf8 and consumes all the input without fail.

expect {
    bytes = "consumes all the input".to_utf8()
    any_thing.parse(bytes, List.is_empty) == Ok(bytes)
}

Match all remaining input as a Str, failing if the bytes are not valid UTF-8.

Parse one ASCII decimal digit into a U64 from 0 through 9.

expect digit->parse_str("0") == Ok(0)
expect digit->parse_str("not a digit").is_err()

Parse a sequence of digits into a U64, accepting leading zeroes

expect digits->parse_str("0123") == Ok(123)
expect digits->parse_str("not a digit").is_err()

Try a bunch of different parsers.

The first parser which is tried is the one at the front of the list, and the next one is tried until one succeeds or the end of the list was reached.

bool_parser : Parser(Utf8, Bool)
bool_parser = {
    one_of([string("true"), string("false")])
    .map(|x| { x == "true" })
}

expect bool_parser->parse_str("true") == Ok(Bool.True)
expect bool_parser->parse_str("false") == Ok(Bool.False)
expect bool_parser->parse_str("not a bool").is_err()

Convert known-valid UTF-8 bytes to a Str. Crashes if the bytes are invalid UTF-8.

Convert one ASCII byte to a Str. Crashes if the byte is not valid as a single-byte UTF-8 scalar.