butcher: Chops a command or program invocation into digestable pieces.

This is a package candidate release! Here you can preview how this package release will appear once published to the main package index (which can be accomplished via the 'maintain' link below). Please note that once a package has been published to the main package index it cannot be undone! Please consult the package uploading documentation for more information.

The evil monadic interface

As long as you only use Applicative or (Kleisli) Arrow, you can use the
interface freely. When you use Monad, there is one rule: Whenever you read
any command-parts like in

f <- addFlag ...
p <- addParam ...

you are only allowed to use bindings bound thusly in any command's
implemenation, i.e. inside the parameter to addCmdImpl. You are not
allowed to force/inspect/patternmatch on them before that. good usage is:

addCmdImpl $ do
print x
print y

while bad would be

f <- addFlag
when f $ do
p <- addParam
-- evil: the existence of the param `p`
-- depends on parse result for the flag `f`.

That means that checking if a combination of flags is allowed must be done
after parsing. (But different commands and their subcommands (can) have
separate sets of flags.)

(abstract) Package intentions

Consider a commandline invocation like "ghc -O -i src -Main.hs -o Main". This
package provides a way for the programmer to simultaneously define the
semantics of your program based on its arguments and retrieve documentation
for the user. More specifically, i had three goals in mind:

Extract necessary information to compute commandline completion results
from any partial input. (This is not implemented to any serious degree.)

Semantics

Basic elements of a command are flags, parameters and subcommands. These can
be composed in certain ways, i.e. flags can have a (or possibly multiple?)
parameters; parameters can be grouped into sequences, and commands can have
subcommands.

Commands are essentially String -> Either ParseError out where out can
be chosen by the user. It could for example be IO ().

To allow more flexible composition, the parts of a command have the "classic"
parser's type: String -> Maybe (p, String) where p depends on the part.
Parse a prefix of the input and return something and the remaining input, or
fail with Nothing.

A command-parser contains a sequence of parts and then a number of subcommands
and/or some implementation.