Trait gobble::ptrait::Parser

pub trait Parser<V>: Sized {
    fn parse<'a>(&self, i: &LCChars<'a>) -> ParseRes<'a, V>;

    fn parse_s(&self, s: &str) -> Result<V, ParseError> { ... }
    fn parse_sn<'a>(&self, s: &'a str) -> Result<(&'a str, V), ParseError> { ... }
    fn then<P: Parser<V2>, V2>(self, p: P) -> Then<Self, P> { ... }
    fn then_ig<P: Parser<V2>, V2>(self, p: P) -> ThenIg<Self, P, V, V2> { ... }
    fn ig_then<P: Parser<V2>, V2>(self, p: P) -> IgThen<Self, P, V, V2> { ... }
    fn or<P: Parser<V>>(self, p: P) -> Or<Self, P> { ... }
    fn map<F: Fn(V) -> V2, V2>(self, f: F) -> Map<Self, V, V2, F> { ... }
    fn try_map<F: Fn(V) -> Result<V2, ECode>, V2>(
        self, 
        f: F
    ) -> TryMap<Self, V, V2, F> { ... }
    fn asv<R: Clone>(self, r: R) -> As<Self, V, R> { ... }
    fn map_err<F: Fn(ECode) -> ECode>(self, f: F) -> MapErr<Self, V, F> { ... }
    fn brk(self) -> Break<Self, V> { ... }
}

The core trait for parsing

Required methods

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

Loading content...

Provided methods

fn parse_s(&self, s: &str) -> Result<V, ParseError>

fn parse_sn<'a>(&self, s: &'a str) -> Result<(&'a str, V), ParseError>

fn then<P: Parser<V2>, V2>(self, p: P) -> Then<Self, P>

returns a parser that will combine the results of this and the given parser into a tuple

fn then_ig<P: Parser<V2>, V2>(self, p: P) -> ThenIg<Self, P, V, V2>

returns a Parser that will require the given parser completes, but ignores its result useful for dropping brackets and whitespace

fn ig_then<P: Parser<V2>, V2>(self, p: P) -> IgThen<Self, P, V, V2>

returns a Parser that will require this parser completes, but only return the result of the given parser useful for dropping brackets and whitespace etc

fn or<P: Parser<V>>(self, p: P) -> Or<Self, P>

Returns a Parser that will try both child parsers, (A first) and return the first successfl result

fn map<F: Fn(V) -> V2, V2>(self, f: F) -> Map<Self, V, V2, F>

Returns a Parser that converts the result of a successful parse to a different type. Much like map on iterators and Result

fn try_map<F: Fn(V) -> Result<V2, ECode>, V2>(
    self,
    f: F
) -> TryMap<Self, V, V2, F>

Returns a Parser that converts the result of a successful parse to a different type. however the map function can fail and return a result The Error type should be err::ECode, this does not have line associated. That will be attacked by the TryMap object so this will pass that error up correctly

fn asv<R: Clone>(self, r: R) -> As<Self, V, R>

fn map_err<F: Fn(ECode) -> ECode>(self, f: F) -> MapErr<Self, V, F>

fn brk(self) -> Break<Self, V>

Loading content...

Implementations on Foreign Types

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

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

impl Parser<char> for char

fn parse<'a>(&self, i: &LCChars<'a>) -> ParseRes<'a, char>

impl<A, AV, B, BV> Parser<(AV, BV)> for (A, B) where
    A: Parser<AV>,
    B: Parser<BV>, 

fn parse<'a>(&self, it: &LCChars<'a>) -> ParseRes<'a, (AV, BV)>

impl<A, AV, B, BV, C, CV> Parser<(AV, BV, CV)> for (A, B, C) where
    A: Parser<AV>,
    B: Parser<BV>,
    C: Parser<CV>, 

fn parse<'a>(&self, it: &LCChars<'a>) -> ParseRes<'a, (AV, BV, CV)>

impl<A, AV, B, BV, C, CV, D, DV> Parser<(AV, BV, CV, DV)> for (A, B, C, D) where
    A: Parser<AV>,
    B: Parser<BV>,
    C: Parser<CV>,
    D: Parser<DV>, 

fn parse<'a>(&self, it: &LCChars<'a>) -> ParseRes<'a, (AV, BV, CV, DV)>

impl<A, AV, B, BV, C, CV, D, DV, E, EV> Parser<(AV, BV, CV, DV, EV)> for (A, B, C, D, E) where
    A: Parser<AV>,
    B: Parser<BV>,
    C: Parser<CV>,
    D: Parser<DV>,
    E: Parser<EV>, 

fn parse<'a>(&self, it: &LCChars<'a>) -> ParseRes<'a, (AV, BV, CV, DV, EV)>

impl<A, AV, B, BV, C, CV, D, DV, E, EV, F, FV> Parser<(AV, BV, CV, DV, EV, FV)> for (A, B, C, D, E, F) where
    A: Parser<AV>,
    B: Parser<BV>,
    C: Parser<CV>,
    D: Parser<DV>,
    E: Parser<EV>,
    F: Parser<FV>, 

fn parse<'a>(&self, it: &LCChars<'a>) -> ParseRes<'a, (AV, BV, CV, DV, EV, FV)>

Loading content...

Implementors

impl Parser<&'static str> for Tag

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

impl Parser<String> for Escape

fn parse<'a>(&self, i: &LCChars<'a>) -> ParseRes<'a, String>

