Struct Parser 

pub struct Parser<'a, I, O> { /* private fields */ }

Parser combinator.

Implementations

impl<'a, I, O> Parser<'a, I, O>

pub fn new<P>(parse: P) -> Parser<'a, I, O>

where P: Fn(&'a [I], usize) -> Result<(O, usize, Option<Error>)> + 'a,

Create new parser.

pub fn parse(&self, input: &'a [I]) -> Result<O>

Apply the parser to parse input.

pub fn parse_at( &self, input: &'a [I], start: usize, ) -> Result<(O, usize, Option<Error>)>

Parse input at specified position.

pub fn map<U, F>(self, f: F) -> Parser<'a, I, U>

where F: Fn(O) -> U + 'a, I: 'a, O: 'a, U: 'a,

Convert parser result to desired value.

pub fn convert<U, E, F>(self, f: F) -> Parser<'a, I, U>

where F: Fn(O, &Option<Error>) -> Result<U, E> + 'a, E: Debug, O: 'a, U: 'a,

Convert parser result to desired value, fail in case of conversion error.

pub fn cache(self) -> Parser<'a, I, O>

where O: Clone + 'a,

Cache parser output result to speed up backtracking.

pub fn debug_ok<S>(self, id: S) -> Parser<'a, I, O>

where O: Debug + 'a, S: AsRef<str> + 'a,

pub fn pos(self) -> Parser<'a, I, usize>

where O: 'a,

Get input position after matching parser.

pub fn collect(self) -> Parser<'a, I, &'a [I]>

where O: 'a,

Collect all matched input symbols.

pub fn discard(self) -> Parser<'a, I, ()>

where O: 'a,

Discard parser output.

pub fn opt(self) -> Parser<'a, I, Option<O>>

where O: 'a,

Make parser optional.

pub fn repeat<R>(self, range: R) -> Parser<'a, I, Vec<O>>

where R: RangeArgument<usize> + Debug + 'a, O: 'a,

p.repeat(5) repeat p exactly 5 times p.repeat(0..) repeat p zero or more times p.repeat(1..) repeat p one or more times p.repeat(1..4) match p at least 1 and at most 3 times

pub fn name(self, name: &'a str) -> Parser<'a, I, O>

where O: 'a,

Give parser a name to identify parsing errors, and stops rollback tracing propagation.

pub fn trace<S>(self, id: S) -> Parser<'a, I, O>

where O: 'a, S: AsRef<str> + 'a,

Trace parser with an identifier for rollback tracing.

pub fn expect(self, name: &'a str) -> Parser<'a, I, O>

where O: 'a,

Mark parser as expected, abort early when failed in ordered choice.

Trait Implementations

impl<'a, I, O: 'a, U: 'a> Add<Parser<'a, I, U>> for Parser<'a, I, O>

Sequence reserve value

type Output = Parser<'a, I, (O, U)>

The resulting type after applying the + operator.

fn add(self, other: Parser<'a, I, U>) -> Self::Output

Performs the + operation.

impl<'a, I, O: 'a> BitOr for Parser<'a, I, O>

Ordered choice

type Output = Parser<'a, I, O>

The resulting type after applying the | operator.

fn bitor(self, other: Parser<'a, I, O>) -> Self::Output

Performs the | operation.

impl<'a, I: 'a, O: 'a, U: 'a> Mul<Parser<'a, I, U>> for Parser<'a, I, O>

Sequence discard first value

type Output = Parser<'a, I, U>

The resulting type after applying the * operator.

fn mul(self, other: Parser<'a, I, U>) -> Self::Output

Performs the * operation.

impl<'a, I, O: 'a> Neg for Parser<'a, I, O>

And predicate

type Output = Parser<'a, I, bool>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<'a, I, O: 'a> Not for Parser<'a, I, O>

Not predicate

type Output = Parser<'a, I, bool>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<'a, I, O: 'a, U: 'a, F: Fn(O) -> Parser<'a, I, U> + 'a> Shr<F> for Parser<'a, I, O>

Chain two parsers where the second parser depends on the first’s result.

type Output = Parser<'a, I, U>

The resulting type after applying the >> operator.

fn shr(self, other: F) -> Self::Output

Performs the >> operation.

impl<'a, I, O: 'a, U: 'a> Sub<Parser<'a, I, U>> for Parser<'a, I, O>

Sequence discard second value

type Output = Parser<'a, I, O>

The resulting type after applying the - operator.

fn sub(self, other: Parser<'a, I, U>) -> Self::Output

Performs the - operation.