Struct Opt 

pub struct Opt { /* private fields */ }

Implementations

impl Opt

pub fn new(short: &str, long: &str, doc: &str, hint: &str) -> Self

Trait Implementations

impl Arg for Opt

type Item = Option<String>

type Error = Never

fn update_switches<S: Switches>(&self, switches: &mut S)

fn name(&self) -> String

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

fn validate(&self) -> Result<(), Invalid>

fn parse_specified_ignoring_validation<I>( self, program_name: String, args: I, ) -> ParseResult<Self::Item, Self::Error>

where I: IntoIterator, I::Item: AsRef<OsStr>,

fn parse_specified<I>( self, program_name: String, args: I, ) -> ParseResult<Self::Item, Self::Error>

where I: IntoIterator, I::Item: AsRef<OsStr>,

fn parse_env(self) -> ParseResult<Self::Item, Self::Error>

fn with_help(self, help_flag: Flag) -> WithHelp<Self>

fn with_help_default(self) -> WithHelp<Self>

fn option_map<F, T, U>(self, f: F) -> OptionMap<Self, F>

where F: FnOnce(T) -> U,

fn with_default<T>(self, default_value: T) -> WithDefault<Self, T>

fn with_default_lazy<F>(self, default_value_f: F) -> WithDefaultLazy<Self, F>

fn choice<O>(self, other: O) -> Choice<Self, O>

where O: Arg<Item = Self::Item>,

fn both<O>(self, other: O) -> Both<Self, O>

where O: Arg,

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

where F: FnOnce(Self::Item) -> U,

fn required(self) -> Required<Self>

fn convert_string<F, T, E>(self, f: F) -> ConvertString<Self, F>

where F: FnOnce(&str) -> Result<T, E>,

fn option_convert_string<F, T, E>(self, f: F) -> OptionConvertString<Self, F>

where F: FnOnce(&str) -> Result<T, E>,

fn vec_convert_string<F, T, E>(self, f: F) -> VecConvertString<Self, F>

where F: FnMut(&str) -> Result<T, E>,

fn vec_singleton(self) -> VecSingleton<Self>

fn depend<O>(self, other: O) -> Depend<Self, O>

where O: Arg,

fn some_if<T>(self, t: T) -> SomeIf<Self, T>