anchor.diff:  Instead of writing: `connection --server hostname=serverIP --server port=123 --client hostname=localhost --client port=456`
   +
   The input could be: `connection --server hostname=serverIP port=123 --client hostname=localhost port=456`
  ++
  +Not yet implemented in `go-getoptions`.
   
   That covers a complete user interface that is flexible enough to accommodate most programs.
   The following are advanced features:
   
   Stop parsing options when `--` is passed::
   Useful when arguments start with dash `-` and you don't want them interpreted as options.
  ++
  +In `go-getoptions` this is the default behaviour.
   
   Allow passing options and non-options in any order::
   Some option parsers force you to put the options before or after the arguments.
   That is really annoying!
  ++
  +In `go-getoptions` this is the default behaviour.
   
   Allow pass through::
   Have an option to pass through unmatched options.
   Useful when writing programs with multiple options depending on the main arguments.
   The initial parser will only capture the help or global options and pass through everything else.
   Additional argument parsing calls are invoked on the remaining arguments based on the initial input.
  ++
  +In `go-getoptions` this is accomplished with:
  ++
  +- `opt.SetUnknownMode("pass")`.
   
   Fail on unknown::
   The opposite of the above option.
   Useful if you want to ensure there are no input mistakes and force the application to stop.
  ++
  +In `go-getoptions` this is the default behaviour.
   
   Warn on unknown::
   Less strict parsing of options.
   This will warn the user that the option used is not a valid option but it will not stop the rest of the program.
  ++
  +In `go-getoptions` this is accomplished with:
  ++
  +- `opt.SetUnknownMode("warn")`.
   
   Option aliases::
   Options should be allowed to have different aliases.
   For example, the same option could be invoked with `--address` or `--hostname`.
  ++
  +In `go-getoptions` all options definitions allow for aliases.
   
   Incremental option::
   Some options can be passed more than once to increment an internal counter.
  
positive.code: Additionally, arguments to options can be passed with the `=` symbol.
  +
  `grepp --ignore=.txt`
  
  The features listed above are enough to create basic programs but an option parser should do better:
  
  
negative.code: `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, aliases)`.
  - `opt.Float64Var(&ptr, name, default_value, aliases)`.
  
  The features listed above relieve the programmer from the cumbersome task of converting the option argument into the expected type.
  
  