Trait Param

pub trait Param {
    type Item;
    type Error: Debug + Display;

    // Required methods
    fn update_options(&self, opts: &mut Options, notes: Notes);
    fn get(&self, matches: &Matches) -> Result<Self::Item, Self::Error>;
    fn name(&self) -> String;

    // Provided methods
    fn parse<C: IntoIterator>(
        &self,
        args: C,
        which_notes_to_document: WhichNotes,
    ) -> (Result<Self::Item, TopLevelError<Self::Error>>, Usage)
       where C::Item: AsRef<OsStr> { ... }
    fn parse_env(
        &self,
        which_notes_to_document: WhichNotes,
        program_name: ProgramName,
    ) -> (Result<Self::Item, TopLevelError<Self::Error>>, UsageWithProgramName) { ... }
    fn parse_env_default(
        &self,
    ) -> (Result<Self::Item, TopLevelError<Self::Error>>, UsageWithProgramName) { ... }
}

Required Associated Types

type Item

type Error: Debug + Display

Required Methods

fn update_options(&self, opts: &mut Options, notes: Notes)

fn get(&self, matches: &Matches) -> Result<Self::Item, Self::Error>

fn name(&self) -> String

Provided Methods

fn parse<C: IntoIterator>( &self, args: C, which_notes_to_document: WhichNotes, ) -> (Result<Self::Item, TopLevelError<Self::Error>>, Usage)

where C::Item: AsRef<OsStr>,

fn parse_env( &self, which_notes_to_document: WhichNotes, program_name: ProgramName, ) -> (Result<Self::Item, TopLevelError<Self::Error>>, UsageWithProgramName)

fn parse_env_default( &self, ) -> (Result<Self::Item, TopLevelError<Self::Error>>, UsageWithProgramName)

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 Param for Arg

type Item = Option<String>

type Error = Never

impl Param for Flag

type Item = bool

type Error = Never

impl<A, B> Param for Join<A, B>

where A: Param, B: Param,

type Item = (<A as Param>::Item, <B as Param>::Item)

type Error = Either<<A as Param>::Error, <B as Param>::Error>

impl<A, F, U, E> Param for Convert<A, F>

where A: Param, A::Item: Clone + Debug + Display, E: Debug + Display, F: Fn(&A::Item) -> Result<U, E>,

type Item = U

type Error = ConvertError<<A as Param>::Error, <A as Param>::Item, E>

impl<A, T> Param for SomeIf<A, T>

where T: Clone, A: Param<Item = bool>,

type Item = Option<T>

type Error = <A as Param>::Error

impl<A, T, U, F> Param for OptMap<A, F>

where A: Param<Item = Option<T>>, F: Fn(T) -> U,

type Item = Option<U>

type Error = <A as Param>::Error

impl<A, U, E, F> Param for TryMap<A, F>

where A: Param, E: Debug + Display, F: Fn(A::Item) -> Result<U, E>,

type Item = U

type Error = TryMapError<<A as Param>::Error, E>

impl<A, U, F> Param for Map<A, F>

where A: Param, F: Fn(A::Item) -> U,

type Item = U

type Error = <A as Param>::Error

impl<P> Param for AddNote<P>

where P: Param,

type Item = <P as Param>::Item

type Error = <P as Param>::Error

impl<P> Param for Rename<P>

where P: Param,

type Item = <P as Param>::Item

type Error = <P as Param>::Error

impl<P> Param for SetNotesToDocument<P>

where P: Param,

type Item = <P as Param>::Item

type Error = <P as Param>::Error

impl<P, T> Param for Required<P>

where P: Param<Item = Option<T>>,

type Item = T

type Error = RequiredError<<P as Param>::Error>

impl<P, T> Param for WithDefault<P, T>

where T: Clone + Display, P: Param<Item = Option<T>>,

type Item = T

type Error = <P as Param>::Error

impl<T> Param for Value<T>

where T: Clone,

type Item = T

type Error = Never

impl<T, A, B> Param for EitherHomogeneous<A, B>

where A: Param<Item = Option<T>>, B: Param<Item = Option<T>>,

type Item = Option<T>

type Error = EitherError<<A as Param>::Error, <B as Param>::Error>

impl<T, A, U, E, F> Param for OptTryMap<A, F>

where A: Param<Item = Option<T>>, E: Debug + Display, F: Fn(T) -> Result<U, E>,

type Item = Option<U>

type Error = TryMapError<<A as Param>::Error, E>

impl<T, A, U, F, E> Param for OptConvert<A, F>

where T: Clone + Debug + Display, E: Clone + Debug + Display, A: Param<Item = Option<T>>, F: Fn(T) -> Result<U, E>,

type Item = Option<U>

type Error = ConvertError<<A as Param>::Error, T, E>

impl<T, C, V> Param for Otherwise<C, V>

where C: Param<Item = Option<T>>, V: Param,

type Item = Either<T, <V as Param>::Item>

type Error = Either<<C as Param>::Error, <V as Param>::Error>

impl<T, U, A, B> Param for Codepend<A, B>

where A: Param<Item = Option<T>>, B: Param<Item = Option<U>>,

type Item = Option<(T, U)>

type Error = CodependError<<A as Param>::Error, <B as Param>::Error>

impl<T, U, A, B> Param for Either<A, B>

where A: Param<Item = Option<T>>, B: Param<Item = Option<U>>,

type Item = Option<Either<T, U>>

type Error = EitherError<<A as Param>::Error, <B as Param>::Error>

impl<V> Param for WithHelp<V>

where V: Param,

type Item = HelpOr<<V as Param>::Item>

type Error = <V as Param>::Error