Struct lip::BoxedParser

pub struct BoxedParser<'a, Output, State> { /* fields omitted */ }

Box Parser trait so its size is decidable in compile time.

Essentially allocate the Parser on the heap in runtime. Makes passing Parser around much easier because types that impl trait may be different under the hood while BoxedParser is always a pointer to a place in the heap.

Implementations

impl<'a, Output, State> BoxedParser<'a, Output, State>

pub fn new<P>(parser: P) -> Self where
    P: Parser<'a, Output, State> + 'a,
    State: Clone, 

Box any type that implements the Parser trait

Trait Implementations

impl<'a, Output: 'a, State: 'a> Clone for BoxedParser<'a, Output, State>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a, Output, State> Parser<'a, Output, State> for BoxedParser<'a, Output, State> where
    State: Clone, 

fn parse(
    &self,
    input: &'a str,
    location: Location,
    state: State
) -> ParseResult<'a, Output, State>

Parse a given input, starting at a given location and state.

fn run(&self, input: &'a str, state: State) -> ParseResult<'a, Output, State>

Run the parser on a given input, starting at the first character.

fn map<F, NewOutput>(self, map_fn: F) -> BoxedParser<'a, NewOutput, State> where
    Self: Sized + 'a,
    Output: 'a,
    NewOutput: 'a,
    State: 'a,
    F: Fn(Output) -> NewOutput + 'a, 

Map the output to a new output if parse succeeds. Otherwise, return error as usual.

fn map_with_state<F, NewOutput>(
    self,
    map_fn: F
) -> BoxedParser<'a, NewOutput, State> where
    Self: Sized + 'a,
    Output: 'a,
    NewOutput: 'a,
    State: 'a,
    F: Fn(Output, State) -> NewOutput + 'a, 

The map function is supplied both the output and the state of the parser. Otherwise, return error as usual.

fn map_err<F>(self, map_fn: F) -> BoxedParser<'a, Output, State> where
    Self: Sized + 'a,
    Output: 'a,
    State: 'a,
    F: Fn(String) -> String + 'a, 

Map the error message to a new message if parse fails. Otherwise, return output as usual.

fn and_then<F, NextParser, NewOutput>(
    self,
    f: F
) -> BoxedParser<'a, NewOutput, State> where
    Self: Sized + 'a,
    Output: 'a,
    NewOutput: 'a,
    State: 'a,
    NextParser: Parser<'a, NewOutput, State> + 'a,
    F: Fn(Output) -> NextParser + 'a, 

Returns a new parser which is given the current output if parse succeeds. Otherwise, return error as usual.

fn pred<F>(
    self,
    predicate: F,
    expecting: &'a str
) -> BoxedParser<'a, Output, State> where
    Self: Sized + 'a,
    Output: Display + 'a,
    State: 'a,
    F: Fn(&Output) -> bool + 'a, 

Judge if the output meets the requirement using a predicate function if the parse succeeds. Otherwise, return error as usual.

fn ignore(self) -> BoxedParser<'a, (), State> where
    Self: Sized + 'a,
    Output: 'a,
    State: 'a, 

Ignore the parse output and return () (emtpy tuple)

fn update_state<F>(self, f: F) -> BoxedParser<'a, Output, State> where
    Self: Sized + 'a,
    State: 'a,
    Output: Clone + 'a,
    F: Fn(Output, State) -> State + 'a, 

Update the state given the new output and state of the parse if parse succeeds. Otherwise, return error as usual.

fn update<F, NewOutput>(self, f: F) -> BoxedParser<'a, NewOutput, State> where
    Self: Sized + 'a,
    State: 'a,
    Output: Clone + 'a,
    NewOutput: Clone + 'a,
    F: Fn(&'a str, Output, Location, State) -> ParseResult<'a, NewOutput, State> + 'a, 

Update the result of the parser if parse succeeds. Otherwise, return error as usual.

fn end(self) -> BoxedParser<'a, Output, State> where
    Self: Sized + 'a,
    Output: Clone + 'a,
    State: 'a, 

Check if you have reached the end of the input you are parsing.

fn keep<A, B, ArgParser>(
    self,
    arg_parser: ArgParser
) -> BoxedParser<'a, B, State> where
    Self: Sized + 'a,
    A: 'a,
    B: 'a,
    State: 'a,
    Output: FnOnce(A) -> B + 'a,
    ArgParser: Parser<'a, A, State> + 'a, 

Keep values in a parser pipeline.

fn skip<P: 'a, A>(self, ignored_parser: P) -> BoxedParser<'a, Output, State> where
    Self: Sized + 'a,
    A: 'a,
    State: 'a,
    Output: 'a,
    P: Parser<'a, A, State>, 

Skip values in a parser pipeline.