cmdargs: Command line argument processing

[ bsd3, console, library ] [ Propose Tags ]

This library provides an easy way to define command line parsers. Most users will want to use the System.Console.CmdArgs.Implicit module, whose documentation contains an example.

  • System.Console.CmdArgs.Explicit provides a way to write command line parsers for both single mode programs (most programs) and multiple mode programs (e.g. darcs or cabal). Parsers are defined by constructing a data structure.

  • System.Console.CmdArgs.Implicit provides a way to concisely define command line parsers, up to three times shorter than getopt. These parsers are translated into the Explicit data type.

  • System.Console.CmdArgs.GetOpt provides a wrapper allowing compatiblity with existing getopt parsers, mapping to the Explicit data type.

For a general reference on what command line flags are commonly used, see http://www.faqs.org/docs/artu/ch10s05.html.


[Skip to Readme]

Flags

Automatic Flags
NameDescriptionDefault
testprog

Build the test program

Disabled
quotation

Build the Quote module

Enabled

Use -f <flag> to enable a flag, or -f -<flag> to disable that flag. More info

Downloads

Note: This package has metadata revisions in the cabal description newer than included in the tarball. To unpack the package including the revisions, use 'cabal get'.

Maintainer's Corner

Package maintainers

For package maintainers and hackage trustees

Candidates

  • No Candidates
Versions [RSS] 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.6.1, 0.6.2, 0.6.3, 0.6.4, 0.6.5, 0.6.6, 0.6.7, 0.6.8, 0.6.9, 0.6.10, 0.7, 0.8, 0.9, 0.9.1, 0.9.2, 0.9.3, 0.9.4, 0.9.5, 0.9.6, 0.9.7, 0.10, 0.10.1, 0.10.2, 0.10.3, 0.10.4, 0.10.5, 0.10.6, 0.10.7, 0.10.8, 0.10.9, 0.10.10, 0.10.11, 0.10.12, 0.10.13, 0.10.14, 0.10.15, 0.10.16, 0.10.17, 0.10.18, 0.10.19, 0.10.20, 0.10.21, 0.10.22
Change log CHANGES.txt
Dependencies base (>=4 && <4.10), filepath, process (>=1.0), template-haskell, transformers (>=0.2) [details]
License BSD-3-Clause
Copyright Neil Mitchell 2009-2014
Author Neil Mitchell <ndmitchell@gmail.com>
Maintainer Neil Mitchell <ndmitchell@gmail.com>
Revised Revision 1 made by NeilMitchell at 2018-03-24T14:13:13Z
Category Console
Home page http://community.haskell.org/~ndm/cmdargs/
Bug tracker https://github.com/ndmitchell/cmdargs/issues
Source repo head: git clone https://github.com/ndmitchell/cmdargs.git
Uploaded by NeilMitchell at 2014-07-22T16:51:15Z
Distributions Arch:0.10.22, Debian:0.10.20, Fedora:0.10.22, FreeBSD:0.10.13, LTSHaskell:0.10.22, NixOS:0.10.22, Stackage:0.10.22, openSUSE:0.10.22
Reverse Dependencies 98 direct, 267 indirect [details]
Executables cmdargs
Downloads 235900 total (301 in the last 30 days)
Rating 2.25 (votes: 2) [estimated by Bayesian average]
Your Rating
  • λ
  • λ
  • λ
Status Docs available [build log]
Successful builds reported [all 1 reports]

Readme for cmdargs-0.10.9

[back to package description]

CmdArgs: Easy Command Line Processing Build Status

CmdArgs is a Haskell library for defining command line parsers. The two features that make it a better choice than the standard getopt library are:

  1. It's very concise to use. The HLint command line handling is three times shorter with CmdArgs.
  2. It supports programs with multiple modes, such as darcs or Cabal.

A very simple example of a command line processor is:

data Sample = Sample {hello :: String} deriving (Show, Data, Typeable)

