Safe Haskell	None
Language	Haskell2010

WithCli.Pure

Contents

Modifiers
Useful Re-exports

Synopsis

withCliPure :: WithCliPure function a => String -> [Modifier] -> [String] -> function -> Result a
class WithCliPure function output
data Result a
- = Success a
- | Errors String
- | OutputAndExit String
handleResult :: Result a -> IO a
class HasArguments a where
- argumentsParser :: Modifiers -> Maybe String -> Result (Parser Unnormalized a)
atomicArgumentsParser :: Argument a => Modifiers -> Maybe String -> Result (Parser Unnormalized a)
class Argument a where
- argumentType :: Proxy a -> String
- parseArgument :: String -> Maybe a
data Modifier
- = AddShortOption String Char
- | RenameOption String String
- | RenameOptions (String -> Maybe String)
- | UseForPositionalArguments String String
- | AddOptionHelp String String
- | AddVersionFlag String
class Generic a
class Typeable (a :: k)
data Proxy (t :: k) = Proxy

Documentation

withCliPure Source #

Arguments

:: WithCliPure function a
=> String
-> [Modifier]
-> [String]
-> function	The `function` parameter can be a function with arbitrary many parameters as long as they have an instance for `HasArguments`. You can choose the return type of `function` freely, `withCliPure` will return it wrapped in `Result` to account for parse errors, etc. (see `Result`).
-> Result a

Pure variant of withCliModified.

class WithCliPure function output Source #

Minimal complete definition

run

Instances

Instances details

WithCliPure output output Source #
Instance details Defined in WithCli.Pure.Internal Methods run :: String -> Modifiers -> Result (Parser Unnormalized input) -> (input -> output) -> [String] -> Result output
(HasArguments input, WithCliPure function output) => WithCliPure (input -> function) output Source #
Instance details Defined in WithCli.Pure.Internal Methods run :: String -> Modifiers -> Result (Parser Unnormalized input0) -> (input0 -> input -> function) -> [String] -> Result output

data Result a Source #

Type to wrap results from withCliPure.

Constructors

Success a

The CLI was used correctly and a value of type a was successfully constructed.

Errors String

The CLI was used incorrectly. The Result contains error messages.

It can also happen that the data type you're trying to use isn't supported. See the README for details.

OutputAndExit String

The CLI was used with --help. The Result contains the help message.

Instances

Instances details

Applicative Result Source #
Instance details Defined in WithCli.Result Methods pure :: a -> Result a # (<>) :: Result (a -> b) -> Result a -> Result b # liftA2 :: (a -> b -> c) -> Result a -> Result b -> Result c # (>) :: Result a -> Result b -> Result b # (<*) :: Result a -> Result b -> Result a #
Functor Result Source #
Instance details Defined in WithCli.Result Methods fmap :: (a -> b) -> Result a -> Result b # (<$) :: a -> Result b -> Result a #
Monad Result Source #
Instance details Defined in WithCli.Result Methods (>>=) :: Result a -> (a -> Result b) -> Result b # (>>) :: Result a -> Result b -> Result b # return :: a -> Result a #
Show a => Show (Result a) Source #
Instance details Defined in WithCli.Result Methods showsPrec :: Int -> Result a -> ShowS # show :: Result a -> String # showList :: [Result a] -> ShowS #
Eq a => Eq (Result a) Source #
Instance details Defined in WithCli.Result Methods (==) :: Result a -> Result a -> Bool # (/=) :: Result a -> Result a -> Bool #
Ord a => Ord (Result a) Source #
Instance details Defined in WithCli.Result Methods compare :: Result a -> Result a -> Ordering # (<) :: Result a -> Result a -> Bool # (<=) :: Result a -> Result a -> Bool # (>) :: Result a -> Result a -> Bool # (>=) :: Result a -> Result a -> Bool # max :: Result a -> Result a -> Result a # min :: Result a -> Result a -> Result a #

handleResult :: Result a -> IO a Source #

Handles an input of type Result a:

On Success a it returns the value a.
On OutputAndExit message it writes the message to stdout and throws ExitSuccess.
On Errors errs it writes the error messages to stderr and throws ExitFailure 1.

This is used by withCli to handle parse results.

class HasArguments a where Source #

Everything that can be used as an argument to your main function (see withCli) needs to have a HasArguments instance.

