pickle

Types

ExpectedToken

The type to represent a kind of token that was expected at a specific position of the input that couldn’t be found.

pub type ExpectedToken {
  Eol
  Eof
  NonEof
  Float
  OctalDigit
  BinaryDigit
  DecimalDigit
  HexadecimalDigit
  DecimalDigitOrPoint
  AsciiLetter
  LowercaseAsciiLetter
  UppercaseAsciiLetter
  Whitespace
  String(String)
}

Constructors

```
Eol
```
```
Eof
```
```
NonEof
```
```
Float
```
```
OctalDigit
```
```
BinaryDigit
```
```
DecimalDigit
```
```
HexadecimalDigit
```
```
DecimalDigitOrPoint
```
```
AsciiLetter
```
```
LowercaseAsciiLetter
```
```
UppercaseAsciiLetter
```
```
Whitespace
```
```
String(String)
```

Parsed

opaque

The type to store unconsumed tokens, the position of the parser and the current value.

pub opaque type Parsed(a)

Parser

The parser type that is an alias for a function that is responsible for parsing input.

pub type Parser(a, b, c) =
  fn(Parsed(a)) -> Result(Parsed(b), ParserFailure(c))

ParserFailure

The error type to represent a reason why a parser failed to parse the input.

pub type ParserFailure(a) {
  UnexpectedToken(
    expected_token: ExpectedToken,
    actual_token: String,
    pos: ParserPosition,
  )
  UnexpectedEof(
    expected_token: ExpectedToken,
    pos: ParserPosition,
  )
  OneOfError(failures: List(ParserFailure(a)))
  GuardError(error: a, pos: ParserPosition)
  Until1Error(pos: ParserPosition)
  NotError(error: a, pos: ParserPosition)
  CustomError(error: a)
}

Constructors

UnexpectedToken(
  expected_token: ExpectedToken,
  actual_token: String,
  pos: ParserPosition,
)

UnexpectedEof(expected_token: ExpectedToken, pos: ParserPosition)

OneOfError(failures: List(ParserFailure(a)))

GuardError(error: a, pos: ParserPosition)

```
Until1Error(pos: ParserPosition)
```
```
NotError(error: a, pos: ParserPosition)
```
```
CustomError(error: a)
```

ParserPosition

The type to represent the current position of the parser.

pub type ParserPosition {
  ParserPosition(row: Int, col: Int)
}

Constructors

```
ParserPosition(row: Int, col: Int)
```

Functions

any

pub fn any(
  mapper: fn(a, String) -> a,
) -> fn(Parsed(a)) -> Result(Parsed(a), ParserFailure(b))

Parses a single token of any kind and fails if there is no further input left to parse.

ascii_letter

pub fn ascii_letter(
  mapper: fn(a, String) -> a,
) -> fn(Parsed(a)) -> Result(Parsed(a), ParserFailure(b))

Parses an ASCII letter.

binary_digit

pub fn binary_digit(
  mapper: fn(a, Int) -> a,
) -> fn(Parsed(a)) -> Result(Parsed(a), ParserFailure(b))

Parses a single binary digit (0|1).

binary_integer

pub fn binary_integer(
  mapper: fn(a, Int) -> a,
) -> fn(Parsed(a)) -> Result(Parsed(a), ParserFailure(b))

Parses a binary integer.

digit

pub fn digit(
  mapper: fn(a, Int) -> a,
) -> fn(Parsed(a)) -> Result(Parsed(a), ParserFailure(b))

Parses a single decimal digit (0-9).

do

pub fn do(
  initial_value: a,
  parser: fn(Parsed(a)) -> Result(Parsed(b), ParserFailure(c)),
  mapper: fn(d, b) -> d,
) -> fn(Parsed(d)) -> Result(Parsed(d), ParserFailure(c))

Applies the initial value to the given parser.

This parser is especially useful when you want or need to transform a value of a different type than the one the parent parser holds (e.g., a type that the AST type of the parent parser can contain).

drop

pub fn drop(value: a, : b) -> a

A mapper to drop the parsed value of the child parser, thus leaving the value of the parent parser unchanged.

eof

pub fn eof() -> fn(Parsed(a)) ->
  Result(Parsed(a), ParserFailure(b))

Parses successfully when there is no further input left to parse.

eol

pub fn eol(
  mapper: fn(a, String) -> a,
) -> fn(Parsed(a)) -> Result(Parsed(a), ParserFailure(b))

Parses an end-of-line character.

float

