Trait Parse

pub trait Parse
where
    Self: Sized,
    Self::Result: PartialEq + Debug,
{
    type Result;

    // Required method
    fn parse<'b>(&self, input: &'b str) -> ParseResult<'b, Self::Result>;

    // Provided methods
    fn run(&self, input: &str) -> Result<Self::Result, String> { ... }
    fn and<U: Parse>(self, other: U) -> And<Self, U> { ... }
    fn and_ref<'a, U: Parse>(&'a self, other: &'a U) -> AndRef<'a, Self, U> { ... }
    fn or<U: Parse>(self, other: U) -> Or<Self, U> { ... }
    fn or_ref<'a, U: Parse>(&'a self, other: &'a U) -> OrRef<'a, Self, U> { ... }
    fn map<U, F: Fn(Self::Result) -> U>(self, f: F) -> Map<Self, F, U> { ... }
    fn map_ref<'a, U, F: Fn(Self::Result) -> U>(
        &'a self,
        f: &'a F,
    ) -> MapRef<'a, Self, F, U> { ... }
    fn zero_or_more(self) -> ZeroOrMoreOf<Self> { ... }
    fn zero_or_more_ref<'a>(&'a self) -> ZeroOrMoreOfRef<'a, Self> { ... }
    fn one_or_more(self) -> OneOrMoreOf<Self> { ... }
    fn one_or_more_ref<'a>(&'a self) -> OneOrMoreOfRef<'a, Self> { ... }
    fn drop<U: Parse>(self, other: U) -> Drop<Self, U> { ... }
    fn drop_ref<'a, U: Parse>(&'a self, other: &'a U) -> DropRef<'a, Self, U> { ... }
    fn keep<U: Parse>(self, other: U) -> Keep<Self, U> { ... }
    fn keep_ref<'a, U: Parse>(&'a self, other: &'a U) -> KeepRef<'a, Self, U> { ... }
    fn sbws(self) -> Sbws<Self> { ... }
    fn sbws_ref<'a>(&'a self) -> SbwsRef<'a, Self> { ... }
    fn sep_by(self, sep: char) -> SepBy<Self> { ... }
    fn sep_by_ref<'a>(&'a self, sep: char) -> SepByRef<'a, Self> { ... }
    fn parse_while<F: Fn(&Self::Result) -> bool>(
        self,
        f: F,
    ) -> ParseWhile<Self, F> { ... }
    fn parse_while_ref<'a, F: Fn(&Self::Result) -> bool>(
        &'a self,
        f: &'a F,
    ) -> ParseWhileRef<'a, Self, F> { ... }
}

Required Associated Types

type Result

Required Methods

fn parse<'b>(&self, input: &'b str) -> ParseResult<'b, Self::Result>

Provided Methods

fn run(&self, input: &str) -> Result<Self::Result, String>

fn and<U: Parse>(self, other: U) -> And<Self, U>

fn and_ref<'a, U: Parse>(&'a self, other: &'a U) -> AndRef<'a, Self, U>

fn or<U: Parse>(self, other: U) -> Or<Self, U>

fn or_ref<'a, U: Parse>(&'a self, other: &'a U) -> OrRef<'a, Self, U>

fn map<U, F: Fn(Self::Result) -> U>(self, f: F) -> Map<Self, F, U>

fn map_ref<'a, U, F: Fn(Self::Result) -> U>( &'a self, f: &'a F, ) -> MapRef<'a, Self, F, U>

fn zero_or_more(self) -> ZeroOrMoreOf<Self>

fn zero_or_more_ref<'a>(&'a self) -> ZeroOrMoreOfRef<'a, Self>

fn one_or_more(self) -> OneOrMoreOf<Self>

fn one_or_more_ref<'a>(&'a self) -> OneOrMoreOfRef<'a, Self>

fn drop<U: Parse>(self, other: U) -> Drop<Self, U>

fn drop_ref<'a, U: Parse>(&'a self, other: &'a U) -> DropRef<'a, Self, U>

fn keep<U: Parse>(self, other: U) -> Keep<Self, U>

fn keep_ref<'a, U: Parse>(&'a self, other: &'a U) -> KeepRef<'a, Self, U>

