`MutuallyExclusive` doesn't work for `PositionalArgument` and `NamedArgument`

[Geod24]

/++ dub.json: {
  "name": "test-mutually-exclusive",
  "dependencies": { "argparse": "~master" }
}
+/

import argparse;

struct Arguments {
    @MutuallyExclusive() {
        @PositionalArgument(0) string files;
        @NamedArgument bool list;
    }
}

mixin CLI!Arguments.main!((args) {
        return 0;
});

Result:

% dub --single test.d -- --list
     Running test-mutually-exclusive --list
Error: The following argument is required: 'files'

Likewise, --help:

% dub -q --single test.d -- --help
Usage: test-mutually-exclusive [--list] [-h] files

Required arguments:
  files

Optional arguments:
  --list
  -h, --help    Show this help message and exit

[SirNickolas]

Could you explain what the expected behavior is, please? From my point of view, it behaves correctly, although nearly useless: positional arguments, unlike named arguments, are required by default. Probably disallowing a required argument to be mutually exclusive with something else is a good idea.

[Geod24]

    @(MutuallyExclusive().Required) {
        @(PositionalArgument(0).Optional) string files;
        @NamedArgument bool list;
    }

This is the expected behavior from my PoV, and the only one that I feel make sense. If one of the MutuallyExclusive arguments is required, then the MutuallyExclusive group is required.

Note that the following doesn't work either:

struct Arguments {
    @(MutuallyExclusive().Required) {
        @PositionalArgument(0) string files;
        @NamedArgument bool list;
    }
}

In this scenario, --list is just not usable. files has to be annotated with Optional for --list to be usable.

[andrey-zherikov]

This is not about positional and named per se, this is about required and optional arguments within an mutually-exclusive group. This kind of group assumes that only one argument is provided and all others are omitted - you can't tell what exact argument is required (files or list in your example). This means that arguments are optional.

Making group itself Required is orthogonal to this because you still can't tell what exact argument is required.

Now we have a code that violates this "rule" and I see two options here:

1. Error out if there is a required argument within MutuallyExclusive group.
2. Silently force all arguments to be Optional if they are in MutuallyExclusive group.

I'm leaning towards erroring out because it will force users to mark arguments as optional explicitly (note that we are speaking about positional arguments only since named are optional by default).

Silent option will lead to weird code like below and a user wondering why it's working:

    @MutuallyExclusive() {
        @(NamedArgument.Required) bool a;
        @(NamedArgument.Required) bool b;
    }