README
- ::and_thenParser::and_then
- ::applyParser::apply
- ::betweenParser::between
- ::from_refParser::from_ref
- ::mapParser::map
- ::newParser::new
- ::omit_firstParser::omit_first
- ::omit_secondParser::omit_second
- ::optionalParser::optional
- ::or_elseParser::or_else
- ::or_othersParser::or_others
- ::parseParser::parse
- ::repeatParser::repeat
- ::repeat_0_to_nParser::repeat_0_to_n
- ::repeat_0_to_n_with_sepParser::repeat_0_to_n_with_sep
- ::repeat_nParser::repeat_n
- ::repeat_n_with_sepParser::repeat_n_with_sep
- ::repeat_with_sepParser::repeat_with_sep
- ::runParser::run
- ::defaultSeq::default
- ::from_arraySeq::from_array
- ::from_listSeq::from_list
- ::from_stringSeq::from_string
- ::is_emptySeq::is_empty
- ::lengthSeq::length
- ::mapSeq::map
- ::newSeq::new
- ::unconsSeq::uncons
V
length
V
lift2
V
one_of
V
pchar
V
pchar_such_that
V
pconst
V
pdigit
V
pfail
V
pint
V
pint64
V
pstring
V
pvalue
V
sequence

parserc

A simple parser combinator

parser

combinator

Download zip

Author

illusory0x0

Version

0.1.5

License

Apache-2.0

Repository

github.com/illusory0x0/parserc.mbt

Last updated

last year

Downloads

No dependencies

#Parser combinator

这是一个从 https://github.com/peter-jerry-ye/moonbit-parser-combinator fork 的项目

A simple parser combinator 简单的语法分析组合子

Support any stream with Seq 利用Seq支持各类流

#Usage 使用方法

test {
  let parser = pstring("Hello").and_then(pint)
  let Some(result, _) = parser.parse(Seq::from_string("Hello1234"))
  inspect(result, content="Hello")
}

Parser

source

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

A parser combinator

Parser::and_then

source

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

Parser::apply

source

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

Parser::between

source

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

Parser::from_ref

source

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

Parser::map

source

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

Parser::new

source

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

Parser::omit_first

source

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

Parser::omit_second

source

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

Parser::optional

source

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

Parser::or_else

source

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

Parser::or_others

source

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

Parser::parse

source

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

Parser::repeat

source

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

Parser::repeat_0_to_n

source

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

Parser::repeat_0_to_n_with_sep

source

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

Parser::repeat_n

source

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

Parser::repeat_n_with_sep

source

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

Parser::repeat_with_sep

source

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

Parser::run

source

fn Parser::run[Token, Value](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] () -> (T, Seq[T])?

A possibility infinite lazy list

impl Show for Seq[T]

Seq::default

source

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

Seq::from_array

source

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

Construct a sequence from array

Seq::from_list

source

fn Seq::from_list[T](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::is_empty

source

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

Checks if the sequence is empty

Seq::length

source

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

Seq::map

source

fn Seq::map[T1, T2](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 Seq::new[T](f : () -> (T, Seq[T])?) -> Seq[T]

Seq::uncons

source

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

Unwrap a sequence

If seq 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

length

source

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

lift2

source

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

one_of

source

fn one_of[A : Show](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 pconst[Token, A](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 pfail[Token, A]() -> 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 pvalue[Token, Value](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 sequence[Token, A](parsers : Array[Parser[Token, A]]) -> Parser[Token, Array[A]]

Source Files

Site source Report issue Packages Build queue Skills Statistics

parserc

#Parser combinator

#Usage 使用方法

#Parser

#Parser::and_then

#Parser::apply

#Parser::between

#Parser::from_ref

#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::is_empty

#Seq::length

#Seq::map

#Seq::new

#Seq::uncons

#length

#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::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::is_empty

Seq::length

Seq::map

Seq::new

Seq::uncons

length

lift2

one_of

pchar

pchar_such_that

pconst

pdigit

pfail

pint

pint64

pstring

pvalue

sequence