A class for interpreting command line arguments into Haskell types.

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.

Argument combinator

Option combinator

Raw monadic combinator

Subcommand combinator

Named command combinator, should only really be used at the top level.

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.

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 naming combinator, giving your program a name 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.

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. All of the different invocations are also stored to give a primitive form of automatically generated documentation.

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. We will deal with the subset of these actions where every function must decrease the size of the state, as those are the actions for which this is a monad.

We can run a CommanderT action on a 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.