anchor.diff:  
   A Java command line parsing framework in a single file, so you can include it _in source form_
   and let users run your application without an external dependency.
  -Produces beautiful and easily tailored usage help messages.
  +Produces clean and easily tailored usage help messages.
   
   How it works: annotate your class and picocli initializes it from the command line arguments,
   converting the input to strongly typed values in the fields of your class.
  
positive.code:     @Parameters Path path;
      @Option(names = "-d") Duration duration;
  }
  CommandLine commandLine = new CommandLine(new App());
  commandLine.registerConverter(java.nio.file.Path.class, s -> java.nio.file.Paths.get(s));
  commandLine.registerConverter(java.time.Duration.class, s -> java.time.Duration.parse(s));
  
  String[] args = { "-d", "PT15M", "file1.txt" };
  List<Object> parsed = commandLine.parse(args); // returns parsed commands and subcommands
  
  App app = parsed.get(0);
  assert app.path.equals(Paths.get("file1.txt"));
  assert app.duration.equals(Duration.parse("PT15M"));
  ----
  
  Numeric values are interpreted as decimal numbers by default. If you want picocli to be more flexible, you can
  use the https://docs.oracle.com/javase/8/docs/api/java/lang/Integer.html#decode-java.lang.String-[decode] method
  to convert strings to numbers.
  
  NOTE: The `decode` method looks at the prefix to determine the radix, so numbers
  starting with `0x`, `0X` or `#` are interpreted as hexadecimal numbers, numbers starting with `0` are interpreted
  as octal numbers, and otherwise the number is interpreted as a decimal number.
  
  [source,java]
  ----
   commandLine.registerConverter(Byte.class,    s -> Byte::decode);
   commandLine.registerConverter(Short.class,   s -> Short::decode);
   commandLine.registerConverter(Integer.class, s -> Integer::decode);
   commandLine.registerConverter(Long.class,    s -> Long::decode);
  ----
  
  === Converting to Collection Elements
  Multiple parameters can be captured together in a single array or `Collection` field. When using a collection, use the `type` attribute to specify the collection element type. For example:
  
  [source,java]
  ----
  class Convert {
      @Option(names = "-patterns", type = java.util.regex.Pattern.class, valueLabel = "PATTERN",
              description = "the regular expressions to use for the conversion");
      List<Pattern> patterns;
  
      @Parameters(type = File.class, valueLabel = "FILE", description = "files to convert")
      List<File> files;
  }
  
  String[] args = { "-patterns", "a*b", "[a-e][i-u]", "--", "file1.txt", "file2.txt" };
  Convert convert = CommandLine.parse(new Convert(), args);
  assert convert.patterns.equals(Arrays.asList(Pattern.compile("a*b"), Pattern.compile("[a-e][i-u]")));
  assert convert.files.equals(Arrays.asList(new File("file1.txt"), new File("file2.txt")));
  ----
  
  IMPORTANT: With array fields picocli uses reflection to discover the array element type, but with collections, Java type erasure means picocli cannot find out the generic type of the collection. The above example uses the `type` attribute to explicitly tell picocli what type to convert the command line arguments to.
  
  == Required Options
  Options can be marked `required` to make it mandatory for the user to specify them on the command line. When a required option is not specified, a `MissingParameterException` is thrown from the `parse` method. For example:
  [source, java]
  ----
  class MyProgram {
      @Parameters(arity = "3", descriptions = "exactly three Files")
      File[] files;
  
      @Option(names = "-x", description = "optional switch")
      boolean x;
  
      @Option(names = "-y", required = true, description = "mandatory switch")
      boolean y;
  
      @Option(names = "-n", required = true, description = "mandatory number")
      int number;
  }
  ----
  The following command line arguments would result in an exception complaining that `y` and `number` are missing:
  ----
  String[] args = { "-x", "file1", "file2", "file3" };
  CommandLine.parse(new MyProgram(), args);
  ----
  The following command line arguments would be accepted:
  ----
  String[] args = { "-x", "-y", "-n", "123", "file1", "file2", "file3" };
  CommandLine.parse(new MyProgram(), args);
  ----
  
  
  IMPORTANT: if arity>1 and args="-opt=val1 val2", arity overrules the "=": both values are assigned
  
  
  == Help Options
  Options with the `help` attribute set to `true` are special: if one of the command line arguments is a "help" option, picocli will stop parsing the remaining arguments and will not check for required options.
  
  This is suitable for options that should trigger the usage help message or application version information being shown on the console.
  
  == Hidden Options and Parameters
  Options and Parameters with the `hidden` attribute set to `true` will not be shown in the usage help message.
  
  == Subclassing to Reuse Options and Command Attributes
  Picocli will walk the class hierarchy to check for annotations, so you can declare common @Options and @Command attributes on a superclass and override these fields or attributes on a subclass.
  
negative.code:     @Parameters(index = "2..*", valueLabel = "<files>", description = "the files to process")
      File[] files;
  }
  ----
  
  Picocli initializes fields with the values at the specified index in the arguments array.
  [source,java]
  ----
  String[] args = { "localhost", "12345", "file1.txt", "file2.txt" };
  PositionalParameters params = CommandLine.parse(new PositionalParameters(), args);
  assert params.host.getHostName().equals("localhost");
  