sample = Sample{hello = def &= help "World argument" &= opt "world"} &= summary "Sample v1"

main = print =<< cmdArgs sample

Despite being very concise, this processor is already fairly well featured:

$ runhaskell Sample.hs --hello=world
Sample {hello = "world"}

$ runhaskell Sample.hs --help Sample v1, (C) Neil Mitchell 2009

sample [FLAG]

-? --help[=FORMAT] Show usage information (optional format) -V --version Show version information -v --verbose Higher verbosity -q --quiet Lower verbosity -h --hello=VALUE World argument (default=world)

User Manual

The rest of this document explains how to write the "hello world" of command line processors, then how to extend it with features into a complex command line processor. Finally this document gives three samples, which the cmdargs program can run. The three samples are:

  1. hlint - the HLint program.
  2. diffy - a program to compare the differences between directories.
  3. maker - a make style program.

For each example you are encouraged to look at it's source (see the darcs repo, or the bottom of this document) and run it (try cmdargs hlint --help). The HLint program is fairly standard in terms of it's argument processing, and previously used the System.Console.GetOpt library. Using GetOpt required 90 lines and a reasonable amount of duplication. Using CmdArgs the code requires 30 lines, and the logic is much simpler.

Acknowledgements

Thanks to Kevin Quick for substantial patches, and additional code contributions from Sebastian Fischer and Daniel Schoepe.

Hello World Example

The following code defines a complete command line argument processor:

