Options.Applicative.Types

data ParseError

Constructors

• ErrorMsg String
• InfoMsg String
• ShowHelpText
• MissingError IsCmdStart SomeParser
• ExpectsArgError String
• UnexpectedError String SomeParser

Instances

• Semigroup ParseError

newtype ParserInfo a

A 'ParserInfo' describes a command line program, used to generate a help screen. Two help modes are supported: brief and full. In brief mode, only an option and argument summary is displayed, while in full mode each available option and command, including hidden ones, is described.

A basic 'ParserInfo' with default values for fields can be created using the 'info' function.

Constructors

• ParserInfo { infoFailureCode :: ExitCode, infoFooter :: Chunk Doc, infoFullDesc :: Boolean, infoHeader :: Chunk Doc, infoParser :: Parser a, infoPolicy :: ArgPolicy, infoProgDesc :: Chunk Doc }

Instances

• Newtype (ParserInfo a) _
• Functor ParserInfo

newtype ParserPrefs

Global preferences for a top-level 'Parser'. A 'ParserPrefs' contains general preferences for all command-line options, and can be built with the 'prefs' function.

Constructors

• ParserPrefs { prefBacktrack :: Backtracking, prefColumns :: Int, prefDisambiguate :: Boolean, prefMultiSuffix :: String, prefShowHelpOnEmpty :: Boolean, prefShowHelpOnError :: Boolean }

Instances

• Newtype ParserPrefs _
• Eq ParserPrefs
• Generic ParserPrefs _
• Show ParserPrefs

newtype Option a

A single option of a parser.

Constructors

• Option { optMain :: OptReader a, optProps :: OptProperties }

Instances

• Newtype (Option a) _
• Show (Option a)
• Functor Option

data OptName

Constructors

• OptShort Char
• OptLong String

Instances

• Eq OptName
• Ord OptName
• Generic OptName _
• Show OptName

data OptReader a

An 'OptReader' defines whether an option matches an command line argument.

Constructors

• OptReader (Array OptName) (CReader a) (String -> ParseError)
• FlagReader (Array OptName) a
• ArgReader (CReader a)
• CmdReader (Maybe String) (Array String) (String -> Maybe (ParserInfo a))

Instances

• Functor OptReader

newtype OptProperties

Specification for an individual parser option.

Constructors

• OptProperties { propDescMod :: Maybe (Doc -> Doc), propHelp :: Chunk Doc, propMetaVar :: String, propShowDefault :: Maybe String, propVisibility :: OptVisibility }

Instances

• Newtype OptProperties _
• Show OptProperties

data OptVisibility

Visibility of an option in the help text.

Constructors

• Internal
• Hidden
• Visible

Instances

• Eq OptVisibility
• Ord OptVisibility
• Generic OptVisibility _
• Show OptVisibility

data Backtracking

Constructors

• Backtrack
• NoBacktrack
• SubparserInline

Instances

• Eq Backtracking
• Generic Backtracking _
• Show Backtracking

newtype ReadM a

A reader is used by the 'option' and 'argument' builders to parse the data passed by the user on the command line into a data type.

The most common are 'str' which is used for 'String', there are readers for Int, Number, Boolean.

More complex types can use the 'eitherReader' or 'maybeReader' functions to pattern match or use a more expressive parser like a member of the 'Parsec' family. A newtype over 'ReaderT String Except', used by option readers.

Constructors

• ReadM (ReaderT String (Except ParseError) a)

Instances

• Newtype (ReadM a) _
• Functor ReadM
• Apply ReadM
• Applicative ReadM
• Alt ReadM
• Bind ReadM
• Monad ReadM
• MonadThrow String ReadM

readerAsk :: ReadM String

Return the value being read.

readerAbort :: forall a. ParseError -> ReadM a

Abort option reader by exiting with a 'ParseError'.

readerError :: forall a. String -> ReadM a

Abort option reader by exiting with an error message.

newtype CReader a

Constructors

• CReader { crCompleter :: Completer, crReader :: ReadM a }

Instances

• Newtype (CReader a) _
• Functor CReader

data Parser a

A 'Parser' is the core type in optparse-applicative. A value of type Parser a@ represents a specification for a set of options, which will yield a value of type a when the command line arguments are successfully parsed.

There are several types of primitive 'Parser'.

• Flags: simple no-argument options. When a flag is encountered on the command line, its value is returned.

• Options: options with an argument. An option can define a /reader/, which converts its argument from String to the desired value, or throws a parse error if the argument does not validate correctly.

• Arguments: positional arguments, validated in the same way as option arguments.

• Commands. A command defines a completely independent sub-parser. When a command is encountered, the whole command line is passed to the corresponding parser.

** Parser builders

Each parser builder takes an option modifier. A modifier can be created by composing the basic modifiers provided by here using the 'Monoid' operations mempty' and 'append', or their aliases 'idm' and '<>'.

