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.

Methods

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, 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>

Run the parser on a given input, starting at a given location and state.

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.