System.Console.CmdArgs.Explicit

Process a list of flags (usually obtained from getArgs/expandArgsAt) with a mode. Returns Left and an error message if the command line fails to parse, or Right and the associated value.

Process the flags obtained by getArgs and expandArgsAt with a mode. Displays an error and exits with failure if the command line fails to parse, or returns the associated value. Implemented in terms of process. This function makes use of the following environment variables:

• $CMDARGS_COMPLETE - causes the program to produce completions using complete, then exit. Completions are based on the result of getArgs, the index of the current argument is taken from $CMDARGS_COMPLETE (set it to - to complete the last argument), and the index within that argument is taken from $CMDARGS_COMPLETE_POS (if set).

• $CMDARGS_HELPER/$CMDARGS_HELPER_PROG - uses the helper mechanism for entering command line programs as described in System.Console.CmdArgs.Helper.

Process a list of flags (usually obtained from getArgs and expandArgsAt) with a mode. Throws an error if the command line fails to parse, or returns the associated value. Implemeneted in terms of process. This function does not take account of any environment variables that may be set (see processArgs).

If you are in IO you will probably get a better user experience by calling processValueIO.

Like processValue but on failure prints to stderr and exits the program.

A help message that goes with either a flag or a mode.

Create a list of modes, with a program name, an initial value, some help text and the child modes.

A mode. Do not use the Mode constructor directly, instead use mode to construct the Mode and then record updates. Each mode has three main features:

• A list of submodes (modeGroupModes)

• A list of flags (modeGroupFlags)

• Optionally an unnamed argument (modeArgs)

To produce the help information for a mode, either use helpText or show.

Like functor, but where the the argument isn't just covariant.

An unnamed argument. Anything not starting with - is considered an argument, apart from "-" which is considered to be the argument "-", and any arguments following "--". For example:

programname arg1 -j - --foo arg3 -- -arg4 --arg5=1 arg6

Would have the arguments:

["arg1","-","arg3","-arg4","--arg5=1","arg6"]

A name, either the name of a flag (--foo) or the name of a mode.

The type of a flag, i.e. --foo=TYPE.

Parse a boolean, accepts as True: true yes on enabled 1.

A group of items (modes or flags). The items are treated as a list, but the group structure is used when displaying the help message.

Convert a group into a list.

Convert a list into a group, placing all fields in groupUnnamed.

A flag, consisting of a list of flag names and other information.

Extract the modes from a Mode

Extract the flags from a Mode

The FlagInfo type has the following meaning:

             FlagReq     FlagOpt      FlagOptRare/FlagNone
-xfoo        -x=foo      -x=foo       -x -foo
-x foo       -x=foo      -x foo       -x foo
-x=foo       -x=foo      -x=foo       -x=foo
--xx foo     --xx=foo    --xx foo     --xx foo
--xx=foo     --xx=foo    --xx=foo     --xx=foo

Extract the value from inside a FlagOpt or FlagOptRare, or raises an error.

A function to take a string, and a value, and either produce an error message (Left), or a modified value (Right).

Check that a mode is well formed.

Restricted version of remap where the values are isomorphic.

Version of remap for the Update type alias.

Create an empty mode specifying only modeValue. All other fields will usually be populated using record updates.

Create a mode with a name, an initial value, some help text, a way of processing arguments and a list of flags.

Create a flag taking no argument value, with a list of flag names, an update function and some help text.

Create a flag taking an optional argument value, with an optional value, a list of flag names, an update function, the type of the argument and some help text.

Create a flag taking a required argument value, with a list of flag names, an update function, the type of the argument and some help text.

Create an argument flag, with an update function and the type of the argument.

Create a boolean flag, with a list of flag names, an update function and some help text.

Create a help flag triggered by -?/--help.

Create a help flag triggered by -?/--help. The user may optionally modify help by specifying the format, such as:

--help=all          - help for all modes
--help=html         - help in HTML format
--help=100          - wrap the text at 100 characters
--help=100,one      - full text wrapped at 100 characters

Create a version flag triggered by -V/--version.

Create a version flag triggered by --numeric-version.

Create verbosity flags triggered by -v/--verbose and -q/--quiet

Specify the format to output the help.

Generate a help message from a mode. The first argument is a prefix, which is prepended when not using HelpFormatBash or HelpFormatZsh.

Expand @ directives in a list of arguments, usually obtained from getArgs. As an example, given the file test.txt with the lines hello and world:

expandArgsAt ["@test.txt","!"] == ["hello","world","!"]

Any @ directives in the files will be recursively expanded (raising an error if there is infinite recursion).

To supress @ expansion, pass any @ arguments after --.

Given a string, split into the available arguments. The inverse of joinArgs.

Given a sequence of arguments, join them together in a manner that could be used on the command line, giving preference to the Windows cmd shell quoting conventions.

For an alternative version, intended for actual running the result in a shell, see "System.Process.showCommandForUser"

How to complete a command line option. The Show instance is suitable for parsing from shell scripts.

Given a current state, return the set of commands you could type now, in preference order.