Safe Haskell	Safe
Language	Haskell98

ReadArgs

Synopsis

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 #