impl Parser<String> for TakeN

fn parse<'a>(&self, i: &LCChars<'a>) -> ParseRes<'a, String>

impl<A, B, AV, BV> Parser<(AV, BV)> for Then<A, B> where
    A: Parser<AV>,
    B: Parser<BV>, 

fn parse<'a>(&self, i: &LCChars<'a>) -> ParseRes<'a, (AV, BV)>

impl<A, B, AV, BV> Parser<String> for String2P<A, B, AV, BV> where
    A: Parser<AV>,
    B: Parser<BV>,
    AV: Into<String>,
    BV: AsRef<str>, 

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

impl<A, B, AV, BV> Parser<Vec<AV>> for Separated<A, B, AV, BV> where
    A: Parser<AV>,
    B: Parser<BV>, 

fn parse<'a>(&self, i: &LCChars<'a>) -> ParseRes<'a, Vec<AV>>

impl<A, B, AV, BV> Parser<AV> for ThenIg<A, B, AV, BV> where
    A: Parser<AV>,
    B: Parser<BV>, 

fn parse<'a>(&self, i: &LCChars<'a>) -> ParseRes<'a, AV>

impl<A, B, AV, BV> Parser<BV> for IgThen<A, B, AV, BV> where
    A: Parser<AV>,
    B: Parser<BV>, 

fn parse<'a>(&self, i: &LCChars<'a>) -> ParseRes<'a, BV>

impl<A, B, C, AV, BV, CV> Parser<(Vec<AV>, BV, Vec<CV>)> for Reflect<A, B, C, AV, BV, CV> where
    A: Parser<AV>,
    B: Parser<BV>,
    C: Parser<CV>, 

fn parse<'a>(&self, it: &LCChars<'a>) -> ParseRes<'a, (Vec<AV>, BV, Vec<CV>)>

impl<A, B, C, AV, BV, CV> Parser<Vec<AV>> for SepUntil<A, B, C, AV, BV, CV> where
    A: Parser<AV>,
    B: Parser<BV>,
    C: Parser<CV>, 

fn parse<'a>(&self, i: &LCChars<'a>) -> ParseRes<'a, Vec<AV>>

impl<A, B, V> Parser<V> for Or<A, B> where
    A: Parser<V>,
    B: Parser<V>, 

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

impl<A, B, VA, VB> Parser<VB> for Wrap<A, B, VA, VB> where
    A: Parser<VA>,
    B: Parser<VB>, 

fn parse<'a>(&self, i: &LCChars<'a>) -> ParseRes<'a, VB>

impl<A, V> Parser<Option<V>> for Maybe<A> where
    A: Parser<V>, 

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

impl<A: Parser<char>, B: Parser<BV>, BV> Parser<String> for CharsUntil<A, B, BV>

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

impl<A: Parser<AV>, AV> Parser<()> for SkipRepeat<A, AV>

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

impl<A: Parser<AV>, AV> Parser<Vec<AV>> for RepeatN<A, AV>

fn parse<'a>(&self, it: &LCChars<'a>) -> ParseRes<'a, Vec<AV>>

impl<A: Parser<AV>, AV> Parser<Vec<AV>> for Repeater<A, AV>

fn parse<'a>(&self, i: &LCChars<'a>) -> ParseRes<'a, Vec<AV>>

impl<A: Parser<AV>, AV, B, F: Fn(AV) -> Result<B, ECode>> Parser<B> for TryMap<A, AV, B, F>

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

impl<A: Parser<AV>, AV, B, F: Fn(AV) -> B> Parser<B> for Map<A, AV, B, F>

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

impl<A: Parser<AV>, AV, R: Clone> Parser<R> for As<A, AV, R>

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

impl<A: Parser<AV>, AV: Into<String> + AsRef<str>> Parser<String> for StringRepeat<A, AV>

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

impl<A: Parser<AV>, B: Parser<BV>, AV, BV> Parser<(Vec<AV>, BV)> for RepUntil<A, B, AV, BV>

fn parse<'a>(&self, i: &LCChars<'a>) -> ParseRes<'a, (Vec<AV>, BV)>

impl<CB: CharBool> Parser<char> for OneChar<CB>

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

impl<CB: CharBool> Parser<()> for Skip<CB>

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

impl<CB: CharBool> Parser<String> for Chars<CB>

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

impl<F> Parser<()> for Take<F> where
    F: Fn(char) -> bool, 

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

impl<F> Parser<String> for Read<F> where
    F: Fn(String, char) -> ReadResult<String>, 

fn parse<'a>(&self, i: &LCChars<'a>) -> ParseRes<'a, String>

impl<F: Fn(char) -> bool> Parser<char> for CharF<F>

fn parse<'a>(&self, i: &LCChars<'a>) -> ParseRes<'a, char>

impl<P: Parser<V>, V> Parser<V> for Break<P, V>

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

impl<P: Parser<V>, V> Parser<V> for KeyWord<P, V>

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

impl<P: Parser<V>, V> Parser<V> for Peek<P, V>

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

impl<P: Parser<V>, V, F: Fn(ECode) -> ECode> Parser<V> for MapErr<P, V, F>

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

impl<P: Parser<V>, V: Debug> Parser<()> for FailOn<P, V>

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

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

fn parse<'b>(&self, i: &LCChars<'b>) -> ParseRes<'b, V>

Loading content...