Trait turtle_syntax::parsing::Parse

pub trait Parse<M>: Sized {
    // Required method
    fn parse_from<L, F>(
        parser: &mut Parser<L, F>,
        token: Meta<Token, Span>
    ) -> Result<Meta<Self, M>, MetaError<L::Error, M>>
       where L: Tokens,
             F: FnMut(Span) -> M;

    // Provided methods
    fn parse_with<L, F>(
        parser: &mut Parser<L, F>
    ) -> Result<Meta<Self, M>, MetaError<L::Error, M>>
       where L: Tokens,
             F: FnMut(Span) -> M { ... }
    fn parse_empty<L>(meta: M) -> Result<Meta<Self, M>, MetaError<L::Error, M>>
       where L: Tokens { ... }
    fn parse<C, F, E>(
        chars: C,
        metadata_builder: F
    ) -> Result<Meta<Self, M>, MetaError<Error<E>, M>>
       where C: Iterator<Item = Result<DecodedChar, E>>,
             F: FnMut(Span) -> M { ... }
    fn parse_infallible<C, F>(
        chars: C,
        metadata_builder: F
    ) -> Result<Meta<Self, M>, MetaError<Error, M>>
       where C: Iterator<Item = DecodedChar>,
             F: FnMut(Span) -> M { ... }
    fn parse_utf8<C, F, E>(
        chars: C,
        metadata_builder: F
    ) -> Result<Meta<Self, M>, MetaError<Error<E>, M>>
       where C: Iterator<Item = Result<char, E>>,
             F: FnMut(Span) -> M { ... }
    fn parse_utf8_infallible<C, F>(
        chars: C,
        metadata_builder: F
    ) -> Result<Meta<Self, M>, MetaError<Error, M>>
       where C: Iterator<Item = char>,
             F: FnMut(Span) -> M { ... }
    fn parse_utf16<C, F, E>(
        chars: C,
        metadata_builder: F
    ) -> Result<Meta<Self, M>, MetaError<Error<E>, M>>
       where C: Iterator<Item = Result<char, E>>,
             F: FnMut(Span) -> M { ... }
    fn parse_utf16_infallible<C, F>(
        chars: C,
        metadata_builder: F
    ) -> Result<Meta<Self, M>, MetaError<Error, M>>
       where C: Iterator<Item = char>,
             F: FnMut(Span) -> M { ... }
    fn parse_str<F>(
        string: &str,
        metadata_builder: F
    ) -> Result<Meta<Self, M>, MetaError<Error, M>>
       where F: FnMut(Span) -> M { ... }
}

Required Methods

fn parse_from<L, F>( parser: &mut Parser<L, F>, token: Meta<Token, Span> ) -> Result<Meta<Self, M>, MetaError<L::Error, M>>where L: Tokens, F: FnMut(Span) -> M,

Provided Methods

fn parse_with<L, F>( parser: &mut Parser<L, F> ) -> Result<Meta<Self, M>, MetaError<L::Error, M>>where L: Tokens, F: FnMut(Span) -> M,

fn parse_empty<L>(meta: M) -> Result<Meta<Self, M>, MetaError<L::Error, M>>where L: Tokens,

fn parse<C, F, E>( chars: C, metadata_builder: F ) -> Result<Meta<Self, M>, MetaError<Error<E>, M>>where C: Iterator<Item = Result<DecodedChar, E>>, F: FnMut(Span) -> M,

fn parse_infallible<C, F>( chars: C, metadata_builder: F ) -> Result<Meta<Self, M>, MetaError<Error, M>>where C: Iterator<Item = DecodedChar>, F: FnMut(Span) -> M,

fn parse_utf8<C, F, E>( chars: C, metadata_builder: F ) -> Result<Meta<Self, M>, MetaError<Error<E>, M>>where C: Iterator<Item = Result<char, E>>, F: FnMut(Span) -> M,

fn parse_utf8_infallible<C, F>( chars: C, metadata_builder: F ) -> Result<Meta<Self, M>, MetaError<Error, M>>where C: Iterator<Item = char>, F: FnMut(Span) -> M,

fn parse_utf16<C, F, E>( chars: C, metadata_builder: F ) -> Result<Meta<Self, M>, MetaError<Error<E>, M>>where C: Iterator<Item = Result<char, E>>, F: FnMut(Span) -> M,

fn parse_utf16_infallible<C, F>( chars: C, metadata_builder: F ) -> Result<Meta<Self, M>, MetaError<Error, M>>where C: Iterator<Item = char>, F: FnMut(Span) -> M,

fn parse_str<F>( string: &str, metadata_builder: F ) -> Result<Meta<Self, M>, MetaError<Error, M>>where F: FnMut(Span) -> M,

Implementations on Foreign Types

impl<M> Parse<M> for Vec<Meta<PredicateObjects<M>, M>>

fn parse_from<L, F>( parser: &mut Parser<L, F>, Meta: Meta<Token, Span> ) -> Result<Meta<Self, M>, MetaError<L::Error, M>>where L: Tokens, F: FnMut(Span) -> M,

Implementors

impl<M> Parse<M> for Directive<M>

impl<M> Parse<M> for Iri<M>

impl<M> Parse<M> for Literal<M>

impl<M> Parse<M> for Object<M>

impl<M> Parse<M> for Statement<M>

impl<M> Parse<M> for Subject<M>

impl<M> Parse<M> for Verb<M>

impl<M> Parse<M> for Collection<M>

impl<M> Parse<M> for Document<M>

impl<M> Parse<M> for Objects<M>

impl<M> Parse<M> for PredicateObjects<M>

impl<M> Parse<M> for Triples<M>