Arguments (std.args)

The std.args module provides safe access to command-line arguments.

import std.args;

The Args Class

The Args class wraps argc and argv from C into safe Nic types.

Creating Args

fn main(argc: i32, argv: **char) -> i32 {
    let args = std.args.Args::from_main(argc, argv);
    defer args.deinit();

    // Use args...
    return 0;
}

Getting the Program Name

let program = args.program();  // argv[0]
println("Running: " + program.as_str());

Counting Arguments

let count = args.len();
println("Got " + int_to_string(count) + " arguments");

Accessing Arguments

// Get argument by index (0-based, includes program name)
match args.get(1) {
    Some(arg) => println("First arg: " + arg.as_str()),
    None => println("No arguments provided"),
}

Checking for Arguments

if args.contains("--verbose") {
    println("Verbose mode enabled");
}

if args.contains("-h") || args.contains("--help") {
    print_help();
    return 0;
}

Getting a Slice of Arguments

// Get all arguments starting from index 1 (skip program name)
let user_args = args.slice_from(1);
defer user_args.deinit();

for i in 0..user_args.len() {
    match user_args.get(i) {
        Some(arg) => println("  " + arg.as_str()),
        None => {},
    }
}

Complete Example

import std.args;

fn main(argc: i32, argv: **char) -> i32 {
    let args = std.args.Args::from_main(argc, argv);
    defer args.deinit();

    // Check for help flag
    if args.contains("-h") || args.contains("--help") {
        println("Usage: " + args.program().as_str() + " [options] <file>");
        println("Options:");
        println("  -h, --help     Show this help");
        println("  -v, --verbose  Enable verbose output");
        return 0;
    }

    // Get the file argument
    match args.get(1) {
        Some(file) => {
            println("Processing: " + file.as_str());
            // Process the file...
        },
        None => {
            println("Error: No file specified");
            return 1;
        },
    }

    return 0;
}

API Reference

class Args {
    /// Create Args from main() parameters
    pub fn from_main(argc: i32, argv: **char) -> *Args;

    /// Number of arguments (including program name)
    pub fn len(self) -> u64;

    /// Get argument at index (0 = program name)
    pub fn get(self, index: u64) -> Option[*String];

    /// Get the program name (argv[0])
    pub fn program(self) -> *String;

    /// Get arguments starting from index
    pub fn slice_from(self, idx: u64) -> *Vec[*String];

    /// Check if an argument is present
    pub fn contains(self, arg: string) -> bool;

    /// Cleanup
    pub fn deinit(self) -> unit;
}

See Also

For more sophisticated command-line parsing with flags, subcommands, and help generation, see std.flags.