Documentation

Data type that represents a defined flag. It contains:

• the name of the flag * help text for the flag * list of configurations for the flags such as type, default values, etc.

Data type for a flag error. It will contain the error message and what kind of error occurred:

• FatalError: an error that the system can't recover from * NonFatalError: an error that does not stop the process

Type that represents a collection of all defined flags.

It has three components:

• A flag map: The key is the flag name and the value is the flag data * An alias map: A map that connects any flag alias with it's unique flag name. This is used to convert each flag alias to it's flag name when parsing. * A list of global validation rules

Type that holds a collection of all flags.

It's a map from flag name to flag data. The flag data holds all defined configuration for each flag such as flag type, parser, default, etc.

Type that holds a map from flag alias to flag name.

It is used to identify the corresponding flag given a flag alias. For example if the user_id flag has two alias, u and uid, this map will have these entries: { uid => user_id, u => user_id }.

Type that represents the final result of the parse process.

It maps a flag name to it's value. This value is of type FlagArgument, which means that it can be empty or not.

This type is used by the user to get each flag value in the main method by using the get method and passing a flag variable.

Data type that represents an input flag argument.

It's type will vary depending on the user input. For example if the user calls the program that expects the user_id flag:

>>> ./runhaskell Program.hs
FlagArgument = FlagMissing "user_id"

>>> ./runhaskell Program.hs --user_id
FlagArgument = FlagValueMissing "user_id"'

>>> ./runhaskell Program.hs --user_id 8
FlagArgument = FlagValue "user_id" "8"

Type that is the list of remaining positional arguments after the parse process is completed. For example:

 ./runhaskell Program.hs --user_id 8 one two three

ArgsResults will contain the list ["one", "two", "three"]

Type that holds the FlagResults and ArgsResults together.

Type of the return value of the process function and it's sub-functions.

Type that represents a pipeline validation/processing function.

It takes a previous state as a parameter and does a set of modifications to this state.

It returns a list of errors (if any error occurred) and a modified state that will be passed in to the next function in the pipeline.

Type that represents a global validation rule for a FlagResults.

It is used to create global validation after the flags are processed. If the result is a Nothing then the rule passed. Otherwise if a Just err' is returned then the ruled failed with the message "err".

Type that represents the result of the tokenize function and it's sub-functions.

It returns either a list of errors or a valid list of tokens.

Type that specifies whether a given validation was successful or not.

If it was not successful it contains a FlagError that explains what failed.

Data type that represent a flag configuration.

It is used when a flag is created to set the type of the flag, how it is parsed, if the flag is required or optional, etc.

Data type that represents a generic flag type configuration.

It is mapped from the FlagConf of each flag so that it can be bundled together with all other flag's data. It is used at the validation/parsing phase of the process method to verify that the input flag value is valid for each flag (i.e. if a required flag was not provided by the user but this flag has a default value then an error does not occur).

It has a direct mapping of each FlagData to a non-generic version.

Data types for the flag operations

Data type that represents the value for a flag when parsed from the input stream.

Data type that represents a flag stream using tokens.

Type that contains a map from flag name to default flag operation.