pears - v1.0.0

pears/chars

Parsers for strings, which pears.parse_string splits into graphemes (Chars).

import pears
import pears/combinators.{sep_by0}

let numbers = sep_by0(lexeme(integer()), lexeme(string(",")))
assert pears.parse_string_all("1, -2, 3", numbers) == Ok([1, -2, 3])

Types

Char

</>

A grapheme is a user-perceived character.

pub type Char =
  String

Values

alphanumeric

</> 
pub fn alphanumeric() -> pears.Parser(String, String)

Parses an ASCII letter or a digit.

import pears

assert pears.parse_string_all("7", alphanumeric()) == Ok("7")

case_insensitive

</> 
pub fn case_insensitive(
  str: String,
) -> pears.Parser(String, String)

Parses a given string, ignoring case, and returns the matched input.

import pears

assert pears.parse_string_all("Select", case_insensitive("SELECT")) == Ok("Select")

digit

</> 
pub fn digit() -> pears.Parser(String, String)

Parses a digit in the range 0-9.

import pears

assert pears.parse_string_all("7", digit()) == Ok("7")

float

</> 
pub fn float() -> pears.Parser(String, Float)

Parses a number with a fractional part and an optional exponent, like -1.5 or 2.0e10. Numbers out of range fail with a custom error.

import pears

assert pears.parse_string_all("-1.5e3", float()) == Ok(-1500.0)

format_error

</> 
pub fn format_error(
  error: pears.ParseError(String),
  source: String,
) -> String

Formats a parse error with the line and column in source, the parsed string, e.g. line 2, column 4: expected "," or "]", found "x".

import pears
import pears/combinators.{many0, or}

let source = "ab\nc!"
let assert Error(error) = pears.parse_string_all(source, many0(or(letter(), whitespace())))
assert format_error(error, source) == "line 2, column 2: expected letter, whitespace or end of input, found \"!\""

hex_digit

</> 
pub fn hex_digit() -> pears.Parser(String, String)

Parses a hexadecimal digit, 0-9, a-f or A-F.

import pears

assert pears.parse_string_all("F", hex_digit()) == Ok("F")

integer

</> 
pub fn integer() -> pears.Parser(String, Int)

Parses an integer with an optional leading -.

import pears

assert pears.parse_string_all("-42", integer()) == Ok(-42)

letter

</> 
pub fn letter() -> pears.Parser(String, String)

Parses an ASCII letter, a-z or A-Z.

import pears

assert pears.parse_string_all("Q", letter()) == Ok("Q")

lexeme

</> 
pub fn lexeme(
  parser: pears.Parser(String, a),
) -> pears.Parser(String, a)

Runs the parser and skips any whitespace after it.

import pears

assert pears.parse_string_all("let  ", lexeme(string("let"))) == Ok("let")

line_column

</> 
pub fn line_column(source: String, position: Int) -> #(Int, Int)

Returns the 1-based line and column of the character at position in source.

assert line_column("ab\ncd", 4) == #(2, 2)

line_comment

</> 
pub fn line_comment(
  start: String,
) -> pears.Parser(String, String)

Parses start and the rest of the line, returning the text after start. The line break isn’t consumed.

import pears

let assert Ok(parsed) = pears.parse_string("// hi\nx", line_comment("//"))
assert parsed.value == " hi"

natural

</> 
pub fn natural() -> pears.Parser(String, Int)

Parses a non-negative integer consisting of one or more digits. On JavaScript, integers too large to be represented exactly fail with a custom error.

import pears

assert pears.parse_string_all("042", natural()) == Ok(42)

string

</> 
pub fn string(str: String) -> pears.Parser(String, String)

Parses a given string. Errors point at the first character that doesn’t match.

import pears.{UnexpectedToken}

assert pears.parse_string_all("let", string("let")) == Ok("let")
assert pears.parse_string("lex", string("let")) == Error(UnexpectedToken(2, ["\"let\""], "x"))

string_literal

</> 
pub fn string_literal() -> pears.Parser(String, String)

Parses a double-quoted string with JSON-style escapes (\", \\, \/, \b, \f, \n, \r, \t and \uXXXX, including surrogate pairs) and returns its contents.

import pears

assert pears.parse_string_all("\"a\\nb\"", string_literal()) == Ok("a\nb")

whitespace

</> 
pub fn whitespace() -> pears.Parser(String, String)

Parses a character if it is whitespace according to the Unicode standard.

import pears

assert pears.parse_string_all("\t", whitespace()) == Ok("\t")

whitespace0

</> 
pub fn whitespace0() -> pears.Parser(String, List(String))

Parses zero or more whitespace characters. Hidden from error messages.

import pears

assert pears.parse_string_all("  ", whitespace0()) == Ok([" ", " "])
assert pears.parse_string_all("", whitespace0()) == Ok([])

whitespace1

</> 
pub fn whitespace1() -> pears.Parser(String, List(String))

Parses one or more whitespace characters.

import pears

assert pears.parse_string_all("  ", whitespace1()) == Ok([" ", " "])
let assert Error(_) = pears.parse_string_all("", whitespace1())
✨ Search Document