anchor.diff:  
   Another feature a better option parser should have is the ability to set a flag to `False`.
   
  -Negatable boolean options::
  +=== Negatable boolean options
  +
   `True` when passed on the command line without any modifier and `False` when the `--no-` modifier is prefixed.
   For example:
  -+
  +
   `command --verbose`
  -+
  +
   and:
  -+
  +
   `command --no-verbose`, or `command --noverbose`
  -+
  -In `go-getoptions` this is accomplished with:
  -+
  +
  +In `go-getoptions` this is accomplished with:
  +
   - `ptr := opt.NBool(name, default_value)` which automatically defines `no-name` and `noname`.
   - `opt.NBoolVar(&ptr, name, default_value)` which automatically defines `no-name` and `noname`.
   
   That covers the most basic set of features, but still it is not enough to get past a basic program.
   The following features will allow for a more complete interface.
   
  -Options with array arguments::
  +=== Options with array arguments
  +
   This allows the same option to be used multiple times with different arguments.
   The list of arguments will be saved into a Slice inside the program.
   For example:
  -+
  +
   `list-files --exclude .txt --exclude .html --exclude .pdf`
  -+
  -In `go-getoptions` this is accomplished with:
  -+
  +
  +In `go-getoptions` this is accomplished with:
  +
   - `ptr := opt.StringSlice(name, 1, 1)`.
   
  -Options with Key Value arguments::
  +=== Options with Key Value arguments
  +
   This allows the same option to be used multiple times with arguments of key value type.
   For example:
  -+
  +
   `rpmbuild --define name=myrpm --define version=123`
  -+
  -In `go-getoptions` this is accomplished with:
  -+
  +
  +In `go-getoptions` this is accomplished with:
  +
   - `strMap := opt.StringMap(name, 1, 1)`.
   
   Both features above should support the basic types listed before: string, integer and floating point.
  
positive.code: 
  An option parser should support, at least, the following:
  
  Boolean options::
  `True` when passed on the command line.
  For example:
  +
  `ls --all`
  +
  In `go-getoptions` this is accomplished with:
  +
  - `ptr := opt.Bool(name, default_value)`.
  - `opt.BoolVar(&ptr, name, default_value)`.
  - Additionally, if all you want to know is if the option was passed you can use: `opt.Bool(name, default_value)` (without capturing its return value) and then check `opt.Called(name)`.
  
  Options with String arguments::
  The option will accept a string argument.
  For example:
  +
  `grepp --ignore .txt`
  +
  Additionally, arguments to options can be passed with the `=` symbol.
  +
  `grepp --ignore=.txt`
  +
  In `go-getoptions` this is accomplished with:
  +
  - `ptr := opt.String(name, default_value)`.
  - `opt.StringVar(&ptr, name, default_value)`.
  
  The features listed above are enough to create basic programs but an option parser should do better:
  
  Options with Integer arguments::
  Parse an option string argument into an Integer and provide an user error if the string provided is not an integer.
  For example:
  +
  `grepp --contex-lines 3`
  +
  and:
  +
  `grepp --context-lines string`
  +
    Error: 'string' is not a valid integer.
  +
  In `go-getoptions` this is accomplished with:
  +
  - `ptr := opt.Int(name, default_value)`.
  - `opt.IntVar(&ptr, name, default_value)`.
  
  Options with Floating point arguments::
  Parse an option string argument into a Floating point value and provide an user error if the string provided is not a valid floating point.
  For example:
  +
  `command --approximation 3.5`
  +
  and:
  +
  `command --approximation string`
  +
    Error: 'string' is not a valid floating point value.
  +
  In `go-getoptions` this is accomplished with:
  +
  - `ptr := opt.Float64(name, default_value)`.
  - `opt.Float64Var(&ptr, name, default_value)`.
  
  
negative.code: +
  Finally, to know with what alias an option was called with used `opt.CalledAs(<name>)`.
  
  === Required options
  
  Mark an option as required.
  Return an error if the option is not called.
  
  In `go-getoptions`, pass `opt.Required()` to any option.
  For example:
  
  `opt.BoolVar(&flag, "flag", false, opt.Required())`
  
  Optionally, override the default error message with `opt.Required(msg)`.
  For example:
  
  `opt.BoolVar(&flag, "flag", false, opt.Required("Missing --flag!"))`
  
  === Incremental option
  
  Some options can be passed more than once to increment an internal counter.
  For example:
  
  `command --v --v --v`
  
  Could increase the verbosity level each time the option is passed.
  
  In `go-getoptions` this is accomplished with:
  
  - `ptr := opt.Increment(name, default_value)`.
  - `opt.IncrementVar(&ptr, name, default_value)`.
  
  === Additional types
  
  The option parser could provide converters to additional types.
  The disadvantage of providing non basic types is that the option parser grows in size.
  
  Not yet implemented in `go-getoptions`.
  
  === Options with optional arguments
  
  With regular options, when the argument is not passed (for example: `--level` instead of `--level=debug`) you will get a _Missing argument_ error.
  When using options with optional arguments, If the argument is not passed, the option will set the default value for the option type.
  For this feature to be fully effective in strong typed languages where types have defaults, there must be a means to query the option parser to determine whether or not the option was called or not.
  
  In `go-getoptions` this is accomplished with:
  
    - `ptr := opt.StringOptional(name, default_value)`.
    - `ptr := opt.IntOptional(name, default_value)`.
    - Not yet implemented for `float64`.
    - The above should be used in combination with `opt.Called(name)`.
  
  For example, for the following definition:
  
  `ptr := opt.StringOptional("level", "info")`
  
  * If the option `level` is called with just `--level`, the value of `*ptr` is the default `"info"` and querying `opt.Called("level")` returns `true`.
  * If the option `level` is called with `--level=debug`, the value of `*ptr` is `"debug"` and querying `opt.Called("level")` returns `true`.
  * Finally, If the option `level` is not called, the value of `*ptr` is the default `"info"` and querying `opt.Called("level")` returns `false`.
  
  === Option flags that call a method internally
  
  If all the flag is doing is call a method or function when present, then having a way to call that function directly saves the programmer some time.
  
  Not yet implemented in `go-getoptions`.
  
  [[operation_modes]]
  == Operation Modes
  
  Notice how so far only long options (options starting with double dash `--`) have been mentioned.
  There are 3 main ways to handle short options (options starting with only one dash `-`).
  
  The behaviour for long options (options starting with double dash `--`) is consistent across operation modes.
  The behaviour for short options (options starting with only one dash `-`) depends on the _operation mode_.
  