README
U
ChildrenContentSpec
Tr
XMLNode
Tr
XMLVisitor
T
AttDef
T
AttType
T
AttlistDecl
T
ChildrenContentSpecOp
- ::innerContentParticle::inner
T
ContentSpec
T
DTDStatement
T
DefaultDecl
T
DocTypeDecl
T
ElementDecl
T
EntityDecl
T
EntityDef
T
ExternalID
T
GetElementVisitor
T
Location
T
MarkUpDecl
T
Misc
T
NotationDecl
T
NotationDeclID
T
SingleContentParticle
T
XMLChildren
- ::get_element_by_nameXMLDocument::get_element_by_name
- ::get_attributeXMLElement::get_attribute
- ::get_childrenXMLElement::get_children
- ::get_textXMLElement::get_text
T
XMLErrorKind
- ::is_fatalXMLParseError::is_fatal
- ::and_thenXMLParser::and_then
- ::from_refXMLParser::from_ref
- ::innerXMLParser::inner
- ::mapXMLParser::map
- ::newXMLParser::new
- ::omit_firstXMLParser::omit_first
- ::omit_secondXMLParser::omit_second
- ::optionalXMLParser::optional
- ::or_elseXMLParser::or_else
- ::repeat_with_sepXMLParser::repeat_with_sep
- ::runXMLParser::run
- ::mergeXMLParserContext::merge
- ::raise_errorXMLParserContext::raise_error
V
pEntityRef
V
pEntityRef_with_ctx
V
pattribute
V
pattribute_with_ctx
V
pattributes
V
pattributes_with_ctx
V
pcdata
V
pcdata_with_ctx
V
pcharRef
V
pcharRef_with_ctx
V
pcomment
V
pcomment_with_ctx
V
pconst
V
pdtd
V
pdtd_with_ctx
V
pelement
V
pelement_with_ctx
V
pname
V
pname_with_ctx
V
ppi
V
ppiTarget
V
ppi_with_ctx
V
pprolog
V
pprolog_with_ctx
V
preference
V
preference_with_ctx
V
ptext
V
ptext_with_ctx
V
pwhite_space
V
pwhite_space_with_ctx
V
pxml
V
pxml_with_ctx
V
xml_from_iter
V
xml_from_string

#ParserC

ParserC is a parser combinator library for Moonbit.

#Usage

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

Parser

pub type 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::inner

source

fn[Token, Value] Parser::inner(self : Parser[Token, Value]) -> ((Seq[Token]) -> (Value, Seq[Token])?)

Convert newtype to its underlying type, automatically derived.

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

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 type Seq[T] ArrayView[T]

A possibility infinite lazy list

impl Show 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 : @moonbitlang/core/immut/list.T
T[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::inner

source

fn[T] Seq::inner(self : Seq[T]) -> ArrayView[T]

Convert newtype to its underlying type, automatically derived.

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

Site source Report issue Packages Build queue Skills Statistics

#ParserC

#Usage

#Parser

#Parser::and_then

#Parser::apply

#Parser::between

#Parser::from_ref

#Parser::inner

#Parser::map

#Parser::new

#Parser::omit_first

#Parser::omit_second

#Parser::optional

#Parser::or_else

#Parser::or_others

#Parser::parse

#Parser::repeat

#Parser::repeat_0_to_n

#Parser::repeat_0_to_n_with_sep

#Parser::repeat_n

#Parser::repeat_n_with_sep

#Parser::repeat_with_sep

#Parser::run

#Seq

#Seq::default

#Seq::from_array

#Seq::from_list

#Seq::from_string

#Seq::inner

#Seq::is_empty

#Seq::length

#Seq::map

#Seq::new

#Seq::peek_char

#Seq::to_array

#Seq::to_iter

#Seq::uncons

#lift2

#one_of

#pchar

#pchar_such_that

#pconst

#pdigit

#pfail

#pint

#pint64

#pstring

#pvalue

#sequence

Source Files

Parser

Parser::and_then

Parser::apply

Parser::between

Parser::from_ref

Parser::inner

Parser::map

Parser::new

Parser::omit_first

Parser::omit_second

Parser::optional

Parser::or_else

Parser::or_others

Parser::parse

Parser::repeat

Parser::repeat_0_to_n

Parser::repeat_0_to_n_with_sep

Parser::repeat_n

Parser::repeat_n_with_sep

Parser::repeat_with_sep

Parser::run

Seq

Seq::default

Seq::from_array

Seq::from_list

Seq::from_string

Seq::inner

Seq::is_empty

Seq::length

Seq::map

Seq::new

Seq::peek_char

Seq::to_array

Seq::to_iter

Seq::uncons

lift2

one_of

pchar

pchar_such_that

pconst

pdigit

pfail

pint

pint64

pstring

pvalue

sequence