🥮 mooncakes.io
README

#ParserC

ParserC is a parser combinator library for Moonbit.

#Usage

Copy from https://github.com/illusory0x0/parserc.mbt

#
Parser

source
pub struct Parser[Token, Value]((Seq[Token]) -> (Value, Seq[Token])?)

A parser combinator

#
Parser::and_then

source
fn[Token, A, B] Parser::and_then(self : Parser[Token, A], other : Parser[Token, B]) -> Parser[Token, (A, B)]

#
Parser::apply

source
fn[Token, A, B] Parser::apply(self : Parser[Token, A], f : Parser[Token, (A) -> B]) -> Parser[Token, B]

#
Parser::between

source
fn[Token, A, B] Parser::between(self : Parser[Token, A], around : Parser[Token, B]) -> Parser[Token, A]

#
Parser::from_ref

source
fn[Token, A] Parser::from_ref(self : 
Ref[Parser[Token, A]]) -> Parser[Token, A]

#
Parser::map

source
fn[Token, A, B] Parser::map(self : Parser[Token, A], f : (A) -> B) -> Parser[Token, B]

#
Parser::new

source
fn[Token, Value] Parser::new(f : (Seq[Token]) -> (Value, Seq[Token])?) -> Parser[Token, Value]

#
Parser::omit_first

source
fn[Token, A, B] Parser::omit_first(parser : Parser[Token, (A, B)]) -> Parser[Token, B]

#
Parser::omit_second

source
fn[Token, A, B] Parser::omit_second(parser : Parser[Token, (A, B)]) -> Parser[Token, A]

#
Parser::optional

source
fn[Token, A] Parser::optional(self : Parser[Token, A]) -> Parser[Token, A?]

#
Parser::or_else

source
fn[Token, A] Parser::or_else(self : Parser[Token, A], other : Parser[Token, A]) -> Parser[Token, A]

#
Parser::or_others

source
fn[Token, A] Parser::or_others(self : Parser[Token, A], others : ArrayView[Parser[Token, A]]) -> Parser[Token, A]

#
Parser::parse

source
#deprecated("use `Parser::run` instead")
fn[Token, Value] Parser::parse(self : Parser[Token, Value], sequence : Seq[Token]) -> (Value, Seq[Token])?

#
Parser::repeat

source
fn[Token, A] Parser::repeat(self : Parser[Token, A]) -> Parser[Token, Array[A]]

#
Parser::repeat_0_to_n

source
fn[Token, A] Parser::repeat_0_to_n(self : Parser[Token, A], n : Int) -> Parser[Token, Array[A]]

#
Parser::repeat_0_to_n_with_sep

source
fn[Token, A, B] Parser::repeat_0_to_n_with_sep(self : Parser[Token, A], n : Int, separator : Parser[Token, B]) -> Parser[Token, Array[A]]

#
Parser::repeat_n

source
fn[Token, A] Parser::repeat_n(self : Parser[Token, A], n : Int) -> Parser[Token, Array[A]]

#
Parser::repeat_n_with_sep

source
fn[Token, A, B] Parser::repeat_n_with_sep(self : Parser[Token, A], n : Int, sep : Parser[Token, B]) -> Parser[Token, Array[A]]

#
Parser::repeat_with_sep

source
fn[Token, A, B] Parser::repeat_with_sep(self : Parser[Token, A], separator : Parser[Token, B]) -> Parser[Token, Array[A]]

#
Parser::run

source
fn[Token, Value] Parser::run(self : Parser[Token, Value], sequence : Seq[Token]) -> (Value, Seq[Token])?

Parses a sequence of tokens

If the parsing succeeds, Some(result, rest) is returned Otherwise, None is returned.

#
Seq

source
pub struct Seq[T](ArrayView[T])

A possibility infinite lazy list
impl Show for Seq[T]
impl Debug for Seq[T]

#
Seq::default

source
fn[T] Seq::default() -> Seq[T]

#
Seq::from_array

source
fn[T] Seq::from_array(array : ArrayView[T]) -> Seq[T]

Construct a sequence from array

#
Seq::from_list

source
fn[T] Seq::from_list(list : 
List[T]) -> Seq[T]

Construct a sequence from list

#
Seq::from_string

source
fn Seq::from_string(str : String) -> Seq[Char]

Construct a sequence from string

#
Seq::is_empty

source
fn[T] Seq::is_empty(self : Seq[T]) -> Bool

Checks if the sequence is empty

#
Seq::length

source
fn[T] Seq::length(self : Seq[T]) -> Int

#
Seq::map

source
fn[T1, T2] Seq::map(seq : Seq[T1], f : (T1) -> T2) -> Seq[T2]

Map the sequence

If the sequence is x0, x1, ... then seq.map(f) is f(x0), f(x1), ...

#
Seq::new

source
fn[T] Seq::new(view : ArrayView[T]) -> Seq[T]

#
Seq::peek_char

source
fn Seq::peek_char(self : Seq[Char], n : Int) -> String?

Look forward n characters

#
Seq::to_array

source
fn[T] Seq::to_array(self : Seq[T]) -> Array[T]

#
Seq::to_iter

source
fn[T] Seq::to_iter(self : Seq[T]) -> Iter[T]

#
Seq::uncons

source
fn[T] Seq::uncons(self : Seq[T]) -> (T, Seq[T])?

Unwrap a sequence

If self is empty, then seq.uncons() is None Else is Some(hd, tl) where hd is the head of the sequence and tl is the tail

#
lift2

source
fn[Token, A, B, C] lift2(f : (A, B) -> C) -> ((Parser[Token, A], Parser[Token, B]) -> Parser[Token, C])

#
one_of

source
fn[A : Show] one_of(array : Array[A]) -> Parser[Char, A]

#
pchar

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

#
pchar_such_that

source
fn pchar_such_that(predicate : (Char) -> Bool) -> Parser[Char, Char]

#
pconst

source
fn[Token, A] pconst(a : A) -> Parser[Token, A]

Parser that always succeed with given value

#
pdigit

source
let pdigit : Parser[Char, Int]

parse digit

%x30-39

#
pfail

source
fn[Token, A] pfail() -> Parser[Token, A]

Parser that always fail

#
pint

source
let pint : Parser[Char, Int]

parser for integer

[ "-" ] ( %x30 / (%x31-39) *(%x30-39)

#
pint64

source
let pint64 : Parser[Char, Int64]

parser for integer 64 bits

[ "-" ] ( %x30 / (%x31-39) *(%x30-39)

#
pstring

source
fn pstring(string : String) -> Parser[Char, String]

parser that tries to match the given string

#
pvalue

source
fn[Token, Value] pvalue(predicate : (Token) -> Value?) -> Parser[Token, Value]

Parses a token with predicate

The predicate should return Some(value) if the tokens fulfills or None otherwise

#
sequence

source
fn[Token, A] sequence(parsers : Array[Parser[Token, A]]) -> Parser[Token, Array[A]]

Source Files

Powered by MoonBit

Site sourceReport issuePackagesBuild queueSkillsStatistics

© 2026 mooncakes.io