Struct Parser 

pub struct Parser<'a, T, E, F = ()> { /* private fields */ }

A parser is a function from a State to a ParseResult. The T type is the type of the value produced by the parser, the E is the type of the errors it can produce. F is the type of failure - this is like an error, but made to be used for backtracking. It is optional. The 'a lifetime is the lifetime of the parser.

Implementations

impl<'a, T, E, F> Parser<'a, T, E, F>

pub fn ret(value: T) -> Self

where T: Clone + 'a,

pub fn ret_with(value: impl Fn() -> T + 'a) -> Self

pub fn fail(value: F) -> Self

where F: Clone + 'a,

pub fn fail_with(value: impl Fn() -> F + 'a) -> Self

pub fn err(value: E) -> Self

where E: Clone + 'a,

pub fn err_with(value: impl Fn() -> E + 'a) -> Self

pub fn from_fn<Func>(func: Func) -> Self

where Func: Fn(State<'a>) -> ParseResult<T, E, F> + 'a,

pub fn parse(&self, state: State<'a>) -> ParseResult<T, E, F>

pub fn with_name(self, name: impl Into<String>) -> Self

This is useful for debugging parsers.

pub fn map<U>(self, f: impl Fn(T) -> U + 'a) -> Parser<'a, U, E, F>

where F: 'a, E: 'a, T: 'a,

pub fn map_fail<G>(self, f: impl Fn(F) -> G + 'a) -> Parser<'a, T, E, G>

where F: 'a, E: 'a, T: 'a,

pub fn map_err<E2>(self, f: impl Fn(E) -> E2 + 'a) -> Parser<'a, T, E2, F>

where F: 'a, E: 'a, T: 'a,

pub fn and_then<U, Func>(self, func: Func) -> Parser<'a, U, E, F>

where Func: Fn(T) -> Parser<'a, U, E, F> + 'a, F: 'a, E: 'a, T: 'a,

pub fn and_then_fail<G, Func>(self, func: Func) -> Parser<'a, T, E, G>

where Func: Fn(F) -> Parser<'a, T, E, G> + 'a, F: 'a, E: 'a, T: 'a,

This is like and_then, but the next parser is called when the first parser fails. Unlike and_then, the next parser is started at the same position as the first parser (not at the position that it stopped).

pub fn and_then_err<E2, Func>(self, func: Func) -> Parser<'a, T, E2, F>

where Func: Fn(E) -> Parser<'a, T, E2, F> + 'a, F: 'a, E: 'a, T: 'a,

This is like and_then, but the next parser is called when the first parser returns an error (Notice - this is different from failure). Unlike and_then, the next parser is started at the same position as the first parser (not at the position that it stopped).

pub fn or<G, H>(self, other: Parser<'a, T, E, G>) -> Parser<'a, T, E, H>

where T: 'a, E: 'a, F: 'a + CombineFail<'a, G, H>, G: 'a,

pub fn or_ret<G>(self, x: T) -> Parser<'a, T, E, G>

where T: Clone + 'a, E: 'a, F: 'a, G: 'a,

pub fn or_fail<G>(self, f: G) -> Parser<'a, T, E, G>

where T: 'a, E: 'a, F: 'a, G: Clone + 'a,

pub fn or_err<G>(self, e: E) -> Parser<'a, T, E, G>

where T: 'a, E: Clone + 'a, F: 'a, G: 'a,

pub fn one_of<G>( parsers: impl IntoIterator<Item = Parser<'a, T, E, F>> + 'a, ) -> Parser<'a, T, E, G>

where T: 'a, E: 'a, F: 'a + CombineManyFail<'a, G>, G: 'a,

pub fn filter(self, pred: impl Fn(&T) -> bool + 'a) -> Self

where T: Clone + 'a, E: 'a, F: Clone + Default + 'a,

impl<'a, E, F> Parser<'a, State<'a>, E, F>

pub fn state() -> Self

A parser that just returns the current state.

impl<'a, T: 'a, F: 'a, E: 'a> Parser<'a, T, E, F>

pub fn of_bool(value: bool) -> Parser<'a, T, E, F>

where T: Default + Clone, F: Default + Clone,

impl<'a, E: 'a> Parser<'a, char, E, EofFailure>

pub fn char() -> Parser<'a, char, E, EofFailure>

impl<'a, F: Clone + Default + 'a, E: 'a> Parser<'a, char, E, F>

pub fn char_eq(ch: char) -> Parser<'a, char, E, F>

impl<'a, E: 'a> Parser<'a, char, E, NotWhitespace>

pub fn whitespace() -> Parser<'a, char, E, NotWhitespace>

impl<'a, F: 'a, E: 'a> Parser<'a, (), E, F>

pub fn skip_whitespace() -> Parser<'a, (), E, F>

impl<'a, E: 'a> Parser<'a, char, E, NotALetter>

pub fn letter() -> Parser<'a, char, E, NotALetter>

impl<'a, E: 'a> Parser<'a, char, E, NotADigit>

pub fn digit() -> Parser<'a, char, E, NotADigit>

impl<'a, E: 'a> Parser<'a, char, E, NotFound>

pub fn eof() -> Parser<'a, (), E, NotFound>

pub fn expect_string(expected: &'static str) -> Parser<'a, (), E, NotFound>

impl<'a, T, F, E> Parser<'a, T, E, F>

pub fn maybe<G>(self) -> Parser<'a, Option<T>, E, G>

where T: 'a, E: 'a, F: 'a,

Repeats this parser zero or one times.

pub fn repeat_0<G>(self) -> Parser<'a, Vec<T>, E, G>

where T: Clone + 'a, E: 'a, F: 'a, G: 'a,

Repeats this parser zero or more times.

pub fn repeat_1(self) -> Parser<'a, Vec<T>, E, F>

where T: Clone + 'a, E: 'a, F: 'a,

Repeats this parser one or more times.

impl<'a, T, F, E> Parser<'a, T, E, F>

pub fn not<G>(self) -> Parser<'a, (), E, G>

where T: 'a, E: 'a, F: 'a, G: Default + 'a,

Trait Implementations

impl<'a, T, E, F> Clone for Parser<'a, T, E, F>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T, E, F> Debug for Parser<'_, T, E, F>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.