README
U
List
- ::newInput::new
- ::consParseError::cons
- ::expectParseError::expect
- ::source_posParseError::source_pos
- ::betweenParser::between
- ::bindParser::bind
- ::charParser::char
- ::curly_bracketParser::curly_bracket
- ::discard_leftParser::discard_left
- ::discard_rightParser::discard_right
- ::discard_spacesParser::discard_spaces
- ::eofParser::eof
- ::foldlParser::foldl
- ::foldl1Parser::foldl1
- ::foldrParser::foldr
- ::foldr1Parser::foldr1
- ::innerParser::inner
- ::labelParser::label
- ::manyParser::many
- ::many_eachParser::many_each
- ::mapParser::map
- ::map_srcposParser::map_srcpos
- ::none_ofParser::none_of
- ::one_ofParser::one_of
- ::orParser::or
- ::pureParser::pure
- ::round_bracketParser::round_bracket
- ::runParser::run
- ::satisfyParser::satisfy
- ::square_bracketParser::square_bracket
- ::stringParser::string
T
SourcePos
V
alphabetic
V
any
V
between
V
bind
V
char
V
curly_bracket
V
digit
V
discard_left
V
discard_right
V
discard_spaces
V
eof
V
expect
V
foldl
V
foldl1
V
foldr
V
foldr1
V
label
V
many
V
many_each
V
map
V
map_srcpos
V
none_of
V
one_of
V
or
V
pure
V
round_bracket
V
run
V
satisfy
V
space
V
space1
V
spaces
V
square_bracket
V
string

simple_parserc

Monadic parser combinators

parser

parser combinator

Download zip

Author

illusory0x0

Version

0.2.1

License

Apache-2.0

Repository

github.com/moonbit-community/simple_parserc

Last updated

last year

Downloads

433

No dependencies

#illusory0x0/simple_parserc

#Primitive combinators

|
- lor or
label

#Monadic combinators

Monad
- bind
- pure
- map
helper function
- map_srcpos
- discard_left
- discard_right

#Folding

foldl
foldl1
foldr
foldr1
many
many_each

#Derivatives of primitive combinators

satisfy
char
one_of
none_of
string
eof

#satisfy helpler function

digit
space
alphabetic
any
space1
spaces

#Surrounding

between
round_bracket
square_bracket
curly_bracket

#Reference

megaparsec

opal

List

source

typealias @moonbitlang/core/list.T
T as List

Input

source

pub(all) struct Input {
  chars : @moonbitlang/core/string.StringView
StringView
  row : Int
  col : Int
}

impl Show for Input

Input::new

source

fn Input::new(chars : @moonbitlang/core/string.StringView
StringView) -> Input

ParseError

source

pub(all) enum ParseError {
  ParseError(SourcePos, @moonbitlang/core/list.T
T[String])
}

impl Show for ParseError

ParseError::cons

source

fn ParseError::cons(self : ParseError, x : String) -> ParseError

ParseError::expect

source

fn ParseError::expect(row~ : Int, col~ : Int, msg : String) -> ParseError

ParseError::source_pos

source

fn ParseError::source_pos(self : ParseError) -> SourcePos

Parser

source

pub(all) type Parser[A] (Input) -> (A, Input) raise ParseError

impl BitOr for Parser[A]

Parser::between

source

fn[A, B, C] Parser::between(self : Parser[A], open~ : Parser[B], close~ : Parser[C]) -> Parser[A]

Parser::bind

source

fn[A, B] Parser::bind(x : Parser[A], f : (A) -> Parser[B]) -> Parser[B]

Parser::char

source

fn Parser::char(ch : Char) -> Parser[Char]

Parser::curly_bracket

source

fn[A] Parser::curly_bracket(self : Parser[A]) -> Parser[A]

Parser::discard_left

source

fn[A, B] Parser::discard_left(x : Parser[A], y : Parser[B]) -> Parser[B]

Parser::discard_right

source

fn[A, B] Parser::discard_right(x : Parser[A], y : Parser[B]) -> Parser[A]

