Trait 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,

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

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>