Safe Haskell	Safe
Language	Haskell2010

Multiarg.Mode.Internal

Description

Internal functions used by Multiarg.Mode. You don't have to worry about "breaking" anything by using this module; it is separate from Multiarg.Mode primarily to tidy up the documentation in that module. The functions in Multiarg.Mode should satisfy most use cases. However, if you want more control over error handling, you can use this module.

Synopsis

Documentation

newtype ModeName #

Constructors

ModeName String

Instances

Eq ModeName #
Methods (==) :: ModeName -> ModeName -> Bool # (/=) :: ModeName -> ModeName -> Bool #
Ord ModeName #
Methods compare :: ModeName -> ModeName -> Ordering # (<) :: ModeName -> ModeName -> Bool # (<=) :: ModeName -> ModeName -> Bool # (>) :: ModeName -> ModeName -> Bool # (>=) :: ModeName -> ModeName -> Bool # max :: ModeName -> ModeName -> ModeName # min :: ModeName -> ModeName -> ModeName #
Show ModeName #
Methods showsPrec :: Int -> ModeName -> ShowS # show :: ModeName -> String # showList :: [ModeName] -> ShowS #

data ParsedMode a #

Constructors

ModeGood a
ModeError [OptionError] (Either OptionError OptName)	There was an error. There may be zero or more initial OptionError. There must be at least one error, which is either an OptionError or the name of an option, if the error is that there were not enough words following the option to provide it with its necessary arguments.

Instances

Functor ParsedMode #
Methods fmap :: (a -> b) -> ParsedMode a -> ParsedMode b # (<$) :: a -> ParsedMode b -> ParsedMode a #
Eq a => Eq (ParsedMode a) #
Methods (==) :: ParsedMode a -> ParsedMode a -> Bool # (/=) :: ParsedMode a -> ParsedMode a -> Bool #
Ord a => Ord (ParsedMode a) #
Methods compare :: ParsedMode a -> ParsedMode a -> Ordering # (<) :: ParsedMode a -> ParsedMode a -> Bool # (<=) :: ParsedMode a -> ParsedMode a -> Bool # (>) :: ParsedMode a -> ParsedMode a -> Bool # (>=) :: ParsedMode a -> ParsedMode a -> Bool # max :: ParsedMode a -> ParsedMode a -> ParsedMode a # min :: ParsedMode a -> ParsedMode a -> ParsedMode a #
Show a => Show (ParsedMode a) #
Methods showsPrec :: Int -> ParsedMode a -> ShowS # show :: ParsedMode a -> String # showList :: [ParsedMode a] -> ShowS #

data Mode r #

A Mode represents a single command line mode, such as check for ghc-pkg check. It contains the name of the mode, as well as a parser that handles all options and positional arguments for the mode. Ordinarily you will create a Mode using the mode function rather than by using the constructor directly.

Constructors

Mode ModeName ([Word] -> ParsedMode r)

Instances

Functor Mode #
Methods fmap :: (a -> b) -> Mode a -> Mode b # (<$) :: a -> Mode b -> Mode a #

parsedCommandLineToParsedMode :: ([a] -> r) -> ParsedCommandLine a -> ParsedMode r #

mode #

Arguments

:: String	Mode name. For instance, for the `check` mode of `ghc-pkg`, this would be `check`.
-> [OptSpec a]	Mode options
-> (String -> a)	Parses positional arguments
-> ([a] -> r)	Processes the result of all mode options
-> Mode r

Creates a new Mode.

data GlobalLocalEnd a #

Constructors

GlobalInsufficientOptArgs OptName
ModeNotFound String [String]
NoMode
ModeFound (ParsedMode a)

Instances

Eq a => Eq (GlobalLocalEnd a) #
Methods (==) :: GlobalLocalEnd a -> GlobalLocalEnd a -> Bool # (/=) :: GlobalLocalEnd a -> GlobalLocalEnd a -> Bool #
Ord a => Ord (GlobalLocalEnd a) #
Methods compare :: GlobalLocalEnd a -> GlobalLocalEnd a -> Ordering # (<) :: GlobalLocalEnd a -> GlobalLocalEnd a -> Bool # (<=) :: GlobalLocalEnd a -> GlobalLocalEnd a -> Bool # (>) :: GlobalLocalEnd a -> GlobalLocalEnd a -> Bool # (>=) :: GlobalLocalEnd a -> GlobalLocalEnd a -> Bool # max :: GlobalLocalEnd a -> GlobalLocalEnd a -> GlobalLocalEnd a # min :: GlobalLocalEnd a -> GlobalLocalEnd a -> GlobalLocalEnd a #
Show a => Show (GlobalLocalEnd a) #
Methods showsPrec :: Int -> GlobalLocalEnd a -> ShowS # show :: GlobalLocalEnd a -> String # showList :: [GlobalLocalEnd a] -> ShowS #

data GlobalLocal g r #

Constructors

GlobalLocal [Either OptionError g] (GlobalLocalEnd r)

Instances

