Struct restq_http::Parser

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

Parser combinator.

Fields

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

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), Error> + 'a, 

Create new parser.

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

Apply the parser to parse input.

pub fn parse_at(
    &self,
    input: &'a [I],
    start: usize
) -> Result<(O, usize), 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
    E: Debug,
    F: Fn(O) -> Result<U, E> + 'a,
    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
    O: 'a,
    R: RangeArgument<usize> + Debug + '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, U> Add<Parser<'a, I, U>> for Parser<'a, I, O> where
    O: 'a,
    U: 'a, 

Sequence reserve value

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

The resulting type after applying the + operator.

pub fn add(
    self,
    other: Parser<'a, I, U>
) -> <Parser<'a, I, O> as Add<Parser<'a, I, U>>>::Output

Performs the + operation.

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

Ordered choice

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

The resulting type after applying the | operator.

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

Performs the | operation.

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

Sequence discard first value

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

The resulting type after applying the * operator.

pub fn mul(
    self,
    other: Parser<'a, I, U>
) -> <Parser<'a, I, O> as Mul<Parser<'a, I, U>>>::Output

Performs the * operation.

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

And predicate

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

The resulting type after applying the - operator.

pub fn neg(self) -> <Parser<'a, I, O> as Neg>::Output

Performs the unary - operation.

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

Not predicate

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

The resulting type after applying the ! operator.

pub fn not(self) -> <Parser<'a, I, O> as Not>::Output

Performs the unary ! operation.

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

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.

pub fn shr(self, other: F) -> <Parser<'a, I, O> as Shr<F>>::Output

Performs the >> operation.

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

Sequence discard second value

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

The resulting type after applying the - operator.

pub fn sub(
    self,
    other: Parser<'a, I, U>
) -> <Parser<'a, I, O> as Sub<Parser<'a, I, U>>>::Output

Performs the - operation.