Struct Between

pub struct Between<L, R, P>(/* private fields */)
where
    L: Parser,
    R: Parser<Input = <L as Parser>::Input>,
    P: Parser<Input = <L as Parser>::Input>;

Trait Implementations

impl<L, R, P> Clone for Between<L, R, P>

where L: Parser + Clone, R: Parser<Input = <L as Parser>::Input> + Clone, P: Parser<Input = <L as Parser>::Input> + Clone,

fn clone(&self) -> Between<L, R, P>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<L, R, P> Parser for Between<L, R, P>

where L: Parser, R: Parser<Input = <L as Parser>::Input>, P: Parser<Input = <L as Parser>::Input>,

type Input = <L as Parser>::Input

A type implementing the Stream trait which is the specific type that is parsed.

type Output = <Skip<With<L, P>, R> as Parser>::Output

The type which is returned when the parsing is successful.

fn parse_state( &mut self, input: State<<Self as Parser>::Input>, ) -> ParseResult<<Self as Parser>::Output, <Self as Parser>::Input, <Self::Input as Stream>::Item>

Parses using the state input by calling Stream::uncons one or more times On success returns Ok((value, new_state)) on failure it returns Err(error)

fn parse_lazy( &mut self, input: State<<Self as Parser>::Input>, ) -> ParseResult<<Self as Parser>::Output, <Self as Parser>::Input, <Self::Input as Stream>::Item>

Specialized version of parse_state where the parser does not need to add an error to the ParseError when it does not consume any input before encountering the error. Instead the error can be added later through the add_error method

fn add_error(&mut self, error: &mut ParseError<<Self::Input as Stream>::Item>)

Adds the first error that would normally be returned by this parser if it failed

fn parse( &mut self, input: Self::Input, ) -> Result<(Self::Output, Self::Input), ParseError<<Self::Input as Stream>::Item>>

Entrypoint of the parser Takes some input and tries to parse it returning a ParseResult