Trait meap::parser::Parser

pub trait Parser: Sized {
    type Item;
    fn register_low_level(
        &self, 
        ll: &mut LowLevelParser
    ) -> Result<(), SpecError>;
    fn parse_low_level(
        &mut self, 
        ll: &mut LowLevelParserOutput
    ) -> Result<Self::Item, Box<dyn Error>>;
    fn update_help(&self, help: &mut Help);

    fn parse_args<A: IntoIterator<Item = String>>(
        self, 
        program_name: String, 
        args: A
    ) -> Result<Self::Item, (Box<dyn Error>, SpentParser<Self>)> { ... }
    fn parse_env(
        self
    ) -> Result<Self::Item, (Box<dyn Error>, SpentParser<Self>)> { ... }
    fn both<PU: Parser>(self, other: PU) -> Both<Self::Item, PU::Item, Self, PU> { ... }
    fn map<U, F: FnOnce(Self::Item) -> U>(
        self, 
        f: F
    ) -> Map<Self::Item, U, F, Self> { ... }
    fn with_help<N: IntoName>(self, name: N) -> WithHelp<Self::Item, Self> { ... }
    fn with_help_default(self) -> WithHelp<Self::Item, Self> { ... }
    fn with_default_general<T>(self, value: T) -> WithDefaultGeneral<T, Self> { ... }
    fn choose_at_most_one<O: Parser>(self, other: O) -> ChooseAtMostOne<Self, O> { ... }
    fn with_default_lazy_general<T, F: FnOnce() -> T>(
        self, 
        f: F
    ) -> WithDefaultLazyGeneral<T, F, Self> { ... }
    fn required_general<S: AsRef<str>>(
        self, 
        error_message: S
    ) -> RequiredGeneral<Self> { ... }
}

Associated Types

type Item

Required methods

fn register_low_level(&self, ll: &mut LowLevelParser) -> Result<(), SpecError>

fn parse_low_level(
    &mut self,
    ll: &mut LowLevelParserOutput
) -> Result<Self::Item, Box<dyn Error>>

fn update_help(&self, help: &mut Help)

Provided methods

fn parse_args<A: IntoIterator<Item = String>>(
    self,
    program_name: String,
    args: A
) -> Result<Self::Item, (Box<dyn Error>, SpentParser<Self>)>

fn parse_env(self) -> Result<Self::Item, (Box<dyn Error>, SpentParser<Self>)>

fn both<PU: Parser>(self, other: PU) -> Both<Self::Item, PU::Item, Self, PU>

fn map<U, F: FnOnce(Self::Item) -> U>(self, f: F) -> Map<Self::Item, U, F, Self>

fn with_help<N: IntoName>(self, name: N) -> WithHelp<Self::Item, Self>

fn with_help_default(self) -> WithHelp<Self::Item, Self>

fn with_default_general<T>(self, value: T) -> WithDefaultGeneral<T, Self>

fn choose_at_most_one<O: Parser>(self, other: O) -> ChooseAtMostOne<Self, O>

fn with_default_lazy_general<T, F: FnOnce() -> T>(
    self,
    f: F
) -> WithDefaultLazyGeneral<T, F, Self>

fn required_general<S: AsRef<str>>(
    self,
    error_message: S
) -> RequiredGeneral<Self>

Implementors

impl<A: Arity, H: HasParam, N: NameType> Parser for Arg<A, H, N> where
    Self: SingleArgParser + SingleArgParserHelp, 

impl<T> Parser for SomeIf<T>

impl<T, F: FnOnce() -> T, P: Parser<Item = Option<T>>> Parser for WithDefaultLazyGeneral<T, F, P>

impl<T, P: Parser<Item = Option<T>>> Parser for RequiredGeneral<P>

impl<T, P: Parser<Item = Option<T>>> Parser for WithDefaultGeneral<T, P>

impl<T, PA: Parser<Item = Option<T>>, PB: Parser<Item = Option<T>>> Parser for ChooseAtMostOne<PA, PB>

impl<T, PT: Parser<Item = T>> Parser for WithHelp<T, PT>

impl<T, U, F: FnOnce(T) -> U, PT: Parser<Item = T>> Parser for Map<T, U, F, PT>

impl<T, U, PT: Parser<Item = T>, PU: Parser<Item = U>> Parser for Both<T, U, PT, PU>

impl<V: FromStr, T: From<V>, D: DefaultValue<Item = T>> Parser for WithDefault<V, T, D>