A class for interpreting command line arguments into Haskell types.

Environment

Argument combinator

Option combinator

Option combinator with default

Raw monadic combinator

Subcommand combinator

Named command combinator, useful at the top level for naming a program. Typically, the name will be the name or alias of the executable you expect to produce.

Boolean flag combinator

A convenience combinator that constructs the program I often want to run out of a program I want to write.

The command line program which consists of trying to enter one and then trying the other.

A meta-combinator that takes a type-level description of a command line program and produces a simple usage program.

Required environment variable combinator

Optional environment variable combinator

Optional environment variable combinator with default

A combinator which takes a program, and a type-level Symbol description of that program, and produces a program here the documentation is annotated with the given description.

A combinator which augments the documentation of the next element, by adding a description after its name and type.

This is a combinator which runs a ProgramT with the options, arguments, and flags that I get using the initialState function, returning Just the output of the program upon successful option and argument parsing and returning Nothing otherwise.

This is a combinator which runs a ProgramT with the options, arguments, and flags that I get using the initialState function, ignoring the output of the program.

The type level program sequencing combinator, taking two program types and sequencing them one after another.

The type level combining combinator, taking two program types as input, and being interpreted as a program which attempts to run the first command line program and, if parsing its flags, subprograms, options or arguments fails, runs the second, otherwise failing.

The type level argument combinator, with a Symbol designating the name of that argument.

The type level option combinator, with a Symbol designating the option's name and another representing the metavariables name for documentation purposes.

The type level combinator for constructing named programs, giving your program a name at the toplevel for the sake of documentation.

The type level raw monadic program combinator, allowing a command line program to just do some computation.

The type level flag combinator, taking a name as input, allowing your program to take flags with the syntax ~flag.

The type level environment variable combinator, taking a name as input, allowing your program to take environment variables as input automatically.

The type level tag for whether or not a variable is required or not.

The type level description combinator, allowing a command line program to have better documentation.

The type level annotated combinator, allowing a command line

This is the workhorse of the library. Basically, it allows you to run your ProgramT representation of your program as a CommanderT and pump the State through it until you've processed all of the arguments, options, and flags that you have specified must be used in your ProgramT. You can think of ProgramT as a useful syntax for command line programs, but CommanderT as the semantics of that program. We also give the ability to hoist ProgramT actions between monads if you can uniformly turn computations in one into another. We also store documentation in the form of a Forest String, in order to automatically generate usage programs.

A CommanderT action is a metaphor for a military commander. At each step, we have a new Action to take, or we could have experienced Defeat, or we can see Victory. While a real life commander worries about moving his troops around in order to achieve a victory in battle, a CommanderT worries about iteratively transforming a state to find some value.

In more practical terms, a term of type CommanderT can be thought of as a backtracking, stateful computation which can either result in a result being produced, or nothing being produced. It is a Monad for any base Functor you want to use as the effect inside of the stateful computation, similarly to the free monad.

We can run a CommanderT on some state and see if it has a successful campaign.

A simple default for getting out the arguments, options, and flags using getArgs. We use the syntax ~flag for flags and -opt for options, with arguments using the typical ordered representation.

This is the State that the CommanderT library uses for its role in this library. It is not inlined, because that does nothing but obfuscate the CommanderT monad. It consists of arguments, options, and flags.

The type of middleware, which can transform interpreted command line programs by meddling with arguments, options, or flags, or by adding effects for every step. You can also change the underlying monad.

Middleware to log the state to standard out for every step of the CommanderT computation.

Middleware to transform the base monad with a natural transformation.

Middleware to add monadic effects for every Action. Useful for debugging complex command line programs.

Middleware to have effects whenever the program might backtrack.

Middleware to have effects whenever the program successfully computes a result.