Struct Chain

pub struct Chain<T, U, P1, P2> { /* private fields */ }

Chains two parsers together.

Follows error coercion rules.

let mut input = ParserString::from("abc   ");
let (string, after) = word.chain(whitespace).parse(&mut input)?;

assert_eq!(string, "abc");
assert_eq!(after, 3);

Implementations

impl<T, U, P1, P2, E> Chain<T, U, P1, P2>

where P1: Parser<T>, E: Into<P1::Err>, P2: Parser<U, Err = E>,

pub fn new(p1: P1, p2: P2) -> Self

Constructs this parser.

Trait Implementations

impl<T, U, P1, P2, E> Parser<(T, U)> for Chain<T, U, P1, P2>

where P1: Parser<T>, E: Into<P1::Err>, P2: Parser<U, Err = E>,

type Err = <P1 as Parser<T>>::Err

The error type this parser can return

fn parse(&self, s: &mut ParserString) -> Result<(T, U), Self::Err>

Run this parser, using a ParserString.

fn try_parse(&self, s: &mut ParserString) -> Result<T, Self::Err>

Run this parser without affecting the string on failure. In other words, the string will be “rewinded” on failure.

fn chain<U, P2: Parser<U, Err = E>, E: Into<Self::Err>>( self, other: P2, ) -> Chain<T, U, Self, P2>

Constructs a Chain combinator.

fn or<P2: Parser<T, Err = E>, E: Into<Self::Err>>( self, other: P2, ) -> Or<T, E, Self, P2>

Constructs a Or combinator.

fn many(self) -> Many<T, Self>

Constructs a Many combinator.

fn many1(self) -> Many1<T, Self>

Constructs a Many1 combinator.

fn map<U: 'static>( self, f: impl Fn(T) -> U + 'static, ) -> impl Parser<U, Err = Self::Err>

Apply a function to the output of this parser on success.

fn map_err<E: 'static>( self, f: impl Fn(Self::Err) -> E + 'static, ) -> impl Parser<T, Err = E>

Apply a function to the Err output of this parser on failure.

fn and_then<U: 'static, E: Into<Self::Err>>( self, f: impl Fn(T) -> Result<U, E> + 'static, ) -> impl Parser<U, Err = Self::Err>

Applies a function to the output of this parser on success, using error coercion rules.

fn after<U, P2: Parser<U, Err = E>, E: Into<Self::Err>>( self, other: P2, ) -> impl Parser<T, Err = Self::Err>

Similar to Chain, but only keeps the output of the first parser.

fn replace<U, P2: Parser<U, Err = E>, E: Into<Self::Err>>( self, other: P2, ) -> impl Parser<U, Err = Self::Err>

Similar to Chain, but only keeps the output of the second parser.

fn convert_err<E: From<Self::Err> + 'static>(self) -> impl Parser<T, Err = E>

Explicitly sets the target error type of this parser. Can help with type inference.