HasArguments also allows to conjure up instances for record types to create more complex command line interfaces. Here's an example:

 {-# LANGUAGE DeriveAnyClass #-}
 {-# LANGUAGE DeriveGeneric #-}

 import WithCli

 data Options
   = Options {
     port :: Int,
     daemonize :: Bool,
     config :: Maybe FilePath
   }
   deriving (Show, Generic, HasArguments)

 main :: IO ()
 main = withCli run

 run :: Options -> IO ()
 run = print

In a shell this program behaves like this:

 $ program --port 8080 --config some/path
 Options {port = 8080, daemonize = False, config = Just "some/path"}
 $ program  --port 8080 --daemonize
 Options {port = 8080, daemonize = True, config = Nothing}
 $ program --port foo
 cannot parse as INTEGER: foo
 # exit-code 1
 $ program
 missing option: --port=INTEGER
 # exit-code 1
 $ program --help
 program [OPTIONS]
       --port=INTEGER
       --daemonize
       --config=STRING (optional)
   -h  --help                      show help and exit

Minimal complete definition

Nothing

Methods

argumentsParser :: Modifiers -> Maybe String -> Result (Parser Unnormalized a) Source #

default argumentsParser :: (Generic a, GTo a, GDatatypeInfo a, All2 HasArguments (GCode a)) => Modifiers -> Maybe String -> Result (Parser Unnormalized a) Source #

Instances

Instances details

HasArguments String Source #
Instance details Defined in WithCli.HasArguments Methods argumentsParser :: Modifiers -> Maybe String -> Result (Parser Unnormalized String) Source #
HasArguments Bool Source #
Instance details Defined in WithCli.HasArguments Methods argumentsParser :: Modifiers -> Maybe String -> Result (Parser Unnormalized Bool) Source #
HasArguments Double Source #
Instance details Defined in WithCli.HasArguments Methods argumentsParser :: Modifiers -> Maybe String -> Result (Parser Unnormalized Double) Source #
HasArguments Float Source #
Instance details Defined in WithCli.HasArguments Methods argumentsParser :: Modifiers -> Maybe String -> Result (Parser Unnormalized Float) Source #
HasArguments Int Source #
Instance details Defined in WithCli.HasArguments Methods argumentsParser :: Modifiers -> Maybe String -> Result (Parser Unnormalized Int) Source #
Argument a => HasArguments (Maybe a) Source #
Instance details Defined in WithCli.HasArguments Methods argumentsParser :: Modifiers -> Maybe String -> Result (Parser Unnormalized (Maybe a)) Source #
Argument a => HasArguments [a] Source #
Instance details Defined in WithCli.HasArguments Methods argumentsParser :: Modifiers -> Maybe String -> Result (Parser Unnormalized [a]) Source #
(HasArguments a, HasArguments b) => HasArguments (a, b) Source #
Instance details Defined in WithCli.HasArguments Methods argumentsParser :: Modifiers -> Maybe String -> Result (Parser Unnormalized (a, b)) Source #
(HasArguments a, HasArguments b, HasArguments c) => HasArguments (a, b, c) Source #
Instance details Defined in WithCli.HasArguments Methods argumentsParser :: Modifiers -> Maybe String -> Result (Parser Unnormalized (a, b, c)) Source #

atomicArgumentsParser :: Argument a => Modifiers -> Maybe String -> Result (Parser Unnormalized a) Source #

Useful for implementing your own instances of HasArguments on top of a custom Argument instance.

class Argument a where Source #

Argument is a typeclass for things that can be parsed as atomic values from single command line arguments, e.g. strings (and filenames) and numbers.

Occasionally you might want to declare your own instance for additional type safety and for providing a more informative command argument type. Here's an example:

 {-# LANGUAGE DeriveDataTypeable #-}

 import WithCli

 data File = File FilePath
   deriving (Show, Typeable)

 instance Argument File where
   argumentType Proxy = "custom-file-type"
   parseArgument f = Just (File f)

 instance HasArguments File where
   argumentsParser = atomicArgumentsParser

 main :: IO ()
 main = withCli run

 run :: File -> IO ()
 run = print

And this is how the above program behaves:

 $ program --help
 program [OPTIONS] custom-file-type
   -h  --help  show help and exit
 $ program some/file
 File "some/file"

Methods

argumentType :: Proxy a -> String Source #

parseArgument :: String -> Maybe a Source #

Instances

Instances details

Argument Integer Source #
Instance details Defined in WithCli.Argument Methods argumentType :: Proxy Integer -> String Source # parseArgument :: String -> Maybe Integer Source #
Argument String Source #
Instance details Defined in WithCli.Argument Methods argumentType :: Proxy String -> String Source # parseArgument :: String -> Maybe String Source #
Argument Double Source #
Instance details Defined in WithCli.Argument Methods argumentType :: Proxy Double -> String Source # parseArgument :: String -> Maybe Double Source #
Argument Float Source #
Instance details Defined in WithCli.Argument Methods argumentType :: Proxy Float -> String Source # parseArgument :: String -> Maybe Float Source #
Argument Int Source #
Instance details Defined in WithCli.Argument Methods argumentType :: Proxy Int -> String Source # parseArgument :: String -> Maybe Int Source #

Modifiers

data Modifier Source #

Modifiers can be used to customize the command line parser.

Constructors

AddShortOption String Char	`AddShortOption fieldName c` adds the `Char` `c` as a short option for the field addressed by `fieldName`.
RenameOption String String	`RenameOption fieldName customName` renames the option generated through the `fieldName` by `customName`.
RenameOptions (String -> Maybe String)	`RenameOptions f` renames all options with the given functions. In case the function returns `Nothing` the original field name is used. Can be used together with `stripPrefix`.
UseForPositionalArguments String String	`UseForPositionalArguments fieldName argumentType` fills the field addressed by `fieldName` with the positional arguments (i.e. arguments that don't correspond to a flag). The field has to have type `[String]`. `argumentType` is used as the type of the positional arguments in the help output.
AddOptionHelp String String	`AddOptionHelp fieldName helpText` adds a help text for the option `fieldName`.
AddVersionFlag String	`AddVersionFlag version` adds a `--version` flag.

Useful Re-exports

class Generic a #

Minimal complete definition

from, to

Instances

Instances details

Generic Void

Instance details