Parser::discard_spaces

source

fn[A] Parser::discard_spaces(self : Parser[A]) -> Parser[A]

Parser::eof

source

fn[A] Parser::eof(x : A) -> Parser[A]

Parser::foldl

source

fn[A, B] Parser::foldl(x : Parser[A], z : Parser[B], f : Parser[(B, A) -> B]) -> Parser[B]

Parser::foldl1

source

fn[A] Parser::foldl1(x : Parser[A], f : Parser[(A, A) -> A]) -> Parser[A]

Parser::foldr

source

fn[A, B] Parser::foldr(x : Parser[A], z : Parser[B], f : Parser[(B, A) -> B]) -> Parser[B]

Parser::foldr1

source

fn[A] Parser::foldr1(x : Parser[A], f : Parser[(A, A) -> A]) -> Parser[A]

Parser::inner

source

fn[A] Parser::inner(self : Parser[A]) -> ((Input) -> (A, Input) raise ParseError)

Convert newtype to its underlying type, automatically derived.

Parser::label

source

fn[A] Parser::label(x : Parser[A], msg : String) -> Parser[A]

Parser::many

source

fn[A] Parser::many(self : Parser[A]) -> Parser[Array[A]]

Parser::many_each

source

fn[A] Parser::many_each(x : Parser[A], f : (A) -> Unit) -> Parser[Unit]

Parser::map

source

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

Parser::map_srcpos

source

fn[A, B] Parser::map_srcpos(self : Parser[A], f : (SourcePos, A) -> B) -> Parser[B]

Parser::none_of

source

fn Parser::none_of(xs : String) -> Parser[Char]

Parser::one_of

source

fn Parser::one_of(xs : String) -> Parser[Char]

Parser::or

source

fn[A] Parser::or(x : Parser[A], y : Parser[A]) -> Parser[A]

Parser::pure

source

fn[A] Parser::pure(x : A) -> Parser[A]

Parser::round_bracket

source

fn[A] Parser::round_bracket(self : Parser[A]) -> Parser[A]

Parser::run

source

fn[A] Parser::run(self : Parser[A], input : Input) -> A raise ParseError

Parser::satisfy

source

fn Parser::satisfy(f : (Char) -> Bool, label~ : String) -> Parser[Char]

Parser::square_bracket

source

fn[A] Parser::square_bracket(self : Parser[A]) -> Parser[A]

Parser::string

source

fn Parser::string(str : String) -> Parser[String]

SourcePos

source

pub(all) struct SourcePos {
  row : Int
  col : Int
}

impl Compare for SourcePos

impl Eq for SourcePos

impl Show for SourcePos

alphabetic

source

let alphabetic : Parser[Char]

any

source

let any : Parser[Char]

between

source

fn[A, B, C] between(self : Parser[A], open~ : Parser[B], close~ : Parser[C]) -> Parser[A]

bind

source

fn[A, B] bind(x : Parser[A], f : (A) -> Parser[B]) -> Parser[B]

char

source

fn char(ch : Char) -> Parser[Char]

curly_bracket

source

fn[A] curly_bracket(self : Parser[A]) -> Parser[A]

digit

source

let digit : Parser[Char]

discard_left

source

fn[A, B] discard_left(x : Parser[A], y : Parser[B]) -> Parser[B]

discard_right

source

fn[A, B] discard_right(x : Parser[A], y : Parser[B]) -> Parser[A]

discard_spaces

source

fn[A] discard_spaces(self : Parser[A]) -> Parser[A]

eof

source

fn[A] eof(x : A) -> Parser[A]

expect

source

fn expect(row~ : Int, col~ : Int, msg : String) -> ParseError

foldl

source

fn[A, B] foldl(x : Parser[A], z : Parser[B], f : Parser[(B, A) -> B]) -> Parser[B]

foldl1

source

fn[A] foldl1(x : Parser[A], f : Parser[(A, A) -> A]) -> Parser[A]

foldr

