ReadArgs

Documentation

readArgs :: ArgumentTuple a => IO a

parse the desired argument tuple from the command line or print a simple usage statment and quit

readArgsFrom :: ArgumentTuple a => [String] -> IO a

read args from the given strings or print a simple usage statment and quit (so you can do option parsing first)

class Arguable a where

a class for types that can be parsed from exactly one command line argument

Methods

parse :: String -> Maybe a

name :: a -> String

name's argument will usually be undefined, so when defining instances of Arguable, it should be lazy in its argument

Instances

Arguable Char

char is a special case, so that we don't force the user to single-quote their input

Arguable String

string is a special case, so that we don't force the user to double-quote their input

(Typeable t, Read t) => Arguable t

all types that are typeable and readable can be used as simple arguments

Arguable Text

Text is a special case, so that we don't force the user to double-quote their input

Arguable FilePath

FilePath is a special case, so that we don't force the user to double-quote their input

class Argument a where

a class for types that can be parsed from some number of command line arguments

Methods

parseArg :: [String] -> [(a, [String])]

argName :: a -> String

argName's argument will usually be undefined, so when defining instances of Arguable, it should be lazy in its argument

Instances

Argument String

make sure strings are handled as a separate type, not a list of chars

Arguable a => Argument a

use the arguable tyep to just parse a single argument

Arguable a => Argument [a]

use a list when it should be parsed from zero or more (greedily)

Arguable a => Argument (Maybe a)

use Maybe when it should be parsed from one or zero (greedily)

Argument (m a) => Argument (NonGreedy m a)

use NonGreedy when it should be parsed non-greedily (e.g. (NonGreedy xs :: NonGreedy [] Int, x :: Maybe Float) <- readArgs)

newtype NonGreedy m a

a wrapper type to indicate a non-greedy list or maybe

Constructors

NonGreedy

Fields

unNonGreedy :: m a

Instances

Eq (m a) => Eq (NonGreedy m a)

Show (m a) => Show (NonGreedy m a)

Argument (m a) => Argument (NonGreedy m a)

use NonGreedy when it should be parsed non-greedily (e.g. (NonGreedy xs :: NonGreedy [] Int, x :: Maybe Float) <- readArgs)

class ArgumentTuple a where

a class for tuples of types that can be parsed from the entire list of arguments

Methods

parseArgsFrom :: [String] -> Maybe a

usageFor :: a -> String

usageFor's argument will usually be undefined, so when defining instances of Arguable, it should be lazy in its argument

Instances

ArgumentTuple ()

use () for no arguments

Argument a => ArgumentTuple a

(Argument b, Argument a) => ArgumentTuple (b, a)

(Argument a, ArgumentTuple y) => ArgumentTuple (:& a y)

(Argument c, Argument b, Argument a) => ArgumentTuple (c, b, a)

(Argument d, Argument c, Argument b, Argument a) => ArgumentTuple (d, c, b, a)

(Argument e, Argument d, Argument c, Argument b, Argument a) => ArgumentTuple (e, d, c, b, a)

(Argument f, Argument e, Argument d, Argument c, Argument b, Argument a) => ArgumentTuple (f, e, d, c, b, a)

(Argument g, Argument f, Argument e, Argument d, Argument c, Argument b, Argument a) => ArgumentTuple (g, f, e, d, c, b, a)

(Argument h, Argument g, Argument f, Argument e, Argument d, Argument c, Argument b, Argument a) => ArgumentTuple (h, g, f, e, d, c, b, a)

(Argument i, Argument h, Argument g, Argument f, Argument e, Argument d, Argument c, Argument b, Argument a) => ArgumentTuple (i, h, g, f, e, d, c, b, a)

(Argument j, Argument i, Argument h, Argument g, Argument f, Argument e, Argument d, Argument c, Argument b, Argument a) => ArgumentTuple (j, i, h, g, f, e, d, c, b, a)

(Argument k, Argument j, Argument i, Argument h, Argument g, Argument f, Argument e, Argument d, Argument c, Argument b, Argument a) => ArgumentTuple (k, j, i, h, g, f, e, d, c, b, a)

(Argument l, Argument k, Argument j, Argument i, Argument h, Argument g, Argument f, Argument e, Argument d, Argument c, Argument b, Argument a) => ArgumentTuple (l, k, j, i, h, g, f, e, d, c, b, a)

(Argument m, Argument l, Argument k, Argument j, Argument i, Argument h, Argument g, Argument f, Argument e, Argument d, Argument c, Argument b, Argument a) => ArgumentTuple (m, l, k, j, i, h, g, f, e, d, c, b, a)

(Argument n, Argument m, Argument l, Argument k, Argument j, Argument i, Argument h, Argument g, Argument f, Argument e, Argument d, Argument c, Argument b, Argument a) => ArgumentTuple (n, m, l, k, j, i, h, g, f, e, d, c, b, a)

(Argument o, Argument n, Argument m, Argument l, Argument k, Argument j, Argument i, Argument h, Argument g, Argument f, Argument e, Argument d, Argument c, Argument b, Argument a) => ArgumentTuple (o, n, m, l, k, j, i, h, g, f, e, d, c, b, a)

data a :& b

use :& to construct arbitrary length tuples of any parsable arguments

Constructors

a :& b

Instances

(Eq a, Eq b) => Eq (:& a b)

(Show a, Show b) => Show (:& a b)

(Argument a, ArgumentTuple y) => ArgumentTuple (:& a y)