# optparse-declarative
`optparse-declarative` is a declarative and easy to use command-line option parser.
# Install
```bash
$ cabal install optparse-declarative
```
# Usage
## Writing a simple command
First, you need to enable `DataKinds` extension and import `Options.Declarative` module.
```hs
{-# LANGUAGE DataKinds #-}
import Options.Declarative
```
Then, define the command line option as a **type of the function**.
For example, this is a simple greeting program:
```hs
greet :: Flag "g" '["greet"] "STRING" "greeting message" (Def "Hello" String)
-> Arg "NAME" String
-> Cmd "greet"
greet msg name = Cmd $ do
putStrLn $ get msg ++ ", " ++ get name ++ "!"
```
There are two type of options, `Flag` and `Arg`.
`Flag` is named argument and `Arg` is unnamed argument.
Last argument of both options is value type.
If you need to specify default value, use the modifiers such as `Def`.
In above, variable `msg` has a very complex type (`Flag "g" '["greet"] "STRING" "greeting message" (Def "Hello" String)`).
In order to get the value of usual type (in this case, that is `String`),
you can use `get` function.
The whole type of command is `Cmd`.
`Cmd <description>` is basically newtype of `IO ()`,
except this contains extra information.
When you define the command, there remains only invoking the command.
```hs
main :: IO ()
main = run_ greet
```
You can execute this program like this:
```bash
$ ghc simple.hs
$ ./simple
simple: not enough arguments
Try 'simple --help' for more information.
$ ./simple --help
Usage: simple [OPTION...] NAME
Options:
-g STRING --greet=STRING greeting message
-? --help display this help and exit
$ ./simple World
Hello, World!
$ ./simple --greet=Goodbye World
Goodbye, World!
```
## Writing multiple sum-commands
You can write (nested) sub-commands.
Just groupe subcommands by `Group`, you got sub-command parser.
This is the example:
```hs
{-# LANGUAGE DataKinds #-}
import Options.Declarative
main :: IO ()
main = run_ $
Group "Test program for library"
[ subCmd "greet" greet
, subCmd "connect" connect
]
greet :: Flag "g" '["greet"] "STRING" "greeting message" (Def "Hello" String)
-> Flag "" '["decolate"] "" "decolate message" Bool
-> Arg "NAME" String
-> Cmd "Greeting command"
greet msg deco name = Cmd $ do
let f x | get deco = "*** " ++ x ++ " ***"
| otherwise = x
putStrLn $ f $ get msg ++ ", " ++ get name ++ "!"
connect :: Flag "h" '["host"] "HOST" "host name" (Def "localhost" String)
-> Flag "p" '["port"] "PORT" "port number" (Def "8080" Int )
-> Cmd "Connect command"
connect host port = Cmd $ do
let addr = get host ++ ":" ++ show (get port)
putStrLn $ "connect to " ++ addr
```
And this is the output:
```bash
$ ./subcmd --help
Usage: subcmd [OPTION...] <COMMAND> [ARGS...]
Options:
-? --help display this help and exit
Commands:
greet Greeting command
port Server command
$ ./subcmd connect --port=1234
connect to localhost:1234
```
For more examples, please see `example` directory.