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

Minimal complete definition

parse, name

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

Methods

parse :: String -> Maybe Char

name :: Char -> String

(Typeable * t, Read t) => Arguable t

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

Methods

parse :: String -> Maybe t

name :: t -> String

Arguable String

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

Methods

parse :: String -> Maybe String

name :: String -> String

Arguable Text

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

Methods

parse :: String -> Maybe Text

name :: Text -> String

Arguable FilePath

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

Methods

parse :: String -> Maybe FilePath

name :: FilePath -> String

class Argument a where

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

Minimal complete definition

parseArg, argName

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

Arguable a => Argument a

use the arguable tyep to just parse a single argument

Methods

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

argName :: a -> String

Argument String

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

Methods

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

argName :: String -> String

Arguable a => Argument [a]

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

Methods

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

argName :: [a] -> String

Arguable a => Argument (Maybe a)

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

Methods

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

argName :: Maybe a -> String

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)

Methods

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

argName :: NonGreedy m a -> String

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)

Methods

(==) :: NonGreedy m a -> NonGreedy m a -> Bool

(/=) :: NonGreedy m a -> NonGreedy m a -> Bool

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

Methods

showsPrec :: Int -> NonGreedy m a -> ShowS

show :: NonGreedy m a -> String

showList :: [NonGreedy m a] -> ShowS

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)

Methods

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

argName :: NonGreedy m a -> String

class ArgumentTuple a where

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

Minimal complete definition

parseArgsFrom, usageFor

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

Methods

parseArgsFrom :: [String] -> Maybe ()

usageFor :: () -> String

Argument a => ArgumentTuple a

Methods

parseArgsFrom :: [String] -> Maybe a

usageFor :: a -> String

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

Methods

parseArgsFrom :: [String] -> Maybe (b, a)

usageFor :: (b, a) -> String

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

Methods

parseArgsFrom :: [String] -> Maybe (a :& y)

usageFor :: (a :& y) -> String

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

Methods

parseArgsFrom :: [String] -> Maybe (c, b, a)

usageFor :: (c, b, a) -> String

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

Methods

parseArgsFrom :: [String] -> Maybe (d, c, b, a)

usageFor :: (d, c, b, a) -> String

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

Methods

parseArgsFrom :: [String] -> Maybe (e, d, c, b, a)

usageFor :: (e, d, c, b, a) -> String

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

Methods

parseArgsFrom :: [String] -> Maybe (f, e, d, c, b, a)

usageFor :: (f, e, d, c, b, a) -> String

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

Methods

parseArgsFrom :: [String] -> Maybe (g, f, e, d, c, b, a)

usageFor :: (g, f, e, d, c, b, a) -> String

(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)

Methods

parseArgsFrom :: [String] -> Maybe (h, g, f, e, d, c, b, a)

usageFor :: (h, g, f, e, d, c, b, a) -> String

(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)

Methods

parseArgsFrom :: [String] -> Maybe (i, h, g, f, e, d, c, b, a)

usageFor :: (i, h, g, f, e, d, c, b, a) -> String

(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)

Methods

parseArgsFrom :: [String] -> Maybe (j, i, h, g, f, e, d, c, b, a)

usageFor :: (j, i, h, g, f, e, d, c, b, a) -> String

(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)

Methods

parseArgsFrom :: [String] -> Maybe (k, j, i, h, g, f, e, d, c, b, a)

usageFor :: (k, j, i, h, g, f, e, d, c, b, a) -> String

(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)

Methods

parseArgsFrom :: [String] -> Maybe (l, k, j, i, h, g, f, e, d, c, b, a)

usageFor :: (l, k, j, i, h, g, f, e, d, c, b, a) -> String

(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)

Methods

parseArgsFrom :: [String] -> Maybe (m, l, k, j, i, h, g, f, e, d, c, b, a)

usageFor :: (m, l, k, j, i, h, g, f, e, d, c, b, a) -> String

(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)

Methods

parseArgsFrom :: [String] -> Maybe (n, m, l, k, j, i, h, g, f, e, d, c, b, a)

usageFor :: (n, m, l, k, j, i, h, g, f, e, d, c, b, a) -> String

(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)

Methods

parseArgsFrom :: [String] -> Maybe (o, n, m, l, k, j, i, h, g, f, e, d, c, b, a)

usageFor :: (o, n, m, l, k, j, i, h, g, f, e, d, c, b, a) -> String

data a :& b infixr 5

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

Constructors

a :& b infixr 5

Instances

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

Methods

(==) :: (a :& b) -> (a :& b) -> Bool

(/=) :: (a :& b) -> (a :& b) -> Bool

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

Methods

showsPrec :: Int -> (a :& b) -> ShowS

show :: (a :& b) -> String

showList :: [a :& b] -> ShowS

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

Methods

parseArgsFrom :: [String] -> Maybe (a :& y)

usageFor :: (a :& y) -> String