Trait Tool 

pub trait Tool<'a> {
    type Error;
    type Data;

    // Required method
    fn parse(
        &self,
        st: View<'a>,
    ) -> Result<(Self::Data, usize, View<'a>), Self::Error>;
}

Parsing tool trait.

An object implementing this trait represents a parsing rule that are applied to string prefixes. If any prefix of a string satisfy this rule then the match is successful and additional data parsed from the matching prefix is returned. If instead no prefix satisfies the rule then an error is returned.

Required Associated Types

type Error

Error type.

type Data

Associated data type.

Required Methods

fn parse( &self, st: View<'a>, ) -> Result<(Self::Data, usize, View<'a>), Self::Error>

The main parsing algorithm.

On a successful match, it additionally returns the parsed data and the length of the match in bytes.

Errors

If no prefix of st satisfies this parsing strategy then Error is returned.

Implementations on Foreign Types

impl<'a> Tool<'a> for char

Matches exactly the first character.

type Error = View<'a>

type Data = char

fn parse( &self, st: View<'a>, ) -> Result<(Self::Data, usize, View<'a>), Self::Error>

impl<'a> Tool<'a> for str

Matches exactly the string prefix.

type Error = View<'a>

type Data = &'a str

fn parse( &self, st: View<'a>, ) -> Result<(Self::Data, usize, View<'a>), Self::Error>

impl<'a, T> Tool<'a> for &T

where T: Tool<'a> + ?Sized,

type Error = <T as Tool<'a>>::Error

type Data = <T as Tool<'a>>::Data

fn parse( &self, st: View<'a>, ) -> Result<(Self::Data, usize, View<'a>), Self::Error>

impl<'a, T> Tool<'a> for [T]

where T: Tool<'a>,

Matches any tool in the given slice.

Tools are evaluated with increasing index ordering, so a later tool would not be tested is a previous tool has already matched.

type Error = Option<<T as Tool<'a>>::Error>

Only the last error is returned.

If you want to keep track of every returned error, use instead multiple nested instances of Or tool.

type Data = (usize, <T as Tool<'a>>::Data)

fn parse( &self, st: View<'a>, ) -> Result<(Self::Data, usize, View<'a>), Self::Error>

impl<'a, T, const N: usize> Tool<'a> for [T; N]

where T: Tool<'a>,

Matches any tool in the given array.

Tools are evaluated with increasing index ordering, so a later tool would not be tested is a previous tool has already matched.

type Error = Option<<T as Tool<'a>>::Error>

Only the last error is returned.

If you want to keep track of every returned error, use instead multiple nested instances of Or tool.

type Data = (usize, <T as Tool<'a>>::Data)

fn parse( &self, st: View<'a>, ) -> Result<(Self::Data, usize, View<'a>), Self::Error>

Implementors

impl<'a> Tool<'a> for AsciiNumber

type Data = usize

type Error = View<'a>

impl<'a> Tool<'a> for Ident

type Data = &'a str

type Error = View<'a>

impl<'a> Tool<'a> for Newline

type Data = ()

type Error = View<'a>

impl<'a> Tool<'a> for PfxAsciiNumber

type Data = usize

type Error = View<'a>

impl<'a> Tool<'a> for WhiteSP

type Error = Infallible

type Data = ()

impl<'a> Tool<'a> for AnyChar

type Data = char

type Error = View<'a>

impl<'a> Tool<'a> for EOFTool

type Data = ()

type Error = View<'a>

impl<'a> Tool<'a> for TrueTool

type Error = Infallible

type Data = ()

impl<'a, D, P: Fn(char) -> Option<D>> Tool<'a> for PredicateData<P>

type Data = D

type Error = View<'a>

impl<'a, F, S> Tool<'a> for Or<F, S>

where F: Tool<'a>, S: Tool<'a>,

type Data = Either<<F as Tool<'a>>::Data, <S as Tool<'a>>::Data>

type Error = (<F as Tool<'a>>::Error, <S as Tool<'a>>::Error)

impl<'a, F, S> Tool<'a> for Seq<F, S>

where F: Tool<'a>, S: Tool<'a>,

type Data = (<F as Tool<'a>>::Data, <S as Tool<'a>>::Data)

type Error = Either<<F as Tool<'a>>::Error, <S as Tool<'a>>::Error>

impl<'a, P> Tool<'a> for NonEmpty<P>

where P: Tool<'a>,

type Data = <P as Tool<'a>>::Data

type Error = Option<<P as Tool<'a>>::Error>

impl<'a, P: Fn(char) -> bool> Tool<'a> for Predicate<P>

type Data = char

type Error = View<'a>

impl<'a, T> Tool<'a> for Check<T>

where T: Tool<'a>,

type Error = <T as Tool<'a>>::Error

type Data = <T as Tool<'a>>::Data

impl<'a, T> Tool<'a> for CheckInv<T>

where T: Tool<'a>,

type Error = <T as Tool<'a>>::Data

type Data = <T as Tool<'a>>::Error

impl<'a, T, D, E, FD, FE> Tool<'a> for MapTool<T, FD, FE>

where T: Tool<'a>, FD: Fn(T::Data) -> D, FE: Fn(T::Error) -> E,

type Data = D

type Error = E

impl<'a, T, E> Tool<'a> for SetError<T, E>

where T: AlwaysTool<'a>,

type Error = E

type Data = <T as Tool<'a>>::Data

impl<'a, T, SEP> Tool<'a> for RepeatAny<T, SEP>

where T: Tool<'a>, SEP: Tool<'a>,

type Data = usize

type Error = Infallible

impl<'a, T, SEP, E> Tool<'a> for Repeat<T, SEP>

where T: Tool<'a, Error = E>, SEP: Tool<'a, Error = E>,

type Data = usize

type Error = E

impl<'a, T, SEP, TERM> Tool<'a> for LazyRepeatAny<T, SEP, TERM>

where T: Tool<'a>, SEP: Tool<'a>, TERM: Tool<'a>,

type Data = usize

type Error = <TERM as Tool<'a>>::Error

impl<'a, T, SEP, TERM, E> Tool<'a> for LazyRepeat<T, SEP, TERM>

where T: Tool<'a, Error = E>, SEP: Tool<'a, Error = E>, TERM: Tool<'a, Error = E>,

type Data = usize

type Error = E