(Eq r, Eq g) => Eq (GlobalLocal g r) #
Methods (==) :: GlobalLocal g r -> GlobalLocal g r -> Bool # (/=) :: GlobalLocal g r -> GlobalLocal g r -> Bool #
(Ord r, Ord g) => Ord (GlobalLocal g r) #
Methods compare :: GlobalLocal g r -> GlobalLocal g r -> Ordering # (<) :: GlobalLocal g r -> GlobalLocal g r -> Bool # (<=) :: GlobalLocal g r -> GlobalLocal g r -> Bool # (>) :: GlobalLocal g r -> GlobalLocal g r -> Bool # (>=) :: GlobalLocal g r -> GlobalLocal g r -> Bool # max :: GlobalLocal g r -> GlobalLocal g r -> GlobalLocal g r # min :: GlobalLocal g r -> GlobalLocal g r -> GlobalLocal g r #
(Show r, Show g) => Show (GlobalLocal g r) #
Methods showsPrec :: Int -> GlobalLocal g r -> ShowS # show :: GlobalLocal g r -> String # showList :: [GlobalLocal g r] -> ShowS #

data ModeResult g r #

The result of parsing a mode command line.

Constructors

ModeResult [g] (Either [String] r)

ModeResult a b is a successfully parsed mode command line, where:

a is a list of all global options parsed; and

b indicates the result of parsing the mode. It is Either c d, where Left c indicates that no mode was parsed. This arises under two circumstances. If the user did not include any words after the global options, then c will be the empty list, []. If the user did include words after the global options, but the first word was not recognized as a mode, then this list will contain the first word and any subsequent words. Therefore, note that if the user attempted to use a mode that does not exist (e.g. she misspelled it), this is not treated as an error. It's up to the client code to deal with this issue (for instance, your program might not view this situation as being an error.)

If b is Right d, this indicates that the user entered a recognized mode, and the result is d.

Instances

(Eq r, Eq g) => Eq (ModeResult g r) #
Methods (==) :: ModeResult g r -> ModeResult g r -> Bool # (/=) :: ModeResult g r -> ModeResult g r -> Bool #
(Ord r, Ord g) => Ord (ModeResult g r) #
Methods compare :: ModeResult g r -> ModeResult g r -> Ordering # (<) :: ModeResult g r -> ModeResult g r -> Bool # (<=) :: ModeResult g r -> ModeResult g r -> Bool # (>) :: ModeResult g r -> ModeResult g r -> Bool # (>=) :: ModeResult g r -> ModeResult g r -> Bool # max :: ModeResult g r -> ModeResult g r -> ModeResult g r # min :: ModeResult g r -> ModeResult g r -> ModeResult g r #
(Show r, Show g) => Show (ModeResult g r) #
Methods showsPrec :: Int -> ModeResult g r -> ShowS # show :: ModeResult g r -> String # showList :: [ModeResult g r] -> ShowS #

getModeResult :: GlobalLocal g r -> Either (String, [String]) (ModeResult g r) #

combine #

Arguments

:: Either (OptionError, [OptionError]) [g]	Global result. Contains either one or more errors, or global option results.
-> Either (String, [String]) (Either [String] r)	Result of parsing mode word, and the mode options and positional arguments. May be `Left a`, where `a` is one or more errors, or `Right b`, where `b` is a good result. A good result `b` may be either `Left c`, where `c` is a list of positional arguments, or `Right d`, where `d` is the mode result. `c` indicates that no mode was recognized and may be either `[]`, which indicates that the user passed no words at all after the global options, or `x:xs`, indicating that the user did pass words after the global options, but the first word was not recognized as a mode.
-> Either (String, [String]) (ModeResult g r)

endToModeResult :: GlobalLocalEnd a -> Either (String, [String]) (Either [String] a) #

extractParsedMode :: ParsedMode a -> Either (String, [String]) (Either b a) #

globalOptErrorToString :: OptionError -> String #

modeOptErrorToString :: OptionError -> String #

optErrorToString :: String -> OptionError -> String #

eiToError :: Either OptionError OptName -> String #

labeledInsufficientOptArgs :: String -> OptName -> String #

parseModeLine #

Arguments

:: [OptSpec g]	Global options. This might, for example, include a `--help` option.
-> [Mode r]	All modes
-> [String]	All command line words
-> Either (String, [String]) (ModeResult g r)	Returns `Either a b`. `Left a` represents an error. Each String represents a single error (this is returned as a pair because there must be at least one error; a simple list would not reflect this requirement.) `Right b` indicates that parsing proceeded successfully; consult `ModeResult` to see what is returned.

Parses a command line that may contain modes.

parseModeLineWithErrors #

Arguments

:: [OptSpec g]	Global options
-> [Mode r]	All modes
-> [String]	All command line tokens
-> GlobalLocal g r

findExactMode :: Word -> [Mode a] -> Maybe (Mode a) #

Takes a token and a list of all modes; returns the matching mode if there is one, or Nothing if there is no match.