pub fn float(
  mapper: fn(a, Float) -> a,
) -> fn(Parsed(a)) -> Result(Parsed(a), ParserFailure(b))

Parses a decimal float.

guard

pub fn guard(
  predicate: fn(a) -> Bool,
  error: b,
) -> fn(Parsed(a)) -> Result(Parsed(a), ParserFailure(b))

Validates the value of the parser.

If the validation fails, a GuardError with the given error will be returned.

hexadecimal_digit

pub fn hexadecimal_digit(
  mapper: fn(a, Int) -> a,
) -> fn(Parsed(a)) -> Result(Parsed(a), ParserFailure(b))

Parses a single hexadecimal digit (0-9, a-f, A-F).

hexadecimal_integer

pub fn hexadecimal_integer(
  mapper: fn(a, Int) -> a,
) -> fn(Parsed(a)) -> Result(Parsed(a), ParserFailure(b))

Parses a hexadecimal integer.

integer

pub fn integer(
  mapper: fn(a, Int) -> a,
) -> fn(Parsed(a)) -> Result(Parsed(a), ParserFailure(b))

Parses a decimal integer.

lookahead

pub fn lookahead(
  parser: fn(Parsed(a)) -> Result(Parsed(b), ParserFailure(c)),
) -> fn(Parsed(a)) -> Result(Parsed(a), ParserFailure(c))

Looksahead whether the given parser succeeds and backtracks if it does.

lowercase_ascii_letter

pub fn lowercase_ascii_letter(
  mapper: fn(a, String) -> a,
) -> fn(Parsed(a)) -> Result(Parsed(a), ParserFailure(b))

Parses a lowercase ASCII letter.

many

pub fn many(
  initial_value: a,
  parser: fn(Parsed(a)) -> Result(Parsed(b), ParserFailure(c)),
  acc: fn(d, b) -> d,
) -> fn(Parsed(d)) -> Result(Parsed(d), ParserFailure(c))

Applies the initial value to the given parser zero to n times until it fails.

many1

pub fn many1(
  initial_value: a,
  parser: fn(Parsed(a)) -> Result(Parsed(b), ParserFailure(c)),
  acc: fn(d, b) -> d,
) -> fn(Parsed(d)) -> Result(Parsed(d), ParserFailure(c))

Applies the initial value to the given parser one to n times until it fails.

The given parser must succeed at least once.

map

pub fn map(
  mapper: fn(a) -> b,
) -> fn(Parsed(a)) -> Result(Parsed(b), ParserFailure(c))

Maps the value of the parser.

map_error

pub fn map_error(
  parser: fn(Parsed(a)) -> Result(Parsed(a), ParserFailure(b)),
  mapper: fn(ParserFailure(b)) -> b,
) -> fn(Parsed(a)) -> Result(Parsed(a), ParserFailure(b))

Maps the error returned by the parser.

not

pub fn not(
  parser: fn(Parsed(a)) -> Result(Parsed(b), ParserFailure(c)),
  error: c,
) -> fn(Parsed(a)) -> Result(Parsed(a), ParserFailure(c))

Succeeds and backtracks if the given parser fails.

The error parameter is meant to convey more information to consumers and its value is wrapped in a NotError.

octal_digit

pub fn octal_digit(
  mapper: fn(a, Int) -> a,
) -> fn(Parsed(a)) -> Result(Parsed(a), ParserFailure(b))

Parses a single octal digit (0-7).

octal_integer

pub fn octal_integer(
  mapper: fn(a, Int) -> a,
) -> fn(Parsed(a)) -> Result(Parsed(a), ParserFailure(b))

Parses an octal integer.

one_of

pub fn one_of(
  parsers: List(
    fn(Parsed(a)) -> Result(Parsed(a), ParserFailure(b)),
  ),
) -> fn(Parsed(a)) -> Result(Parsed(a), ParserFailure(b))

Applies each given parser in order until one succeeds. If all parsers failed, the collected failures wrapped in an OneOfError will be returned.

optional

pub fn optional(
  parser: fn(Parsed(a)) -> Result(Parsed(a), ParserFailure(b)),
) -> fn(Parsed(a)) -> Result(Parsed(a), ParserFailure(b))

Applies the given parser, and if it fails, ignores its failure and backtracks.

parse

pub fn parse(
  input: String,
  initial_value: a,
  parser: fn(Parsed(a)) -> Result(Parsed(b), ParserFailure(c)),
) -> Result(b, ParserFailure(c))

