Struct pom::parser::Parser

pub struct Parser<'a, I, O> {
    pub method: Box<dyn Fn(&'a [I], usize) -> Result<(O, usize)> + 'a>,
}

Parser combinator.

Fields

method: Box<dyn Fn(&'a [I], usize) -> Result<(O, usize)> + 'a>

Methods

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)> + '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)>

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) -> 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 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.

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<Parser<'a, I, O>> 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.