walkzzz/astrolabe/core - mooncakes.io

README
U
ParseError
U
ParseHint
U
ParseResult
U
Parser
U
Pos
U
State
V
alt
V
any_char
V
attempt
V
between
V
bind
V
chainl1
V
chainr1
V
char
V
char_class
V
char_range
V
choice
V
commit
V
count
V
count_min_max
V
end_of_input
V
filter
V
fix
V
format_error
V
format_error_with_input
V
label
V
many
V
many1
V
many_till
V
map
V
map_error
V
not_followed_by
V
option
V
palt
V
parse
V
parse_full
V
parse_full_raise
V
parse_raise
V
pbind
V
peek
V
pmap
V
poption
V
pure
V
recover
V
reject
V
satisfy
V
sep_by
V
sep_by1
V
sep_end_by
V
sep_end_by1
V
seq2
V
seq3
V
seq4
V
skip
V
skip_many
V
skip_many1
V
string
V
succeed
V
take
V
take_while
V
take_while1
V
validate
V
with_context
V
with_hint

walkzzz/astrolabe/core does not have a README file

ParseError

pub(all) suberror ParseError {
  ParseError(Pos, Array[String], Bool, Array[String])
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

committed = true — backtracking is suppressed in alt

impl Show for ParseError

ParseError::at

source

fn ParseError::at(pos~ : Pos, expected~ : String) -> ParseError

Convenience factory for the common case: single expected token, no context, uncommitted.

ParseError::commit

source

fn ParseError::commit(self : ParseError) -> ParseError

Return a copy with committed = true, used for sequence-commit semantics.

ParseError::committed

source

fn ParseError::committed(self : ParseError) -> Bool

Return the commitment status.

ParseError::context

source

fn ParseError::context(self : ParseError) -> String

Return the context label (joined with " > ").

ParseError::contexts

source

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

Return the context chain.

ParseError::equal

source

fn ParseError::equal(ParseError, ParseError) -> Bool

ParseError::expected

source

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

Return the list of expected tokens.

ParseError::format

source

fn ParseError::format(self : ParseError) -> String

The context line is omitted when empty.

ParseError::format_with_input

source

fn ParseError::format_with_input(self : ParseError, input : String) -> String

up to 20 characters before and after the error position.

ParseError::merge

source

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

OR the committed flags, and keep the first error's context chain

ParseError::not_equal

source

fn ParseError::not_equal(x : ParseError, y : ParseError) -> Bool

ParseError::output

source

fn ParseError::output(self : ParseError, logger : &Logger) -> Unit

Add the derived to_string from Show.

ParseError::pos

source

fn ParseError::pos(self : ParseError) -> Pos

Return the position where the error occurred.

ParseError::to_repr

source

fn ParseError::to_repr(ParseError) -> @moonbitlang/core/debug.Repr
Repr

ParseError::to_string

source

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

Add the derived to_string from Show.

ParseError::with_context

source

fn ParseError::with_context(self : ParseError, ctx : String) -> ParseError

Return a copy with ctx appended to the context chain.

ParseHint

source

pub extenum ParseHint {
}

Users can add custom variants via extenum ParseHint += { ... }.

ParseHint::heavy

source

fn ParseHint::heavy() -> ParseHint

Convenience factory: Heavy hint.

ParseHint::light

source

fn ParseHint::light() -> ParseHint

Convenience factory: Light hint.

ParseHint::recovery

source

fn ParseHint::recovery() -> ParseHint

Convenience factory: Recovery hint.

ParseResult

source

pub(all) enum ParseResult[T] {
  Success(T, State)
  Failure(ParseError)
}

Failure(error) — failed; error carries position and commitment for alt

Parser

source

pub(all) struct Parser[T] {
  run : (State) -> ParseResult[T]
}

into larger parsers without exposing the internal State machinery.

Parser::of

source

fn[T] Parser::of(f : (State) -> ParseResult[T]) -> Parser[T]

Wrap a raw function into a Parser[T] — the universal extension point.

Parser::parse

source

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

Use parse_full when you need to ensure the entire input is consumed.

Parser::parse_full

source

fn[T] Parser::parse_full(self : Parser[T], input : String) -> Result[T, ParseError]

If the parser succeeds without reaching EOF, returns an Err.

Parser::parse_full_raise

source

fn[T] Parser::parse_full_raise(self : Parser[T], input : String) -> T raise ParseError

Like parse_full, but converts Err to raise for use in try...catch.

Parser::parse_raise

source

fn[T] Parser::parse_raise(self : Parser[T], input : String) -> T raise ParseError

Like parse, but converts Err to raise for use in try...catch.

Parser::run_fn

source

fn[T] Parser::run_fn(self : Parser[T]) -> ((State) -> ParseResult[T])

ParserLike extension point.

Pos

source

pub(all) struct Pos {
  line : Int
  column : Int
  offset : Int
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

offset — 0 起始的字节偏移

Pos::advance

source

fn Pos::advance(self : Pos, ch : Char) -> Pos

Returns a new Pos; the original is not mutated.

Pos::equal

source

fn Pos::equal(Pos, Pos) -> Bool

Pos::initial

source

fn Pos::initial() -> Pos

Create the initial position (line 1, column 1, offset 0).

Pos::not_equal

source

fn Pos::not_equal(x : Pos, y : Pos) -> Bool

Pos::to_repr

source

fn Pos::to_repr(Pos) -> @moonbitlang/core/debug.Repr
Repr

State

source

pub(all) struct State {
  input : String
  offset : Int
  pos : Pos
} derive(@moonbitlang/core/debug.Debug
Debug)

pos — 当前可读位置（行、列、偏移）

State::advance_by

source

fn State::advance_by(self : State, n : Int) -> Unit

Caller must ensure n <= remaining().

State::advance_one

source

fn State::advance_one(self : State) -> Unit

No-op when already at EOF.

State::is_eof

source

fn State::is_eof(self : State) -> Bool

True when the cursor has reached or passed the end of input.

State::new

source

fn State::new(input : String) -> State

Create a fresh State positioned at the start of input.

State::peek

source

fn State::peek(self : State) -> Char?

Returns Some(ch) if not at EOF, None otherwise.

State::remaining

source

fn State::remaining(self : State) -> Int

Number of characters remaining from the current offset to end-of-input.

State::slice

source

fn State::slice(self : State, start : Int, end : Int) -> String

Does not modify the cursor. Used internally to read matched input.

State::to_repr

source

fn State::to_repr(State) -> @moonbitlang/core/debug.Repr
Repr

palt

source

fn[A] palt(run1 : (State) -> ParseResult[A], run2 : (State) -> ParseResult[A]) -> Parser[A]

both branches fail (same semantics as alt).

pbind

source

fn[A, B] pbind(run : (State) -> ParseResult[A], f : (A) -> Parser[B]) -> Parser[B]

committed.

pmap

source

fn[A, B] pmap(run : (State) -> ParseResult[A], f : (A) -> B) -> Parser[B]

extension. Returns a concrete Parser[B]; failure semantics match map.

poption

source

fn[A] poption(run : (State) -> ParseResult[A], default : A) -> Parser[A]

option).

Source Files

Install

Download zip

Position-aware parser combinators for MoonBit — inspired by OCaml Angstrom

parsercombinatorparseposition-awareangstrom

walkzzz

MIT

github.com/walkzzz/astrolabe.git

Updated 14 hours ago

52 downloads

#ParseError

#ParseError::at

#ParseError::commit

#ParseError::committed

#ParseError::context

#ParseError::contexts

#ParseError::equal

#ParseError::expected

#ParseError::format

#ParseError::format_with_input

#ParseError::merge

#ParseError::not_equal

#ParseError::output

#ParseError::pos

#ParseError::to_repr

#ParseError::to_string

#ParseError::with_context

#ParseHint

#ParseHint::heavy

#ParseHint::light

#ParseHint::recovery

#ParseResult

#Parser

#Parser::of

#Parser::parse

#Parser::parse_full

#Parser::parse_full_raise

#Parser::parse_raise

#Parser::run_fn

#Pos

#Pos::advance

#Pos::equal

#Pos::initial

#Pos::not_equal

#Pos::to_repr

#State

#State::advance_by

#State::advance_one

#State::is_eof

#State::new

#State::peek

#State::remaining

#State::slice

#State::to_repr

#palt

#pbind

#pmap

#poption

Source Files

ParseError

ParseError::at

ParseError::commit

ParseError::committed

ParseError::context

ParseError::contexts

ParseError::equal

ParseError::expected

ParseError::format

ParseError::format_with_input

ParseError::merge

ParseError::not_equal

ParseError::output

ParseError::pos

ParseError::to_repr

ParseError::to_string

ParseError::with_context

ParseHint

ParseHint::heavy

ParseHint::light

ParseHint::recovery

ParseResult

Parser

Parser::of

Parser::parse

Parser::parse_full

Parser::parse_full_raise

Parser::parse_raise

Parser::run_fn

Pos

Pos::advance

Pos::equal

Pos::initial

Pos::not_equal

Pos::to_repr

State

State::advance_by

State::advance_one

State::is_eof

State::new

State::peek

State::remaining

State::slice

State::to_repr

palt

pbind

pmap

poption