Enum Opt 

pub enum Opt {
    Long {
        spec: OptSpec,
        metadata: Metadata,
        index: usize,
        value: String,
    },
    Short {
        spec: OptSpec,
        metadata: Metadata,
        index: usize,
        value: String,
    },
    Env {
        spec: OptSpec,
        metadata: Metadata,
        value: String,
    },
    Default {
        spec: OptSpec,
        metadata: Metadata,
    },
    Example {
        spec: OptSpec,
        metadata: Metadata,
    },
    MissingValue {
        spec: OptSpec,
        long: bool,
    },
    None {
        spec: OptSpec,
    },
}

A named argument with value.

Variants

Long

Fields

spec: OptSpec

metadata: Metadata

index: usize

value: String

Short

Fields

spec: OptSpec

metadata: Metadata

index: usize

value: String

Env

Fields

spec: OptSpec

metadata: Metadata

value: String

Default

Fields

spec: OptSpec

metadata: Metadata

Example

Fields

spec: OptSpec

metadata: Metadata

MissingValue

Fields

spec: OptSpec

long: bool

None

Fields

spec: OptSpec

Implementations

impl Opt

pub fn spec(&self) -> OptSpec

Returns the specification of this option.

pub fn is_present(&self) -> bool

Returns true if this option is present.

pub fn is_value_present(&self) -> bool

Returns true if this option is present and has a value.

pub fn present(self) -> Option<Self>

Returns Some(self) if this option is present.

pub fn then<F, T, E>(self, f: F) -> Result<T, Error>

where F: FnOnce(Self) -> Result<T, E>, E: Display,

Applies additional conversion or validation to the option.

This method allows for chaining transformations and validations when an option is present. It first checks if the option has a value and then applies the provided function.

Examples

let mut args = noargs::RawArgs::new(["example", "--num=42"].iter().map(|a| a.to_string()));
let opt = noargs::opt("num").take(&mut args);

// Parse as number and ensure it's positive
let num = opt.then(|opt| -> Result<_, Box<dyn std::error::Error>> {
    let n: i32 = opt.value().parse()?;
    if n <= 0 {
        return Err("number must be positive".into());
    }
    Ok(n)
})?;

Errors

• Returns Error::MissingOpt if self.is_value_present() is false (option is missing)
• Returns Error::InvalidOpt if f(self) returns Err(_) (validation or conversion failed)

pub fn present_and_then<F, T, E>(self, f: F) -> Result<Option<T>, Error>

where F: FnOnce(Self) -> Result<T, E>, E: Display,

Shorthand for self.present().map(|opt| opt.then(f)).transpose().

pub fn value(&self) -> &str

Returns the raw value of this option, or an empty string if not present.

pub fn index(&self) -> Option<usize>

Returns the index at which the raw value associated with the name of this option was located in RawArgs.

Trait Implementations

impl Clone for Opt

fn clone(&self) -> Opt

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Opt

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Hash for Opt

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Opt

fn eq(&self, other: &Opt) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for Opt

impl StructuralPartialEq for Opt