Struct MapErr 

pub struct MapErr<T, P, F, E>
where
    P: Parse<T>,
    F: Fn(P::Err) -> E,
{ /* private fields */ }

The parser for Parse::map_err, see method for documentation.

Trait Implementations

impl<T: Clone, P, F, E: Clone> Clone for MapErr<T, P, F, E>

where P: Parse<T> + Clone, F: Fn(P::Err) -> E + Clone,

fn clone(&self) -> MapErr<T, P, F, E>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug, P, F, E: Debug> Debug for MapErr<T, P, F, E>

where P: Parse<T> + Debug, F: Fn(P::Err) -> E + Debug,

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

Formats the value using the given formatter.

impl<T: Hash, P, F, E: Hash> Hash for MapErr<T, P, F, E>

where P: Parse<T> + Hash, F: Fn(P::Err) -> E + Hash,

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T, P, F, E> Parse<T> for MapErr<T, P, F, E>

where P: Parse<T>, F: Fn(P::Err) -> E,

type Err = E

type Output = <P as Parse<T>>::Output

fn parse(self, input: T) -> Result<(T, Self::Output), Self::Err>

Try to parse part of a slice, returning a tuple of the remainder (the unparsed slice) and the output value.

fn map<F, O>(self, func: F) -> Map<T, Self, F, O>

where F: Fn(Self::Output) -> O, Self: Sized,

Maps the output of a parser with a function to produce a new output.

fn map_err<F, E>(self, func: F) -> MapErr<T, Self, F, E>

where F: Fn(Self::Err) -> E, Self: Sized,

Maps the error of a parser with a function to produce a new error.

fn maybe(self) -> Maybe<T, Self>

where T: Clone, Self: Sized,

Executes the parser if possible, wrapping up the output in an Option.

fn chain<I>(self, inner: I) -> Chain<T, Self, I>

where I: Parse<Self::Output, Err = Self::Err>, Self: Sized,

Parses the output of this parser with an inner parser, and passes the output through.

fn or<O>(self, other: O) -> Or<T, Self, O>

where T: Clone, O: Parse<T, Output = Self::Output, Err = Self::Err>, Self: Sized,

Takes the union of both combinators, accepting input which passes either parser. Both parsers must output the same type.

fn and<O>(self, length_err: Self::Err, other: O) -> And<T, Self, O>

where T: Clone + Eq, O: Parse<T, Err = Self::Err>, Self: Sized,

Takes the conjunction of both combinators, accepting input which passes both parsers. The remainders of both combinators must be equal, otherwise the specified length error is yielded.

fn fuse<O>(self, other: O) -> Fuse<T, Self, O>

where O: Parse<T, Err = Self::Err>, Self: Sized,

Accepts input which passes this parser first and then other, packing the output as a tuple. The remainder of the input is passed to other.

fn fuse_extend<O>(self, other: O) -> FuseExtend<T, Self, Self::Output, O>

where O: Parse<T, Err = Self::Err>, Self::Output: Extend<O::Output>, Self: Sized,

Accepts input which passes this parser first and then other, extending this output with other’s output. The remainder of the input is passed to other.

fn repeat_const<const N: usize>(self) -> RepeatConst<T, Self, N>

where Self: Clone + Sized,

Accepts exactly a constant amount of repetitions of this parser, packing the output as a constant array.

fn repeat_greedy<O>(self, default: O) -> RepeatGreedy<T, Self, O>

where T: Clone, O: Extend<Self::Output>, Self: Clone + Sized,

Accepts any amount of repetitions of this parser, extending the output into the given collection.

impl<T: PartialEq, P, F, E: PartialEq> PartialEq for MapErr<T, P, F, E>

where P: Parse<T> + PartialEq, F: Fn(P::Err) -> E + PartialEq,

fn eq(&self, other: &MapErr<T, P, F, E>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: Eq, P, F, E: Eq> Eq for MapErr<T, P, F, E>

where P: Parse<T> + Eq, F: Fn(P::Err) -> E + Eq,

impl<T, P, F, E> StructuralPartialEq for MapErr<T, P, F, E>

where P: Parse<T>, F: Fn(P::Err) -> E,