Trait Arg

pub trait Arg: Sized {
    type Item;
    type Error: Debug + Display;

    // Required methods
    fn update_switches<S: Switches>(&self, switches: &mut S);
    fn name(&self) -> String;
    fn get(self, matches: &Matches) -> Result<Self::Item, Self::Error>;

    // Provided methods
    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> { ... }
}

Required Associated Types

type Item

type Error: Debug + Display

Required Methods

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

fn name(&self) -> String

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

Provided Methods

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>

Examples found in repository

examples/hello.rs (line 9)

fn main() {
    match free::<String>()
        .vec_singleton()
        .required()
        .parse_env()
        .result
    {
        Ok(name) => println!("Hello, {}!", name),
        Err(msg) => eprintln!("Error: {}", msg),
    }
}

examples/area.rs (line 11)

fn main() {
    match opt::<f32>("", "width", "", "")
        .depend(opt::<f32>("", "height", "", ""))
        .option_map(|(x, y)| (x, y))
        .option_map(|(x, y)| x * y)
        .required()
        .parse_env()
        .result
    {
        Ok(area) => println!("area: {:?}", area),
        Err(e) => panic!("{}", e),
    }
}

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

fn with_help_default(self) -> WithHelp<Self>

Examples found in repository

examples/dimensions.rs (line 24)

fn main() {
    let dimensions = Dimensions::args().with_help_default().parse_env_or_exit();
    println!("{:#?}", dimensions);
}

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

where F: FnOnce(T) -> U,

Examples found in repository

examples/area.rs (line 8)

fn main() {
    match opt::<f32>("", "width", "", "")
        .depend(opt::<f32>("", "height", "", ""))
        .option_map(|(x, y)| (x, y))
        .option_map(|(x, y)| x * y)
        .required()
        .parse_env()
        .result
    {
        Ok(area) => println!("area: {:?}", area),
        Err(e) => panic!("{}", e),
    }
}

examples/dimensions.rs (line 17)

    fn args() -> impl Arg<Item = Self> {
        let window = args_depend! {
            opt("", "width", "", ""),
            opt("", "height", "", ""),
        }
        .option_map(|(width, height)| Dimensions::Window { width, height });
        let fullscreen = flag("", "fullscreen", "").some_if(Dimensions::Fullscreen);
        window.choice(fullscreen).required()
    }

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>,

Examples found in repository

examples/dimensions.rs (line 19)

    fn args() -> impl Arg<Item = Self> {
        let window = args_depend! {
            opt("", "width", "", ""),
            opt("", "height", "", ""),
        }
        .option_map(|(width, height)| Dimensions::Window { width, height });
        let fullscreen = flag("", "fullscreen", "").some_if(Dimensions::Fullscreen);
        window.choice(fullscreen).required()
    }

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>

Examples found in repository

examples/hello.rs (line 8)

fn main() {
    match free::<String>()
        .vec_singleton()
        .required()
        .parse_env()
        .result
    {
        Ok(name) => println!("Hello, {}!", name),
        Err(msg) => eprintln!("Error: {}", msg),
    }
}

examples/area.rs (line 10)

fn main() {
    match opt::<f32>("", "width", "", "")
        .depend(opt::<f32>("", "height", "", ""))
        .option_map(|(x, y)| (x, y))
        .option_map(|(x, y)| x * y)
        .required()
        .parse_env()
        .result
    {
        Ok(area) => println!("area: {:?}", area),
        Err(e) => panic!("{}", e),
    }
}

examples/dimensions.rs (line 19)

    fn args() -> impl Arg<Item = Self> {
        let window = args_depend! {
            opt("", "width", "", ""),
            opt("", "height", "", ""),
        }
        .option_map(|(width, height)| Dimensions::Window { width, height });
        let fullscreen = flag("", "fullscreen", "").some_if(Dimensions::Fullscreen);
        window.choice(fullscreen).required()
    }

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>

Examples found in repository

examples/hello.rs (line 7)

