Struct transduce::Parser

pub struct Parser<'input, Inside: Parse<'input>>(_, _);

Wrapper around a parser to work with the orphan rule.

Implementations

impl<'input, Inside: Parse<'input>> Parser<'input, Inside>

pub const fn new(inside: Inside) -> Self

Create a Parser without worrying about workarounds like PhantomData.

pub fn parse( &self, input: &'input [Inside::Input] ) -> Result<Inside::Output, String>

Parse a list of items (usually characters, in which case this “list of characters” is effectively a string).

Errors

If parsing fails, if we run out of input, or if we have leftover input afterward.

pub fn parse_or_panic(&self, slice: &'input [Inside::Input]) -> Inside::Output

Parse a list of items (usually characters, in which case this “list of characters” is effectively a string).

Panics

If parsing fails, if we run out of input, or if we have leftover input afterward.

pub const fn discard_left<Right: Parse<'input, Input = Inside::Input>>( self, right: Parser<'input, Right> ) -> Parser<'input, DiscardLeft<'input, Inside, Right>>

Consume this parser and integrate it into a two-part parser that returns only the second result.

pub const fn discard_right<Right: Parse<'input, Input = Inside::Input>>( self, right: Parser<'input, Right> ) -> Parser<'input, DiscardRight<'input, Inside, Right>>

Consume this parser and integrate it into a two-part parser that returns only the first result.

pub const fn both<Right: Parse<'input, Input = Inside::Input>>( self, right: Parser<'input, Right> ) -> Parser<'input, Both<'input, Inside, Right>>

Consume this parser and integrate it into a two-part parser that returns both results as a tuple.

pub const fn either<Right: Parse<'input, Input = Inside::Input, Output = Inside::Output>>( self, right: Parser<'input, Right> ) -> Parser<'input, Either<'input, Inside, Right>>

Consume this parser and integrate it into a two-part parser that returns the first one to succeed, or the second error if neither succeed.

pub const fn pipe<FinalOutput, Right: Fn(Inside::Output) -> Result<FinalOutput, String>>( self, right: Right ) -> Parser<'input, Pipe<'input, Inside, FinalOutput, Right>>

Consume this parser and integrate it into a two-part parser that pipes parsed output into a normal function and returns its output.

Trait Implementations

impl<'input, Left: Parse<'input>, Right: Parse<'input, Input = Left::Input>> BitAnd<Parser<'input, Right>> for Parser<'input, Left>

type Output = Parser<'input, Both<'input, Left, Right>>

The resulting type after applying the & operator.

fn bitand(self, rhs: Parser<'input, Right>) -> Self::Output

Performs the & operation.

impl<'input, Left: Parse<'input>, Right: Parse<'input, Input = Left::Input, Output = Left::Output>> BitOr<Parser<'input, Right>> for Parser<'input, Left>

type Output = Parser<'input, Either<'input, Left, Right>>

The resulting type after applying the | operator.

fn bitor(self, rhs: Parser<'input, Right>) -> Self::Output

Performs the | operation.

impl<'input, Left: Parse<'input>, FinalOutput, Right: Fn(Left::Output) -> Result<FinalOutput, String>> BitXor<Right> for Parser<'input, Left>

type Output = Parser<'input, Pipe<'input, Left, FinalOutput, Right>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Right) -> Self::Output

Performs the ^ operation.

impl<'input, Inside: Clone + Parse<'input>> Clone for Parser<'input, Inside>

fn clone(&self) -> Parser<'input, Inside>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'input, Inside: Debug + Parse<'input>> Debug for Parser<'input, Inside>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'input, Inside: Parse<'input>> Parse<'input> for Parser<'input, Inside>

type Input = <Inside as Parse<'input>>::Input

Raw type, of which we parse a slice. E.g. u8 if we want to parse a string of bytes, not &[u8]: the slice is implied.

type Output = <Inside as Parse<'input>>::Output

Output of parsing a slice of Inputs.

fn partial( &self, input: &'input [Self::Input] ) -> Result<(Self::Output, &'input [Self::Input]), ParseError>

Parse exactly one item of input; don’t continue without further instruction.

impl<'input, Left: Parse<'input>, Right: Parse<'input, Input = Left::Input>> Shl<Parser<'input, Right>> for Parser<'input, Left>

type Output = Parser<'input, DiscardRight<'input, Left, Right>>

The resulting type after applying the << operator.

fn shl(self, rhs: Parser<'input, Right>) -> Self::Output

Performs the << operation.

impl<'input, Left: Parse<'input, Input = Right::Input>, Right: Parse<'input>> Shr<Parser<'input, Right>> for Parser<'input, Left>

type Output = Parser<'input, DiscardLeft<'input, Left, Right>>

The resulting type after applying the >> operator.

fn shr(self, rhs: Parser<'input, Right>) -> Self::Output

Performs the >> operation.