Struct restq_http::Parser

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

Parser combinator.

Fields

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

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

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

Performs the + operation.

impl<'a, Left, Right> Add<Parser<'a, Right>> for Parser<'a, u8, Left>

where Left: 'a, Right: 'a,

Sequence reserve value (but degrade to non-utf8 parser)

type Output = Parser<'a, u8, (Left, Right)>

The resulting type after applying the + operator.

fn add( self, other: Parser<'a, Right> ) -> <Parser<'a, u8, Left> as Add<Parser<'a, Right>>>::Output

Performs the + operation.

impl<'a, O> BitOr<Parser<'a, O>> for Parser<'a, u8, O>

where O: 'a,

Ordered choice (but degrade to non-utf8 parser)

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

The resulting type after applying the | operator.

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

Performs the | operation.

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

where O: 'a,

Ordered choice

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

The resulting type after applying the | operator.

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

Performs the | operation.

impl<'a, O> From<Parser<'a, O>> for Parser<'a, u8, O>

fn from(parser: Parser<'a, O>) -> Parser<'a, u8, O>

Converts to this type from the input type.

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.

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

Performs the * operation.

impl<'a, Left, Right> Mul<Parser<'a, Right>> for Parser<'a, u8, Left>

where Left: 'a, Right: 'a,

Sequence discard first value (but degrade to non-utf8 parser)

type Output = Parser<'a, u8, Right>

The resulting type after applying the * operator.

fn mul( self, other: Parser<'a, Right> ) -> <Parser<'a, u8, Left> as Mul<Parser<'a, Right>>>::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.

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.

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 O: 'a, U: 'a, F: Fn(O) -> Parser<'a, I, 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.

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.

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

Performs the - operation.

impl<'a, Left, Right> Sub<Parser<'a, Right>> for Parser<'a, u8, Left>

where Left: 'a, Right: 'a,

Sequence discard second value (but degrade to non-utf8 parser)

type Output = Parser<'a, u8, Left>

The resulting type after applying the - operator.

fn sub( self, other: Parser<'a, Right> ) -> <Parser<'a, u8, Left> as Sub<Parser<'a, Right>>>::Output

Performs the - operation.