nibble

Types

DeadEnd

pub type DeadEnd(ctx) {
  DeadEnd(
    row: Int,
    col: Int,
    problem: Error,
    context: List(Located(ctx)),
  )
}

Constructors

DeadEnd(
  row: Int,
  col: Int,
  problem: Error,
  context: List(Located(ctx)),
)

Error

</>

pub type Error {
  BadParser(String)
  Custom(String)
  EndOfInput
  Expected(String, got: String)
  Unexpected(String)
}

Constructors

```
BadParser(String)
```
```
Custom(String)
```
```
EndOfInput
```
```
Expected(String, got: String)
```
```
Unexpected(String)
```

Located

</>

pub type Located(ctx) {
  Located(row: Int, col: Int, context: ctx)
}

Constructors

Located(row: Int, col: Int, context: ctx)

Loop

</>

pub type Loop(a, state) {
  Continue(state)
  Break(a)
}

Constructors

```
Continue(state)
```
```
Break(a)
```

Parser

</>

pub opaque type Parser(a, ctx)

Functions

any

</>

pub fn any() -> Parser(String, a)

backtrackable

</>

pub fn backtrackable(parser: Parser(a, b)) -> Parser(a, b)

commit

</>

pub fn commit(to a: a) -> Parser(a, b)

drop

</>

pub fn drop(parse_a: Parser(a, b), parse_x: Parser(c, b)) -> Parser(
  a,
  b,
)

eof

</>

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

fail

</>

pub fn fail(message: String) -> Parser(a, b)

float

</>

pub fn float() -> Parser(Float, a)

grapheme

</>

pub fn grapheme(str: String) -> Parser(Nil, a)

in

</>

pub fn in(parser: Parser(a, b), context: b) -> Parser(a, b)

inspect

</>

pub fn inspect(parser: Parser(a, b), message: String) -> Parser(
  a,
  b,
)

Run the given parser and then inspect it’s state.

int

</>

pub fn int() -> Parser(Int, a)

keep

</>

pub fn keep(parse_f: Parser(fn(a) -> b, c), parse_a: Parser(a, c)) -> Parser(
  b,
  c,
)

lazy

</>

pub fn lazy(parser: fn() -> Parser(a, b)) -> Parser(a, b)

loop

</>

pub fn loop(init: a, step: fn(a) -> Parser(Loop(b, a), c)) -> Parser(
  b,
  c,
)

many

</>

pub fn many(parser: Parser(a, b), separator: Parser(c, b)) -> Parser(
  List(a),
  b,
)

map

</>

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

one_of

</>

pub fn one_of(parsers: List(Parser(a, b))) -> Parser(a, b)

replace

</>

pub fn replace(parser: Parser(a, b), with b: c) -> Parser(c, b)

run

</>

pub fn run(src: String, parser: Parser(a, b)) -> Result(
  a,
  List(DeadEnd(b)),
)

spaces

</>

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

string

</>

pub fn string(str: String) -> Parser(Nil, a)

succeed

</>

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

take_if

</>

pub fn take_if(predicate: fn(String) -> Bool, expecting: String) -> Parser(
  String,
  a,
)

take_if_and_while

</>

pub fn take_if_and_while(predicate: fn(String) -> Bool, expecting: String) -> Parser(
  String,
  a,
)

take_until

</>

pub fn take_until(predicate: fn(String) -> Bool) -> Parser(
  String,
  a,
)

take_while

</>

pub fn take_while(predicate: fn(String) -> Bool) -> Parser(
  String,
  a,
)

then

</>

pub fn then(parser: Parser(a, b), f: fn(a) -> Parser(c, b)) -> Parser(
  c,
  b,
)

whitespace

</>

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