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", so this trait is not object safe.

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>