{-# LANGUAGE DeriveDataTypeable #-}
module Sample where
import System.Console.CmdArgs

data Sample = Sample {hello :: String}
              deriving (Show, Data, Typeable)

sample = Sample{hello = def}

main = print =<< cmdArgs sample

To use the CmdArgs library there are three steps:

  1. Define a record data type (Sample) that contains a field for each argument. This type needs to have instances for Show, Data and Typeable.
  2. Give a value of that type (sample) with default values (def is a default value of any type, but I could also have written ""). This value is turned into a command line by calling the cmdArgs function.

Now we have a reasonably functional command line argument processor. Some sample interactions are:

$ runhaskell Sample.hs --hello=world
Sample {hello = "world"}

$ runhaskell Sample.hs --version The sample program

$ runhaskell Sample.hs --help The sample program

sample [OPTIONS]

-? --help Display help message -V --version Print version information -h --hello=ITEM

CmdArgs uses defaults to automatically infer a command line parser for a value, and provides annotations to override any of the the defaults. CmdArgs automatically supports --help and --version flags, and optionally supports verbosity flags.

Specifying Attributes

In order to control the behaviour we can add attributes. For example to add an attribute specifying the help text for the --hello argument we can write:

sample = Sample{hello = def &= help "Who to say hello to"}

We can add additional attributes, for example to specify the type of the value expected by hello:

sample = Sample {hello = def &= help "Who to say hello to" &= typ "WORLD"}

Now when running --help the final line is:

  -h --hello=WORLD  Who to say hello to

There are many more attributes, detailed in the Haddock documentation.

Multiple Modes

To specify a program with multiple modes, similar to darcs, we can supply a data type with multiple constructors, for example:

data Sample = Hello {whom :: String}
            | Goodbye
              deriving (Show, Data, Typeable)

hello = Hello{whom = def}
goodbye = Goodbye

main = print =<< cmdArgs (modes [hello,goodbye])

Compared to the first example, we now have multiple constructors, and a sample value for each constructor is passed to cmdArgs. Some sample interactions with this command line are:

$ runhaskell Sample.hs hello --whom=world
Hello {whom = "world"}

$ runhaskell Sample.hs goodbye Goodbye

$ runhaskell Sample.hs --help The sample program

sample [OPTIONS]

Common flags -? --help Display help message -V --version Print version information

sample hello [OPTIONS]

-w --whom=ITEM

sample goodbye [OPTIONS]

As before, the behaviour can be customised using attributes.

Larger Examples

For each of the following examples we first explain the purpose of the program, then give the source code, and finally the output of --help=HTML. The programs are intended to show sample uses of CmdArgs, and are available to experiment with through cmdargs progname.

HLint

The HLint program analyses a list of files, using various options to control the analysis. The command line processing is simple, but a few interesting points are:

  • The --report flag can be used to output a report in a standard location, but giving the flag a value changes where the file is output.
  • The color field is assigned two flag aliases, --colour and -c. Assigning the -c short flag explicitly stops either of the CPP fields using it.
  • The show_ field would clash with show if given the expected name, but CmdArgs automatically strips the trailing underscore.
  • The cpp_define field has an underscore in it's name, which is transformed into a hyphen for the flag name.
{-# LANGUAGE DeriveDataTypeable #-}
module HLint where
import System.Console.CmdArgs

data HLint = HLint
    {report :: [FilePath]
    ,hint :: [FilePath]
    ,color :: Bool
    ,ignore_ :: [String]
    ,show_ :: Bool
    ,extension :: [String]
    ,language :: [String]
    ,utf8 :: Bool
    ,encoding :: String
    ,find :: [FilePath]
    ,test_ :: Bool
    ,datadir :: [FilePath]
    ,cpp_define :: [String]
    ,cpp_include :: [FilePath]
    ,files :: [FilePath]
    }
    deriving (Data,Typeable,Show,Eq)

hlint = HLint
    {report = def &= opt "report.html" &= typFile &= help "Generate a report in HTML"
    ,hint = def &= typFile &= help "Hint/ignore file to use"
    ,color = def &= name "c" &= name "colour" &= help "Color the output (requires ANSI terminal)"
    ,ignore_ = def &= typ "MESSAGE" &= help "Ignore a particular hint"
    ,show_ = def &= help "Show all ignored ideas"
    ,extension = def &= typ "EXT" &= help "File extensions to search (defaults to hs and lhs)"
    ,language = def &= name "X" &= typ "LANG" &= help "Language extension (Arrows, NoCPP)"
    ,utf8 = def &= help "Use UTF-8 text encoding"
    ,encoding = def &= typ "ENC" &= help "Choose the text encoding"
    ,find = def &= typFile &= help "Find hints in a Haskell file"
    ,test_ = def &= help "Run in test mode"
    ,datadir = def &= typDir &= help "Override the data directory"
    ,cpp_define = def &= typ "NAME[=VALUE]" &= help "CPP #define"
    ,cpp_include = def &= typDir &= help "CPP include path"
    ,files = def &= args &= typ "FILES/DIRS"
    } &=
    verbosity &=
    help "Suggest improvements to Haskell source code" &=
    summary "HLint v0.0.0, (C) Neil Mitchell" &=
    details ["Hlint gives hints on how to improve Haskell code",""
            ,"To check all Haskell files in 'src' and generate a report type:","  hlint src --report"]

mode = cmdArgsMode hlint
HLint v0.0.0, (C) Neil Mitchell

hlint [OPTIONS] [FILES/DIRS]
Suggest improvements to Haskell source code

Common flags:
  -r --report[=FILE]	        Generate a report in HTML
  -h --hint=FILE	            Hint/ignore file to use
  -c --colour --color	        Color the output (requires ANSI terminal)
  -i --ignore=MESSAGE	        Ignore a particular hint
  -s --show                     Show all ignored ideas
     --extension=EXT            File extensions to search (defaults to hs and lhs)
  -X --language=LANG	        Language extension (Arrows, NoCPP)
  -u --utf8	                    Use UTF-8 text encoding
     --encoding=ENC	            Choose the text encoding
  -f --find=FILE	            Find hints in a Haskell file
  -t --test	                    Run in test mode
  -d --datadir=DIR	            Override the data directory
     --cpp-define=NAME[=VALUE]  CPP #define
     --cpp-include=DIR	        CPP include path
  -? --help	                    Display help message
  -V --version	                Print version information
  -v --verbose	                Loud verbosity
  -q --quiet	                Quiet verbosity

Hlint gives hints on how to improve Haskell code

To check all Haskell files in 'src' and generate a report type:
  hlint src --report

Diffy

The Diffy sample is a based on the idea of creating directory listings and comparing them. The tool can operate in two separate modes, create or diff. This sample is fictional, but the ideas are drawn from a real program. A few notable features:

  • There are multiple modes of execution, creating and diffing.
  • The diff mode takes exactly two arguments, the old file and the new file.
  • Default values are given for the out field, which are different in both modes.
{-# LANGUAGE DeriveDataTypeable #-}
module Diffy where
import System.Console.CmdArgs

data Diffy = Create {src :: Maybe FilePath, out :: FilePath}
           | Diff {old :: FilePath, new :: FilePath, out :: FilePath}
             deriving (Data,Typeable,Show,Eq)

outFlags x = x &= help "Output file" &= typFile

create = Create
    {src = def &= help "Source directory" &= typDir
    ,out = outFlags "ls.txt"
    } &= help "Create a fingerprint"

diff = Diff
    {old = def &= typ "OLDFILE" &= argPos 0
    ,new = def &= typ "NEWFILE" &= argPos 1
    ,out = outFlags "diff.txt"
    } &= help "Perform a diff"

mode = cmdArgsMode $ modes [create,diff] &= help "Create and compare differences" &= program "diffy" &= summary "Diffy v1.0"
Diffy v1.0
 
diffy [COMMAND] ... [OPTIONS]
  Create and compare differences
 
Common flags:
  -o --out=FILE	 Output file
  -? --help	     Display help message
  -V --version	 Print version information
 
diffy create [OPTIONS]
  Create a fingerprint
 
  -s  --src=DIR  Source directory
 
diffy diff [OPTIONS] OLDFILE NEWFILE
  Perform a diff

Maker

The Maker sample is based around a build system, where we can either build a project, clean the temporary files, or run a test. Some interesting features are:

  • The build mode is the default, so maker on it's own will be interpretted as a build command.
  • The build method is an enumeration.
  • The threads field is in two of the constructors, but not all three. It is given the short flag -j, rather than the default -t.
{-# LANGUAGE DeriveDataTypeable #-}
module Maker where
import System.Console.CmdArgs

data Method = Debug | Release | Profile
              deriving (Data,Typeable,Show,Eq)

data Maker
    = Wipe
    | Test {threads :: Int, extra :: [String]}
    | Build {threads :: Int, method :: Method, files :: [FilePath]}
      deriving (Data,Typeable,Show,Eq)

threadsMsg x = x &= help "Number of threads to use" &= name "j" &= typ "NUM"

wipe = Wipe &= help "Clean all build objects"

test_ = Test
    {threads = threadsMsg def
    ,extra = def &= typ "ANY" &= args
    } &= help "Run the test suite"

build = Build
    {threads = threadsMsg def
    ,method = enum
        [Release &= help "Release build"
        ,Debug &= help "Debug build"
        ,Profile &= help "Profile build"]
    ,files = def &= args
    } &= help "Build the project" &= auto

mode = cmdArgsMode $ modes [build,wipe,test_] &= help "Build helper program" &= program "maker" &= summary "Maker v1.0\nMake it"
Maker v1.0
  Make it
 
maker [COMMAND] ... [OPTIONS]
  Build helper program
 
Common flags:
  -? --help     Display help message
  -V --version  Print version information
 
maker [build] [OPTIONS] [ITEM]
  Build the project
 
  -j --threads=NUM  Number of threads to use
  -r --release      Release build
  -d --debug        Debug build
  -p --profile      Profile build
 
maker wipe [OPTIONS]
  Clean all build objects
 
maker test [OPTIONS] [ANY]
  Run the test suite
 
  -j --threads=NUM  Number of threads to use