Trait Parser 

pub trait Parser<I: TimeTravel> {
    type Output;

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

    // Provided methods
    fn map<U, F>(self, f: F) -> Map<Self, I, F>
       where Self: Sized,
             F: FnMut(Self::Output) -> U { ... }
    fn and<B>(self, b: B) -> And<Self, B, I>
       where Self: Sized,
             B: Parser<I> { ... }
    fn or<B>(self, b: B) -> Or<Self, B, I>
       where Self: Sized,
             B: Parser<I, Output = Self::Output> { ... }
    fn not(self) -> Not<Self, I>
       where Self: Sized { ... }
    fn many(self) -> Many<Self, I>
       where Self: Sized { ... }
    fn many1(self) -> Many<Self, I>
       where Self: Sized { ... }
    fn many_min(self, min: usize) -> Many<Self, I>
       where Self: Sized { ... }
    fn many_max(self, max: usize) -> Many<Self, I>
       where Self: Sized { ... }
    fn many1_max(self, max: usize) -> Many<Self, I>
       where Self: Sized { ... }
    fn many_min_max(self, min: usize, max: usize) -> Many<Self, I>
       where Self: Sized { ... }
    fn some(self, count: usize) -> Many<Self, I>
       where Self: Sized { ... }
    fn may(self) -> May<Self, I>
       where Self: Sized { ... }
    fn iter(self) -> Iter<Self, I>
       where Self: Sized { ... }
    fn and_then<U, F>(self, f: F) -> AndThen<Self, I, F>
       where Self: Sized,
             U: Parser<I>,
             F: FnMut(Self::Output) -> U { ... }
    fn or_else<U, F>(self, f: F) -> OrElse<Self, I, F>
       where Self: Sized,
             U: Parser<I, Output = Self::Output>,
             F: FnMut() -> U { ... }
    fn or_trans<F>(self, no_retry: bool, f: F) -> OrTrans<Self, I, F>
       where Self: Sized,
             F: FnMut(I, Range<usize>) -> Self::Output { ... }
    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 { ... }
    fn dyns(self) -> Dyn<I, Self::Output>
       where Self: Sized + 'static { ... }
}

Abstract Parser with chain call

Required Associated Types

type Output

Required Methods

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

do parse

Provided Methods

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

• no_retry Stop immediately without trying to get the error range

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

• no_retry Stop immediately without trying to get the error range

fn dyns(self) -> Dyn<I, Self::Output>

where Self: Sized + 'static,

Wrap to dynamic

Implementors

impl<B: Parser<I>, I: TimeTravel, F> Parser<I> for OrTrans<B, I, F>

where F: FnMut(I, Range<usize>) -> B::Output,

type Output = <B as Parser<I>>::Output

impl<B: Parser<I>, I: TimeTravel, U, F> Parser<I> for AndThen<B, I, F>

where U: Parser<I>, F: FnMut(B::Output) -> U,

type Output = <U as Parser<I>>::Output

impl<B: Parser<I>, I: TimeTravel, U, F> Parser<I> for Map<B, I, F>

where F: FnMut(B::Output) -> U,

type Output = U

impl<B: Parser<I>, I: TimeTravel, U, F> Parser<I> for OrElse<B, I, F>

where U: Parser<I, Output = B::Output>, F: FnMut() -> U,

type Output = <B as Parser<I>>::Output

impl<I, F> Parser<I> for Satisfy<F, I>

where I: TimeTravel, F: FnMut(I::Item) -> bool,

type Output = Range<usize>

impl<I, U, F> Parser<I> for F

where I: TimeTravel, F: Fn(I) -> Option<U>,

type Output = U

impl<I: TimeTravel, A> Parser<I> for Iter<A, I>

where A: Parser<I> + Clone,

type Output = ParserIter<A, I>

impl<I: TimeTravel, A> Parser<I> for Many<A, I>

where A: Parser<I>,

type Output = Vec<<A as Parser<I>>::Output>

impl<I: TimeTravel, A> Parser<I> for May<A, I>

where A: Parser<I>,

type Output = Option<<A as Parser<I>>::Output>

impl<I: TimeTravel, A> Parser<I> for Not<A, I>

where A: Parser<I>,

type Output = ()

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)

impl<I: TimeTravel, A, B> Parser<I> for Or<A, B, I>

where A: Parser<I>, B: Parser<I, Output = A::Output>,

type Output = <A as Parser<I>>::Output

impl<I: TimeTravel, O> Parser<I> for Dyn<I, O>

type Output = O

impl<I: TimeTravel, T> Parser<I> for One<T>

where I::Item: PartialEq<T>,

type Output = Range<usize>

impl<I: TimeTravel, T> Parser<I> for Sub<T>

where I::Item: PartialEq<T>,

type Output = Range<usize>