import std.getopt;

string data = "file.dat";
int length = 24;
bool verbose;
enum Color { no, yes };
Color color;

void main(string[] args)
{
  getopt(
    args,
    "length",  &length,    // numeric

    "file",    &data,      // string

    "verbose", &verbose,   // flag

    "color",   &color);    // enum

  ...
}

1. Boolean options. A lone argument sets the option to true. Additionally true or false can be set within the option separated with an "=" sign:
   
   

     bool verbose = false, debugging = true;
     getopt(args, "verbose", &verbose, "debug", &debugging);
   

   
   
   To set verbose to true, invoke the program with either --verbose or --verbose=true.
   
   To set debugging to false, invoke the program with --debugging=false.
   
   
2. Numeric options. If an option is bound to a numeric type, a number is expected as the next option, or right within the option separated with an "=" sign:
   
   

     uint timeout;
     getopt(args, "timeout", &timeout);
   

   
   
   To set timeout to 5, invoke the program with either --timeout=5 or --timeout 5.
   
   
   • Incremental options. If an option name has a "+" suffix and is bound to a numeric type, then the option's value tracks the number of times the option occurred on the command line:
     
     

       uint paranoid;
       getopt(args, "paranoid+", &paranoid);
     

     
     
     Invoking the program with "--paranoid --paranoid --paranoid" will set paranoid to 3. Note that an incremental option never expects a parameter, e.g. in the command line "--paranoid 42 --paranoid", the "42" does not set paranoid to 42; instead, paranoid is set to 2 and "42" is not considered as part of the normal program arguments.



3. Enum options. If an option is bound to an enum, an enum symbol as a string is expected as the next option, or right within the option separated with an "=" sign:
   
   

     enum Color { no, yes };
     Color color; // default initialized to Color.no
   
     getopt(args, "color", &color);
   

   
   
   To set color to Color.yes, invoke the program with either --color=yes or --color yes.



4. String options. If an option is bound to a string, a string is expected as the next option, or right within the option separated with an "=" sign:
   
   

   string outputFile;
   getopt(args, "output", &outputFile);
   

   
   
   Invoking the program with "--output=myfile.txt" or "--output myfile.txt" will set outputFile to "myfile.txt". If you want to pass a string containing spaces, you need to use the quoting that is appropriate to your shell, e.g. --output='my file.txt'.



5. Array options. If an option is bound to an array, a new element is appended to the array each time the option occurs:
   
   

   string[] outputFiles;
   getopt(args, "output", &outputFiles);
   

   
   
   Invoking the program with "--output=myfile.txt --output=yourfile.txt" or "--output myfile.txt --output yourfile.txt" will set outputFiles to [ "myfile.txt", "yourfile.txt" ] .



6. Hash options. If an option is bound to an associative array, a string of the form "name=value" is expected as the next option, or right within the option separated with an "=" sign:
   
   

   double[string] tuningParms;
   getopt(args, "tune", &tuningParms);
   

   
   
   Invoking the program with e.g. "--tune=alpha=0.5 --tune beta=0.6" will set tuningParms to [ "alpha" : 0.5, "beta" : 0.6 ]. In general, keys and values can be of any parsable types.



7. Callback options. An option can be bound to a function or delegate with the signature void function(), void function(string option), void function(string option, string value), or their delegate equivalents.
   
   
   • If the callback doesn't take any arguments, the callback is invoked whenever the option is seen.
   • If the callback takes one string argument, the option string (without the leading dash(es)) is passed to the callback. After that, the option string is considered handled and removed from the options array.
     
     

     void main(string[] args)
     {
       uint verbosityLevel = 1;
       void myHandler(string option)
       {
         if (option == "quiet")
         {
           verbosityLevel = 0;
         }
         else
         {
           assert(option == "verbose");
           verbosityLevel = 2;
         }
       }
       getopt(args, "verbose", &myHandler, "quiet", &myHandler);
     }
     

     
     
     
   • If the callback takes two string arguments, the option string is handled as an option with one argument, and parsed accordingly. The option and its value are passed to the callback. After that, whatever was passed to the callback is considered handled and removed from the list.
     
     

     void main(string[] args)
     {
       uint verbosityLevel = 1;
       void myHandler(string option, string value)
       {
         switch (value)
         {
           case "quiet": verbosityLevel = 0; break;
           case "verbose": verbosityLevel = 2; break;
           case "shouting": verbosityLevel = verbosityLevel.max; break;
           default :
             stderr.writeln("Dunno how verbose you want me to be by saying ",
               value);
             exit(1);
         }
       }
       getopt(args, "verbosity", &myHandler);
     }
     

bool verbose;
getopt(args, "verbose|loquacious|garrulous", &verbose);

bool foo, bar;
getopt(args,
    std.getopt.config.caseSensitive,
    "foo", &foo,
    "bar", &bar);

bool foo, bar;
getopt(args,
    std.getopt.config.caseSensitive,
    "foo", &foo,
    std.getopt.config.caseInsensitive,
    "bar", &bar);

uint timeout;
getopt(args, "timeout|t", &timeout);

bool foo, bar;
getopt(args,
    std.getopt.config.bundling,
    "foo|f", &foo,
    "bar|b", &bar);

bool foo, bar;
getopt(args,
    std.getopt.config.passThrough,
    "foo", &foo,
    "bar", &bar);