ramble

Types

FinalParseResult

pub type FinalParseResult(t, a) {
  FinalParseResult(
    value: Result(a, ParseError(t)),
    errors: List(ParseError(t)),
  )
}

Constructors

FinalParseResult(
  value: Result(a, ParseError(t)),
  errors: List(ParseError(t)),
)

ParseError

pub type ParseError(t) {
  Unexpected(
    pos: Position,
    token: Token(t),
    expected: List(Token(t)),
  )
}

Constructors

Unexpected(
  pos: Position,
  token: Token(t),
  expected: List(Token(t)),
)

ParseResult

pub type ParseResult(t, a) {
  ParseResult(
    value: Result(a, ParseError(t)),
    rest: List(t),
    new_pos: Position,
    errors: List(ParseError(t)),
  )
}

Constructors

ParseResult(
  value: Result(a, ParseError(t)),
  rest: List(t),
  new_pos: Position,
  errors: List(ParseError(t)),
)

Parser

The parser type, parameterized by the type it parses and the user-defined error type it can return.

pub type Parser(t, a) {
  Parser(
    parse: fn(
      List(t),
      Position,
      ParserConfig(t),
      Option(Parser(t, t)),
    ) ->
      ParseResult(t, a),
  )
}

Constructors

Parser(
  parse: fn(
    List(t),
    Position,
    ParserConfig(t),
    Option(Parser(t, t)),
  ) ->
    ParseResult(t, a),
)

ParserConfig

pub type ParserConfig(t) {
  ParserConfig(
    newline: t,
    eof: t,
    source_name: String,
    token_to_string: fn(t) -> String,
  )
}

Constructors

ParserConfig(
  newline: t,
  eof: t,
  source_name: String,
  token_to_string: fn(t) -> String,
)

Token

pub type Token(t) {
  Token(t)
  LabeledToken(String)
}

Constructors

```
Token(t)
```
```
LabeledToken(String)
```

Functions

an_token

pub fn an_token(c: String) -> Parser(String, String)

any_token

pub fn any_token() -> Parser(a, a)

char_in_range

pub fn char_in_range(
  from from: Int,
  until to: Int,
) -> Parser(String, String)

choice

pub fn choice(ps: List(Parser(a, b))) -> Parser(a, b)

Parse with the first parser in the list that doesn’t fail.

consume_and_discard_until

pub fn consume_and_discard_until(
  p: Parser(a, a),
) -> Parser(a, Nil)

desperate_custom_parser

pub fn desperate_custom_parser(
  parse: fn(
    List(a),
    Position,
    ParserConfig(a),
    Option(Parser(a, a)),
  ) -> ParseResult(a, b),
) -> Parser(a, b)

This grants full control over parsing by allowing a custom parse function. This is like making the Parser type not-opaque. Use this with caution, and be sure to mind the invariants of the library. It should be very rare that you need to use this.

digit

pub fn digit() -> Parser(String, String)

Parse a digit.

do_and_recover

pub fn do_and_recover(
  p: Parser(a, b),
  recovery: Parser(a, a),
) -> Parser(a, b)

either

pub fn either(p1: Parser(a, b), p2: Parser(a, b)) -> Parser(a, b)

exact

pub fn exact(s: String) -> Parser(String, String)

Parse an exact string of characters.

extract

pub fn extract(
  p: Parser(a, b),
  k: fn(b) -> Parser(a, c),
) -> Parser(a, c)

get_config

pub fn get_config() -> Parser(a, ParserConfig(a))

get_errors

pub fn get_errors(res: ParseResult(a, b)) -> List(ParseError(a))

go

pub fn go(
  p: Parser(String, a),
  src: String,
  config: ParserConfig(String),
) -> FinalParseResult(String, a)

Apply a parser to a string.

go_on_tokens

pub fn go_on_tokens(
  p: Parser(a, b),
  src: List(a),
  config: ParserConfig(a),
) -> FinalParseResult(a, b)

label

pub fn label(
  label: String,
  p: fn() -> Parser(a, b),
) -> Parser(a, b)

letter

pub fn letter() -> Parser(String, String)

Parse a lowercase or uppercase letter.

lowercase_letter

pub fn lowercase_letter() -> Parser(String, String)

Parse a lowercase letter.

main

pub fn main() -> Nil

map

pub fn map(p: Parser(a, b), f: fn(b) -> c) -> Parser(a, c)

Do p, then apply f to the result if it succeeded.

position

pub fn position() -> Parser(a, Position)

Get the current parser position.

recover

pub fn recover() -> Parser(a, Nil)

return

pub fn return(a: a) -> Parser(b, a)

satisfy

pub fn satisfy(when pred: fn(a) -> Bool) -> Parser(a, a)

Parse a character if it matches the predicate.

seq

pub fn seq(p1: Parser(a, b), p2: Parser(a, c)) -> Parser(a, c)

token

pub fn token(t: a) -> Parser(a, a)

Parse a specific character.

uppercase_letter

pub fn uppercase_letter() -> Parser(String, String)

Parse an uppercase letter.