System.Console.CmdTheLine.ArgVal

Parsing values from the command line

class ArgVal a where

The class of values that can be parsed from the command line. Instances must provide both parser and pp.

Methods

parser

Arguments

:: ArgParser a

A parser of instance values.

pp

Arguments

:: ArgPrinter a

A pretty printer for instance values.

Instances

ArgVal Bool

ArgVal Double

ArgVal Float

ArgVal Int

ArgVal Integer

ArgVal HelpFormat

ArgVal [Char]

ArgVal (Ratio Integer)

ArgVal (Maybe Bool)

ArgVal (Maybe Double)

ArgVal (Maybe Float)

ArgVal (Maybe Int)

ArgVal (Maybe Integer)

ArgVal (Maybe [Char])

ArgVal (Maybe (Ratio Integer))

ArgVal (Maybe HelpFormat)

type ArgParser a = String -> Either Doc a

The type of parsers of individual command line argument values.

type ArgPrinter a = a -> Doc

The type of printers of values retrieved from the command line.

Helpers for instantiating ArgVal

fromParsec :: (String -> Doc) -> Parsec String () a -> ArgParser a

fromParsec onErr p makes an ArgParser from p using onErr to produce meaningful error messages. On failure, onErr will receive a raw string of the value found on the command line.

enum :: [(String, a)] -> ArgParser a

A parser of enumerated values conveyed as an association list of ( string, value ) pairs. Unambiguous prefixes of string map to value.

Maybe values

just :: ArgVal a => ArgParser (Maybe a)

A parser of Maybe values of ArgVal instances. A convenient default that merely lifts the ArgVal instance's parsed value with Just.

maybePP :: ArgVal a => ArgPrinter (Maybe a)

A printer of Maybe values of ArgVal instances. A convenient default that prints nothing on the Nothing and just the value on the Just.

List values

list :: ArgVal a => Char -> ArgParser [a]

list sep creates a parser of lists of an ArgVal instance separated by sep.

listPP :: ArgVal a => Char -> ArgPrinter [a]

listPP sep creates a pretty printer of lists of an ArgVal instance seperated by sep.

Tuple values

pair :: (ArgVal a, ArgVal b) => Char -> ArgParser (a, b)

pair sep creates a parser of pairs of ArgVal instances separated by sep.

pairPP :: (ArgVal a, ArgVal b) => Char -> ArgPrinter (a, b)

pairPP sep creates a pretty printer of pairs of ArgVal instances separated by sep

triple :: (ArgVal a, ArgVal b, ArgVal c) => Char -> ArgParser (a, b, c)

triple sep creates a parser of triples of ArgVal instances separated by sep.

triplePP :: (ArgVal a, ArgVal b, ArgVal c) => Char -> ArgPrinter (a, b, c)

triplePP sep creates a pretty printer of triples of ArgVal instances separated by sep

quadruple :: (ArgVal a, ArgVal b, ArgVal c, ArgVal d) => Char -> ArgParser (a, b, c, d)

quadruple sep creates a parser of quadruples of ArgVal instances separated by sep.

quadruplePP :: (ArgVal a, ArgVal b, ArgVal c, ArgVal d) => Char -> ArgPrinter (a, b, c, d)

quadruplePP sep creates a pretty printer of quadruples of ArgVal instances separated by sep

quintuple :: (ArgVal a, ArgVal b, ArgVal c, ArgVal d, ArgVal e) => Char -> ArgParser (a, b, c, d, e)

quintuple sep creates a parser of quintuples of ArgVal instances separated by sep.

quintuplePP :: (ArgVal a, ArgVal b, ArgVal c, ArgVal d, ArgVal e) => Char -> ArgPrinter (a, b, c, d, e)

quintuplePP sep creates a pretty printer of quintuples of ArgVal instances separated by sep