Struct parser_fuck::combinators::And

pub struct And<A, B, I = ()> { /* private fields */ }

Only pass if both subparsers pass

Implementations

impl<I: TimeTravel, A, B> And<A, B, I>where A: Parser<I>, B: Parser<I>,

pub fn new(a: A, b: B) -> Self

Trait Implementations

impl<A: Clone, B: Clone, I: Clone> Clone for And<A, B, I>

fn clone(&self) -> And<A, B, I>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<A: Debug, B: Debug, I: Debug> Debug for And<A, B, I>

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

Formats the value using the given formatter.

impl<I: TimeTravel, A, B> Parser<I> for And<A, B, I>where A: Parser<I>, B: Parser<I>,

type Output = (<A as Parser<I>>::Output, <B as Parser<I>>::Output)

fn parse(&self, input: I) -> Option<Self::Output>

do parse

fn map<U, F>(self, f: F) -> Map<Self, I, F>where Self: Sized, F: FnMut(Self::Output) -> U,

Map a Parser<Output = T> to Parser<Output = U> by applying a function to a contained value

fn and<B>(self, b: B) -> And<Self, B, I>where Self: Sized, B: Parser<I>,

Only pass if both subparsers pass

fn or<B>(self, b: B) -> Or<Self, B, I>where Self: Sized, B: Parser<I, Output = Self::Output>,

Pass when any subparser passes

fn not(self) -> Not<Self, I>where Self: Sized,

Pass if the subparser fail

fn many(self) -> Many<Self, I>where Self: Sized,

*, >= 0

fn many1(self) -> Many<Self, I>where Self: Sized,

+, >= 1

fn many_min(self, min: usize) -> Many<Self, I>where Self: Sized,

{n,}, >= n

fn many_max(self, max: usize) -> Many<Self, I>where Self: Sized,

{,m}, <= m

fn many1_max(self, max: usize) -> Many<Self, I>where Self: Sized,

{1,m}, >= 1 && <= m

fn many_min_max(self, min: usize, max: usize) -> Many<Self, I>where Self: Sized,

{n,m}, >= n && <= m

fn some(self, count: usize) -> Many<Self, I>where Self: Sized,

{n}, == n

fn may(self) -> May<Self, I>where Self: Sized,

?, 0 or 1

fn iter(self) -> Iter<Self, I>where Self: Sized,

Continuously parse into iterators

fn and_then<U, F>(self, f: F) -> AndThen<Self, I, F>where Self: Sized, U: Parser<I>, F: FnMut(Self::Output) -> U,

Fail if the subparser fail, otherwise calls f with the new Parser and parse the Parser

fn or_else<U, F>(self, f: F) -> OrElse<Self, I, F>where Self: Sized, U: Parser<I, Output = Self::Output>, F: FnMut() -> U,

Pass if subparser pass, otherwise calls f and parse the result Parser

fn or_trans<F>(self, no_retry: bool, f: F) -> OrTrans<Self, I, F>where Self: Sized, F: FnMut(I, Range<usize>) -> Self::Output,

Pass if subparser pass, otherwise calls f with error point

fn or_trans_noend<F>(self, no_retry: bool, f: F) -> OrTrans<Self, I, F>where Self: Sized, F: FnMut(I, Range<usize>) -> Self::Output,

Pass if subparser pass, otherwise calls f with error point, but ignore EOF

fn dyns(self) -> Dyn<I, Self::Output>where Self: Sized + 'static,

Wrap to dynamic

impl<A: PartialEq, B: PartialEq, I: PartialEq> PartialEq for And<A, B, I>

fn eq(&self, other: &And<A, B, I>) -> bool

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

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

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

impl<A: Eq, B: Eq, I: Eq> Eq for And<A, B, I>

impl<A, B, I> StructuralEq for And<A, B, I>

impl<A, B, I> StructuralPartialEq for And<A, B, I>