nibble/lexer

Types

Error

pub type Error {
  NoMatchFound(row: Int, col: Int, lexeme: String)
}

Constructors

NoMatchFound(row: Int, col: Int, lexeme: String)

Lexer

</>

pub opaque type Lexer(a, mode)

Match

</>

pub type Match(a, mode) {
  Keep(a, mode)
  Skip
  Drop(mode)
  NoMatch
}

Constructors

```
Keep(a, mode)
```
```
Skip
```
```
Drop(mode)
```
```
NoMatch
```

Matcher

</>

pub opaque type Matcher(a, mode)

Span

</>

pub type Span {
  Span(
    row_start: Int,
    col_start: Int,
    row_end: Int,
    col_end: Int,
  )
}

Constructors

Span(row_start: Int, col_start: Int, row_end: Int, col_end: Int)

Token

</>

pub type Token(a) {
  Token(span: Span, lexeme: String, value: a)
}

Constructors

Token(span: Span, lexeme: String, value: a)

Functions

advanced

</>

pub fn advanced(
  matchers: fn(a) -> List(Matcher(b, a)),
) -> Lexer(b, a)

comment

</>

pub fn comment(
  start: String,
  to_value: fn(String) -> a,
) -> Matcher(a, b)

custom

</>

pub fn custom(
  f: fn(a, String, String) -> Match(b, a),
) -> Matcher(b, a)

drop

</>

pub fn drop(f: fn(String, String) -> Bool) -> Matcher(a, b)

float

</>

pub fn float(to_value: fn(Float) -> a) -> Matcher(a, b)

float_with_separator

</>

pub fn float_with_separator(
  separator: String,
  to_value: fn(Float) -> a,
) -> Matcher(a, b)

identifier

</>

pub fn identifier(
  start: String,
  inner: String,
  reserved: Set(String),
  to_value: fn(String) -> a,
) -> Matcher(a, b)

ignore

</>

pub fn ignore(matcher: Matcher(a, b)) -> Matcher(c, b)

int

</>

pub fn int(to_value: fn(Int) -> a) -> Matcher(a, b)

int_with_separator

</>

pub fn int_with_separator(
  separator: String,
  to_value: fn(Int) -> a,
) -> Matcher(a, b)

into

</>

pub fn into(
  matcher: Matcher(a, b),
  f: fn(b) -> b,
) -> Matcher(a, b)

keep

</>

pub fn keep(
  f: fn(String, String) -> Result(a, Nil),
) -> Matcher(a, b)

keyword

</>

pub fn keyword(
  str: String,
  breaker: String,
  value: a,
) -> Matcher(a, b)

map

</>

pub fn map(
  matcher: Matcher(a, b),
  f: fn(a) -> c,
) -> Matcher(c, b)

number

</>

pub fn number(
  from_int: fn(Int) -> a,
  from_float: fn(Float) -> a,
) -> Matcher(a, b)

number_with_separator

</>

pub fn number_with_separator(
  separator: String,
  from_int: fn(Int) -> a,
  from_float: fn(Float) -> a,
) -> Matcher(a, b)

run

</>

pub fn run(
  source: String,
  lexer: Lexer(a, Nil),
) -> Result(List(Token(a)), Error)

run_advanced

</>

pub fn run_advanced(
  source: String,
  mode: a,
  lexer: Lexer(b, a),
) -> Result(List(Token(b)), Error)

simple

</>

pub fn simple(matchers: List(Matcher(a, Nil))) -> Lexer(a, Nil)

skip

</>

pub fn skip(matcher: Matcher(a, b)) -> Matcher(c, b)

spaces

</>

pub fn spaces(token: a) -> Matcher(a, b)

spaces_

</>

pub fn spaces_(to_value: fn(String) -> a) -> Matcher(a, b)

string

</>

pub fn string(
  char: String,
  to_value: fn(String) -> a,
) -> Matcher(a, b)

symbol

</>

pub fn symbol(
  str: String,
  breaker: String,
  value: a,
) -> Matcher(a, b)

then

</>

pub fn then(
  matcher: Matcher(a, b),
  f: fn(a) -> Match(c, b),
) -> Matcher(c, b)

token

</>

pub fn token(str: String, value: a) -> Matcher(a, b)

try_identifier

</>

pub fn try_identifier(
  start: String,
  inner: String,
  reserved: Set(String),
  to_value: fn(String) -> a,
) -> Result(Matcher(a, b), CompileError)

variable

</>

pub fn variable(
  reserved: Set(String),
  to_value: fn(String) -> a,
) -> Matcher(a, b)

whitespace

</>

pub fn whitespace(token: a) -> Matcher(a, b)