🥮 mooncakes.io
    Sign in

    talcparsec

    parser
    parsec
    combinator
    pratt
    Download zip
    Author
    Version
    0.1.1
    License
    AGPL-3.0
    Repository
    Last updated
    2 months ago
    Downloads
    7K

    #

    CParser

    source
    type CParser = Parser[Input, Char]

    SParser

    source
    type SParser = Parser[Input, String]

    StringParser

    source
    type StringParser[T] = Parser[Input, T]

    Convenience alias for Parser[Input, T], used for string-input parsers.

    Cursor

    source
    pub(open) trait Cursor {
      fn cursor(Self) -> Int
      fn position(Self) -> Position
      fn is_at_eof(Self) -> Bool
      fn same_cursor(Self, other : Self) -> Bool = _
    }

    Operations shared by parser input cursors. cursor must increase whenever an input element is consumed.

    Input

    source
    pub(all) struct Input {
      source : String
      offset : Int
      line : Int
      column : Int
    } derive(Eq, 
    Debug    )

    Immutable character input cursor. Offsets are UTF-16 code unit offsets, matching MoonBit string indexing.
    impl Cursor for Input

    Input::advance

    source
    fn Input::advance(self : Input, ch : Char) -> Input

    Input::advance_string

    source
    fn Input::advance_string(self : Input, text : String) -> Input

    Input::is_eof

    source
    fn Input::is_eof(self : Input) -> Bool

    Input::new

    source
    fn Input::new(source : String) -> Input

    Input::next

    source
    fn Input::next(self : Input) -> (Char, Input)?

    Input::peek

    source
    fn Input::peek(self : Input) -> Char?

    Input::remaining

    source
    fn Input::remaining(self : Input) -> StringView

    ParseError

    source
    pub(all) struct ParseError {
      offset : Int
      line : Int
      column : Int
      expected : Array[String]
      message : String
      committed : Bool
    } derive(Eq, 
    Debug    )

    Parse failure metadata. committed prevents alternatives from backtracking across input that has already been consumed.

    ParseError::column

    source
    fn ParseError::column(self : ParseError) -> Int

    ParseError::expected

    source
    fn ParseError::expected(self : ParseError) -> Array[String]

    ParseError::is_committed

    source
    fn ParseError::is_committed(self : ParseError) -> Bool

    ParseError::line

    source
    fn ParseError::line(self : ParseError) -> Int

    ParseError::merge

    source
    fn ParseError::merge(self : ParseError, other : ParseError) -> ParseError

    ParseError::message

    source
    fn[I : Cursor] ParseError::message(input : I, message : String) -> ParseError

    ParseError::message_text

    source
    fn ParseError::message_text(self : ParseError) -> String

    ParseError::new

    source
    fn[I : Cursor] ParseError::new(input : I, expected : String) -> ParseError

    ParseError::offset

    source
    fn ParseError::offset(self : ParseError) -> Int

    ParseError::reject_if_committed

    source
    fn[I, T] ParseError::reject_if_committed(self : ParseError, value : T, rest : I) -> Result[(T, I), ParseError]

    ParseError::to_string

    source
    fn ParseError::to_string(self : ParseError) -> String

    ParseError::with_commit

    source
    fn ParseError::with_commit(self : ParseError) -> ParseError

    ParseError::without_commit

    source
    fn ParseError::without_commit(self : ParseError) -> ParseError

    Parser

    source
    pub(all) struct Parser[I, T] {
      parse_fn : (I) -> Result[(T, I), ParseError]
    }

    Parser::after

    source
    fn[I : Cursor, T, L] Parser::after(self : Parser[I, T], left : Parser[I, L]) -> Parser[I, T]

    Runs left then self, returning self's result.

    Parameters:

    • self : The parser whose result is returned.
    • left : The parser whose result is discarded.

    Equivalent to left *> self.

    Parser::attempt

    source
    fn[I, T] Parser::attempt(self : Parser[I, T]) -> Parser[I, T]

    Strips the committed flag from any error.

    Parameters:

    • self : The parser to wrap.

    Enables backtracking across input consumed by self. Use sparingly — prefer grammars where alternatives are distinguishable without backtracking.

    Parser::before

    source
    fn[I : Cursor, T, R] Parser::before(self : Parser[I, T], right : Parser[I, R]) -> Parser[I, T]

    Runs self then right, returning self's result.

    Parameters:

    • self : The parser whose result is returned.
    • right : The parser whose result is discarded.

    Equivalent to self <* right.

    Parser::between

    source
    fn[I : Cursor, T, L, R] Parser::between(self : Parser[I, T], left : Parser[I, L], right : Parser[I, R]) -> Parser[I, T]

    Runs left, then self, then right, returning self's result.

    Parameters:

    • self : The middle parser whose result is returned.
    • left : The opening parser; its result is discarded.
    • right : The closing parser; its result is discarded.

    Equivalent to left.then(self).skip(right).

    Parser::bind

    source
    fn[I : Cursor, T, U] Parser::bind(self : Parser[I, T], next : (T) -> Parser[I, U]) -> Parser[I, U]

    Monadic bind. Runs self, passes the result to next.

    Parameters:

    • self : The first parser to run.
    • next : A function that takes the result of self and returns the next parser to run.

    If self consumed input, any error from next is marked committed, preventing backtracking across consumed input.

    Returns a parser that runs self, then feeds its result to next.

    Parser::label

    source
    fn[I : Cursor, T] Parser::label(self : Parser[I, T], expected : String) -> Parser[I, T]

    Replaces the expected label in the error if self fails without having advanced the cursor.

    Parameters:

    • self : The parser to label.
    • expected : The label to report on failure.

    If input was consumed before failure, the original error is preserved (furthest position wins).

    Parser::lexeme

    source
    fn[T] Parser::lexeme(self : Parser[Input, T]) -> Parser[Input, T]

    Wraps self as a lexeme by skipping trailing whitespace.

    Parameters:

    • self : The parser to wrap.

    Only valid for Input-based parsers.

    Returns a parser that runs self then skips whitespace.

    Parser::many

    source
    fn[I : Cursor, T] Parser::many(self : Parser[I, T]) -> Parser[I, Array[T]]

    Zero or more repetitions of self.

    Parameters:

    • self : The parser to repeat.

    Stops on non-committed failure. Rejects parsers that accept empty input (infinite loop guard).

    Returns an array of accumulated results.

    Parser::many_until

    source
    fn[I : Cursor, T, U] Parser::many_until(self : Parser[I, T], terminator : Parser[I, U]) -> Parser[I, Array[T]]

    Keeps running self until terminator succeeds.

    Parameters:

    • self : The body parser to repeat.
    • terminator : The terminator parser. It is consumed but its result is not included in the output.

    If self fails with a non-committed error, accumulated values are returned. Committed errors from self propagate immediately.

    Returns an array of results from self.

    Parser::map

    source
    fn[I : Cursor, T, U] Parser::map(self : Parser[I, T], f : (T) -> U) -> Parser[I, U]

    Transforms the result of a successful parse using f.

    Parameters:

    • self : The parser whose result to transform.
    • f : The transformation function.

    Returns a parser that parses the same input as self and applies f to the result on success.

    Parser::new

    source
    fn[I, T] Parser::new(parse_fn : (I) -> Result[(T, I), ParseError]) -> Parser[I, T]

    Parser::not_followed_by

    source
    fn[I : Cursor, T] Parser::not_followed_by(self : Parser[I, T], label : String) -> Parser[I, Unit]

    Negative lookahead. Succeeds with () (consuming no input) when self fails.

    Parameters:

    • self : The parser to check for absence.
    • label : The label for error messages when self succeeds.

    When self succeeds, fails with an uncommitted error "unexpected {label}".

    Parser::optional

    source
    fn[I, T] Parser::optional(self : Parser[I, T]) -> Parser[I, T?]

    Runs self and returns Some(result) on success.

    Parameters:

    • self : The parser to try.

    Returns None on non-committed failure. Committed failures propagate immediately.

    Parser::or

    source
    fn[I, T] Parser::or(self : Parser[I, T], other : Parser[I, T]) -> Parser[I, T]

    Choice with commit-aware backtracking.

    Parameters:

    • self : The first alternative.
    • other : The second alternative, tried if self fails without committing.

    If self fails with committed error, other is NOT tried. Errors are merged by furthest position.

    Returns the result of the first successful alternative.

    Parser::parse

    source
    fn[I : Cursor, T] Parser::parse(self : Parser[I, T], input : I) -> Result[T, ParseError]

    Parser::parse_partial

    source
    fn[I, T] Parser::parse_partial(self : Parser[I, T], input : I) -> Result[(T, I), ParseError]

    Parser::run

    source
    fn[I, T] Parser::run(self : Parser[I, T], input : I) -> Result[(T, I), ParseError]

    Parser::sep_by

    source
    fn[I : Cursor, T, S] Parser::sep_by(self : Parser[I, T], sep : Parser[I, S]) -> Parser[I, Array[T]]

    Zero or more repetitions of self separated by sep.

    Parameters:

    • self : The value parser.
    • sep : The separator parser; its result is discarded.

    Returns empty array on no match.

    Parser::sep_by1

    source
    fn[I : Cursor, T, S] Parser::sep_by1(self : Parser[I, T], separator : Parser[I, S]) -> Parser[I, Array[T]]

    One or more repetitions of self separated by separator.

    Parameters:

    • self : The value parser.
    • separator : The separator parser; its result is discarded.

    Requires at least one match of self.

    Returns an array of value results.

    Parser::skip

    source
    fn[I : Cursor, T, U] Parser::skip(self : Parser[I, T], next : Parser[I, U]) -> Parser[I, T]

    Runs self then next, returning self's result.

    Parameters:

    • self : The first parser; its result is returned.
    • next : The second parser; its result is discarded.

    Equivalent to self <* next.

    Parser::some

    source
    fn[I : Cursor, T] Parser::some(self : Parser[I, T]) -> Parser[I, Array[T]]

    One or more repetitions of self.

    Parameters:

    • self : The parser to repeat. Must match at least once.

    Implemented as self followed by self.many().

    Returns an array of accumulated results.

    Parser::string_map

    source
    fn[U] Parser::string_map(self : Parser[Input, Char], f : (String) -> U) -> Parser[Input, U]

    Maps a char parser's result to a String before applying f.

    Parameters:

    • self : A parser that yields a single Char.
    • f : A function from String to the desired result type.

    Returns a parser that yields the result of f applied to the string representation of the matched character.

    Parser::then

    source
    fn[I : Cursor, T, U] Parser::then(self : Parser[I, T], next : Parser[I, U]) -> Parser[I, U]

    Runs self then next, discarding self's result.

    Parameters:

    • self : The first parser; its result is discarded.
    • next : The second parser; its result is returned.

    Equivalent to self >> next.

    Position

    source
    pub(all) struct Position {
      offset : Int
      line : Int
      column : Int
    } derive(Eq, 
    Debug    )

    A source position reported by parser diagnostics.

    array_cons

    source
    fn[T] array_cons(tail : Array[T], head : T) -> Array[T]

    ascii_digit

    source
    fn ascii_digit() -> Parser[Input, Char]

    ascii_letter

    source
    fn ascii_letter() -> Parser[Input, Char]

    between

    source
    fn[I : Cursor, T, L, R] between(left : Parser[I, L], parser : Parser[I, T], right : Parser[I, R]) -> Parser[I, T]

    Standalone version of Parser::between.

    Parameters:

    • left : The opening parser; its result is discarded.
    • parser : The middle parser whose result is returned.
    • right : The closing parser; its result is discarded.

    char

    source
    fn char(expected : Char) -> Parser[Input, Char]

    choice

    source
    fn[I : Cursor, T] choice(parsers : Array[Parser[I, T]]) -> Parser[I, T]

    Tries each parser in the array in order on the same input.

    Parameters:

    • parsers : The array of alternative parsers.

    Returns the first success. Merges errors from all failures (furthest position wins). Aborts immediately on committed errors.

    delay

    source
    fn[I, T] delay(thunk : () -> Parser[I, T]) -> Parser[I, T]

    eof

    source
    fn[I : Cursor] eof() -> Parser[I, Unit]

    fail

    source
    fn[I : Cursor, T] fail(expected : String) -> Parser[I, T]

    lexeme

    source
    fn[T] lexeme(parser : Parser[Input, T]) -> Parser[Input, T]

    Standalone version of Parser::lexeme.

    Parameters:

    • parser : The parser to wrap.

    Returns a parser that runs parser then skips trailing whitespace.

    line_content

    source
    let line_content : Parser[Input, String]

    many_chars

    source
    fn many_chars(parser : Parser[Input, Char]) -> Parser[Input, String]

    Zero or more repetitions of a char parser, collecting results into a String.

    Parameters:

    • parser : A char parser to repeat.

    Unlike take_while, succeeds on zero matches (returns empty string). Stops on non-committed failure.

    Returns a parser that yields the collected characters as a String.

    many_chars1

    source
    fn many_chars1(parser : Parser[Input, Char]) -> Parser[Input, String]

    One or more repetitions of a char parser, collecting results into a String.

    Parameters:

    • parser : A char parser to repeat. Must match at least once.

    Fails on zero matches. Returns a parser that yields the collected characters as a String.

    newline

    source
    let newline : Parser[Input, Char]

    none_of

    source
    fn none_of(chars : String) -> Parser[Input, Char]

    not_newline

    source
    let not_newline : Parser[Input, Char]

    one_of

    source
    fn one_of(chars : String) -> Parser[Input, Char]

    pure

    source
    fn[I, T] pure(value : T) -> Parser[I, T]

    rest_of_line

    source
    let rest_of_line : Parser[Input, String]

    satisfy

    source
    fn satisfy(name : String, predicate : (Char) -> Bool) -> Parser[Input, Char]

    satisfy_input

    source
    fn[I : Cursor, T] satisfy_input(next : (I) -> (T, I)?, name : String, predicate : (T) -> Bool) -> Parser[I, T]

    space

    source
    let space : Parser[Input, Char]

    spaces

    source
    fn spaces() -> Parser[Input, Array[Char]]

    string

    source
    fn string(expected : String) -> Parser[Input, String]

    symbol

    source
    fn symbol(text : String) -> Parser[Input, String]

    Matches an exact string, then skips trailing whitespace.

    Parameters:

    • text : The string to match.

    Returns a parser that matches text followed by optional whitespace.

    take_while

    source
    fn take_while(name : String, predicate : (Char) -> Bool) -> Parser[Input, String]

    whitespace

    source
    fn whitespace() -> Parser[Input, Char]

    with_line

    source
    fn with_line(String) -> Parser[Input, String]

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io