source

fn[A, B] foldr(x : Parser[A], z : Parser[B], f : Parser[(B, A) -> B]) -> Parser[B]

foldr1

source

fn[A] foldr1(x : Parser[A], f : Parser[(A, A) -> A]) -> Parser[A]

label

source

fn[A] label(x : Parser[A], msg : String) -> Parser[A]

many

source

fn[A] many(self : Parser[A]) -> Parser[Array[A]]

many_each

source

fn[A] many_each(x : Parser[A], f : (A) -> Unit) -> Parser[Unit]

map

source

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

map_srcpos

source

fn[A, B] map_srcpos(self : Parser[A], f : (SourcePos, A) -> B) -> Parser[B]

none_of

source

fn none_of(xs : String) -> Parser[Char]

one_of

source

fn one_of(xs : String) -> Parser[Char]

or

source

fn[A] or(x : Parser[A], y : Parser[A]) -> Parser[A]

pure

source

fn[A] pure(x : A) -> Parser[A]

round_bracket

source

fn[A] round_bracket(self : Parser[A]) -> Parser[A]

run

source

fn[A] run(self : Parser[A], input : Input) -> A raise ParseError

satisfy

source

fn satisfy(f : (Char) -> Bool, label~ : String) -> Parser[Char]

space

source

let space : Parser[Char]

space1

source

let space1 : Parser[Char]

spaces

source

let spaces : Parser[Char]

square_bracket

source

fn[A] square_bracket(self : Parser[A]) -> Parser[A]

string

source

fn string(str : String) -> Parser[String]

Source Files

Site source Report issue Packages Build queue Skills Statistics

simple_parserc

#illusory0x0/simple_parserc

#Primitive combinators

#Monadic combinators

#Folding

#Derivatives of primitive combinators

#satisfy helpler function

#Surrounding

#Reference

#List

#Input

#Input::new

#ParseError

#ParseError::cons

#ParseError::expect

#ParseError::source_pos

#Parser

#Parser::between

#Parser::bind

#Parser::char

#Parser::curly_bracket

#Parser::discard_left

#Parser::discard_right

#Parser::discard_spaces

#Parser::eof

#Parser::foldl

#Parser::foldl1

#Parser::foldr

#Parser::foldr1

#Parser::inner

#Parser::label

#Parser::many

#Parser::many_each

#Parser::map

#Parser::map_srcpos

#Parser::none_of

#Parser::one_of

#Parser::or

#Parser::pure

#Parser::round_bracket

#Parser::run

#Parser::satisfy

#Parser::square_bracket

#Parser::string

#SourcePos

#alphabetic

#any

#between

#bind

#char

#curly_bracket

#digit

#discard_left

#discard_right

#discard_spaces

#eof

#expect

#foldl

#foldl1

#foldr

#foldr1

#label

#many

#many_each

#map

#map_srcpos

#none_of

#one_of

#or

#pure

#round_bracket

#run

#satisfy

#space

#space1

#spaces

#square_bracket

#string

Source Files

List

Input

Input::new

ParseError

ParseError::cons

ParseError::expect

ParseError::source_pos

Parser

Parser::between

Parser::bind

Parser::char

Parser::curly_bracket

Parser::discard_left

Parser::discard_right

Parser::discard_spaces

Parser::eof

Parser::foldl

Parser::foldl1

Parser::foldr

Parser::foldr1

Parser::inner

Parser::label

Parser::many

Parser::many_each

Parser::map

Parser::map_srcpos

Parser::none_of

Parser::one_of

Parser::or

Parser::pure

Parser::round_bracket

Parser::run

Parser::satisfy

Parser::square_bracket

Parser::string

SourcePos

alphabetic

any

between

bind

char

curly_bracket

digit

discard_left

discard_right

discard_spaces

eof

expect

foldl

foldl1

foldr

foldr1

label

many

many_each

map

map_srcpos

none_of

one_of

or

pure

round_bracket

run

satisfy

space

space1

spaces

square_bracket

string