Trait bogobble::parser::Parser

pub trait Parser<'a>: Sized {
    type Out;
    fn parse(&self, it: &PIter<'a>) -> ParseRes<'a, Self::Out>;

    fn parse_s(&self, s: &'a str) -> Result<Self::Out, PErr<'a>> { ... }
    fn or<B: Parser<'a, Out = Self::Out>>(self, b: B) -> Or<Self, B> { ... }
    fn br(&self) -> BRP<'_, Self> { ... }
    fn asv<V: Clone>(self, v: V) -> Asv<Self, V> { ... }
    fn map<B, F: Fn(Self::Out) -> B>(self, f: F) -> Map<Self, F> { ... }
    fn try_map<B, F: Fn(Self::Out) -> Result<B, Expected>>(
        self, 
        f: F
    ) -> TryMap<Self, F> { ... }
    fn ig(self) -> Ig<Self> { ... }
    fn brk(self) -> Break<Self> { ... }
}

Associated Types

type Out

Required methods

fn parse(&self, it: &PIter<'a>) -> ParseRes<'a, Self::Out>

Provided methods

fn parse_s(&self, s: &'a str) -> Result<Self::Out, PErr<'a>>

fn or<B: Parser<'a, Out = Self::Out>>(self, b: B) -> Or<Self, B>

fn br(&self) -> BRP<'_, Self>

Borrowed Parser

fn asv<V: Clone>(self, v: V) -> Asv<Self, V>

fn map<B, F: Fn(Self::Out) -> B>(self, f: F) -> Map<Self, F>

fn try_map<B, F: Fn(Self::Out) -> Result<B, Expected>>(
    self,
    f: F
) -> TryMap<Self, F>

fn ig(self) -> Ig<Self>

fn brk(self) -> Break<Self>

Implementations on Foreign Types

impl<'a> Parser<'a> for &'static str

type Out = &'static str

fn parse(&self, i: &PIter<'a>) -> ParseRes<'a, Self::Out>

impl<'a> Parser<'a> for char

type Out = char

fn parse(&self, i: &PIter<'a>) -> ParseRes<'a, Self::Out>

impl<'a, A, B> Parser<'a> for (A, B) where
    A: Parser<'a>,
    B: Parser<'a>, 

type Out = (A::Out, B::Out)

fn parse(&self, it: &PIter<'a>) -> ParseRes<'a, Self::Out>

impl<'a, A, B, C> Parser<'a> for (A, B, C) where
    A: Parser<'a>,
    B: Parser<'a>,
    C: Parser<'a>, 

type Out = (A::Out, B::Out, C::Out)

fn parse(&self, it: &PIter<'a>) -> ParseRes<'a, Self::Out>

impl<'a, A, B, C, D> Parser<'a> for (A, B, C, D) where
    A: Parser<'a>,
    B: Parser<'a>,
    C: Parser<'a>,
    D: Parser<'a>, 

type Out = (A::Out, B::Out, C::Out, D::Out)

fn parse(&self, it: &PIter<'a>) -> ParseRes<'a, Self::Out>

impl<'a, A, B, C, D, E> Parser<'a> for (A, B, C, D, E) where
    A: Parser<'a>,
    B: Parser<'a>,
    C: Parser<'a>,
    D: Parser<'a>,
    E: Parser<'a>, 

type Out = (A::Out, B::Out, C::Out, D::Out, E::Out)

fn parse(&self, it: &PIter<'a>) -> ParseRes<'a, Self::Out>

impl<'a, A, B, C, D, E, F> Parser<'a> for (A, B, C, D, E, F) where
    A: Parser<'a>,
    B: Parser<'a>,
    C: Parser<'a>,
    D: Parser<'a>,
    E: Parser<'a>,
    F: Parser<'a>, 

type Out = (A::Out, B::Out, C::Out, D::Out, E::Out, F::Out)

fn parse(&self, it: &PIter<'a>) -> ParseRes<'a, Self::Out>

Implementors

impl<'a> Parser<'a> for Bool

fn parse(&self, it: &PIter<'a>) -> ParseRes<'a, Self::Out>

Parse run the main parser

type Out = bool

impl<'a> Parser<'a> for Esc

fn parse(&self, it: &PIter<'a>) -> ParseRes<'a, Self::Out>

Parse run the main parser

type Out = char

impl<'a> Parser<'a> for Exponent

fn parse(&self, it: &PIter<'a>) -> ParseRes<'a, Self::Out>

Parse run the main parser

type Out = isize

impl<'a> Parser<'a> for Float

fn parse(&self, it: &PIter<'a>) -> ParseRes<'a, Self::Out>

Parse run the main parser

type Out = f64

impl<'a> Parser<'a> for Ident

fn parse(&self, it: &PIter<'a>) -> ParseRes<'a, Self::Out>

Parse run the main parser

type Out = String

impl<'a> Parser<'a> for Int

fn parse(&self, it: &PIter<'a>) -> ParseRes<'a, Self::Out>

Parse run the main parser

type Out = isize

impl<'a> Parser<'a> for Quoted

fn parse(&self, it: &PIter<'a>) -> ParseRes<'a, Self::Out>

Parse run the main parser

type Out = String

impl<'a> Parser<'a> for UInt

fn parse(&self, it: &PIter<'a>) -> ParseRes<'a, Self::Out>

Parse run the main parser

type Out = usize

impl<'a> Parser<'a> for S

type Out = &'static str

fn parse(&self, it: &PIter<'a>) -> ParseRes<'a, Self::Out>

impl<'a> Parser<'a> for EOI

fn parse(&self, it: &PIter<'a>) -> ParseRes<'a, Self::Out>

Parse run the main parser

type Out = ()

impl<'a, 'b, P: Parser<'a>> Parser<'a> for BRP<'b, P>

type Out = P::Out

fn parse(&self, it: &PIter<'a>) -> ParseRes<'a, Self::Out>

impl<'a, A> Parser<'a> for Maybe<A> where
    A: Parser<'a>, 

type Out = Option<A::Out>

fn parse(&self, i: &PIter<'a>) -> ParseRes<'a, Self::Out>

impl<'a, A, B> Parser<'a> for Wrap<A, B> where
    A: Parser<'a>,
    B: Parser<'a>, 

type Out = B::Out

fn parse(&self, i: &PIter<'a>) -> ParseRes<'a, Self::Out>

impl<'a, A, B> Parser<'a> for PSepPlus<A, B> where
    A: Parser<'a>,
    B: Parser<'a>, 

type Out = Vec<A::Out>

fn parse(&self, it: &PIter<'a>) -> ParseRes<'a, Self::Out>

impl<'a, A, B> Parser<'a> for PSepStar<A, B> where
    A: Parser<'a>,
    B: Parser<'a>, 

type Out = Vec<A::Out>

fn parse(&self, it: &PIter<'a>) -> ParseRes<'a, Self::Out>

impl<'a, A, B> Parser<'a> for SepPlus<A, B> where
    A: Parser<'a>,
    B: Parser<'a>, 

type Out = Vec<A::Out>

fn parse(&self, it: &PIter<'a>) -> ParseRes<'a, Self::Out>

impl<'a, A, B> Parser<'a> for SepStar<A, B> where
    A: Parser<'a>,
    B: Parser<'a>, 

type Out = Vec<A::Out>

fn parse(&self, it: &PIter<'a>) -> ParseRes<'a, Self::Out>

impl<'a, A, B, C> Parser<'a> for Reflect<A, B, C> where
    A: Parser<'a>,
    B: Parser<'a>,
    C: Parser<'a>, 

type Out = (Vec<A::Out>, B::Out, Vec<C::Out>)

fn parse(&self, it: &PIter<'a>) -> ParseRes<'a, Self::Out>

impl<'a, A, B, C> Parser<'a> for SepUntil<A, B, C> where
    A: Parser<'a>,
    B: Parser<'a>,
    C: Parser<'a>, 

type Out = (Vec<A::Out>, C::Out)

fn parse(&self, i: &PIter<'a>) -> ParseRes<'a, Self::Out>

impl<'a, A, B, I> Parser<'a> for Merger<A, B, I> where
    A: Parser<'a, Out = PosTree<I>>,
    B: Parser<'a, Out = PosTree<I>>,
    I: Clone, 

type Out = PosTree<I>

fn parse(&self, it: &PIter<'a>) -> ParseRes<'a, PosTree<I>>

impl<'a, A, B, I> Parser<'a> for OPusher<A, B> where
    A: Parser<'a, Out = PosTree<I>>,
    B: Parser<'a, Out = Option<PosTree<I>>>,
    I: Clone, 

type Out = PosTree<I>

fn parse(&self, it: &PIter<'a>) -> ParseRes<'a, PosTree<I>>

impl<'a, A, B, I> Parser<'a> for Pusher<A, B> where
    A: Parser<'a, Out = PosTree<I>>,
    B: Parser<'a, Out = PosTree<I>>,
    I: Clone, 

type Out = PosTree<I>

fn parse(&self, it: &PIter<'a>) -> ParseRes<'a, PosTree<I>>

impl<'a, A, B, V> Parser<'a> for Or<A, B> where
    A: Parser<'a, Out = V>,
    B: Parser<'a, Out = V>, 

type Out = V

fn parse(&self, i: &PIter<'a>) -> ParseRes<'a, V>

impl<'a, A, R, O> Parser<'a> for FirstRes<A> where
    A: Parser<'a, Out = R>,
    R: Firster<Item = O>, 

type Out = O

fn parse(&self, i: &PIter<'a>) -> ParseRes<'a, Self::Out>

impl<'a, A, R, O> Parser<'a> for LastRes<A> where
    A: Parser<'a, Out = R>,
    R: Laster<Item = O>, 

type Out = O

fn parse(&self, i: &PIter<'a>) -> ParseRes<'a, Self::Out>

impl<'a, A: CharBool> Parser<'a> for CharExact<A>

type Out = &'a str

fn parse(&self, i: &PIter<'a>) -> ParseRes<'a, Self::Out>

impl<'a, A: CharBool> Parser<'a> for CharMin<A>

type Out = &'a str

fn parse(&self, i: &PIter<'a>) -> ParseRes<'a, Self::Out>

impl<'a, A: CharBool, E: Parser<'a>> Parser<'a> for CharUntil<A, E>

type Out = (&'a str, E::Out)

fn parse(&self, i_start: &PIter<'a>) -> ParseRes<'a, Self::Out>

impl<'a, A: Parser<'a>> Parser<'a> for PExact<A>

type Out = Vec<A::Out>

fn parse(&self, it: &PIter<'a>) -> ParseRes<'a, Vec<A::Out>>

impl<'a, A: Parser<'a>> Parser<'a> for PPlus<A>

type Out = Vec<A::Out>

fn parse(&self, i: &PIter<'a>) -> ParseRes<'a, Self::Out>

impl<'a, A: Parser<'a>> Parser<'a> for PStar<A>

type Out = Vec<A::Out>

fn parse(&self, i: &PIter<'a>) -> ParseRes<'a, Self::Out>

impl<'a, A: Parser<'a>> Parser<'a> for Exact<A>

type Out = Vec<A::Out>

fn parse(&self, it: &PIter<'a>) -> ParseRes<'a, Vec<A::Out>>

impl<'a, A: Parser<'a>> Parser<'a> for Plus<A>

type Out = Vec<A::Out>

fn parse(&self, i: &PIter<'a>) -> ParseRes<'a, Self::Out>

impl<'a, A: Parser<'a>> Parser<'a> for Star<A>

type Out = Vec<A::Out>

fn parse(&self, i: &PIter<'a>) -> ParseRes<'a, Self::Out>

impl<'a, A: Parser<'a>> Parser<'a> for Ig<A>

type Out = ()

fn parse(&self, i: &PIter<'a>) -> ParseRes<'a, Self::Out>

impl<'a, A: Parser<'a>> Parser<'a> for StringsPlus<A> where
    A::Out: AsRef<str>, 

type Out = String

fn parse(&self, it: &PIter<'a>) -> ParseRes<'a, String>

impl<'a, A: Parser<'a>> Parser<'a> for Break<A>

type Out = A::Out

fn parse(&self, it: &PIter<'a>) -> ParseRes<'a, A::Out>

impl<'a, A: Parser<'a>, B, F: Fn(A::Out) -> Result<B, Expected>> Parser<'a> for TryMap<A, F>

type Out = B

fn parse(&self, i: &PIter<'a>) -> ParseRes<'a, B>

impl<'a, A: Parser<'a>, B, F: Fn(A::Out) -> B> Parser<'a> for Map<A, F>

type Out = B

fn parse(&self, i: &PIter<'a>) -> ParseRes<'a, B>

impl<'a, A: Parser<'a>, B: Parser<'a>> Parser<'a> for PlusUntil<A, B>

type Out = (Vec<A::Out>, B::Out)

fn parse(&self, i: &PIter<'a>) -> ParseRes<'a, Self::Out>

impl<'a, A: Parser<'a>, B: Parser<'a>> Parser<'a> for StarUntil<A, B>

type Out = (Vec<A::Out>, B::Out)

fn parse(&self, i: &PIter<'a>) -> ParseRes<'a, Self::Out>

impl<'a, A: Parser<'a>, B: Parser<'a>> Parser<'a> for First<A, B>

type Out = A::Out

fn parse(&self, i: &PIter<'a>) -> ParseRes<'a, Self::Out>

impl<'a, A: Parser<'a>, B: Parser<'a>> Parser<'a> for Last<A, B>

type Out = B::Out

fn parse(&self, i: &PIter<'a>) -> ParseRes<'a, Self::Out>

impl<'a, A: Parser<'a>, B: Parser<'a>, C: Parser<'a>> Parser<'a> for Middle<A, B, C>

type Out = B::Out

fn parse(&self, i: &PIter<'a>) -> ParseRes<'a, Self::Out>

impl<'a, A: Parser<'a>, V: Clone> Parser<'a> for Asv<A, V>

type Out = V

fn parse(&self, i: &PIter<'a>) -> ParseRes<'a, V>

impl<'a, A: Parser<'a, Out = char>, B: Parser<'a>> Parser<'a> for CharsUntil<A, B>

type Out = (String, B::Out)

fn parse(&self, it: &PIter<'a>) -> ParseRes<'a, Self::Out>

impl<'a, A: Parser<'a, Out = String>, B: Parser<'a>> Parser<'a> for StringsPlusUntil<A, B>

type Out = (String, B::Out)

fn parse(&self, it: &PIter<'a>) -> ParseRes<'a, Self::Out>

impl<'a, A: Parser<'a, Out = String>, B: Parser<'a>> Parser<'a> for StringsStarUntil<A, B>

type Out = (String, B::Out)

fn parse(&self, it: &PIter<'a>) -> ParseRes<'a, Self::Out>

impl<'a, A: Parser<'a, Out = AV>, AV: Into<String> + AsRef<str>> Parser<'a> for StringRepeat<A>

type Out = String

fn parse(&self, it: &PIter<'a>) -> ParseRes<'a, String>

impl<'a, C: CharBool, P: Parser<'a, Out = PosTree<I>>, I: Clone> Parser<'a> for PCUntil<C, P, I>

type Out = (PosTree<I>, P::Out)

fn parse(&self, it: &PIter<'a>) -> ParseRes<'a, Self::Out>

impl<'a, CB: CharBool> Parser<'a> for CharPlus<CB>

type Out = &'a str

fn parse(&self, i: &PIter<'a>) -> ParseRes<'a, &'a str>

impl<'a, CB: CharBool> Parser<'a> for CharStar<CB>

type Out = &'a str

fn parse(&self, i: &PIter<'a>) -> ParseRes<'a, Self::Out>

impl<'a, CB: CharBool> Parser<'a> for ICharExact<CB>

type Out = ()

fn parse(&self, i: &PIter<'a>) -> ParseRes<'a, Self::Out>

impl<'a, CB: CharBool> Parser<'a> for ICharPlus<CB>

type Out = ()

fn parse(&self, i: &PIter<'a>) -> ParseRes<'a, Self::Out>

impl<'a, CB: CharBool> Parser<'a> for ICharStar<CB>

type Out = ()

fn parse(&self, i: &PIter<'a>) -> ParseRes<'a, Self::Out>

impl<'a, CB: CharBool> Parser<'a> for OneChar<CB>

type Out = char

fn parse(&self, it: &PIter<'a>) -> ParseRes<'a, char>

impl<'a, F, V> Parser<'a> for F where
    F: Fn(&PIter<'a>) -> ParseRes<'a, V>, 

type Out = V

fn parse(&self, it: &PIter<'a>) -> ParseRes<'a, V>

impl<'a, I: Clone, P: Parser<'a, Out = PosTree<I>>> Parser<'a> for PMaybe<P, I>

type Out = PosTree<I>

fn parse(&self, it: &PIter<'a>) -> ParseRes<'a, Self::Out>

impl<'a, P: Parser<'a>> Parser<'a> for Exists<P>

type Out = bool

fn parse(&self, it: &PIter<'a>) -> ParseRes<'a, bool>

impl<'a, P: Parser<'a>> Parser<'a> for PDebugger<P>

type Out = P::Out

fn parse(&self, it: &PIter<'a>) -> ParseRes<'a, Self::Out>

impl<'a, P: Parser<'a>> Parser<'a> for KeyWord<P>

type Out = P::Out

fn parse(&self, it: &PIter<'a>) -> ParseRes<'a, P::Out>

impl<'a, P: Parser<'a>> Parser<'a> for PPos<P>

type Out = Pos<P::Out>

fn parse(&self, it: &PIter<'a>) -> ParseRes<'a, Self::Out>

impl<'a, P: Parser<'a>> Parser<'a> for Peek<P>

type Out = P::Out

fn parse(&self, it: &PIter<'a>) -> ParseRes<'a, P::Out>

impl<'a, P: Parser<'a>> Parser<'a> for WN_<P>

type Out = P::Out

fn parse(&self, it: &PIter<'a>) -> ParseRes<'a, Self::Out>

impl<'a, P: Parser<'a>> Parser<'a> for WS_<P>

type Out = P::Out

fn parse(&self, it: &PIter<'a>) -> ParseRes<'a, Self::Out>

impl<'a, P: Parser<'a>> Parser<'a> for WS__<P>

type Out = P::Out

fn parse(&self, it: &PIter<'a>) -> ParseRes<'a, Self::Out>

impl<'a, P: Parser<'a>> Parser<'a> for StrRange<P>

type Out = &'a str

fn parse(&self, i: &PIter<'a>) -> ParseRes<'a, Self::Out>

impl<'a, P: Parser<'a>> Parser<'a> for StringRange<P>

type Out = String

fn parse(&self, i: &PIter<'a>) -> ParseRes<'a, Self::Out>

impl<'a, P: Parser<'a>, I: Clone> Parser<'a> for PosTreeParse<P, I>

type Out = PosTree<I>

fn parse(&self, it: &PIter<'a>) -> ParseRes<'a, PosTree<I>>

impl<'a, P: Parser<'a, Out = Vec<PosTree<I>>>, I: Clone> Parser<'a> for PosVecParse<P, I>

type Out = PosTree<I>

fn parse(&self, it: &PIter<'a>) -> ParseRes<'a, Self::Out>

impl<'a, P: Parser<'a, Out = V>, V: Debug> Parser<'a> for FailOn<P>

type Out = ()

fn parse(&self, it: &PIter<'a>) -> ParseRes<'a, ()>