nibble - v1.0.0-rc.3

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)
✨ Search Document