Applies the provided input and initial value to the given parser to parse the input and transform the initial value.

return

pub fn return(
  value: a,
) -> fn(Parsed(b)) -> Result(Parsed(a), ParserFailure(c))

Replaces the value of the parser with the given value.

skip_until

pub fn skip_until(
  terminator: fn(Parsed(a)) ->
    Result(Parsed(b), ParserFailure(c)),
) -> fn(Parsed(a)) -> Result(Parsed(a), ParserFailure(c))

Applies the given parser zero to n times until the given terminator succeeds and drops the parsed tokens.

It fails if the given terminator doesn’t succeed before no further tokens are left to parse.

skip_until1

pub fn skip_until1(
  terminator: fn(Parsed(a)) ->
    Result(Parsed(b), ParserFailure(c)),
) -> fn(Parsed(a)) -> Result(Parsed(a), ParserFailure(c))

Applies the given parser one to n times until the given terminator succeeds and drops the parsed tokens.

It fails if no single token could be skipped or the given terminator doesn’t succeed before no further tokens are left to parse.

If the terminator succeeds before no single token could be skipped, an Until1Error with the current parser position will be returned.

skip_whitespace

pub fn skip_whitespace() -> fn(Parsed(a)) ->
  Result(Parsed(a), ParserFailure(b))

Parses whitespace zero to n times until encountering a non-whitespace token and drops the parsed whitespace.

skip_whitespace1

pub fn skip_whitespace1() -> fn(Parsed(a)) ->
  Result(Parsed(a), ParserFailure(b))

Parses whitespace one to n times until encountering a non-whitespace token and drops the parsed whitespace.

It fails if not at least one whitespace token could be parsed.

string

pub fn string(
  expected: String,
  mapper: fn(a, String) -> a,
) -> fn(Parsed(a)) -> Result(Parsed(a), ParserFailure(b))

Parses a specific string.

then

pub fn then(
  prev: fn(Parsed(a)) -> Result(Parsed(b), ParserFailure(c)),
  successor: fn(Parsed(b)) -> Result(Parsed(d), ParserFailure(c)),
) -> fn(Parsed(a)) -> Result(Parsed(d), ParserFailure(c))

Chains two given parsers.

If prev fails, successor won’t be invoked.

times

pub fn times(
  parser: fn(Parsed(a)) -> Result(Parsed(a), ParserFailure(b)),
  parse_times: Int,
) -> fn(Parsed(a)) -> Result(Parsed(a), ParserFailure(b))

Applies the given parser a specified amount of times.

until

pub fn until(
  initial_value: a,
  parser: fn(Parsed(a)) -> Result(Parsed(a), ParserFailure(b)),
  terminator: fn(Parsed(c)) ->
    Result(Parsed(d), ParserFailure(b)),
  acc: fn(c, a) -> c,
) -> fn(Parsed(c)) -> Result(Parsed(c), ParserFailure(b))

Applies the given parser zero to n times until the given terminator succeeds.

It fails if the given parser fails or the given terminator doesn’t succeed before no further tokens are left to parse.

until1

pub fn until1(
  initial_value: a,
  parser: fn(Parsed(a)) -> Result(Parsed(a), ParserFailure(b)),
  terminator: fn(Parsed(c)) ->
    Result(Parsed(d), ParserFailure(b)),
  acc: fn(c, a) -> c,
) -> fn(Parsed(c)) -> Result(Parsed(c), ParserFailure(b))

Applies the given parser one to n times until the given terminator succeeds.

It fails if the given parser fails or could not be applied once, or the given terminator doesn’t succeed before no further tokens are left to parse.

If the terminator succeeds before the given parser could succeed, an Until1Error with the current parser position will be returned.

uppercase_ascii_letter

pub fn uppercase_ascii_letter(
  mapper: fn(a, String) -> a,
) -> fn(Parsed(a)) -> Result(Parsed(a), ParserFailure(b))

Parses an uppercase ASCII letter.

whitespace

pub fn whitespace(
  mapper: fn(a, String) -> a,
) -> fn(Parsed(a)) -> Result(Parsed(a), ParserFailure(b))

Parses whitespace zero to n times until encountering a non-whitespace token.

whitespace1

pub fn whitespace1(
  mapper: fn(a, String) -> a,
) -> fn(Parsed(a)) -> Result(Parsed(a), ParserFailure(b))

Parses whitespace one to n times until encountering a non-whitespace token.

It fails if not at least one whitespace token could be parsed.