{-# LANGUAGE CPP, Rank2Types, ExistentialQuantification #-}
module Options.Applicative.Types (
ParseError(..),
ParserInfo(..),
ParserPrefs(..),
Option(..),
OptName(..),
isShortName,
isLongName,
OptReader(..),
OptProperties(..),
OptVisibility(..),
Backtracking(..),
ReadM(..),
readerAsk,
readerAbort,
readerError,
CReader(..),
Parser(..),
ParserM(..),
Completer(..),
mkCompleter,
CompletionResult(..),
ParserFailure(..),
ParserResult(..),
overFailure,
Args,
ArgPolicy(..),
OptHelpInfo(..),
AltNodeType(..),
OptTree(..),
ParserHelp(..),
SomeParser(..),
Context(..),
IsCmdStart(..),
fromM,
oneM,
manyM,
someM,
filterOptional,
optVisibility,
optMetaVar,
optHelp,
optShowDefault,
optDescMod
) where
import Control.Applicative
import Control.Monad (ap, liftM, MonadPlus, mzero, mplus)
import Control.Monad.Trans.Except (Except, throwE)
import Control.Monad.Trans.Class (lift)
import Control.Monad.Trans.Reader (ReaderT, ask)
import qualified Control.Monad.Fail as Fail
import Data.Semigroup hiding (Option)
import Prelude
import System.Exit (ExitCode(..))
import Options.Applicative.Help.Types
import Options.Applicative.Help.Pretty
import Options.Applicative.Help.Chunk
data ParseError
= ErrorMsg String
| InfoMsg String
| ShowHelpText
| UnknownError
| MissingError IsCmdStart SomeParser
| ExpectsArgError String
| UnexpectedError String SomeParser
data IsCmdStart = CmdStart | CmdCont
deriving Int -> IsCmdStart -> ShowS
[IsCmdStart] -> ShowS
IsCmdStart -> String
(Int -> IsCmdStart -> ShowS)
-> (IsCmdStart -> String)
-> ([IsCmdStart] -> ShowS)
-> Show IsCmdStart
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [IsCmdStart] -> ShowS
$cshowList :: [IsCmdStart] -> ShowS
show :: IsCmdStart -> String
$cshow :: IsCmdStart -> String
showsPrec :: Int -> IsCmdStart -> ShowS
$cshowsPrec :: Int -> IsCmdStart -> ShowS
Show
instance Monoid ParseError where
mempty :: ParseError
mempty = ParseError
UnknownError
mappend :: ParseError -> ParseError -> ParseError
mappend = ParseError -> ParseError -> ParseError
forall a. Semigroup a => a -> a -> a
(<>)
instance Semigroup ParseError where
m :: ParseError
m <> :: ParseError -> ParseError -> ParseError
<> UnknownError = ParseError
m
_ <> m :: ParseError
m = ParseError
m
data ParserInfo a = ParserInfo
{ ParserInfo a -> Parser a
infoParser :: Parser a
, ParserInfo a -> Bool
infoFullDesc :: Bool
, ParserInfo a -> Chunk Doc
infoProgDesc :: Chunk Doc
, :: Chunk Doc
, :: Chunk Doc
, ParserInfo a -> Int
infoFailureCode :: Int
, ParserInfo a -> ArgPolicy
infoPolicy :: ArgPolicy
}
instance Functor ParserInfo where
fmap :: (a -> b) -> ParserInfo a -> ParserInfo b
fmap f :: a -> b
f i :: ParserInfo a
i = ParserInfo a
i { infoParser :: Parser b
infoParser = (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f (ParserInfo a -> Parser a
forall a. ParserInfo a -> Parser a
infoParser ParserInfo a
i) }
data Backtracking
= Backtrack
| NoBacktrack
| SubparserInline
deriving (Backtracking -> Backtracking -> Bool
(Backtracking -> Backtracking -> Bool)
-> (Backtracking -> Backtracking -> Bool) -> Eq Backtracking
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Backtracking -> Backtracking -> Bool
$c/= :: Backtracking -> Backtracking -> Bool
== :: Backtracking -> Backtracking -> Bool
$c== :: Backtracking -> Backtracking -> Bool
Eq, Int -> Backtracking -> ShowS
[Backtracking] -> ShowS
Backtracking -> String
(Int -> Backtracking -> ShowS)
-> (Backtracking -> String)
-> ([Backtracking] -> ShowS)
-> Show Backtracking
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Backtracking] -> ShowS
$cshowList :: [Backtracking] -> ShowS
show :: Backtracking -> String
$cshow :: Backtracking -> String
showsPrec :: Int -> Backtracking -> ShowS
$cshowsPrec :: Int -> Backtracking -> ShowS
Show)
data ParserPrefs = ParserPrefs
{ ParserPrefs -> String
prefMultiSuffix :: String
, ParserPrefs -> Bool
prefDisambiguate :: Bool
, ParserPrefs -> Bool
prefShowHelpOnError :: Bool
, ParserPrefs -> Bool
prefShowHelpOnEmpty :: Bool
, ParserPrefs -> Backtracking
prefBacktrack :: Backtracking
, ParserPrefs -> Int
prefColumns :: Int
, ParserPrefs -> Bool
prefHelpLongEquals :: Bool
} deriving (ParserPrefs -> ParserPrefs -> Bool
(ParserPrefs -> ParserPrefs -> Bool)
-> (ParserPrefs -> ParserPrefs -> Bool) -> Eq ParserPrefs
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ParserPrefs -> ParserPrefs -> Bool
$c/= :: ParserPrefs -> ParserPrefs -> Bool
== :: ParserPrefs -> ParserPrefs -> Bool
$c== :: ParserPrefs -> ParserPrefs -> Bool
Eq, Int -> ParserPrefs -> ShowS
[ParserPrefs] -> ShowS
ParserPrefs -> String
(Int -> ParserPrefs -> ShowS)
-> (ParserPrefs -> String)
-> ([ParserPrefs] -> ShowS)
-> Show ParserPrefs
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ParserPrefs] -> ShowS
$cshowList :: [ParserPrefs] -> ShowS
show :: ParserPrefs -> String
$cshow :: ParserPrefs -> String
showsPrec :: Int -> ParserPrefs -> ShowS
$cshowsPrec :: Int -> ParserPrefs -> ShowS
Show)
data OptName = OptShort !Char
| OptLong !String
deriving (OptName -> OptName -> Bool
(OptName -> OptName -> Bool)
-> (OptName -> OptName -> Bool) -> Eq OptName
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: OptName -> OptName -> Bool
$c/= :: OptName -> OptName -> Bool
== :: OptName -> OptName -> Bool
$c== :: OptName -> OptName -> Bool
Eq, Eq OptName
Eq OptName =>
(OptName -> OptName -> Ordering)
-> (OptName -> OptName -> Bool)
-> (OptName -> OptName -> Bool)
-> (OptName -> OptName -> Bool)
-> (OptName -> OptName -> Bool)
-> (OptName -> OptName -> OptName)
-> (OptName -> OptName -> OptName)
-> Ord OptName
OptName -> OptName -> Bool
OptName -> OptName -> Ordering
OptName -> OptName -> OptName
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: OptName -> OptName -> OptName
$cmin :: OptName -> OptName -> OptName
max :: OptName -> OptName -> OptName
$cmax :: OptName -> OptName -> OptName
>= :: OptName -> OptName -> Bool
$c>= :: OptName -> OptName -> Bool
> :: OptName -> OptName -> Bool
$c> :: OptName -> OptName -> Bool
<= :: OptName -> OptName -> Bool
$c<= :: OptName -> OptName -> Bool
< :: OptName -> OptName -> Bool
$c< :: OptName -> OptName -> Bool
compare :: OptName -> OptName -> Ordering
$ccompare :: OptName -> OptName -> Ordering
$cp1Ord :: Eq OptName
Ord, Int -> OptName -> ShowS
[OptName] -> ShowS
OptName -> String
(Int -> OptName -> ShowS)
-> (OptName -> String) -> ([OptName] -> ShowS) -> Show OptName
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [OptName] -> ShowS
$cshowList :: [OptName] -> ShowS
show :: OptName -> String
$cshow :: OptName -> String
showsPrec :: Int -> OptName -> ShowS
$cshowsPrec :: Int -> OptName -> ShowS
Show)
isShortName :: OptName -> Bool
isShortName :: OptName -> Bool
isShortName (OptShort _) = Bool
True
isShortName (OptLong _) = Bool
False
isLongName :: OptName -> Bool
isLongName :: OptName -> Bool
isLongName = Bool -> Bool
not (Bool -> Bool) -> (OptName -> Bool) -> OptName -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. OptName -> Bool
isShortName
data OptVisibility
= Internal
| Hidden
| Visible
deriving (OptVisibility -> OptVisibility -> Bool
(OptVisibility -> OptVisibility -> Bool)
-> (OptVisibility -> OptVisibility -> Bool) -> Eq OptVisibility
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: OptVisibility -> OptVisibility -> Bool
$c/= :: OptVisibility -> OptVisibility -> Bool
== :: OptVisibility -> OptVisibility -> Bool
$c== :: OptVisibility -> OptVisibility -> Bool
Eq, Eq OptVisibility
Eq OptVisibility =>
(OptVisibility -> OptVisibility -> Ordering)
-> (OptVisibility -> OptVisibility -> Bool)
-> (OptVisibility -> OptVisibility -> Bool)
-> (OptVisibility -> OptVisibility -> Bool)
-> (OptVisibility -> OptVisibility -> Bool)
-> (OptVisibility -> OptVisibility -> OptVisibility)
-> (OptVisibility -> OptVisibility -> OptVisibility)
-> Ord OptVisibility
OptVisibility -> OptVisibility -> Bool
OptVisibility -> OptVisibility -> Ordering
OptVisibility -> OptVisibility -> OptVisibility
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: OptVisibility -> OptVisibility -> OptVisibility
$cmin :: OptVisibility -> OptVisibility -> OptVisibility
max :: OptVisibility -> OptVisibility -> OptVisibility
$cmax :: OptVisibility -> OptVisibility -> OptVisibility
>= :: OptVisibility -> OptVisibility -> Bool
$c>= :: OptVisibility -> OptVisibility -> Bool
> :: OptVisibility -> OptVisibility -> Bool
$c> :: OptVisibility -> OptVisibility -> Bool
<= :: OptVisibility -> OptVisibility -> Bool
$c<= :: OptVisibility -> OptVisibility -> Bool
< :: OptVisibility -> OptVisibility -> Bool
$c< :: OptVisibility -> OptVisibility -> Bool
compare :: OptVisibility -> OptVisibility -> Ordering
$ccompare :: OptVisibility -> OptVisibility -> Ordering
$cp1Ord :: Eq OptVisibility
Ord, Int -> OptVisibility -> ShowS
[OptVisibility] -> ShowS
OptVisibility -> String
(Int -> OptVisibility -> ShowS)
-> (OptVisibility -> String)
-> ([OptVisibility] -> ShowS)
-> Show OptVisibility
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [OptVisibility] -> ShowS
$cshowList :: [OptVisibility] -> ShowS
show :: OptVisibility -> String
$cshow :: OptVisibility -> String
showsPrec :: Int -> OptVisibility -> ShowS
$cshowsPrec :: Int -> OptVisibility -> ShowS
Show)
data OptProperties = OptProperties
{ OptProperties -> OptVisibility
propVisibility :: OptVisibility
, OptProperties -> Chunk Doc
propHelp :: Chunk Doc
, OptProperties -> String
propMetaVar :: String
, OptProperties -> Maybe String
propShowDefault :: Maybe String
, OptProperties -> Maybe (Doc -> Doc)
propDescMod :: Maybe ( Doc -> Doc )
}
instance Show OptProperties where
showsPrec :: Int -> OptProperties -> ShowS
showsPrec p :: Int
p (OptProperties pV :: OptVisibility
pV pH :: Chunk Doc
pH pMV :: String
pMV pSD :: Maybe String
pSD _)
= Bool -> ShowS -> ShowS
showParen (Int
p Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= 11)
(ShowS -> ShowS) -> ShowS -> ShowS
forall a b. (a -> b) -> a -> b
$ String -> ShowS
showString "OptProperties { propVisibility = " ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. OptVisibility -> ShowS
forall a. Show a => a -> ShowS
shows OptVisibility
pV
ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ShowS
showString ", propHelp = " ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Chunk Doc -> ShowS
forall a. Show a => a -> ShowS
shows Chunk Doc
pH
ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ShowS
showString ", propMetaVar = " ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ShowS
forall a. Show a => a -> ShowS
shows String
pMV
ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ShowS
showString ", propShowDefault = " ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Maybe String -> ShowS
forall a. Show a => a -> ShowS
shows Maybe String
pSD
ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ShowS
showString ", propDescMod = _ }"
data Option a = Option
{ Option a -> OptReader a
optMain :: OptReader a
, Option a -> OptProperties
optProps :: OptProperties
}
data SomeParser = forall a . SomeParser (Parser a)
data Context = forall a . Context String (ParserInfo a)
instance Show (Option a) where
show :: Option a -> String
show opt :: Option a
opt = "Option {optProps = " String -> ShowS
forall a. [a] -> [a] -> [a]
++ OptProperties -> String
forall a. Show a => a -> String
show (Option a -> OptProperties
forall a. Option a -> OptProperties
optProps Option a
opt) String -> ShowS
forall a. [a] -> [a] -> [a]
++ "}"
instance Functor Option where
fmap :: (a -> b) -> Option a -> Option b
fmap f :: a -> b
f (Option m :: OptReader a
m p :: OptProperties
p) = OptReader b -> OptProperties -> Option b
forall a. OptReader a -> OptProperties -> Option a
Option ((a -> b) -> OptReader a -> OptReader b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f OptReader a
m) OptProperties
p
newtype ReadM a = ReadM
{ ReadM a -> ReaderT String (Except ParseError) a
unReadM :: ReaderT String (Except ParseError) a }
instance Functor ReadM where
fmap :: (a -> b) -> ReadM a -> ReadM b
fmap f :: a -> b
f (ReadM r :: ReaderT String (Except ParseError) a
r) = ReaderT String (Except ParseError) b -> ReadM b
forall a. ReaderT String (Except ParseError) a -> ReadM a
ReadM ((a -> b)
-> ReaderT String (Except ParseError) a
-> ReaderT String (Except ParseError) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f ReaderT String (Except ParseError) a
r)
instance Applicative ReadM where
pure :: a -> ReadM a
pure = ReaderT String (Except ParseError) a -> ReadM a
forall a. ReaderT String (Except ParseError) a -> ReadM a
ReadM (ReaderT String (Except ParseError) a -> ReadM a)
-> (a -> ReaderT String (Except ParseError) a) -> a -> ReadM a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> ReaderT String (Except ParseError) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure
ReadM x :: ReaderT String (Except ParseError) (a -> b)
x <*> :: ReadM (a -> b) -> ReadM a -> ReadM b
<*> ReadM y :: ReaderT String (Except ParseError) a
y = ReaderT String (Except ParseError) b -> ReadM b
forall a. ReaderT String (Except ParseError) a -> ReadM a
ReadM (ReaderT String (Except ParseError) b -> ReadM b)
-> ReaderT String (Except ParseError) b -> ReadM b
forall a b. (a -> b) -> a -> b
$ ReaderT String (Except ParseError) (a -> b)
x ReaderT String (Except ParseError) (a -> b)
-> ReaderT String (Except ParseError) a
-> ReaderT String (Except ParseError) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ReaderT String (Except ParseError) a
y
instance Alternative ReadM where
empty :: ReadM a
empty = ReadM a
forall (m :: * -> *) a. MonadPlus m => m a
mzero
<|> :: ReadM a -> ReadM a -> ReadM a
(<|>) = ReadM a -> ReadM a -> ReadM a
forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
mplus
instance Monad ReadM where
return :: a -> ReadM a
return = a -> ReadM a
forall (f :: * -> *) a. Applicative f => a -> f a
pure
ReadM r :: ReaderT String (Except ParseError) a
r >>= :: ReadM a -> (a -> ReadM b) -> ReadM b
>>= f :: a -> ReadM b
f = ReaderT String (Except ParseError) b -> ReadM b
forall a. ReaderT String (Except ParseError) a -> ReadM a
ReadM (ReaderT String (Except ParseError) b -> ReadM b)
-> ReaderT String (Except ParseError) b -> ReadM b
forall a b. (a -> b) -> a -> b
$ ReaderT String (Except ParseError) a
r ReaderT String (Except ParseError) a
-> (a -> ReaderT String (Except ParseError) b)
-> ReaderT String (Except ParseError) b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= ReadM b -> ReaderT String (Except ParseError) b
forall a. ReadM a -> ReaderT String (Except ParseError) a
unReadM (ReadM b -> ReaderT String (Except ParseError) b)
-> (a -> ReadM b) -> a -> ReaderT String (Except ParseError) b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> ReadM b
f
#if !(MIN_VERSION_base(4,13,0))
fail = Fail.fail
#endif
instance Fail.MonadFail ReadM where
fail :: String -> ReadM a
fail = String -> ReadM a
forall a. String -> ReadM a
readerError
instance MonadPlus ReadM where
mzero :: ReadM a
mzero = ReaderT String (Except ParseError) a -> ReadM a
forall a. ReaderT String (Except ParseError) a -> ReadM a
ReadM ReaderT String (Except ParseError) a
forall (m :: * -> *) a. MonadPlus m => m a
mzero
mplus :: ReadM a -> ReadM a -> ReadM a
mplus (ReadM x :: ReaderT String (Except ParseError) a
x) (ReadM y :: ReaderT String (Except ParseError) a
y) = ReaderT String (Except ParseError) a -> ReadM a
forall a. ReaderT String (Except ParseError) a -> ReadM a
ReadM (ReaderT String (Except ParseError) a -> ReadM a)
-> ReaderT String (Except ParseError) a -> ReadM a
forall a b. (a -> b) -> a -> b
$ ReaderT String (Except ParseError) a
-> ReaderT String (Except ParseError) a
-> ReaderT String (Except ParseError) a
forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
mplus ReaderT String (Except ParseError) a
x ReaderT String (Except ParseError) a
y
readerAsk :: ReadM String
readerAsk :: ReadM String
readerAsk = ReaderT String (Except ParseError) String -> ReadM String
forall a. ReaderT String (Except ParseError) a -> ReadM a
ReadM ReaderT String (Except ParseError) String
forall (m :: * -> *) r. Monad m => ReaderT r m r
ask
readerAbort :: ParseError -> ReadM a
readerAbort :: ParseError -> ReadM a
readerAbort = ReaderT String (Except ParseError) a -> ReadM a
forall a. ReaderT String (Except ParseError) a -> ReadM a
ReadM (ReaderT String (Except ParseError) a -> ReadM a)
-> (ParseError -> ReaderT String (Except ParseError) a)
-> ParseError
-> ReadM a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ExceptT ParseError Identity a
-> ReaderT String (Except ParseError) a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (ExceptT ParseError Identity a
-> ReaderT String (Except ParseError) a)
-> (ParseError -> ExceptT ParseError Identity a)
-> ParseError
-> ReaderT String (Except ParseError) a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ParseError -> ExceptT ParseError Identity a
forall (m :: * -> *) e a. Monad m => e -> ExceptT e m a
throwE
readerError :: String -> ReadM a
readerError :: String -> ReadM a
readerError = ParseError -> ReadM a
forall a. ParseError -> ReadM a
readerAbort (ParseError -> ReadM a)
-> (String -> ParseError) -> String -> ReadM a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ParseError
ErrorMsg
data CReader a = CReader
{ CReader a -> Completer
crCompleter :: Completer
, CReader a -> ReadM a
crReader :: ReadM a }
instance Functor CReader where
fmap :: (a -> b) -> CReader a -> CReader b
fmap f :: a -> b
f (CReader c :: Completer
c r :: ReadM a
r) = Completer -> ReadM b -> CReader b
forall a. Completer -> ReadM a -> CReader a
CReader Completer
c ((a -> b) -> ReadM a -> ReadM b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f ReadM a
r)
data OptReader a
= OptReader [OptName] (CReader a) (String -> ParseError)
| FlagReader [OptName] !a
| ArgReader (CReader a)
| CmdReader (Maybe String) [String] (String -> Maybe (ParserInfo a))
instance Functor OptReader where
fmap :: (a -> b) -> OptReader a -> OptReader b
fmap f :: a -> b
f (OptReader ns :: [OptName]
ns cr :: CReader a
cr e :: String -> ParseError
e) = [OptName] -> CReader b -> (String -> ParseError) -> OptReader b
forall a.
[OptName] -> CReader a -> (String -> ParseError) -> OptReader a
OptReader [OptName]
ns ((a -> b) -> CReader a -> CReader b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f CReader a
cr) String -> ParseError
e
fmap f :: a -> b
f (FlagReader ns :: [OptName]
ns x :: a
x) = [OptName] -> b -> OptReader b
forall a. [OptName] -> a -> OptReader a
FlagReader [OptName]
ns (a -> b
f a
x)
fmap f :: a -> b
f (ArgReader cr :: CReader a
cr) = CReader b -> OptReader b
forall a. CReader a -> OptReader a
ArgReader ((a -> b) -> CReader a -> CReader b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f CReader a
cr)
fmap f :: a -> b
f (CmdReader n :: Maybe String
n cs :: [String]
cs g :: String -> Maybe (ParserInfo a)
g) = Maybe String
-> [String] -> (String -> Maybe (ParserInfo b)) -> OptReader b
forall a.
Maybe String
-> [String] -> (String -> Maybe (ParserInfo a)) -> OptReader a
CmdReader Maybe String
n [String]
cs (((ParserInfo a -> ParserInfo b)
-> Maybe (ParserInfo a) -> Maybe (ParserInfo b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((ParserInfo a -> ParserInfo b)
-> Maybe (ParserInfo a) -> Maybe (ParserInfo b))
-> ((a -> b) -> ParserInfo a -> ParserInfo b)
-> (a -> b)
-> Maybe (ParserInfo a)
-> Maybe (ParserInfo b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> b) -> ParserInfo a -> ParserInfo b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap) a -> b
f (Maybe (ParserInfo a) -> Maybe (ParserInfo b))
-> (String -> Maybe (ParserInfo a))
-> String
-> Maybe (ParserInfo b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Maybe (ParserInfo a)
g)
data Parser a
= NilP (Maybe a)
| OptP (Option a)
| forall x . MultP (Parser (x -> a)) (Parser x)
| AltP (Parser a) (Parser a)
| forall x . BindP (Parser x) (x -> Parser a)
instance Functor Parser where
fmap :: (a -> b) -> Parser a -> Parser b
fmap f :: a -> b
f (NilP x :: Maybe a
x) = Maybe b -> Parser b
forall a. Maybe a -> Parser a
NilP ((a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f Maybe a
x)
fmap f :: a -> b
f (OptP opt :: Option a
opt) = Option b -> Parser b
forall a. Option a -> Parser a
OptP ((a -> b) -> Option a -> Option b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f Option a
opt)
fmap f :: a -> b
f (MultP p1 :: Parser (x -> a)
p1 p2 :: Parser x
p2) = Parser (x -> b) -> Parser x -> Parser b
forall a x. Parser (x -> a) -> Parser x -> Parser a
MultP (((x -> a) -> x -> b) -> Parser (x -> a) -> Parser (x -> b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (a -> b
f(a -> b) -> (x -> a) -> x -> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
.) Parser (x -> a)
p1) Parser x
p2
fmap f :: a -> b
f (AltP p1 :: Parser a
p1 p2 :: Parser a
p2) = Parser b -> Parser b -> Parser b
forall a. Parser a -> Parser a -> Parser a
AltP ((a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f Parser a
p1) ((a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f Parser a
p2)
fmap f :: a -> b
f (BindP p :: Parser x
p k :: x -> Parser a
k) = Parser x -> (x -> Parser b) -> Parser b
forall a x. Parser x -> (x -> Parser a) -> Parser a
BindP Parser x
p ((a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f (Parser a -> Parser b) -> (x -> Parser a) -> x -> Parser b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. x -> Parser a
k)
instance Applicative Parser where
pure :: a -> Parser a
pure = Maybe a -> Parser a
forall a. Maybe a -> Parser a
NilP (Maybe a -> Parser a) -> (a -> Maybe a) -> a -> Parser a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Maybe a
forall a. a -> Maybe a
Just
<*> :: Parser (a -> b) -> Parser a -> Parser b
(<*>) = Parser (a -> b) -> Parser a -> Parser b
forall a x. Parser (x -> a) -> Parser x -> Parser a
MultP
newtype ParserM r = ParserM
{ ParserM r -> forall x. (r -> Parser x) -> Parser x
runParserM :: forall x . (r -> Parser x) -> Parser x }
instance Monad ParserM where
return :: a -> ParserM a
return = a -> ParserM a
forall (f :: * -> *) a. Applicative f => a -> f a
pure
ParserM f :: forall x. (a -> Parser x) -> Parser x
f >>= :: ParserM a -> (a -> ParserM b) -> ParserM b
>>= g :: a -> ParserM b
g = (forall x. (b -> Parser x) -> Parser x) -> ParserM b
forall r. (forall x. (r -> Parser x) -> Parser x) -> ParserM r
ParserM ((forall x. (b -> Parser x) -> Parser x) -> ParserM b)
-> (forall x. (b -> Parser x) -> Parser x) -> ParserM b
forall a b. (a -> b) -> a -> b
$ \k :: b -> Parser x
k -> (a -> Parser x) -> Parser x
forall x. (a -> Parser x) -> Parser x
f (\x :: a
x -> ParserM b -> (b -> Parser x) -> Parser x
forall r. ParserM r -> forall x. (r -> Parser x) -> Parser x
runParserM (a -> ParserM b
g a
x) b -> Parser x
k)
instance Functor ParserM where
fmap :: (a -> b) -> ParserM a -> ParserM b
fmap = (a -> b) -> ParserM a -> ParserM b
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM
instance Applicative ParserM where
pure :: a -> ParserM a
pure x :: a
x = (forall x. (a -> Parser x) -> Parser x) -> ParserM a
forall r. (forall x. (r -> Parser x) -> Parser x) -> ParserM r
ParserM ((forall x. (a -> Parser x) -> Parser x) -> ParserM a)
-> (forall x. (a -> Parser x) -> Parser x) -> ParserM a
forall a b. (a -> b) -> a -> b
$ \k :: a -> Parser x
k -> a -> Parser x
k a
x
<*> :: ParserM (a -> b) -> ParserM a -> ParserM b
(<*>) = ParserM (a -> b) -> ParserM a -> ParserM b
forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
ap
fromM :: ParserM a -> Parser a
fromM :: ParserM a -> Parser a
fromM (ParserM f :: forall x. (a -> Parser x) -> Parser x
f) = (a -> Parser a) -> Parser a
forall x. (a -> Parser x) -> Parser x
f a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure
oneM :: Parser a -> ParserM a
oneM :: Parser a -> ParserM a
oneM p :: Parser a
p = (forall x. (a -> Parser x) -> Parser x) -> ParserM a
forall r. (forall x. (r -> Parser x) -> Parser x) -> ParserM r
ParserM (Parser a -> (a -> Parser x) -> Parser x
forall a x. Parser x -> (x -> Parser a) -> Parser a
BindP Parser a
p)
manyM :: Parser a -> ParserM [a]
manyM :: Parser a -> ParserM [a]
manyM p :: Parser a
p = do
Maybe a
mx <- Parser (Maybe a) -> ParserM (Maybe a)
forall a. Parser a -> ParserM a
oneM (Parser a -> Parser (Maybe a)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser a
p)
case Maybe a
mx of
Nothing -> [a] -> ParserM [a]
forall (m :: * -> *) a. Monad m => a -> m a
return []
Just x :: a
x -> (a
xa -> [a] -> [a]
forall a. a -> [a] -> [a]
:) ([a] -> [a]) -> ParserM [a] -> ParserM [a]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a -> ParserM [a]
forall a. Parser a -> ParserM [a]
manyM Parser a
p
someM :: Parser a -> ParserM [a]
someM :: Parser a -> ParserM [a]
someM p :: Parser a
p = (:) (a -> [a] -> [a]) -> ParserM a -> ParserM ([a] -> [a])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a -> ParserM a
forall a. Parser a -> ParserM a
oneM Parser a
p ParserM ([a] -> [a]) -> ParserM [a] -> ParserM [a]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a -> ParserM [a]
forall a. Parser a -> ParserM [a]
manyM Parser a
p
instance Alternative Parser where
empty :: Parser a
empty = Maybe a -> Parser a
forall a. Maybe a -> Parser a
NilP Maybe a
forall a. Maybe a
Nothing
<|> :: Parser a -> Parser a -> Parser a
(<|>) = Parser a -> Parser a -> Parser a
forall a. Parser a -> Parser a -> Parser a
AltP
many :: Parser a -> Parser [a]
many p :: Parser a
p = ParserM [a] -> Parser [a]
forall a. ParserM a -> Parser a
fromM (ParserM [a] -> Parser [a]) -> ParserM [a] -> Parser [a]
forall a b. (a -> b) -> a -> b
$ Parser a -> ParserM [a]
forall a. Parser a -> ParserM [a]
manyM Parser a
p
some :: Parser a -> Parser [a]
some p :: Parser a
p = ParserM [a] -> Parser [a]
forall a. ParserM a -> Parser a
fromM (ParserM [a] -> Parser [a]) -> ParserM [a] -> Parser [a]
forall a b. (a -> b) -> a -> b
$ (:) (a -> [a] -> [a]) -> ParserM a -> ParserM ([a] -> [a])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a -> ParserM a
forall a. Parser a -> ParserM a
oneM Parser a
p ParserM ([a] -> [a]) -> ParserM [a] -> ParserM [a]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a -> ParserM [a]
forall a. Parser a -> ParserM [a]
manyM Parser a
p
newtype Completer = Completer
{ Completer -> String -> IO [String]
runCompleter :: String -> IO [String] }
mkCompleter :: (String -> IO [String]) -> Completer
mkCompleter :: (String -> IO [String]) -> Completer
mkCompleter = (String -> IO [String]) -> Completer
Completer
instance Semigroup Completer where
(Completer c1 :: String -> IO [String]
c1) <> :: Completer -> Completer -> Completer
<> (Completer c2 :: String -> IO [String]
c2) =
(String -> IO [String]) -> Completer
Completer ((String -> IO [String]) -> Completer)
-> (String -> IO [String]) -> Completer
forall a b. (a -> b) -> a -> b
$ \s :: String
s -> [String] -> [String] -> [String]
forall a. [a] -> [a] -> [a]
(++) ([String] -> [String] -> [String])
-> IO [String] -> IO ([String] -> [String])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> String -> IO [String]
c1 String
s IO ([String] -> [String]) -> IO [String] -> IO [String]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> String -> IO [String]
c2 String
s
instance Monoid Completer where
mempty :: Completer
mempty = (String -> IO [String]) -> Completer
Completer ((String -> IO [String]) -> Completer)
-> (String -> IO [String]) -> Completer
forall a b. (a -> b) -> a -> b
$ \_ -> [String] -> IO [String]
forall (m :: * -> *) a. Monad m => a -> m a
return []
mappend :: Completer -> Completer -> Completer
mappend = Completer -> Completer -> Completer
forall a. Semigroup a => a -> a -> a
(<>)
newtype CompletionResult = CompletionResult
{ CompletionResult -> String -> IO String
execCompletion :: String -> IO String }
instance Show CompletionResult where
showsPrec :: Int -> CompletionResult -> ShowS
showsPrec p :: Int
p _ = Bool -> ShowS -> ShowS
showParen (Int
p Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> 10) (ShowS -> ShowS) -> ShowS -> ShowS
forall a b. (a -> b) -> a -> b
$
String -> ShowS
showString "CompletionResult _"
newtype ParserFailure h = ParserFailure
{ ParserFailure h -> String -> (h, ExitCode, Int)
execFailure :: String -> (h, ExitCode, Int) }
instance Show h => Show (ParserFailure h) where
showsPrec :: Int -> ParserFailure h -> ShowS
showsPrec p :: Int
p (ParserFailure f :: String -> (h, ExitCode, Int)
f)
= Bool -> ShowS -> ShowS
showParen (Int
p Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> 10)
(ShowS -> ShowS) -> ShowS -> ShowS
forall a b. (a -> b) -> a -> b
$ String -> ShowS
showString "ParserFailure "
ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> (h, ExitCode, Int) -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec 11 (String -> (h, ExitCode, Int)
f "<program>")
instance Functor ParserFailure where
fmap :: (a -> b) -> ParserFailure a -> ParserFailure b
fmap f :: a -> b
f (ParserFailure err :: String -> (a, ExitCode, Int)
err) = (String -> (b, ExitCode, Int)) -> ParserFailure b
forall h. (String -> (h, ExitCode, Int)) -> ParserFailure h
ParserFailure ((String -> (b, ExitCode, Int)) -> ParserFailure b)
-> (String -> (b, ExitCode, Int)) -> ParserFailure b
forall a b. (a -> b) -> a -> b
$ \progn :: String
progn ->
let (h :: a
h, exit :: ExitCode
exit, cols :: Int
cols) = String -> (a, ExitCode, Int)
err String
progn in (a -> b
f a
h, ExitCode
exit, Int
cols)
data ParserResult a
= Success a
| Failure (ParserFailure ParserHelp)
| CompletionInvoked CompletionResult
deriving Int -> ParserResult a -> ShowS
[ParserResult a] -> ShowS
ParserResult a -> String
(Int -> ParserResult a -> ShowS)
-> (ParserResult a -> String)
-> ([ParserResult a] -> ShowS)
-> Show (ParserResult a)
forall a. Show a => Int -> ParserResult a -> ShowS
forall a. Show a => [ParserResult a] -> ShowS
forall a. Show a => ParserResult a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ParserResult a] -> ShowS
$cshowList :: forall a. Show a => [ParserResult a] -> ShowS
show :: ParserResult a -> String
$cshow :: forall a. Show a => ParserResult a -> String
showsPrec :: Int -> ParserResult a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> ParserResult a -> ShowS
Show
instance Functor ParserResult where
fmap :: (a -> b) -> ParserResult a -> ParserResult b
fmap f :: a -> b
f (Success a :: a
a) = b -> ParserResult b
forall a. a -> ParserResult a
Success (a -> b
f a
a)
fmap _ (Failure f :: ParserFailure ParserHelp
f) = ParserFailure ParserHelp -> ParserResult b
forall a. ParserFailure ParserHelp -> ParserResult a
Failure ParserFailure ParserHelp
f
fmap _ (CompletionInvoked c :: CompletionResult
c) = CompletionResult -> ParserResult b
forall a. CompletionResult -> ParserResult a
CompletionInvoked CompletionResult
c
overFailure :: (ParserHelp -> ParserHelp)
-> ParserResult a -> ParserResult a
overFailure :: (ParserHelp -> ParserHelp) -> ParserResult a -> ParserResult a
overFailure f :: ParserHelp -> ParserHelp
f (Failure failure :: ParserFailure ParserHelp
failure) = ParserFailure ParserHelp -> ParserResult a
forall a. ParserFailure ParserHelp -> ParserResult a
Failure (ParserFailure ParserHelp -> ParserResult a)
-> ParserFailure ParserHelp -> ParserResult a
forall a b. (a -> b) -> a -> b
$ (ParserHelp -> ParserHelp)
-> ParserFailure ParserHelp -> ParserFailure ParserHelp
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ParserHelp -> ParserHelp
f ParserFailure ParserHelp
failure
overFailure _ r :: ParserResult a
r = ParserResult a
r
instance Applicative ParserResult where
pure :: a -> ParserResult a
pure = a -> ParserResult a
forall a. a -> ParserResult a
Success
Success f :: a -> b
f <*> :: ParserResult (a -> b) -> ParserResult a -> ParserResult b
<*> r :: ParserResult a
r = (a -> b) -> ParserResult a -> ParserResult b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f ParserResult a
r
Failure f :: ParserFailure ParserHelp
f <*> _ = ParserFailure ParserHelp -> ParserResult b
forall a. ParserFailure ParserHelp -> ParserResult a
Failure ParserFailure ParserHelp
f
CompletionInvoked c :: CompletionResult
c <*> _ = CompletionResult -> ParserResult b
forall a. CompletionResult -> ParserResult a
CompletionInvoked CompletionResult
c
instance Monad ParserResult where
return :: a -> ParserResult a
return = a -> ParserResult a
forall (f :: * -> *) a. Applicative f => a -> f a
pure
Success x :: a
x >>= :: ParserResult a -> (a -> ParserResult b) -> ParserResult b
>>= f :: a -> ParserResult b
f = a -> ParserResult b
f a
x
Failure f :: ParserFailure ParserHelp
f >>= _ = ParserFailure ParserHelp -> ParserResult b
forall a. ParserFailure ParserHelp -> ParserResult a
Failure ParserFailure ParserHelp
f
CompletionInvoked c :: CompletionResult
c >>= _ = CompletionResult -> ParserResult b
forall a. CompletionResult -> ParserResult a
CompletionInvoked CompletionResult
c
type Args = [String]
data ArgPolicy
= Intersperse
| NoIntersperse
| AllPositionals
| ForwardOptions
deriving (ArgPolicy -> ArgPolicy -> Bool
(ArgPolicy -> ArgPolicy -> Bool)
-> (ArgPolicy -> ArgPolicy -> Bool) -> Eq ArgPolicy
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ArgPolicy -> ArgPolicy -> Bool
$c/= :: ArgPolicy -> ArgPolicy -> Bool
== :: ArgPolicy -> ArgPolicy -> Bool
$c== :: ArgPolicy -> ArgPolicy -> Bool
Eq, Eq ArgPolicy
Eq ArgPolicy =>
(ArgPolicy -> ArgPolicy -> Ordering)
-> (ArgPolicy -> ArgPolicy -> Bool)
-> (ArgPolicy -> ArgPolicy -> Bool)
-> (ArgPolicy -> ArgPolicy -> Bool)
-> (ArgPolicy -> ArgPolicy -> Bool)
-> (ArgPolicy -> ArgPolicy -> ArgPolicy)
-> (ArgPolicy -> ArgPolicy -> ArgPolicy)
-> Ord ArgPolicy
ArgPolicy -> ArgPolicy -> Bool
ArgPolicy -> ArgPolicy -> Ordering
ArgPolicy -> ArgPolicy -> ArgPolicy
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: ArgPolicy -> ArgPolicy -> ArgPolicy
$cmin :: ArgPolicy -> ArgPolicy -> ArgPolicy
max :: ArgPolicy -> ArgPolicy -> ArgPolicy
$cmax :: ArgPolicy -> ArgPolicy -> ArgPolicy
>= :: ArgPolicy -> ArgPolicy -> Bool
$c>= :: ArgPolicy -> ArgPolicy -> Bool
> :: ArgPolicy -> ArgPolicy -> Bool
$c> :: ArgPolicy -> ArgPolicy -> Bool
<= :: ArgPolicy -> ArgPolicy -> Bool
$c<= :: ArgPolicy -> ArgPolicy -> Bool
< :: ArgPolicy -> ArgPolicy -> Bool
$c< :: ArgPolicy -> ArgPolicy -> Bool
compare :: ArgPolicy -> ArgPolicy -> Ordering
$ccompare :: ArgPolicy -> ArgPolicy -> Ordering
$cp1Ord :: Eq ArgPolicy
Ord, Int -> ArgPolicy -> ShowS
[ArgPolicy] -> ShowS
ArgPolicy -> String
(Int -> ArgPolicy -> ShowS)
-> (ArgPolicy -> String)
-> ([ArgPolicy] -> ShowS)
-> Show ArgPolicy
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ArgPolicy] -> ShowS
$cshowList :: [ArgPolicy] -> ShowS
show :: ArgPolicy -> String
$cshow :: ArgPolicy -> String
showsPrec :: Int -> ArgPolicy -> ShowS
$cshowsPrec :: Int -> ArgPolicy -> ShowS
Show)
data OptHelpInfo = OptHelpInfo
{ OptHelpInfo -> Bool
hinfoMulti :: Bool
, OptHelpInfo -> Bool
hinfoUnreachableArgs :: Bool
} deriving (OptHelpInfo -> OptHelpInfo -> Bool
(OptHelpInfo -> OptHelpInfo -> Bool)
-> (OptHelpInfo -> OptHelpInfo -> Bool) -> Eq OptHelpInfo
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: OptHelpInfo -> OptHelpInfo -> Bool
$c/= :: OptHelpInfo -> OptHelpInfo -> Bool
== :: OptHelpInfo -> OptHelpInfo -> Bool
$c== :: OptHelpInfo -> OptHelpInfo -> Bool
Eq, Int -> OptHelpInfo -> ShowS
[OptHelpInfo] -> ShowS
OptHelpInfo -> String
(Int -> OptHelpInfo -> ShowS)
-> (OptHelpInfo -> String)
-> ([OptHelpInfo] -> ShowS)
-> Show OptHelpInfo
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [OptHelpInfo] -> ShowS
$cshowList :: [OptHelpInfo] -> ShowS
show :: OptHelpInfo -> String
$cshow :: OptHelpInfo -> String
showsPrec :: Int -> OptHelpInfo -> ShowS
$cshowsPrec :: Int -> OptHelpInfo -> ShowS
Show)
data AltNodeType = MarkDefault | NoDefault
deriving (Int -> AltNodeType -> ShowS
[AltNodeType] -> ShowS
AltNodeType -> String
(Int -> AltNodeType -> ShowS)
-> (AltNodeType -> String)
-> ([AltNodeType] -> ShowS)
-> Show AltNodeType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AltNodeType] -> ShowS
$cshowList :: [AltNodeType] -> ShowS
show :: AltNodeType -> String
$cshow :: AltNodeType -> String
showsPrec :: Int -> AltNodeType -> ShowS
$cshowsPrec :: Int -> AltNodeType -> ShowS
Show, AltNodeType -> AltNodeType -> Bool
(AltNodeType -> AltNodeType -> Bool)
-> (AltNodeType -> AltNodeType -> Bool) -> Eq AltNodeType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AltNodeType -> AltNodeType -> Bool
$c/= :: AltNodeType -> AltNodeType -> Bool
== :: AltNodeType -> AltNodeType -> Bool
$c== :: AltNodeType -> AltNodeType -> Bool
Eq)
data OptTree a
= Leaf a
| MultNode [OptTree a]
| AltNode AltNodeType [OptTree a]
deriving Int -> OptTree a -> ShowS
[OptTree a] -> ShowS
OptTree a -> String
(Int -> OptTree a -> ShowS)
-> (OptTree a -> String)
-> ([OptTree a] -> ShowS)
-> Show (OptTree a)
forall a. Show a => Int -> OptTree a -> ShowS
forall a. Show a => [OptTree a] -> ShowS
forall a. Show a => OptTree a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [OptTree a] -> ShowS
$cshowList :: forall a. Show a => [OptTree a] -> ShowS
show :: OptTree a -> String
$cshow :: forall a. Show a => OptTree a -> String
showsPrec :: Int -> OptTree a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> OptTree a -> ShowS
Show
filterOptional :: OptTree a -> OptTree a
filterOptional :: OptTree a -> OptTree a
filterOptional t :: OptTree a
t = case OptTree a
t of
Leaf a :: a
a
-> a -> OptTree a
forall a. a -> OptTree a
Leaf a
a
MultNode xs :: [OptTree a]
xs
-> [OptTree a] -> OptTree a
forall a. [OptTree a] -> OptTree a
MultNode ((OptTree a -> OptTree a) -> [OptTree a] -> [OptTree a]
forall a b. (a -> b) -> [a] -> [b]
map OptTree a -> OptTree a
forall a. OptTree a -> OptTree a
filterOptional [OptTree a]
xs)
AltNode MarkDefault _
-> AltNodeType -> [OptTree a] -> OptTree a
forall a. AltNodeType -> [OptTree a] -> OptTree a
AltNode AltNodeType
MarkDefault []
AltNode NoDefault xs :: [OptTree a]
xs
-> AltNodeType -> [OptTree a] -> OptTree a
forall a. AltNodeType -> [OptTree a] -> OptTree a
AltNode AltNodeType
NoDefault ((OptTree a -> OptTree a) -> [OptTree a] -> [OptTree a]
forall a b. (a -> b) -> [a] -> [b]
map OptTree a -> OptTree a
forall a. OptTree a -> OptTree a
filterOptional [OptTree a]
xs)
optVisibility :: Option a -> OptVisibility
optVisibility :: Option a -> OptVisibility
optVisibility = OptProperties -> OptVisibility
propVisibility (OptProperties -> OptVisibility)
-> (Option a -> OptProperties) -> Option a -> OptVisibility
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Option a -> OptProperties
forall a. Option a -> OptProperties
optProps
optHelp :: Option a -> Chunk Doc
optHelp :: Option a -> Chunk Doc
optHelp = OptProperties -> Chunk Doc
propHelp (OptProperties -> Chunk Doc)
-> (Option a -> OptProperties) -> Option a -> Chunk Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Option a -> OptProperties
forall a. Option a -> OptProperties
optProps
optMetaVar :: Option a -> String
optMetaVar :: Option a -> String
optMetaVar = OptProperties -> String
propMetaVar (OptProperties -> String)
-> (Option a -> OptProperties) -> Option a -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Option a -> OptProperties
forall a. Option a -> OptProperties
optProps
optShowDefault :: Option a -> Maybe String
optShowDefault :: Option a -> Maybe String
optShowDefault = OptProperties -> Maybe String
propShowDefault (OptProperties -> Maybe String)
-> (Option a -> OptProperties) -> Option a -> Maybe String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Option a -> OptProperties
forall a. Option a -> OptProperties
optProps
optDescMod :: Option a -> Maybe ( Doc -> Doc )
optDescMod :: Option a -> Maybe (Doc -> Doc)
optDescMod = OptProperties -> Maybe (Doc -> Doc)
propDescMod (OptProperties -> Maybe (Doc -> Doc))
-> (Option a -> OptProperties) -> Option a -> Maybe (Doc -> Doc)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Option a -> OptProperties
forall a. Option a -> OptProperties
optProps