fn main() {
    match free::<String>()
        .vec_singleton()
        .required()
        .parse_env()
        .result
    {
        Ok(name) => println!("Hello, {}!", name),
        Err(msg) => eprintln!("Error: {}", msg),
    }
}

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

where O: Arg,

Examples found in repository

examples/area.rs (line 7)

fn main() {
    match opt::<f32>("", "width", "", "")
        .depend(opt::<f32>("", "height", "", ""))
        .option_map(|(x, y)| (x, y))
        .option_map(|(x, y)| x * y)
        .required()
        .parse_env()
        .result
    {
        Ok(area) => println!("area: {:?}", area),
        Err(e) => panic!("{}", e),
    }
}

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

Examples found in repository

examples/dimensions.rs (line 18)

    fn args() -> impl Arg<Item = Self> {
        let window = args_depend! {
            opt("", "width", "", ""),
            opt("", "height", "", ""),
        }
        .option_map(|(width, height)| Dimensions::Window { width, height });
        let fullscreen = flag("", "fullscreen", "").some_if(Dimensions::Fullscreen);
        window.choice(fullscreen).required()
    }

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

type Item = bool

type Error = Never

impl Arg for Free

type Item = Vec<String>

type Error = Never

impl Arg for Opt

type Item = Option<String>

type Error = Never

impl<A> Arg for WithHelp<A>

where A: Arg,

type Item = OrHelp<<A as Arg>::Item>

type Error = <A as Arg>::Error

impl<A, B> Arg for Both<A, B>

where A: Arg, B: Arg,

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

type Error = BothError<<A as Arg>::Error, <B as Arg>::Error>

impl<A, B, T> Arg for Choice<A, B>

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

type Item = Option<T>

type Error = ChoiceError<<A as Arg>::Error, <B as Arg>::Error>

impl<A, F, T> Arg for WithDefaultLazy<A, F>

where A: Arg<Item = Option<T>>, F: FnOnce() -> T,

type Item = T

type Error = <A as Arg>::Error

impl<A, F, T, E> Arg for ConvertString<A, F>

where A: Arg<Item = String>, F: FnOnce(&str) -> Result<T, E>, E: Display + Debug,

type Item = T

type Error = ConvertStringError<<A as Arg>::Error, E>

impl<A, F, T, E> Arg for OptionConvertString<A, F>

where A: Arg<Item = Option<String>>, F: FnOnce(&str) -> Result<T, E>, E: Display + Debug,

type Item = Option<T>

type Error = OptionConvertStringError<<A as Arg>::Error, E>

impl<A, F, T, E> Arg for VecConvertString<A, F>

where A: Arg<Item = Vec<String>>, F: FnMut(&str) -> Result<T, E>, E: Display + Debug,

type Item = Vec<T>

type Error = VecConvertStringError<<A as Arg>::Error, E>

impl<A, F, T, U> Arg for OptionMap<A, F>

where A: Arg<Item = Option<T>>, F: FnOnce(T) -> U,

type Item = Option<U>

type Error = <A as Arg>::Error

impl<A, T> Arg for Required<A>

where A: Arg<Item = Option<T>>,

type Item = T

type Error = RequiredError<<A as Arg>::Error>

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

where A: Arg<Item = bool>,

type Item = Option<T>

type Error = <A as Arg>::Error

impl<A, T> Arg for VecSingleton<A>

where A: Arg<Item = Vec<T>>,

type Item = Option<T>

type Error = VecSingletonError<<A as Arg>::Error>

impl<A, T> Arg for WithDefault<A, T>

where A: Arg<Item = Option<T>>,

type Item = T

type Error = <A as Arg>::Error

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

where A: Arg, F: FnOnce(A::Item) -> U,

type Item = U

type Error = <A as Arg>::Error

impl<T> Arg for Value<T>

type Item = T

type Error = Never

impl<T, U, A, B> Arg for Depend<A, B>

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

type Item = Option<(T, U)>

type Error = DependError<<A as Arg>::Error, <B as Arg>::Error>