anchor.diff:  
   In `go-getoptions` this is currently enabled by default when using:
   
  -`intSlice := opt.IntSlice(name, minArgs, maxArgs)`
  +- `intSlice := opt.IntSlice(name, minArgs, maxArgs)`
  +- `opt.IntSliceVar(&ptr, name, minArgs, maxArgs)`.
   
   === Options with key value arguments and multiple entries
   
  
positive.code: 
  In `go-getoptions` this is the default behaviour.
  
  === Stop parsing options when a subcommand is passed
  
  A subcommand is assumed to be the first argument that is not an option or an argument to an option.
  When a subcommand is found, stop parsing arguments and let a subcommand handler handle the remaining arguments.
  For example:
  
  `command --opt arg subcommand --subopt subarg`
  
  In the example above, `--opt` is an option and `arg` is an argument to an option, making `subcommand` the first non option argument.
  
  This method is useful when both the command and the subcommand have option handlers for the same option.
  
  For example, with:
  
  `command --help`
  
  `--help` is handled by `command`, and with:
  
  `command subcommand --help`
  
  `--help` is not handled by `command` since there was a subcommand that caused the parsing to stop.
  
  Additionally, when mixed with _pass through_, it will also stop parsing arguments when it finds the first unmatched option.
  
  In `go-getoptions` this is accomplished with:
  
  - `opt.SetRequireOrder()`.
  
  And can be combined with:
  
  - `opt.SetUnknownMode(getoptions.Pass)`.
  
  === Allow passing options and non-options in any order
  
  
negative.code: 
  • Errors exposed as public variables to allow overriding them for internationalization.
  
  • Supports program commands (when a command is passed a command function is triggered to handle the command logic).
  
  • Built in `opt.Dispatch` function calls commands and propagates context, options, arguments and cancellation signals.
  
  • Multiple ways of managing unknown options:
    - Fail on unknown (default).
    - Warn on unknown.
    - Pass through, allows for commands and can be combined with Require Order.
  
  • Require order: Allows for commands. Stop parsing arguments when the first non-option is found.
  When mixed with Pass through, it also stops parsing arguments when the first unmatched option is found.
  
  • Set options by reading Environment Variables.
  