fn sbws(self) -> Sbws<Self>

fn sbws_ref<'a>(&'a self) -> SbwsRef<'a, Self>

fn sep_by(self, sep: char) -> SepBy<Self>

fn sep_by_ref<'a>(&'a self, sep: char) -> SepByRef<'a, Self>

fn parse_while<F: Fn(&Self::Result) -> bool>(self, f: F) -> ParseWhile<Self, F>

fn parse_while_ref<'a, F: Fn(&Self::Result) -> bool>( &'a self, f: &'a F, ) -> ParseWhileRef<'a, Self, F>

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.

Implementors

impl Parse for AnyCharParser

type Result = char

impl Parse for CharParser

type Result = char

impl Parse for NullParser

type Result = ()

impl Parse for StringParser

type Result = String

impl Parse for WhitespaceParser

type Result = String

impl<'a, T: Parse> Parse for AllOfRef<'a, T>

type Result = Vec<<T as Parse>::Result>

impl<'a, T: Parse> Parse for OneOfRef<'a, T>

type Result = <T as Parse>::Result

impl<'a, T: Parse> Parse for OneOrMoreOfRef<'a, T>

type Result = Vec<<T as Parse>::Result>

impl<'a, T: Parse> Parse for ParseSquareListRef<'a, T>

type Result = Vec<<T as Parse>::Result>

impl<'a, T: Parse> Parse for SbwsRef<'a, T>

type Result = <T as Parse>::Result

impl<'a, T: Parse> Parse for ZeroOrMoreOfRef<'a, T>

type Result = Vec<<T as Parse>::Result>

impl<'a, T: Parse, F: Fn(&<T as Parse>::Result) -> bool> Parse for ParseWhile<T, F>

type Result = Vec<<T as Parse>::Result>

impl<'a, T: Parse, F: Fn(&<T as Parse>::Result) -> bool> Parse for ParseWhileRef<'a, T, F>

type Result = Vec<<T as Parse>::Result>

impl<'a, T: Parse, U: PartialEq + Debug, F: Fn(<T as Parse>::Result) -> U> Parse for MapRef<'a, T, F, U>

type Result = U

impl<'a, T: Parse, U: Parse> Parse for AndRef<'a, T, U>

type Result = (<T as Parse>::Result, <U as Parse>::Result)

impl<'a, T: Parse, U: Parse> Parse for DropRef<'a, T, U>

type Result = <U as Parse>::Result

impl<'a, T: Parse, U: Parse> Parse for KeepRef<'a, T, U>

type Result = <T as Parse>::Result

impl<'a, T: Parse, U: Parse> Parse for OrRef<'a, T, U>

type Result = Either<<T as Parse>::Result, <U as Parse>::Result>

impl<'b, T: Parse> Parse for SepByRef<'b, T>

type Result = Vec<<T as Parse>::Result>

impl<T: Parse> Parse for AllOf<T>

type Result = Vec<<T as Parse>::Result>

impl<T: Parse> Parse for OneOf<T>

type Result = <T as Parse>::Result

impl<T: Parse> Parse for OneOrMoreOf<T>

type Result = Vec<<T as Parse>::Result>

impl<T: Parse> Parse for ParseSquareList<T>

type Result = Vec<<T as Parse>::Result>

impl<T: Parse> Parse for Sbws<T>

type Result = <T as Parse>::Result

impl<T: Parse> Parse for SepBy<T>

type Result = Vec<<T as Parse>::Result>

impl<T: Parse> Parse for ZeroOrMoreOf<T>

type Result = Vec<<T as Parse>::Result>

impl<T: Parse, U: PartialEq + Debug, F: Fn(<T as Parse>::Result) -> U> Parse for Map<T, F, U>

type Result = U

impl<T: Parse, U: Parse> Parse for And<T, U>

type Result = (<T as Parse>::Result, <U as Parse>::Result)

impl<T: Parse, U: Parse> Parse for Drop<T, U>

type Result = <U as Parse>::Result

impl<T: Parse, U: Parse> Parse for Keep<T, U>

type Result = <T as Parse>::Result

impl<T: Parse, U: Parse> Parse for Or<T, U>

type Result = Either<<T as Parse>::Result, <U as Parse>::Result>