Enum Argument 

pub enum Argument<'a> {
    Long(&'a str),
    Short(char),
    Value(Cow<'a, str>),
    Stdio,
}

Represents a parsed command-line argument.

Each argument parsed by Parser::forward is represented as one of these variants. The parser automatically categorizes arguments based on their prefix and structure.

Examples

use sap::{Parser, Argument};

let mut parser = Parser::from_arbitrary(["prog", "--verbose", "-x", "file.txt"]).unwrap();

assert_eq!(parser.forward().unwrap(), Some(Argument::Long("verbose")));
assert_eq!(parser.forward().unwrap(), Some(Argument::Short('x')));
assert_eq!(parser.forward().unwrap(), Some(Argument::Value("file.txt".into())));

Variants

Long(&'a str)

A long option starting with -- (e.g., --verbose, --file).

Long options can have associated values via --option=value syntax. Use Parser::value after parsing to retrieve the value if present.

Short(char)

A short option starting with - followed by a single character (e.g., -v, -x).

Short options can be combined (-abc becomes three separate Short arguments). They cannot have values attached with = syntax, but can consume the next argument as a value.

Value(Cow<'a, str>)

A positional argument or operand (e.g., file.txt, /path/to/file).

This includes any argument that doesn’t start with - or --, as well as all arguments following the -- terminator.

Stdio

The special - argument, typically representing stdin/stdout.

This is commonly used in Unix tools to indicate reading from standard input or writing to standard output.

Implementations

impl<'a> Argument<'a>

pub fn into_error<A>(self, value: A) -> ParsingError

where A: Into<Option<&'a str>>,

Converts this argument into a ParsingError::UnexpectedArg error.

This is a convenience method for creating contextual error messages when an argument is encountered but not expected by the application. The resulting error message includes appropriate formatting based on the argument type.

Parameters

• value - Optional value associated with the argument (primarily used with options)

Examples

use sap::Argument;

// Long option with value
let arg = Argument::Long("unknown");
let error = arg.into_error(Some("value"));
assert_eq!(error.to_string(), "unexpected argument: --unknown=value");

// Short option without value
let arg = Argument::Short('x');
let error = arg.into_error(None::<&str>);
assert_eq!(error.to_string(), "unexpected argument: -x");

// Stdio argument
let arg = Argument::Stdio;
let error = arg.into_error(None::<&str>);
assert_eq!(error.to_string(), "unexpected argument: -");

Trait Implementations

impl<'a> Clone for Argument<'a>

fn clone(&self) -> Argument<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Argument<'a>

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

Formats the value using the given formatter.

impl Display for Argument<'_>

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

Formats the value using the given formatter.

impl<'a> Hash for Argument<'a>

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<'a> Ord for Argument<'a>

fn cmp(&self, other: &Argument<'a>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<'a> PartialEq for Argument<'a>

fn eq(&self, other: &Argument<'a>) -> 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<'a> PartialOrd for Argument<'a>

fn partial_cmp(&self, other: &Argument<'a>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<'a> Eq for Argument<'a>

impl<'a> StructuralPartialEq for Argument<'a>