Struct pcomb::parse::Match

pub struct Match<T: Slice + Eq>(pub T);

Accepts the slice if the input matches the specified sliced.

Tuple Fields

0: T

Trait Implementations

impl<T: Clone + Slice + Eq> Clone for Match<T>

fn clone(&self) -> Match<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug + Slice + Eq> Debug for Match<T>

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

Formats the value using the given formatter.

impl<T: Hash + Slice + Eq> Hash for Match<T>

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, 

Feeds a slice of this type into the given Hasher.

impl<T: Slice<Output = T> + Eq> Parse<T> for Match<T>

type Err = ParseError

type Output = 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 + Slice + Eq> PartialEq<Match<T>> for Match<T>

fn eq(&self, other: &Match<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Match<T>) -> bool

This method tests for !=.

impl<T: Eq + Slice> Eq for Match<T>

impl<T: Slice + Eq> StructuralEq for Match<T>

impl<T: Slice + Eq> StructuralPartialEq for Match<T>