anchor.diff:              description = "use archive file or device ARCHIVE")
       File archive;
   
  -    @Option(names = { "-v", "--verbose" }, description = "verbosely list files processed")
  -    boolean verbose;
  -
  -    @Option(names = { "-h", "-?", "--help" }, help = true,
  -            description = "give this help list")
  -    boolean helpRequested;
  -
  -    @Option(names = { "-V", "--version" }, help = true,
  -            description = "print program version")
  -    boolean versionRequested;
  -
       @Parameters(valueLabel = "FILE", description = "one ore more files to archive")
       File[] files;
   }
  -----
  +
  +String[] args = { "-cf", "result.tar", "file1.txt", "file2.txt" };
  +Tar tar = CommandLine.parse(new Tar(), args);
  +assert  tar.create;
  +assert !tar.extract;
  +assert  tar.archive.equals(new File("result.tar"));
  +assert  Arrays.equals(tar.files, new File[] {new File("file1.txt"), new File("file2.txt")});
  +----
  +
  +Picocli supports http://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap12.html#tag_12_02[POSIX clustered short options]:
  +One or more options without option-arguments, followed by at most one option that takes an option-argument, should be accepted when grouped behind one '-' delimiter.
  +
  +
  +For example, given this annotated class:
  +[source,java]
  +----
  +class ClusteredShortOptions {
  +    @Option(names = "-a") boolean a;
  +    @Option(names = "-b") boolean b;
  +    @Option(names = "-c") boolean c;
  +    @Option(names = "-f") String  f;
  +}
  +----
  +The following command line arguments are all equivalent and parsing them will give the same result:
  +
  +[source,java]
  +----
  +<command> -abcfInputFile.txt
  +<command> -a -b -c -fInputFile.txt
  +<command> -a -b -c -f InputFile.txt
  +<command> -a -b -c -f=InputFile.txt
  +<command> -ab -cf=InputFile.txt
  +...
  +----
  +
   
   === Positional Parameters
   Positional parameters (also called operands) are the command line arguments following the options.
  -Positional parameters can be captured together as an array or a List, or you can capture individual parameters in separate fields. The advantage of capturing individual parameters in separate fields is that you can enforce strong typing. For example:
  +
  +Use the (zero-based) `index` attribute to specify exactly which parameters to capture. Omitting the `index` attribute means the field is initialized with all positional parameters (so the field should be an array or a collection).
  +The `index` attribute accepts "range" values, so an annotation like `@Parameters(index="2..4")` captures arguments at index 2, 3 and 4. Range values can be open-ended. For example, `@Parameters(index="3..*")` captures all arguments from index 3 and up.
  +
  +The advantage of capturing individual parameters in separate fields is that you can enforce strong typing. For example:
   
   [source,java]
   ----
   class PositionalParameters {
  -    @Parameters(hidden = true) // don't show this parameter in usage help message
  -    List<String> allParameters;
  -
  -    @Parameters(index = 0, valueLabel = "<host>",
  +    @Parameters(hidden = true)  // "hidden": don't show this parameter in usage help message
  +    List<String> allParameters; // no "index" attribute: captures _all_ arguments (as Strings)
  +
  +    @Parameters(index = "0", valueLabel = "<host>", // index=0: the first positional parameter
                   description = "Host name or IP address to connect to")
       InetAddress host;
   
  -    @Parameters(index = 1, valueLabel = "<port>",
  +    @Parameters(index = "1", valueLabel = "<port>", // index=1: the second positional parameter
                   description = "Port number to connect to")
       int port;
  -}
  -----
  -
  -If all parameters are the same type, you can capture them together in a single array or `Collection` field.  For example:
  -
  -[source,java]
  -----
  -class Convert {
  -    @Parameters(type = File.class, valueLabel = "FILES",
  -                description = "The files to convert.")
  -    List<File> files;
  -}
  -----
  -
  -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.
  +
  +    @Parameters(index = "2..*", valueLabel = "<files>", description = "the files to process")
  +    File[] files;
  +}
  +
  +String[] args = { "localhost", "12345", "file1.txt", "file2.txt" };
  +PositionalParameters params = CommandLine.parse(new PositionalParameters(), args);
  +assert params.host.getHostName().equals("localhost");
  +assert params.port == 12345;
  +assert Arrays.equals(params.files, new File[] {new File("file1.txt"), new File("file2.txt")});
  +assert params.allParameters.equals(Arrays.asList("localhost", "12345", "file1.txt", "file2.txt"));
  +----
  +
  +See <<Type Conversion>> for which types are supported out of the box and how to add custom types.
   
   === Double dash (`--`)
   When one of the command line arguments is two dashes without any characters attached (`--`), picocli interprets all following arguments as positional parameters, even arguments that match an option name.
  
positive.code:  commandLine.registerConverter(Long.class,    s -> Long::decode);
  ----
  
  
  == Putting it all Together
  Imagine an application that takes some input files and compresses them to an output file.
  
negative.code: }
  ----
  
  
  == Download
  
  