pickle

Types

ExpectedToken

pub type ExpectedToken {
  Eof
  Float
  Integer
  OctalDigit
  BinaryDigit
  DecimalDigit
  HexadecimalDigit
  DecimalDigitOrPoint
  String(String)
}

Constructors

```
Eof
```
```
Float
```
```
Integer
```
```
OctalDigit
```
```
BinaryDigit
```
```
DecimalDigit
```
```
HexadecimalDigit
```
```
DecimalDigitOrPoint
```
```
String(String)
```

Parser

opaque </>

pub opaque type Parser(a)

ParserFailure

</>

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)
  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)

```
CustomError(error: a)
```

ParserPosition

</>

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

Constructors

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

Functions

binary_integer

</>

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

decimal_integer

</>

pub fn decimal_integer(
  mapper: fn(a, Int) -> a,
) -> fn(Parser(a)) -> Result(Parser(a), ParserFailure(b))

drop

</>

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

eof

</>

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

float

</>

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

guard

</>

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

hexadecimal_integer

</>

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

integer

</>

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

many

</>

pub fn many(
  initial_value: a,
  combinator: fn(Parser(a)) ->
    Result(Parser(a), ParserFailure(b)),
  acc: fn(c, a) -> c,
) -> fn(Parser(c)) -> Result(Parser(c), ParserFailure(b))

map

</>

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

map_error

</>

pub fn map_error(
  combinator: fn(Parser(a)) ->
    Result(Parser(a), ParserFailure(b)),
  mapper: fn(ParserFailure(b)) -> b,
) -> fn(Parser(a)) -> Result(Parser(a), ParserFailure(b))

octal_integer

</>

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

one_of

</>

pub fn one_of(
  combinators: List(
    fn(Parser(a)) -> Result(Parser(a), ParserFailure(b)),
  ),
) -> fn(Parser(a)) -> Result(Parser(a), ParserFailure(b))

optional

</>

pub fn optional(
  combinator: fn(Parser(a)) ->
    Result(Parser(a), ParserFailure(b)),
) -> fn(Parser(a)) -> Result(Parser(a), ParserFailure(b))

parse

</>

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

return

</>

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

skip_until

</>

pub fn skip_until(
  terminator: String,
) -> fn(Parser(a)) -> Result(Parser(a), ParserFailure(b))

skip_whitespace

</>

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

string

</>

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

then

</>

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

until

</>

pub fn until(
  terminator: String,
  mapper: fn(a, String) -> a,
) -> fn(Parser(a)) -> Result(Parser(a), ParserFailure(b))

whitespace

</>

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