For example:

out = strOption ( long "output" <> short 'o' <> metavar "FILENAME" )

creates a parser for an option called "output".

Constructors

• NilP a
• OptP (Option a)
• MultP (Exists (MultPE a))
• AltP (Parser a) (Parser a)
• BindP (Free Parser a)

Instances

• Functor Parser
• Apply Parser
• Applicative Parser
• Alt Parser

data MultPE a x

Constructors

• MultPE (Parser (x -> a)) (Parser x)

newtype Completer

optparse-applicative supplies a rich completion system for bash, zsh, and fish shells.

'Completer' functions are used for option and argument to complete their values.

Use the 'completer' builder to use these. The 'action' and 'completeWith' builders are also provided for convenience, to use 'bashCompleter' and 'listCompleter' as a 'Mod'.

Constructors

• Completer (String -> Effect (Array String))

Instances

• Newtype Completer _
• Semigroup Completer
• Monoid Completer

mkCompleter :: (String -> Effect (Array String)) -> Completer

Smart constructor for a 'Completer'

newtype CompletionResult

Constructors

• CompletionResult { execCompletion :: String -> Effect String }

Instances

• Newtype CompletionResult _
• Show CompletionResult

newtype ParserFailure h

Constructors

• ParserFailure (String -> Tuple3 h ExitCode Int)

Instances

• Newtype (ParserFailure h) _
• Show (ParserFailure h)
• Functor ParserFailure

data ParserResult a

Result of 'execParserPure'.

Constructors

• Success a
• Failure (ParserFailure ParserHelp)
• CompletionInvoked CompletionResult

Instances

• Generic (ParserResult a) _
• (Show a) => Show (ParserResult a)
• Functor ParserResult
• Apply ParserResult
• Applicative ParserResult
• Bind ParserResult
• Monad ParserResult

overFailure :: forall a. (ParserHelp -> ParserHelp) -> ParserResult a -> ParserResult a

type Args = List String

data ArgPolicy

Policy for how to handle options within the parse

Constructors

• Intersperse
• NoIntersperse
• AllPositionals
• ForwardOptions

Instances

• Eq ArgPolicy
• Ord ArgPolicy
• Generic ArgPolicy _
• Show ArgPolicy

newtype OptHelpInfo

Constructors

• OptHelpInfo { hinfoDefault :: Boolean, hinfoMulti :: Boolean, hinfoUnreachableArgs :: Boolean }

Instances

• Newtype OptHelpInfo _
• Eq OptHelpInfo
• Generic OptHelpInfo _
• Show OptHelpInfo

data OptTree a

Constructors

• Leaf a
• MultNode (Array (OptTree a))
• AltNode (Array (OptTree a))

Instances

• Generic (OptTree a) _
• (Show a) => Show (OptTree a)

data SomeParser

Constructors

• SomeParser (Exists Parser)

data Context

Subparser context, containing the 'name' of the subparser, and its parser info. Used by parserFailure to display relevant usage information when parsing inside a subparser fails.

Constructors

• Context String (Exists ParserInfo)

data IsCmdStart

Constructors

• CmdStart
• CmdCont

Instances

• Generic IsCmdStart _
• Show IsCmdStart

optVisibility :: forall a. Option a -> OptVisibility

optMetaVar :: forall a. Option a -> String

optHelp :: forall a. Option a -> Chunk Doc

optShowDefault :: forall a. Option a -> Maybe String

optDescMod :: forall a. Option a -> Maybe (Doc -> Doc)

many :: forall a. Parser a -> Parser (List a)

Parses 0 or more values using the given parser. Note: this should never be used with the value modifier.

For example, by using this option many (strOption (long "arg-name"))

one could write

command
# produces Nil

command --arg-name first
# produces ("first" : Nil)

command --arg-name first --arg-name second
# produces ("first" : "second" : Nil)

To parse 1 or more values, see some instead.

some :: forall a. Parser a -> Parser (NonEmptyList a)

Parses 1 or more values using the given parser. Note: this should never be used with the value modifier.

For example, by using this option some (strOption (long "arg-name"))

one could write

command
# produces failure message

command --arg-name first
# produces (NonEmptyList "first" Nil)

command --arg-name first --arg-name second
# produces (NonEmptyList "first" ("second" : Nil))

To parse 0 or more values, see many instead.

optional :: forall f a. Alt f => Applicative f => f a -> f (Maybe a)

newtype ParserHelp

Constructors

• ParserHelp { helpBody :: Chunk Doc, helpError :: Chunk Doc, helpFooter :: Chunk Doc, helpHeader :: Chunk Doc, helpSuggestions :: Chunk Doc, helpUsage :: Chunk Doc }

Instances

• Newtype ParserHelp _
• Show ParserHelp
• Semigroup ParserHelp
• Monoid ParserHelp