{-# LANGUAGE DeriveDataTypeable #-}

module Development.NSIS.Type where

import Data.Data

class Default a where def :: a
instance Default (Maybe a) where def :: Maybe a
def = Maybe a
forall a. Maybe a
Nothing
instance Default [a] where def :: [a]
def = []


newtype Var = Var Int deriving (Typeable Var
Typeable Var =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Var -> c Var)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Var)
-> (Var -> Constr)
-> (Var -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Var))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Var))
-> ((forall b. Data b => b -> b) -> Var -> Var)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Var -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Var -> r)
-> (forall u. (forall d. Data d => d -> u) -> Var -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Var -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Var -> m Var)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Var -> m Var)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Var -> m Var)
-> Data Var
Var -> Constr
Var -> DataType
(forall b. Data b => b -> b) -> Var -> Var
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Var -> u
forall u. (forall d. Data d => d -> u) -> Var -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Var -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Var -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Var -> m Var
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Var -> m Var
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Var
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Var -> c Var
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Var)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Var)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Var -> c Var
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Var -> c Var
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Var
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Var
$ctoConstr :: Var -> Constr
toConstr :: Var -> Constr
$cdataTypeOf :: Var -> DataType
dataTypeOf :: Var -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Var)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Var)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Var)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Var)
$cgmapT :: (forall b. Data b => b -> b) -> Var -> Var
gmapT :: (forall b. Data b => b -> b) -> Var -> Var
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Var -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Var -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Var -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Var -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Var -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Var -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Var -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Var -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Var -> m Var
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Var -> m Var
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Var -> m Var
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Var -> m Var
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Var -> m Var
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Var -> m Var
Data,Typeable,Var -> Var -> Bool
(Var -> Var -> Bool) -> (Var -> Var -> Bool) -> Eq Var
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Var -> Var -> Bool
== :: Var -> Var -> Bool
$c/= :: Var -> Var -> Bool
/= :: Var -> Var -> Bool
Eq)
instance Default Var where def :: Var
def = Int -> Var
Var Int
0
instance Show Var where show :: Var -> String
show (Var Int
i) = String
"$_" String -> ShowS
forall a. [a] -> [a] -> [a]
++ Int -> String
forall a. Show a => a -> String
show Int
i


-- | A code label, used for @goto@ programming, see 'Development.NSIS.Sugar.newLabel'.
newtype Label = Label Int deriving (Typeable Label
Typeable Label =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Label -> c Label)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Label)
-> (Label -> Constr)
-> (Label -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Label))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Label))
-> ((forall b. Data b => b -> b) -> Label -> Label)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Label -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Label -> r)
-> (forall u. (forall d. Data d => d -> u) -> Label -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Label -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Label -> m Label)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Label -> m Label)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Label -> m Label)
-> Data Label
Label -> Constr
Label -> DataType
(forall b. Data b => b -> b) -> Label -> Label
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Label -> u
forall u. (forall d. Data d => d -> u) -> Label -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Label -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Label -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Label -> m Label
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Label -> m Label
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Label
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Label -> c Label
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Label)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Label)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Label -> c Label
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Label -> c Label
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Label
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Label
$ctoConstr :: Label -> Constr
toConstr :: Label -> Constr
$cdataTypeOf :: Label -> DataType
dataTypeOf :: Label -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Label)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Label)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Label)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Label)
$cgmapT :: (forall b. Data b => b -> b) -> Label -> Label
gmapT :: (forall b. Data b => b -> b) -> Label -> Label
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Label -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Label -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Label -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Label -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Label -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Label -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Label -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Label -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Label -> m Label
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Label -> m Label
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Label -> m Label
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Label -> m Label
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Label -> m Label
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Label -> m Label
Data,Typeable,Label -> Label -> Bool
(Label -> Label -> Bool) -> (Label -> Label -> Bool) -> Eq Label
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Label -> Label -> Bool
== :: Label -> Label -> Bool
$c/= :: Label -> Label -> Bool
/= :: Label -> Label -> Bool
Eq)
instance Show Label where show :: Label -> String
show (Label Int
i) = if Int
i Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
0 then String
"0" else String
"_lbl" String -> ShowS
forall a. [a] -> [a] -> [a]
++ Int -> String
forall a. Show a => a -> String
show Int
i


newtype Fun = Fun String deriving (Typeable Fun
Typeable Fun =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Fun -> c Fun)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Fun)
-> (Fun -> Constr)
-> (Fun -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Fun))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Fun))
-> ((forall b. Data b => b -> b) -> Fun -> Fun)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Fun -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Fun -> r)
-> (forall u. (forall d. Data d => d -> u) -> Fun -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Fun -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Fun -> m Fun)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Fun -> m Fun)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Fun -> m Fun)
-> Data Fun
Fun -> Constr
Fun -> DataType
(forall b. Data b => b -> b) -> Fun -> Fun
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Fun -> u
forall u. (forall d. Data d => d -> u) -> Fun -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Fun -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Fun -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Fun -> m Fun
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Fun -> m Fun
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Fun
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Fun -> c Fun
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Fun)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Fun)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Fun -> c Fun
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Fun -> c Fun
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Fun
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Fun
$ctoConstr :: Fun -> Constr
toConstr :: Fun -> Constr
$cdataTypeOf :: Fun -> DataType
dataTypeOf :: Fun -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Fun)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Fun)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Fun)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Fun)
$cgmapT :: (forall b. Data b => b -> b) -> Fun -> Fun
gmapT :: (forall b. Data b => b -> b) -> Fun -> Fun
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Fun -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Fun -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Fun -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Fun -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Fun -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Fun -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Fun -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Fun -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Fun -> m Fun
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Fun -> m Fun
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Fun -> m Fun
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Fun -> m Fun
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Fun -> m Fun
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Fun -> m Fun
Data,Typeable,Fun -> Fun -> Bool
(Fun -> Fun -> Bool) -> (Fun -> Fun -> Bool) -> Eq Fun
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Fun -> Fun -> Bool
== :: Fun -> Fun -> Bool
$c/= :: Fun -> Fun -> Bool
/= :: Fun -> Fun -> Bool
Eq,Eq Fun
Eq Fun =>
(Fun -> Fun -> Ordering)
-> (Fun -> Fun -> Bool)
-> (Fun -> Fun -> Bool)
-> (Fun -> Fun -> Bool)
-> (Fun -> Fun -> Bool)
-> (Fun -> Fun -> Fun)
-> (Fun -> Fun -> Fun)
-> Ord Fun
Fun -> Fun -> Bool
Fun -> Fun -> Ordering
Fun -> Fun -> Fun
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
$ccompare :: Fun -> Fun -> Ordering
compare :: Fun -> Fun -> Ordering
$c< :: Fun -> Fun -> Bool
< :: Fun -> Fun -> Bool
$c<= :: Fun -> Fun -> Bool
<= :: Fun -> Fun -> Bool
$c> :: Fun -> Fun -> Bool
> :: Fun -> Fun -> Bool
$c>= :: Fun -> Fun -> Bool
>= :: Fun -> Fun -> Bool
$cmax :: Fun -> Fun -> Fun
max :: Fun -> Fun -> Fun
$cmin :: Fun -> Fun -> Fun
min :: Fun -> Fun -> Fun
Ord)
instance Show Fun where show :: Fun -> String
show (Fun String
i) = String
i

newFun :: Int -> Fun
newFun :: Int -> Fun
newFun Int
i = String -> Fun
Fun (String -> Fun) -> String -> Fun
forall a b. (a -> b) -> a -> b
$ String
"_fun" String -> ShowS
forall a. [a] -> [a] -> [a]
++ Int -> String
forall a. Show a => a -> String
show Int
i

newtype SectionId = SectionId Int deriving (Typeable SectionId
Typeable SectionId =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> SectionId -> c SectionId)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SectionId)
-> (SectionId -> Constr)
-> (SectionId -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SectionId))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SectionId))
-> ((forall b. Data b => b -> b) -> SectionId -> SectionId)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SectionId -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SectionId -> r)
-> (forall u. (forall d. Data d => d -> u) -> SectionId -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> SectionId -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> SectionId -> m SectionId)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SectionId -> m SectionId)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SectionId -> m SectionId)
-> Data SectionId
SectionId -> Constr
SectionId -> DataType
(forall b. Data b => b -> b) -> SectionId -> SectionId
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> SectionId -> u
forall u. (forall d. Data d => d -> u) -> SectionId -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SectionId -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SectionId -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SectionId -> m SectionId
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SectionId -> m SectionId
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SectionId
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SectionId -> c SectionId
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SectionId)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SectionId)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SectionId -> c SectionId
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SectionId -> c SectionId
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SectionId
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SectionId
$ctoConstr :: SectionId -> Constr
toConstr :: SectionId -> Constr
$cdataTypeOf :: SectionId -> DataType
dataTypeOf :: SectionId -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SectionId)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SectionId)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SectionId)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SectionId)
$cgmapT :: (forall b. Data b => b -> b) -> SectionId -> SectionId
gmapT :: (forall b. Data b => b -> b) -> SectionId -> SectionId
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SectionId -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SectionId -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SectionId -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SectionId -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SectionId -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> SectionId -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SectionId -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SectionId -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SectionId -> m SectionId
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SectionId -> m SectionId
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SectionId -> m SectionId
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SectionId -> m SectionId
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SectionId -> m SectionId
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SectionId -> m SectionId
Data,Typeable)
instance Show SectionId where show :: SectionId -> String
show (SectionId Int
i) = String
"${_sec" String -> ShowS
forall a. [a] -> [a] -> [a]
++ Int -> String
forall a. Show a => a -> String
show Int
i String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
"}"


type Val = [Val_]
data Val_ = Var_ Var | Builtin String | Literal String deriving (Typeable Val_
Typeable Val_ =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Val_ -> c Val_)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Val_)
-> (Val_ -> Constr)
-> (Val_ -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Val_))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Val_))
-> ((forall b. Data b => b -> b) -> Val_ -> Val_)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Val_ -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Val_ -> r)
-> (forall u. (forall d. Data d => d -> u) -> Val_ -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Val_ -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Val_ -> m Val_)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Val_ -> m Val_)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Val_ -> m Val_)
-> Data Val_
Val_ -> Constr
Val_ -> DataType
(forall b. Data b => b -> b) -> Val_ -> Val_
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Val_ -> u
forall u. (forall d. Data d => d -> u) -> Val_ -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Val_ -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Val_ -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Val_ -> m Val_
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Val_ -> m Val_
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Val_
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Val_ -> c Val_
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Val_)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Val_)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Val_ -> c Val_
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Val_ -> c Val_
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Val_
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Val_
$ctoConstr :: Val_ -> Constr
toConstr :: Val_ -> Constr
$cdataTypeOf :: Val_ -> DataType
dataTypeOf :: Val_ -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Val_)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Val_)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Val_)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Val_)
$cgmapT :: (forall b. Data b => b -> b) -> Val_ -> Val_
gmapT :: (forall b. Data b => b -> b) -> Val_ -> Val_
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Val_ -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Val_ -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Val_ -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Val_ -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Val_ -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Val_ -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Val_ -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Val_ -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Val_ -> m Val_
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Val_ -> m Val_
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Val_ -> m Val_
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Val_ -> m Val_
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Val_ -> m Val_
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Val_ -> m Val_
Data,Typeable,Val_ -> Val_ -> Bool
(Val_ -> Val_ -> Bool) -> (Val_ -> Val_ -> Bool) -> Eq Val_
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Val_ -> Val_ -> Bool
== :: Val_ -> Val_ -> Bool
$c/= :: Val_ -> Val_ -> Bool
/= :: Val_ -> Val_ -> Bool
Eq)

instance Show Val_ where
    show :: Val_ -> String
show Val_
x = [Val_] -> String
forall a. Show a => a -> String
show [Val_
x]
    showList :: [Val_] -> ShowS
showList [Val_]
xs = String -> ShowS
showString (String -> ShowS) -> String -> ShowS
forall a b. (a -> b) -> a -> b
$ String
"\"" String -> ShowS
forall a. [a] -> [a] -> [a]
++ (Val_ -> String) -> [Val_] -> String
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap Val_ -> String
f [Val_]
xs String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
"\""
        where
            f :: Val_ -> String
f (Var_ Var
x) = Var -> String
forall a. Show a => a -> String
show Var
x
            f (Builtin String
x) = String
"$" String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
x
            f (Literal String
x) = (Char -> String) -> ShowS
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap Char -> String
g String
x

            g :: Char -> String
g Char
'\"' = String
"$\\\""
            g Char
'\r' = String
"$\\r"
            g Char
'\n' = String
"$\\n"
            g Char
'\t' = String
"$\\t"
            g Char
'$' = String
"$$"
            g Char
x = [Char
x]


data NSIS
      -- primitives
    = Assign Var Val
    | Goto Label
    | Labeled Label

      -- functions and branches
    | StrCmpS Val Val Label Label
    | IntCmp Val Val Label Label Label
    | IntOp Var Val String Val
    | StrCpy Var Val Val Val
    | StrLen Var Val
    | GetFileTime Val Var Var
    | IfErrors Label Label
    | SectionGetText SectionId Var
    | SectionSetText SectionId Val
    | SectionGetFlags SectionId Var
    | SectionSetFlags SectionId Val
    | IfFileExists Val Label Label
    | FindFirst Var Var Val
    | FindNext Val Var
    | FindClose Val
    | Push Val
    | Pop Var

      -- blocks
    | Section ASection [NSIS]
    | SectionGroup ASectionGroup [NSIS]
    | Function Fun [NSIS]
    | Call Fun

      -- Global settings
    | Name Val
    | File AFile
    | OutFile Val
    | InstallDir Val
    | InstallIcon Val
    | UninstallIcon Val
    | HeaderImage (Maybe Val)
    | Page Page
    | Unpage Page

      -- Actions
    | SetOutPath Val
    | CreateDirectory Val
    | SetCompressor ACompressor
    | WriteUninstaller Val
    | FileOpen Var Val FileMode
    | FileWrite Val Val
    | FileClose Val
    | MessageBox [MessageBoxType] Val [(String,Label)]
    | CreateShortcut AShortcut
    | WriteRegStr HKEY Val Val Val
    | WriteRegExpandStr HKEY Val Val Val
    | WriteRegDWORD HKEY Val Val Val
    | WriteRegMultiStr HKEY Val Val Val
    | ReadRegStr Var HKEY Val Val
    | DeleteRegKey HKEY Val
    | DeleteRegValue HKEY Val Val
    | ReadEnvStr Var Val
    | Exec Val
    | ExecWait Val
    | ExecShell AExecShell
    | ExecShellWait AExecShell
    | ClearErrors
    | Delete ADelete
    | RMDir ARMDir
    | CopyFiles ACopyFiles
    | RequestExecutionLevel Level
    | Target Target
    | AddPluginDir Val
    | InstallDirRegKey HKEY Val Val
    | AllowRootDirInstall Bool
    | Caption Val
    | ShowInstDetails Visibility
    | ShowUninstDetails Visibility
    | Unicode Bool
    | SetDetailsPrint DetailsPrint
    | DetailPrint Val
    | Plugin String String [Val]
    | Sleep Val
    | FindWindow Var Val Val (Maybe Val) (Maybe Val)
    | GetDlgItem Var Val Val
    | SendMessage Val Val Val Val Var (Maybe Int)
    | Abort Val

      -- Escape hatch
    | UnsafeInject String
    | UnsafeInjectGlobal String
      deriving (Typeable NSIS
Typeable NSIS =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> NSIS -> c NSIS)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c NSIS)
-> (NSIS -> Constr)
-> (NSIS -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c NSIS))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NSIS))
-> ((forall b. Data b => b -> b) -> NSIS -> NSIS)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NSIS -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NSIS -> r)
-> (forall u. (forall d. Data d => d -> u) -> NSIS -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> NSIS -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> NSIS -> m NSIS)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NSIS -> m NSIS)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NSIS -> m NSIS)
-> Data NSIS
NSIS -> Constr
NSIS -> DataType
(forall b. Data b => b -> b) -> NSIS -> NSIS
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> NSIS -> u
forall u. (forall d. Data d => d -> u) -> NSIS -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NSIS -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NSIS -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NSIS -> m NSIS
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NSIS -> m NSIS
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NSIS
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NSIS -> c NSIS
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NSIS)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NSIS)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NSIS -> c NSIS
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NSIS -> c NSIS
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NSIS
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NSIS
$ctoConstr :: NSIS -> Constr
toConstr :: NSIS -> Constr
$cdataTypeOf :: NSIS -> DataType
dataTypeOf :: NSIS -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NSIS)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NSIS)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NSIS)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NSIS)
$cgmapT :: (forall b. Data b => b -> b) -> NSIS -> NSIS
gmapT :: (forall b. Data b => b -> b) -> NSIS -> NSIS
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NSIS -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NSIS -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NSIS -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NSIS -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> NSIS -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> NSIS -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> NSIS -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> NSIS -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NSIS -> m NSIS
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NSIS -> m NSIS
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NSIS -> m NSIS
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NSIS -> m NSIS
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NSIS -> m NSIS
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NSIS -> m NSIS
Data,Typeable,Int -> NSIS -> ShowS
[NSIS] -> ShowS
NSIS -> String
(Int -> NSIS -> ShowS)
-> (NSIS -> String) -> ([NSIS] -> ShowS) -> Show NSIS
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> NSIS -> ShowS
showsPrec :: Int -> NSIS -> ShowS
$cshow :: NSIS -> String
show :: NSIS -> String
$cshowList :: [NSIS] -> ShowS
showList :: [NSIS] -> ShowS
Show)

-- | Value to use with 'setDetailsPrint'.
data DetailsPrint = NoDetailsPrint | ListOnly | TextOnly | Both | LastUsed
    deriving (Typeable DetailsPrint
Typeable DetailsPrint =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> DetailsPrint -> c DetailsPrint)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DetailsPrint)
-> (DetailsPrint -> Constr)
-> (DetailsPrint -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DetailsPrint))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DetailsPrint))
-> ((forall b. Data b => b -> b) -> DetailsPrint -> DetailsPrint)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DetailsPrint -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DetailsPrint -> r)
-> (forall u. (forall d. Data d => d -> u) -> DetailsPrint -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DetailsPrint -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DetailsPrint -> m DetailsPrint)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DetailsPrint -> m DetailsPrint)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DetailsPrint -> m DetailsPrint)
-> Data DetailsPrint
DetailsPrint -> Constr
DetailsPrint -> DataType
(forall b. Data b => b -> b) -> DetailsPrint -> DetailsPrint
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> DetailsPrint -> u
forall u. (forall d. Data d => d -> u) -> DetailsPrint -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DetailsPrint -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DetailsPrint -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DetailsPrint -> m DetailsPrint
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DetailsPrint -> m DetailsPrint
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DetailsPrint
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DetailsPrint -> c DetailsPrint
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DetailsPrint)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DetailsPrint)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DetailsPrint -> c DetailsPrint
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DetailsPrint -> c DetailsPrint
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DetailsPrint
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DetailsPrint
$ctoConstr :: DetailsPrint -> Constr
toConstr :: DetailsPrint -> Constr
$cdataTypeOf :: DetailsPrint -> DataType
dataTypeOf :: DetailsPrint -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DetailsPrint)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DetailsPrint)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DetailsPrint)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DetailsPrint)
$cgmapT :: (forall b. Data b => b -> b) -> DetailsPrint -> DetailsPrint
gmapT :: (forall b. Data b => b -> b) -> DetailsPrint -> DetailsPrint
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DetailsPrint -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DetailsPrint -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DetailsPrint -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DetailsPrint -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DetailsPrint -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> DetailsPrint -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DetailsPrint -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DetailsPrint -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DetailsPrint -> m DetailsPrint
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DetailsPrint -> m DetailsPrint
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DetailsPrint -> m DetailsPrint
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DetailsPrint -> m DetailsPrint
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DetailsPrint -> m DetailsPrint
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DetailsPrint -> m DetailsPrint
Data,Typeable,DetailsPrint
DetailsPrint -> DetailsPrint -> Bounded DetailsPrint
forall a. a -> a -> Bounded a
$cminBound :: DetailsPrint
minBound :: DetailsPrint
$cmaxBound :: DetailsPrint
maxBound :: DetailsPrint
Bounded,Int -> DetailsPrint
DetailsPrint -> Int
DetailsPrint -> [DetailsPrint]
DetailsPrint -> DetailsPrint
DetailsPrint -> DetailsPrint -> [DetailsPrint]
DetailsPrint -> DetailsPrint -> DetailsPrint -> [DetailsPrint]
(DetailsPrint -> DetailsPrint)
-> (DetailsPrint -> DetailsPrint)
-> (Int -> DetailsPrint)
-> (DetailsPrint -> Int)
-> (DetailsPrint -> [DetailsPrint])
-> (DetailsPrint -> DetailsPrint -> [DetailsPrint])
-> (DetailsPrint -> DetailsPrint -> [DetailsPrint])
-> (DetailsPrint -> DetailsPrint -> DetailsPrint -> [DetailsPrint])
-> Enum DetailsPrint
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: DetailsPrint -> DetailsPrint
succ :: DetailsPrint -> DetailsPrint
$cpred :: DetailsPrint -> DetailsPrint
pred :: DetailsPrint -> DetailsPrint
$ctoEnum :: Int -> DetailsPrint
toEnum :: Int -> DetailsPrint
$cfromEnum :: DetailsPrint -> Int
fromEnum :: DetailsPrint -> Int
$cenumFrom :: DetailsPrint -> [DetailsPrint]
enumFrom :: DetailsPrint -> [DetailsPrint]
$cenumFromThen :: DetailsPrint -> DetailsPrint -> [DetailsPrint]
enumFromThen :: DetailsPrint -> DetailsPrint -> [DetailsPrint]
$cenumFromTo :: DetailsPrint -> DetailsPrint -> [DetailsPrint]
enumFromTo :: DetailsPrint -> DetailsPrint -> [DetailsPrint]
$cenumFromThenTo :: DetailsPrint -> DetailsPrint -> DetailsPrint -> [DetailsPrint]
enumFromThenTo :: DetailsPrint -> DetailsPrint -> DetailsPrint -> [DetailsPrint]
Enum,DetailsPrint -> DetailsPrint -> Bool
(DetailsPrint -> DetailsPrint -> Bool)
-> (DetailsPrint -> DetailsPrint -> Bool) -> Eq DetailsPrint
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DetailsPrint -> DetailsPrint -> Bool
== :: DetailsPrint -> DetailsPrint -> Bool
$c/= :: DetailsPrint -> DetailsPrint -> Bool
/= :: DetailsPrint -> DetailsPrint -> Bool
Eq,Eq DetailsPrint
Eq DetailsPrint =>
(DetailsPrint -> DetailsPrint -> Ordering)
-> (DetailsPrint -> DetailsPrint -> Bool)
-> (DetailsPrint -> DetailsPrint -> Bool)
-> (DetailsPrint -> DetailsPrint -> Bool)
-> (DetailsPrint -> DetailsPrint -> Bool)
-> (DetailsPrint -> DetailsPrint -> DetailsPrint)
-> (DetailsPrint -> DetailsPrint -> DetailsPrint)
-> Ord DetailsPrint
DetailsPrint -> DetailsPrint -> Bool
DetailsPrint -> DetailsPrint -> Ordering
DetailsPrint -> DetailsPrint -> DetailsPrint
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
$ccompare :: DetailsPrint -> DetailsPrint -> Ordering
compare :: DetailsPrint -> DetailsPrint -> Ordering
$c< :: DetailsPrint -> DetailsPrint -> Bool
< :: DetailsPrint -> DetailsPrint -> Bool
$c<= :: DetailsPrint -> DetailsPrint -> Bool
<= :: DetailsPrint -> DetailsPrint -> Bool
$c> :: DetailsPrint -> DetailsPrint -> Bool
> :: DetailsPrint -> DetailsPrint -> Bool
$c>= :: DetailsPrint -> DetailsPrint -> Bool
>= :: DetailsPrint -> DetailsPrint -> Bool
$cmax :: DetailsPrint -> DetailsPrint -> DetailsPrint
max :: DetailsPrint -> DetailsPrint -> DetailsPrint
$cmin :: DetailsPrint -> DetailsPrint -> DetailsPrint
min :: DetailsPrint -> DetailsPrint -> DetailsPrint
Ord)

instance Show DetailsPrint where
    show :: DetailsPrint -> String
show DetailsPrint
NoDetailsPrint = String
"None"
    show DetailsPrint
ListOnly = String
"ListOnly"
    show DetailsPrint
TextOnly = String
"TextOnly"
    show DetailsPrint
Both = String
"Both"
    show DetailsPrint
LastUsed = String
"LastUsed"

-- | Mode to use with 'Development.
data FileMode
    = ModeRead -- ^ Read a file.
    | ModeWrite -- All contents of file are destroyed.
    | ModeAppend -- ^ Opened for both read and write, contents preserved.
     deriving (Typeable FileMode
Typeable FileMode =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> FileMode -> c FileMode)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c FileMode)
-> (FileMode -> Constr)
-> (FileMode -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c FileMode))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FileMode))
-> ((forall b. Data b => b -> b) -> FileMode -> FileMode)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FileMode -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FileMode -> r)
-> (forall u. (forall d. Data d => d -> u) -> FileMode -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> FileMode -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> FileMode -> m FileMode)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FileMode -> m FileMode)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FileMode -> m FileMode)
-> Data FileMode
FileMode -> Constr
FileMode -> DataType
(forall b. Data b => b -> b) -> FileMode -> FileMode
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> FileMode -> u
forall u. (forall d. Data d => d -> u) -> FileMode -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FileMode -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FileMode -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FileMode -> m FileMode
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FileMode -> m FileMode
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FileMode
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FileMode -> c FileMode
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FileMode)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FileMode)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FileMode -> c FileMode
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FileMode -> c FileMode
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FileMode
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FileMode
$ctoConstr :: FileMode -> Constr
toConstr :: FileMode -> Constr
$cdataTypeOf :: FileMode -> DataType
dataTypeOf :: FileMode -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FileMode)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FileMode)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FileMode)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FileMode)
$cgmapT :: (forall b. Data b => b -> b) -> FileMode -> FileMode
gmapT :: (forall b. Data b => b -> b) -> FileMode -> FileMode
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FileMode -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FileMode -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FileMode -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FileMode -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> FileMode -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> FileMode -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> FileMode -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> FileMode -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FileMode -> m FileMode
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FileMode -> m FileMode
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FileMode -> m FileMode
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FileMode -> m FileMode
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FileMode -> m FileMode
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FileMode -> m FileMode
Data,Typeable,FileMode
FileMode -> FileMode -> Bounded FileMode
forall a. a -> a -> Bounded a
$cminBound :: FileMode
minBound :: FileMode
$cmaxBound :: FileMode
maxBound :: FileMode
Bounded,Int -> FileMode
FileMode -> Int
FileMode -> [FileMode]
FileMode -> FileMode
FileMode -> FileMode -> [FileMode]
FileMode -> FileMode -> FileMode -> [FileMode]
(FileMode -> FileMode)
-> (FileMode -> FileMode)
-> (Int -> FileMode)
-> (FileMode -> Int)
-> (FileMode -> [FileMode])
-> (FileMode -> FileMode -> [FileMode])
-> (FileMode -> FileMode -> [FileMode])
-> (FileMode -> FileMode -> FileMode -> [FileMode])
-> Enum FileMode
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: FileMode -> FileMode
succ :: FileMode -> FileMode
$cpred :: FileMode -> FileMode
pred :: FileMode -> FileMode
$ctoEnum :: Int -> FileMode
toEnum :: Int -> FileMode
$cfromEnum :: FileMode -> Int
fromEnum :: FileMode -> Int
$cenumFrom :: FileMode -> [FileMode]
enumFrom :: FileMode -> [FileMode]
$cenumFromThen :: FileMode -> FileMode -> [FileMode]
enumFromThen :: FileMode -> FileMode -> [FileMode]
$cenumFromTo :: FileMode -> FileMode -> [FileMode]
enumFromTo :: FileMode -> FileMode -> [FileMode]
$cenumFromThenTo :: FileMode -> FileMode -> FileMode -> [FileMode]
enumFromThenTo :: FileMode -> FileMode -> FileMode -> [FileMode]
Enum,FileMode -> FileMode -> Bool
(FileMode -> FileMode -> Bool)
-> (FileMode -> FileMode -> Bool) -> Eq FileMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FileMode -> FileMode -> Bool
== :: FileMode -> FileMode -> Bool
$c/= :: FileMode -> FileMode -> Bool
/= :: FileMode -> FileMode -> Bool
Eq,Eq FileMode
Eq FileMode =>
(FileMode -> FileMode -> Ordering)
-> (FileMode -> FileMode -> Bool)
-> (FileMode -> FileMode -> Bool)
-> (FileMode -> FileMode -> Bool)
-> (FileMode -> FileMode -> Bool)
-> (FileMode -> FileMode -> FileMode)
-> (FileMode -> FileMode -> FileMode)
-> Ord FileMode
FileMode -> FileMode -> Bool
FileMode -> FileMode -> Ordering
FileMode -> FileMode -> FileMode
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
$ccompare :: FileMode -> FileMode -> Ordering
compare :: FileMode -> FileMode -> Ordering
$c< :: FileMode -> FileMode -> Bool
< :: FileMode -> FileMode -> Bool
$c<= :: FileMode -> FileMode -> Bool
<= :: FileMode -> FileMode -> Bool
$c> :: FileMode -> FileMode -> Bool
> :: FileMode -> FileMode -> Bool
$c>= :: FileMode -> FileMode -> Bool
>= :: FileMode -> FileMode -> Bool
$cmax :: FileMode -> FileMode -> FileMode
max :: FileMode -> FileMode -> FileMode
$cmin :: FileMode -> FileMode -> FileMode
min :: FileMode -> FileMode -> FileMode
Ord)

instance Show FileMode where
    show :: FileMode -> String
show FileMode
ModeRead = String
"r"
    show FileMode
ModeWrite = String
"w"
    show FileMode
ModeAppend = String
"a"


data AShortcut = AShortcut
    {AShortcut -> [Val_]
scFile :: Val
    ,AShortcut -> [Val_]
scTarget :: Val
    ,AShortcut -> [Val_]
scParameters :: Val
    ,AShortcut -> [Val_]
scIconFile :: Val
    ,AShortcut -> [Val_]
scIconIndex :: Val
    ,AShortcut -> String
scStartOptions :: String
    ,AShortcut -> String
scKeyboardShortcut :: String
    ,AShortcut -> [Val_]
scDescription :: Val
    } deriving (Typeable AShortcut
Typeable AShortcut =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> AShortcut -> c AShortcut)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c AShortcut)
-> (AShortcut -> Constr)
-> (AShortcut -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c AShortcut))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AShortcut))
-> ((forall b. Data b => b -> b) -> AShortcut -> AShortcut)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> AShortcut -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> AShortcut -> r)
-> (forall u. (forall d. Data d => d -> u) -> AShortcut -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> AShortcut -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> AShortcut -> m AShortcut)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AShortcut -> m AShortcut)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AShortcut -> m AShortcut)
-> Data AShortcut
AShortcut -> Constr
AShortcut -> DataType
(forall b. Data b => b -> b) -> AShortcut -> AShortcut
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> AShortcut -> u
forall u. (forall d. Data d => d -> u) -> AShortcut -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AShortcut -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> AShortcut -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> AShortcut -> m AShortcut
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AShortcut -> m AShortcut
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AShortcut
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AShortcut -> c AShortcut
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c AShortcut)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AShortcut)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AShortcut -> c AShortcut
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AShortcut -> c AShortcut
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AShortcut
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AShortcut
$ctoConstr :: AShortcut -> Constr
toConstr :: AShortcut -> Constr
$cdataTypeOf :: AShortcut -> DataType
dataTypeOf :: AShortcut -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c AShortcut)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c AShortcut)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AShortcut)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AShortcut)
$cgmapT :: (forall b. Data b => b -> b) -> AShortcut -> AShortcut
gmapT :: (forall b. Data b => b -> b) -> AShortcut -> AShortcut
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AShortcut -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AShortcut -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> AShortcut -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> AShortcut -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> AShortcut -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> AShortcut -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> AShortcut -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> AShortcut -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> AShortcut -> m AShortcut
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> AShortcut -> m AShortcut
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AShortcut -> m AShortcut
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AShortcut -> m AShortcut
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AShortcut -> m AShortcut
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AShortcut -> m AShortcut
Data,Typeable,Int -> AShortcut -> ShowS
[AShortcut] -> ShowS
AShortcut -> String
(Int -> AShortcut -> ShowS)
-> (AShortcut -> String)
-> ([AShortcut] -> ShowS)
-> Show AShortcut
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> AShortcut -> ShowS
showsPrec :: Int -> AShortcut -> ShowS
$cshow :: AShortcut -> String
show :: AShortcut -> String
$cshowList :: [AShortcut] -> ShowS
showList :: [AShortcut] -> ShowS
Show)

instance Default AShortcut where def :: AShortcut
def = [Val_]
-> [Val_]
-> [Val_]
-> [Val_]
-> [Val_]
-> String
-> String
-> [Val_]
-> AShortcut
AShortcut [Val_]
forall a. Default a => a
def [Val_]
forall a. Default a => a
def [Val_]
forall a. Default a => a
def [Val_]
forall a. Default a => a
def [Val_]
forall a. Default a => a
def String
forall a. Default a => a
def String
forall a. Default a => a
def [Val_]
forall a. Default a => a
def

data ASection = ASection
    {ASection -> SectionId
secId :: SectionId
    ,ASection -> [Val_]
secName :: Val
    ,ASection -> [Val_]
secDescription :: Val
    ,ASection -> Bool
secBold :: Bool
    ,ASection -> Bool
secRequired :: Bool
    ,ASection -> Bool
secUnselected :: Bool
    } deriving (Typeable ASection
Typeable ASection =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> ASection -> c ASection)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ASection)
-> (ASection -> Constr)
-> (ASection -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ASection))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ASection))
-> ((forall b. Data b => b -> b) -> ASection -> ASection)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ASection -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ASection -> r)
-> (forall u. (forall d. Data d => d -> u) -> ASection -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> ASection -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ASection -> m ASection)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ASection -> m ASection)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ASection -> m ASection)
-> Data ASection
ASection -> Constr
ASection -> DataType
(forall b. Data b => b -> b) -> ASection -> ASection
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> ASection -> u
forall u. (forall d. Data d => d -> u) -> ASection -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ASection -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ASection -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ASection -> m ASection
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ASection -> m ASection
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ASection
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ASection -> c ASection
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ASection)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ASection)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ASection -> c ASection
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ASection -> c ASection
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ASection
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ASection
$ctoConstr :: ASection -> Constr
toConstr :: ASection -> Constr
$cdataTypeOf :: ASection -> DataType
dataTypeOf :: ASection -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ASection)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ASection)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ASection)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ASection)
$cgmapT :: (forall b. Data b => b -> b) -> ASection -> ASection
gmapT :: (forall b. Data b => b -> b) -> ASection -> ASection
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ASection -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ASection -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ASection -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ASection -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ASection -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> ASection -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ASection -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ASection -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ASection -> m ASection
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ASection -> m ASection
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ASection -> m ASection
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ASection -> m ASection
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ASection -> m ASection
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ASection -> m ASection
Data,Typeable,Int -> ASection -> ShowS
[ASection] -> ShowS
ASection -> String
(Int -> ASection -> ShowS)
-> (ASection -> String) -> ([ASection] -> ShowS) -> Show ASection
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ASection -> ShowS
showsPrec :: Int -> ASection -> ShowS
$cshow :: ASection -> String
show :: ASection -> String
$cshowList :: [ASection] -> ShowS
showList :: [ASection] -> ShowS
Show)

instance Default ASection where def :: ASection
def = SectionId -> [Val_] -> [Val_] -> Bool -> Bool -> Bool -> ASection
ASection (Int -> SectionId
SectionId Int
0) [Val_]
forall a. Default a => a
def [Val_]
forall a. Default a => a
def Bool
False Bool
False Bool
False

data ASectionGroup = ASectionGroup
    {ASectionGroup -> SectionId
secgId :: SectionId
    ,ASectionGroup -> [Val_]
secgName :: Val
    ,ASectionGroup -> Bool
secgExpanded :: Bool
    ,ASectionGroup -> [Val_]
secgDescription :: Val
    } deriving (Typeable ASectionGroup
Typeable ASectionGroup =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> ASectionGroup -> c ASectionGroup)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ASectionGroup)
-> (ASectionGroup -> Constr)
-> (ASectionGroup -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ASectionGroup))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c ASectionGroup))
-> ((forall b. Data b => b -> b) -> ASectionGroup -> ASectionGroup)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ASectionGroup -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ASectionGroup -> r)
-> (forall u. (forall d. Data d => d -> u) -> ASectionGroup -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ASectionGroup -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ASectionGroup -> m ASectionGroup)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ASectionGroup -> m ASectionGroup)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ASectionGroup -> m ASectionGroup)
-> Data ASectionGroup
ASectionGroup -> Constr
ASectionGroup -> DataType
(forall b. Data b => b -> b) -> ASectionGroup -> ASectionGroup
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> ASectionGroup -> u
forall u. (forall d. Data d => d -> u) -> ASectionGroup -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ASectionGroup -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ASectionGroup -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ASectionGroup -> m ASectionGroup
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ASectionGroup -> m ASectionGroup
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ASectionGroup
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ASectionGroup -> c ASectionGroup
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ASectionGroup)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ASectionGroup)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ASectionGroup -> c ASectionGroup
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ASectionGroup -> c ASectionGroup
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ASectionGroup
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ASectionGroup
$ctoConstr :: ASectionGroup -> Constr
toConstr :: ASectionGroup -> Constr
$cdataTypeOf :: ASectionGroup -> DataType
dataTypeOf :: ASectionGroup -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ASectionGroup)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ASectionGroup)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ASectionGroup)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ASectionGroup)
$cgmapT :: (forall b. Data b => b -> b) -> ASectionGroup -> ASectionGroup
gmapT :: (forall b. Data b => b -> b) -> ASectionGroup -> ASectionGroup
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ASectionGroup -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ASectionGroup -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ASectionGroup -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ASectionGroup -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ASectionGroup -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> ASectionGroup -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ASectionGroup -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ASectionGroup -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ASectionGroup -> m ASectionGroup
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ASectionGroup -> m ASectionGroup
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ASectionGroup -> m ASectionGroup
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ASectionGroup -> m ASectionGroup
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ASectionGroup -> m ASectionGroup
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ASectionGroup -> m ASectionGroup
Data,Typeable,Int -> ASectionGroup -> ShowS
[ASectionGroup] -> ShowS
ASectionGroup -> String
(Int -> ASectionGroup -> ShowS)
-> (ASectionGroup -> String)
-> ([ASectionGroup] -> ShowS)
-> Show ASectionGroup
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ASectionGroup -> ShowS
showsPrec :: Int -> ASectionGroup -> ShowS
$cshow :: ASectionGroup -> String
show :: ASectionGroup -> String
$cshowList :: [ASectionGroup] -> ShowS
showList :: [ASectionGroup] -> ShowS
Show)

instance Default ASectionGroup where def :: ASectionGroup
def = SectionId -> [Val_] -> Bool -> [Val_] -> ASectionGroup
ASectionGroup (Int -> SectionId
SectionId Int
0) [Val_]
forall a. Default a => a
def Bool
False [Val_]
forall a. Default a => a
def

data Compressor = LZMA | ZLIB | BZIP2 deriving (Typeable Compressor
Typeable Compressor =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Compressor -> c Compressor)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Compressor)
-> (Compressor -> Constr)
-> (Compressor -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Compressor))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c Compressor))
-> ((forall b. Data b => b -> b) -> Compressor -> Compressor)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Compressor -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Compressor -> r)
-> (forall u. (forall d. Data d => d -> u) -> Compressor -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Compressor -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Compressor -> m Compressor)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Compressor -> m Compressor)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Compressor -> m Compressor)
-> Data Compressor
Compressor -> Constr
Compressor -> DataType
(forall b. Data b => b -> b) -> Compressor -> Compressor
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Compressor -> u
forall u. (forall d. Data d => d -> u) -> Compressor -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Compressor -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Compressor -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Compressor -> m Compressor
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Compressor -> m Compressor
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Compressor
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Compressor -> c Compressor
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Compressor)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Compressor)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Compressor -> c Compressor
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Compressor -> c Compressor
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Compressor
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Compressor
$ctoConstr :: Compressor -> Constr
toConstr :: Compressor -> Constr
$cdataTypeOf :: Compressor -> DataType
dataTypeOf :: Compressor -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Compressor)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Compressor)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Compressor)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Compressor)
$cgmapT :: (forall b. Data b => b -> b) -> Compressor -> Compressor
gmapT :: (forall b. Data b => b -> b) -> Compressor -> Compressor
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Compressor -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Compressor -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Compressor -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Compressor -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Compressor -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Compressor -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Compressor -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Compressor -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Compressor -> m Compressor
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Compressor -> m Compressor
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Compressor -> m Compressor
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Compressor -> m Compressor
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Compressor -> m Compressor
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Compressor -> m Compressor
Data,Typeable,Int -> Compressor -> ShowS
[Compressor] -> ShowS
Compressor -> String
(Int -> Compressor -> ShowS)
-> (Compressor -> String)
-> ([Compressor] -> ShowS)
-> Show Compressor
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Compressor -> ShowS
showsPrec :: Int -> Compressor -> ShowS
$cshow :: Compressor -> String
show :: Compressor -> String
$cshowList :: [Compressor] -> ShowS
showList :: [Compressor] -> ShowS
Show)

instance Default Compressor where def :: Compressor
def = Compressor
ZLIB

data ACompressor = ACompressor
    {ACompressor -> Compressor
compType :: Compressor
    ,ACompressor -> Bool
compSolid :: Bool
    ,ACompressor -> Bool
compFinal :: Bool
    } deriving (Typeable ACompressor
Typeable ACompressor =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> ACompressor -> c ACompressor)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ACompressor)
-> (ACompressor -> Constr)
-> (ACompressor -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ACompressor))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c ACompressor))
-> ((forall b. Data b => b -> b) -> ACompressor -> ACompressor)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ACompressor -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ACompressor -> r)
-> (forall u. (forall d. Data d => d -> u) -> ACompressor -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ACompressor -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ACompressor -> m ACompressor)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ACompressor -> m ACompressor)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ACompressor -> m ACompressor)
-> Data ACompressor
ACompressor -> Constr
ACompressor -> DataType
(forall b. Data b => b -> b) -> ACompressor -> ACompressor
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> ACompressor -> u
forall u. (forall d. Data d => d -> u) -> ACompressor -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ACompressor -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ACompressor -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ACompressor -> m ACompressor
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ACompressor -> m ACompressor
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ACompressor
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ACompressor -> c ACompressor
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ACompressor)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ACompressor)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ACompressor -> c ACompressor
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ACompressor -> c ACompressor
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ACompressor
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ACompressor
$ctoConstr :: ACompressor -> Constr
toConstr :: ACompressor -> Constr
$cdataTypeOf :: ACompressor -> DataType
dataTypeOf :: ACompressor -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ACompressor)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ACompressor)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ACompressor)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ACompressor)
$cgmapT :: (forall b. Data b => b -> b) -> ACompressor -> ACompressor
gmapT :: (forall b. Data b => b -> b) -> ACompressor -> ACompressor
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ACompressor -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ACompressor -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ACompressor -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ACompressor -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ACompressor -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> ACompressor -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ACompressor -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ACompressor -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ACompressor -> m ACompressor
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ACompressor -> m ACompressor
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ACompressor -> m ACompressor
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ACompressor -> m ACompressor
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ACompressor -> m ACompressor
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ACompressor -> m ACompressor
Data,Typeable,Int -> ACompressor -> ShowS
[ACompressor] -> ShowS
ACompressor -> String
(Int -> ACompressor -> ShowS)
-> (ACompressor -> String)
-> ([ACompressor] -> ShowS)
-> Show ACompressor
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ACompressor -> ShowS
showsPrec :: Int -> ACompressor -> ShowS
$cshow :: ACompressor -> String
show :: ACompressor -> String
$cshowList :: [ACompressor] -> ShowS
showList :: [ACompressor] -> ShowS
Show)

instance Default ACompressor where def :: ACompressor
def = Compressor -> Bool -> Bool -> ACompressor
ACompressor Compressor
forall a. Default a => a
def Bool
False Bool
False

data AFile = AFile
    {AFile -> [Val_]
filePath :: Val
    ,AFile -> Bool
fileNonFatal :: Bool
    ,AFile -> Bool
fileRecursive :: Bool
    ,AFile -> Maybe [Val_]
fileOName :: Maybe Val
    } deriving (Typeable AFile
Typeable AFile =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> AFile -> c AFile)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c AFile)
-> (AFile -> Constr)
-> (AFile -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c AFile))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AFile))
-> ((forall b. Data b => b -> b) -> AFile -> AFile)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AFile -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AFile -> r)
-> (forall u. (forall d. Data d => d -> u) -> AFile -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> AFile -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> AFile -> m AFile)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AFile -> m AFile)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AFile -> m AFile)
-> Data AFile
AFile -> Constr
AFile -> DataType
(forall b. Data b => b -> b) -> AFile -> AFile
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> AFile -> u
forall u. (forall d. Data d => d -> u) -> AFile -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AFile -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AFile -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> AFile -> m AFile
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AFile -> m AFile
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AFile
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AFile -> c AFile
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c AFile)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AFile)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AFile -> c AFile
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AFile -> c AFile
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AFile
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AFile
$ctoConstr :: AFile -> Constr
toConstr :: AFile -> Constr
$cdataTypeOf :: AFile -> DataType
dataTypeOf :: AFile -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c AFile)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c AFile)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AFile)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AFile)
$cgmapT :: (forall b. Data b => b -> b) -> AFile -> AFile
gmapT :: (forall b. Data b => b -> b) -> AFile -> AFile
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AFile -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AFile -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AFile -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AFile -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> AFile -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> AFile -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> AFile -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> AFile -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> AFile -> m AFile
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> AFile -> m AFile
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AFile -> m AFile
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AFile -> m AFile
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AFile -> m AFile
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AFile -> m AFile
Data,Typeable,Int -> AFile -> ShowS
[AFile] -> ShowS
AFile -> String
(Int -> AFile -> ShowS)
-> (AFile -> String) -> ([AFile] -> ShowS) -> Show AFile
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> AFile -> ShowS
showsPrec :: Int -> AFile -> ShowS
$cshow :: AFile -> String
show :: AFile -> String
$cshowList :: [AFile] -> ShowS
showList :: [AFile] -> ShowS
Show)

instance Default AFile where def :: AFile
def = [Val_] -> Bool -> Bool -> Maybe [Val_] -> AFile
AFile [Val_]
forall a. Default a => a
def Bool
False Bool
False Maybe [Val_]
forall a. Maybe a
Nothing

data ARMDir = ARMDir
    {ARMDir -> [Val_]
rmDir :: Val
    ,ARMDir -> Bool
rmRecursive :: Bool
    ,ARMDir -> Bool
rmRebootOK :: Bool
    } deriving (Typeable ARMDir
Typeable ARMDir =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> ARMDir -> c ARMDir)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ARMDir)
-> (ARMDir -> Constr)
-> (ARMDir -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ARMDir))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ARMDir))
-> ((forall b. Data b => b -> b) -> ARMDir -> ARMDir)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ARMDir -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ARMDir -> r)
-> (forall u. (forall d. Data d => d -> u) -> ARMDir -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> ARMDir -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ARMDir -> m ARMDir)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ARMDir -> m ARMDir)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ARMDir -> m ARMDir)
-> Data ARMDir
ARMDir -> Constr
ARMDir -> DataType
(forall b. Data b => b -> b) -> ARMDir -> ARMDir
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> ARMDir -> u
forall u. (forall d. Data d => d -> u) -> ARMDir -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ARMDir -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ARMDir -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ARMDir -> m ARMDir
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ARMDir -> m ARMDir
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ARMDir
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ARMDir -> c ARMDir
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ARMDir)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ARMDir)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ARMDir -> c ARMDir
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ARMDir -> c ARMDir
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ARMDir
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ARMDir
$ctoConstr :: ARMDir -> Constr
toConstr :: ARMDir -> Constr
$cdataTypeOf :: ARMDir -> DataType
dataTypeOf :: ARMDir -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ARMDir)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ARMDir)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ARMDir)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ARMDir)
$cgmapT :: (forall b. Data b => b -> b) -> ARMDir -> ARMDir
gmapT :: (forall b. Data b => b -> b) -> ARMDir -> ARMDir
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ARMDir -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ARMDir -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ARMDir -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ARMDir -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ARMDir -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> ARMDir -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ARMDir -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ARMDir -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ARMDir -> m ARMDir
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ARMDir -> m ARMDir
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ARMDir -> m ARMDir
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ARMDir -> m ARMDir
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ARMDir -> m ARMDir
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ARMDir -> m ARMDir
Data,Typeable,Int -> ARMDir -> ShowS
[ARMDir] -> ShowS
ARMDir -> String
(Int -> ARMDir -> ShowS)
-> (ARMDir -> String) -> ([ARMDir] -> ShowS) -> Show ARMDir
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ARMDir -> ShowS
showsPrec :: Int -> ARMDir -> ShowS
$cshow :: ARMDir -> String
show :: ARMDir -> String
$cshowList :: [ARMDir] -> ShowS
showList :: [ARMDir] -> ShowS
Show)

instance Default ARMDir where def :: ARMDir
def = [Val_] -> Bool -> Bool -> ARMDir
ARMDir [Val_]
forall a. Default a => a
def Bool
False Bool
False

data ADelete = ADelete
    {ADelete -> [Val_]
delFile :: Val
    ,ADelete -> Bool
delRebootOK :: Bool
    } deriving (Typeable ADelete
Typeable ADelete =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> ADelete -> c ADelete)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ADelete)
-> (ADelete -> Constr)
-> (ADelete -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ADelete))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ADelete))
-> ((forall b. Data b => b -> b) -> ADelete -> ADelete)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ADelete -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ADelete -> r)
-> (forall u. (forall d. Data d => d -> u) -> ADelete -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> ADelete -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ADelete -> m ADelete)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ADelete -> m ADelete)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ADelete -> m ADelete)
-> Data ADelete
ADelete -> Constr
ADelete -> DataType
(forall b. Data b => b -> b) -> ADelete -> ADelete
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> ADelete -> u
forall u. (forall d. Data d => d -> u) -> ADelete -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ADelete -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ADelete -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ADelete -> m ADelete
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ADelete -> m ADelete
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ADelete
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ADelete -> c ADelete
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ADelete)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ADelete)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ADelete -> c ADelete
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ADelete -> c ADelete
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ADelete
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ADelete
$ctoConstr :: ADelete -> Constr
toConstr :: ADelete -> Constr
$cdataTypeOf :: ADelete -> DataType
dataTypeOf :: ADelete -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ADelete)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ADelete)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ADelete)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ADelete)
$cgmapT :: (forall b. Data b => b -> b) -> ADelete -> ADelete
gmapT :: (forall b. Data b => b -> b) -> ADelete -> ADelete
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ADelete -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ADelete -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ADelete -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ADelete -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ADelete -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> ADelete -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ADelete -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ADelete -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ADelete -> m ADelete
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ADelete -> m ADelete
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ADelete -> m ADelete
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ADelete -> m ADelete
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ADelete -> m ADelete
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ADelete -> m ADelete
Data,Typeable,Int -> ADelete -> ShowS
[ADelete] -> ShowS
ADelete -> String
(Int -> ADelete -> ShowS)
-> (ADelete -> String) -> ([ADelete] -> ShowS) -> Show ADelete
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ADelete -> ShowS
showsPrec :: Int -> ADelete -> ShowS
$cshow :: ADelete -> String
show :: ADelete -> String
$cshowList :: [ADelete] -> ShowS
showList :: [ADelete] -> ShowS
Show)

instance Default ADelete where def :: ADelete
def = [Val_] -> Bool -> ADelete
ADelete [Val_]
forall a. Default a => a
def Bool
False

data AExecShell = AExecShell
    {AExecShell -> [Val_]
esCommand :: Val
    ,AExecShell -> ShowWindow
esShow :: ShowWindow
    } deriving (Typeable AExecShell
Typeable AExecShell =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> AExecShell -> c AExecShell)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c AExecShell)
-> (AExecShell -> Constr)
-> (AExecShell -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c AExecShell))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c AExecShell))
-> ((forall b. Data b => b -> b) -> AExecShell -> AExecShell)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> AExecShell -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> AExecShell -> r)
-> (forall u. (forall d. Data d => d -> u) -> AExecShell -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> AExecShell -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> AExecShell -> m AExecShell)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AExecShell -> m AExecShell)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AExecShell -> m AExecShell)
-> Data AExecShell
AExecShell -> Constr
AExecShell -> DataType
(forall b. Data b => b -> b) -> AExecShell -> AExecShell
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> AExecShell -> u
forall u. (forall d. Data d => d -> u) -> AExecShell -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AExecShell -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> AExecShell -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> AExecShell -> m AExecShell
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AExecShell -> m AExecShell
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AExecShell
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AExecShell -> c AExecShell
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c AExecShell)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AExecShell)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AExecShell -> c AExecShell
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AExecShell -> c AExecShell
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AExecShell
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AExecShell
$ctoConstr :: AExecShell -> Constr
toConstr :: AExecShell -> Constr
$cdataTypeOf :: AExecShell -> DataType
dataTypeOf :: AExecShell -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c AExecShell)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c AExecShell)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AExecShell)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AExecShell)
$cgmapT :: (forall b. Data b => b -> b) -> AExecShell -> AExecShell
gmapT :: (forall b. Data b => b -> b) -> AExecShell -> AExecShell
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AExecShell -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AExecShell -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> AExecShell -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> AExecShell -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> AExecShell -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> AExecShell -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> AExecShell -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> AExecShell -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> AExecShell -> m AExecShell
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> AExecShell -> m AExecShell
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AExecShell -> m AExecShell
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AExecShell -> m AExecShell
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AExecShell -> m AExecShell
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AExecShell -> m AExecShell
Data,Typeable,Int -> AExecShell -> ShowS
[AExecShell] -> ShowS
AExecShell -> String
(Int -> AExecShell -> ShowS)
-> (AExecShell -> String)
-> ([AExecShell] -> ShowS)
-> Show AExecShell
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> AExecShell -> ShowS
showsPrec :: Int -> AExecShell -> ShowS
$cshow :: AExecShell -> String
show :: AExecShell -> String
$cshowList :: [AExecShell] -> ShowS
showList :: [AExecShell] -> ShowS
Show)

instance Default AExecShell where def :: AExecShell
def = [Val_] -> ShowWindow -> AExecShell
AExecShell [Val_]
forall a. Default a => a
def ShowWindow
forall a. Default a => a
def

data ACopyFiles = ACopyFiles
    {ACopyFiles -> [Val_]
cpFrom :: Val
    ,ACopyFiles -> [Val_]
cpTo :: Val
    ,ACopyFiles -> Bool
cpSilent :: Bool
    ,ACopyFiles -> Bool
cpFilesOnly :: Bool
    } deriving (Typeable ACopyFiles
Typeable ACopyFiles =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> ACopyFiles -> c ACopyFiles)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ACopyFiles)
-> (ACopyFiles -> Constr)
-> (ACopyFiles -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ACopyFiles))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c ACopyFiles))
-> ((forall b. Data b => b -> b) -> ACopyFiles -> ACopyFiles)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ACopyFiles -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ACopyFiles -> r)
-> (forall u. (forall d. Data d => d -> u) -> ACopyFiles -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ACopyFiles -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ACopyFiles -> m ACopyFiles)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ACopyFiles -> m ACopyFiles)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ACopyFiles -> m ACopyFiles)
-> Data ACopyFiles
ACopyFiles -> Constr
ACopyFiles -> DataType
(forall b. Data b => b -> b) -> ACopyFiles -> ACopyFiles
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> ACopyFiles -> u
forall u. (forall d. Data d => d -> u) -> ACopyFiles -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ACopyFiles -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ACopyFiles -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ACopyFiles -> m ACopyFiles
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ACopyFiles -> m ACopyFiles
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ACopyFiles
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ACopyFiles -> c ACopyFiles
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ACopyFiles)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ACopyFiles)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ACopyFiles -> c ACopyFiles
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ACopyFiles -> c ACopyFiles
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ACopyFiles
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ACopyFiles
$ctoConstr :: ACopyFiles -> Constr
toConstr :: ACopyFiles -> Constr
$cdataTypeOf :: ACopyFiles -> DataType
dataTypeOf :: ACopyFiles -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ACopyFiles)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ACopyFiles)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ACopyFiles)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ACopyFiles)
$cgmapT :: (forall b. Data b => b -> b) -> ACopyFiles -> ACopyFiles
gmapT :: (forall b. Data b => b -> b) -> ACopyFiles -> ACopyFiles
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ACopyFiles -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ACopyFiles -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ACopyFiles -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ACopyFiles -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ACopyFiles -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> ACopyFiles -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ACopyFiles -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ACopyFiles -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ACopyFiles -> m ACopyFiles
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ACopyFiles -> m ACopyFiles
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ACopyFiles -> m ACopyFiles
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ACopyFiles -> m ACopyFiles
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ACopyFiles -> m ACopyFiles
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ACopyFiles -> m ACopyFiles
Data,Typeable,Int -> ACopyFiles -> ShowS
[ACopyFiles] -> ShowS
ACopyFiles -> String
(Int -> ACopyFiles -> ShowS)
-> (ACopyFiles -> String)
-> ([ACopyFiles] -> ShowS)
-> Show ACopyFiles
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ACopyFiles -> ShowS
showsPrec :: Int -> ACopyFiles -> ShowS
$cshow :: ACopyFiles -> String
show :: ACopyFiles -> String
$cshowList :: [ACopyFiles] -> ShowS
showList :: [ACopyFiles] -> ShowS
Show)

instance Default ACopyFiles where def :: ACopyFiles
def = [Val_] -> [Val_] -> Bool -> Bool -> ACopyFiles
ACopyFiles [Val_]
forall a. Default a => a
def [Val_]
forall a. Default a => a
def Bool
False Bool
False

data ShowWindow
    = SW_SHOWDEFAULT
    | SW_SHOWNORMAL
    | SW_SHOWMAXIMIZED
    | SW_SHOWMINIMIZED
    | SW_HIDE
     deriving (Int -> ShowWindow -> ShowS
[ShowWindow] -> ShowS
ShowWindow -> String
(Int -> ShowWindow -> ShowS)
-> (ShowWindow -> String)
-> ([ShowWindow] -> ShowS)
-> Show ShowWindow
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ShowWindow -> ShowS
showsPrec :: Int -> ShowWindow -> ShowS
$cshow :: ShowWindow -> String
show :: ShowWindow -> String
$cshowList :: [ShowWindow] -> ShowS
showList :: [ShowWindow] -> ShowS
Show,Typeable ShowWindow
Typeable ShowWindow =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> ShowWindow -> c ShowWindow)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ShowWindow)
-> (ShowWindow -> Constr)
-> (ShowWindow -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ShowWindow))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c ShowWindow))
-> ((forall b. Data b => b -> b) -> ShowWindow -> ShowWindow)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ShowWindow -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ShowWindow -> r)
-> (forall u. (forall d. Data d => d -> u) -> ShowWindow -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ShowWindow -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ShowWindow -> m ShowWindow)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ShowWindow -> m ShowWindow)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ShowWindow -> m ShowWindow)
-> Data ShowWindow
ShowWindow -> Constr
ShowWindow -> DataType
(forall b. Data b => b -> b) -> ShowWindow -> ShowWindow
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> ShowWindow -> u
forall u. (forall d. Data d => d -> u) -> ShowWindow -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ShowWindow -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ShowWindow -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ShowWindow -> m ShowWindow
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ShowWindow -> m ShowWindow
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ShowWindow
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ShowWindow -> c ShowWindow
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ShowWindow)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ShowWindow)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ShowWindow -> c ShowWindow
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ShowWindow -> c ShowWindow
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ShowWindow
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ShowWindow
$ctoConstr :: ShowWindow -> Constr
toConstr :: ShowWindow -> Constr
$cdataTypeOf :: ShowWindow -> DataType
dataTypeOf :: ShowWindow -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ShowWindow)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ShowWindow)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ShowWindow)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ShowWindow)
$cgmapT :: (forall b. Data b => b -> b) -> ShowWindow -> ShowWindow
gmapT :: (forall b. Data b => b -> b) -> ShowWindow -> ShowWindow
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ShowWindow -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ShowWindow -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ShowWindow -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ShowWindow -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ShowWindow -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> ShowWindow -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ShowWindow -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ShowWindow -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ShowWindow -> m ShowWindow
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ShowWindow -> m ShowWindow
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ShowWindow -> m ShowWindow
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ShowWindow -> m ShowWindow
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ShowWindow -> m ShowWindow
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ShowWindow -> m ShowWindow
Data,Typeable,ReadPrec [ShowWindow]
ReadPrec ShowWindow
Int -> ReadS ShowWindow
ReadS [ShowWindow]
(Int -> ReadS ShowWindow)
-> ReadS [ShowWindow]
-> ReadPrec ShowWindow
-> ReadPrec [ShowWindow]
-> Read ShowWindow
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ShowWindow
readsPrec :: Int -> ReadS ShowWindow
$creadList :: ReadS [ShowWindow]
readList :: ReadS [ShowWindow]
$creadPrec :: ReadPrec ShowWindow
readPrec :: ReadPrec ShowWindow
$creadListPrec :: ReadPrec [ShowWindow]
readListPrec :: ReadPrec [ShowWindow]
Read,ShowWindow
ShowWindow -> ShowWindow -> Bounded ShowWindow
forall a. a -> a -> Bounded a
$cminBound :: ShowWindow
minBound :: ShowWindow
$cmaxBound :: ShowWindow
maxBound :: ShowWindow
Bounded,Int -> ShowWindow
ShowWindow -> Int
ShowWindow -> [ShowWindow]
ShowWindow -> ShowWindow
ShowWindow -> ShowWindow -> [ShowWindow]
ShowWindow -> ShowWindow -> ShowWindow -> [ShowWindow]
(ShowWindow -> ShowWindow)
-> (ShowWindow -> ShowWindow)
-> (Int -> ShowWindow)
-> (ShowWindow -> Int)
-> (ShowWindow -> [ShowWindow])
-> (ShowWindow -> ShowWindow -> [ShowWindow])
-> (ShowWindow -> ShowWindow -> [ShowWindow])
-> (ShowWindow -> ShowWindow -> ShowWindow -> [ShowWindow])
-> Enum ShowWindow
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: ShowWindow -> ShowWindow
succ :: ShowWindow -> ShowWindow
$cpred :: ShowWindow -> ShowWindow
pred :: ShowWindow -> ShowWindow
$ctoEnum :: Int -> ShowWindow
toEnum :: Int -> ShowWindow
$cfromEnum :: ShowWindow -> Int
fromEnum :: ShowWindow -> Int
$cenumFrom :: ShowWindow -> [ShowWindow]
enumFrom :: ShowWindow -> [ShowWindow]
$cenumFromThen :: ShowWindow -> ShowWindow -> [ShowWindow]
enumFromThen :: ShowWindow -> ShowWindow -> [ShowWindow]
$cenumFromTo :: ShowWindow -> ShowWindow -> [ShowWindow]
enumFromTo :: ShowWindow -> ShowWindow -> [ShowWindow]
$cenumFromThenTo :: ShowWindow -> ShowWindow -> ShowWindow -> [ShowWindow]
enumFromThenTo :: ShowWindow -> ShowWindow -> ShowWindow -> [ShowWindow]
Enum,ShowWindow -> ShowWindow -> Bool
(ShowWindow -> ShowWindow -> Bool)
-> (ShowWindow -> ShowWindow -> Bool) -> Eq ShowWindow
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ShowWindow -> ShowWindow -> Bool
== :: ShowWindow -> ShowWindow -> Bool
$c/= :: ShowWindow -> ShowWindow -> Bool
/= :: ShowWindow -> ShowWindow -> Bool
Eq,Eq ShowWindow
Eq ShowWindow =>
(ShowWindow -> ShowWindow -> Ordering)
-> (ShowWindow -> ShowWindow -> Bool)
-> (ShowWindow -> ShowWindow -> Bool)
-> (ShowWindow -> ShowWindow -> Bool)
-> (ShowWindow -> ShowWindow -> Bool)
-> (ShowWindow -> ShowWindow -> ShowWindow)
-> (ShowWindow -> ShowWindow -> ShowWindow)
-> Ord ShowWindow
ShowWindow -> ShowWindow -> Bool
ShowWindow -> ShowWindow -> Ordering
ShowWindow -> ShowWindow -> ShowWindow
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
$ccompare :: ShowWindow -> ShowWindow -> Ordering
compare :: ShowWindow -> ShowWindow -> Ordering
$c< :: ShowWindow -> ShowWindow -> Bool
< :: ShowWindow -> ShowWindow -> Bool
$c<= :: ShowWindow -> ShowWindow -> Bool
<= :: ShowWindow -> ShowWindow -> Bool
$c> :: ShowWindow -> ShowWindow -> Bool
> :: ShowWindow -> ShowWindow -> Bool
$c>= :: ShowWindow -> ShowWindow -> Bool
>= :: ShowWindow -> ShowWindow -> Bool
$cmax :: ShowWindow -> ShowWindow -> ShowWindow
max :: ShowWindow -> ShowWindow -> ShowWindow
$cmin :: ShowWindow -> ShowWindow -> ShowWindow
min :: ShowWindow -> ShowWindow -> ShowWindow
Ord)

instance Default ShowWindow where def :: ShowWindow
def = ShowWindow
SW_SHOWDEFAULT

data HKEY
    = HKCR  | HKEY_CLASSES_ROOT
    | HKLM  | HKEY_LOCAL_MACHINE
    | HKCU  | HKEY_CURRENT_USER
    | HKU   | HKEY_USERS
    | HKCC  | HKEY_CURRENT_CONFIG
    | HKDD  | HKEY_DYN_DATA
    | HKPD  | HKEY_PERFORMANCE_DATA
    | SHCTX | SHELL_CONTEXT
     deriving (Int -> HKEY -> ShowS
[HKEY] -> ShowS
HKEY -> String
(Int -> HKEY -> ShowS)
-> (HKEY -> String) -> ([HKEY] -> ShowS) -> Show HKEY
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> HKEY -> ShowS
showsPrec :: Int -> HKEY -> ShowS
$cshow :: HKEY -> String
show :: HKEY -> String
$cshowList :: [HKEY] -> ShowS
showList :: [HKEY] -> ShowS
Show,Typeable HKEY
Typeable HKEY =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> HKEY -> c HKEY)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HKEY)
-> (HKEY -> Constr)
-> (HKEY -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HKEY))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HKEY))
-> ((forall b. Data b => b -> b) -> HKEY -> HKEY)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HKEY -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HKEY -> r)
-> (forall u. (forall d. Data d => d -> u) -> HKEY -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> HKEY -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HKEY -> m HKEY)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HKEY -> m HKEY)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HKEY -> m HKEY)
-> Data HKEY
HKEY -> Constr
HKEY -> DataType
(forall b. Data b => b -> b) -> HKEY -> HKEY
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> HKEY -> u
forall u. (forall d. Data d => d -> u) -> HKEY -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HKEY -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HKEY -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> HKEY -> m HKEY
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HKEY -> m HKEY
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HKEY
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HKEY -> c HKEY
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c HKEY)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HKEY)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HKEY -> c HKEY
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HKEY -> c HKEY
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HKEY
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HKEY
$ctoConstr :: HKEY -> Constr
toConstr :: HKEY -> Constr
$cdataTypeOf :: HKEY -> DataType
dataTypeOf :: HKEY -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c HKEY)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c HKEY)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HKEY)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HKEY)
$cgmapT :: (forall b. Data b => b -> b) -> HKEY -> HKEY
gmapT :: (forall b. Data b => b -> b) -> HKEY -> HKEY
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HKEY -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HKEY -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HKEY -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HKEY -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> HKEY -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> HKEY -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HKEY -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HKEY -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> HKEY -> m HKEY
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> HKEY -> m HKEY
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HKEY -> m HKEY
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HKEY -> m HKEY
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HKEY -> m HKEY
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HKEY -> m HKEY
Data,Typeable,ReadPrec [HKEY]
ReadPrec HKEY
Int -> ReadS HKEY
ReadS [HKEY]
(Int -> ReadS HKEY)
-> ReadS [HKEY] -> ReadPrec HKEY -> ReadPrec [HKEY] -> Read HKEY
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS HKEY
readsPrec :: Int -> ReadS HKEY
$creadList :: ReadS [HKEY]
readList :: ReadS [HKEY]
$creadPrec :: ReadPrec HKEY
readPrec :: ReadPrec HKEY
$creadListPrec :: ReadPrec [HKEY]
readListPrec :: ReadPrec [HKEY]
Read,HKEY
HKEY -> HKEY -> Bounded HKEY
forall a. a -> a -> Bounded a
$cminBound :: HKEY
minBound :: HKEY
$cmaxBound :: HKEY
maxBound :: HKEY
Bounded,Int -> HKEY
HKEY -> Int
HKEY -> [HKEY]
HKEY -> HKEY
HKEY -> HKEY -> [HKEY]
HKEY -> HKEY -> HKEY -> [HKEY]
(HKEY -> HKEY)
-> (HKEY -> HKEY)
-> (Int -> HKEY)
-> (HKEY -> Int)
-> (HKEY -> [HKEY])
-> (HKEY -> HKEY -> [HKEY])
-> (HKEY -> HKEY -> [HKEY])
-> (HKEY -> HKEY -> HKEY -> [HKEY])
-> Enum HKEY
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: HKEY -> HKEY
succ :: HKEY -> HKEY
$cpred :: HKEY -> HKEY
pred :: HKEY -> HKEY
$ctoEnum :: Int -> HKEY
toEnum :: Int -> HKEY
$cfromEnum :: HKEY -> Int
fromEnum :: HKEY -> Int
$cenumFrom :: HKEY -> [HKEY]
enumFrom :: HKEY -> [HKEY]
$cenumFromThen :: HKEY -> HKEY -> [HKEY]
enumFromThen :: HKEY -> HKEY -> [HKEY]
$cenumFromTo :: HKEY -> HKEY -> [HKEY]
enumFromTo :: HKEY -> HKEY -> [HKEY]
$cenumFromThenTo :: HKEY -> HKEY -> HKEY -> [HKEY]
enumFromThenTo :: HKEY -> HKEY -> HKEY -> [HKEY]
Enum,HKEY -> HKEY -> Bool
(HKEY -> HKEY -> Bool) -> (HKEY -> HKEY -> Bool) -> Eq HKEY
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: HKEY -> HKEY -> Bool
== :: HKEY -> HKEY -> Bool
$c/= :: HKEY -> HKEY -> Bool
/= :: HKEY -> HKEY -> Bool
Eq,Eq HKEY
Eq HKEY =>
(HKEY -> HKEY -> Ordering)
-> (HKEY -> HKEY -> Bool)
-> (HKEY -> HKEY -> Bool)
-> (HKEY -> HKEY -> Bool)
-> (HKEY -> HKEY -> Bool)
-> (HKEY -> HKEY -> HKEY)
-> (HKEY -> HKEY -> HKEY)
-> Ord HKEY
HKEY -> HKEY -> Bool
HKEY -> HKEY -> Ordering
HKEY -> HKEY -> HKEY
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
$ccompare :: HKEY -> HKEY -> Ordering
compare :: HKEY -> HKEY -> Ordering
$c< :: HKEY -> HKEY -> Bool
< :: HKEY -> HKEY -> Bool
$c<= :: HKEY -> HKEY -> Bool
<= :: HKEY -> HKEY -> Bool
$c> :: HKEY -> HKEY -> Bool
> :: HKEY -> HKEY -> Bool
$c>= :: HKEY -> HKEY -> Bool
>= :: HKEY -> HKEY -> Bool
$cmax :: HKEY -> HKEY -> HKEY
max :: HKEY -> HKEY -> HKEY
$cmin :: HKEY -> HKEY -> HKEY
min :: HKEY -> HKEY -> HKEY
Ord)

data MessageBoxType
    = MB_OK -- ^ Display with an OK button
    | MB_OKCANCEL -- ^ Display with an OK and a cancel button
    | MB_ABORTRETRYIGNORE -- ^ Display with abort, retry, ignore buttons
    | MB_RETRYCANCEL -- ^ Display with retry and cancel buttons
    | MB_YESNO -- ^ Display with yes and no buttons
    | MB_YESNOCANCEL -- ^ Display with yes, no, cancel buttons
    | MB_ICONEXCLAMATION -- ^ Display with exclamation icon
    | MB_ICONINFORMATION -- ^ Display with information icon
    | MB_ICONQUESTION -- ^ Display with question mark icon
    | MB_ICONSTOP -- ^ Display with stop icon
    | MB_USERICON -- ^ Display with installer's icon
    | MB_TOPMOST -- ^ Make messagebox topmost
    | MB_SETFOREGROUND -- ^ Set foreground
    | MB_RIGHT -- ^ Right align text
    | MB_RTLREADING -- ^ RTL reading order
    | MB_DEFBUTTON1 -- ^ Button 1 is default
    | MB_DEFBUTTON2 -- ^ Button 2 is default
    | MB_DEFBUTTON3 -- ^ Button 3 is default
    | MB_DEFBUTTON4 -- ^ Button 4 is default
     deriving (Int -> MessageBoxType -> ShowS
[MessageBoxType] -> ShowS
MessageBoxType -> String
(Int -> MessageBoxType -> ShowS)
-> (MessageBoxType -> String)
-> ([MessageBoxType] -> ShowS)
-> Show MessageBoxType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MessageBoxType -> ShowS
showsPrec :: Int -> MessageBoxType -> ShowS
$cshow :: MessageBoxType -> String
show :: MessageBoxType -> String
$cshowList :: [MessageBoxType] -> ShowS
showList :: [MessageBoxType] -> ShowS
Show,Typeable MessageBoxType
Typeable MessageBoxType =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> MessageBoxType -> c MessageBoxType)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c MessageBoxType)
-> (MessageBoxType -> Constr)
-> (MessageBoxType -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c MessageBoxType))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c MessageBoxType))
-> ((forall b. Data b => b -> b)
    -> MessageBoxType -> MessageBoxType)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> MessageBoxType -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> MessageBoxType -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> MessageBoxType -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> MessageBoxType -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> MessageBoxType -> m MessageBoxType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> MessageBoxType -> m MessageBoxType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> MessageBoxType -> m MessageBoxType)
-> Data MessageBoxType
MessageBoxType -> Constr
MessageBoxType -> DataType
(forall b. Data b => b -> b) -> MessageBoxType -> MessageBoxType
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> MessageBoxType -> u
forall u. (forall d. Data d => d -> u) -> MessageBoxType -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MessageBoxType -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MessageBoxType -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> MessageBoxType -> m MessageBoxType
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> MessageBoxType -> m MessageBoxType
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MessageBoxType
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MessageBoxType -> c MessageBoxType
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MessageBoxType)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c MessageBoxType)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MessageBoxType -> c MessageBoxType
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MessageBoxType -> c MessageBoxType
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MessageBoxType
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MessageBoxType
$ctoConstr :: MessageBoxType -> Constr
toConstr :: MessageBoxType -> Constr
$cdataTypeOf :: MessageBoxType -> DataType
dataTypeOf :: MessageBoxType -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MessageBoxType)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MessageBoxType)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c MessageBoxType)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c MessageBoxType)
$cgmapT :: (forall b. Data b => b -> b) -> MessageBoxType -> MessageBoxType
gmapT :: (forall b. Data b => b -> b) -> MessageBoxType -> MessageBoxType
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MessageBoxType -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MessageBoxType -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MessageBoxType -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MessageBoxType -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> MessageBoxType -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> MessageBoxType -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> MessageBoxType -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> MessageBoxType -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> MessageBoxType -> m MessageBoxType
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> MessageBoxType -> m MessageBoxType
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> MessageBoxType -> m MessageBoxType
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> MessageBoxType -> m MessageBoxType
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> MessageBoxType -> m MessageBoxType
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> MessageBoxType -> m MessageBoxType
Data,Typeable,ReadPrec [MessageBoxType]
ReadPrec MessageBoxType
Int -> ReadS MessageBoxType
ReadS [MessageBoxType]
(Int -> ReadS MessageBoxType)
-> ReadS [MessageBoxType]
-> ReadPrec MessageBoxType
-> ReadPrec [MessageBoxType]
-> Read MessageBoxType
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS MessageBoxType
readsPrec :: Int -> ReadS MessageBoxType
$creadList :: ReadS [MessageBoxType]
readList :: ReadS [MessageBoxType]
$creadPrec :: ReadPrec MessageBoxType
readPrec :: ReadPrec MessageBoxType
$creadListPrec :: ReadPrec [MessageBoxType]
readListPrec :: ReadPrec [MessageBoxType]
Read,MessageBoxType
MessageBoxType -> MessageBoxType -> Bounded MessageBoxType
forall a. a -> a -> Bounded a
$cminBound :: MessageBoxType
minBound :: MessageBoxType
$cmaxBound :: MessageBoxType
maxBound :: MessageBoxType
Bounded,Int -> MessageBoxType
MessageBoxType -> Int
MessageBoxType -> [MessageBoxType]
MessageBoxType -> MessageBoxType
MessageBoxType -> MessageBoxType -> [MessageBoxType]
MessageBoxType
-> MessageBoxType -> MessageBoxType -> [MessageBoxType]
(MessageBoxType -> MessageBoxType)
-> (MessageBoxType -> MessageBoxType)
-> (Int -> MessageBoxType)
-> (MessageBoxType -> Int)
-> (MessageBoxType -> [MessageBoxType])
-> (MessageBoxType -> MessageBoxType -> [MessageBoxType])
-> (MessageBoxType -> MessageBoxType -> [MessageBoxType])
-> (MessageBoxType
    -> MessageBoxType -> MessageBoxType -> [MessageBoxType])
-> Enum MessageBoxType
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: MessageBoxType -> MessageBoxType
succ :: MessageBoxType -> MessageBoxType
$cpred :: MessageBoxType -> MessageBoxType
pred :: MessageBoxType -> MessageBoxType
$ctoEnum :: Int -> MessageBoxType
toEnum :: Int -> MessageBoxType
$cfromEnum :: MessageBoxType -> Int
fromEnum :: MessageBoxType -> Int
$cenumFrom :: MessageBoxType -> [MessageBoxType]
enumFrom :: MessageBoxType -> [MessageBoxType]
$cenumFromThen :: MessageBoxType -> MessageBoxType -> [MessageBoxType]
enumFromThen :: MessageBoxType -> MessageBoxType -> [MessageBoxType]
$cenumFromTo :: MessageBoxType -> MessageBoxType -> [MessageBoxType]
enumFromTo :: MessageBoxType -> MessageBoxType -> [MessageBoxType]
$cenumFromThenTo :: MessageBoxType
-> MessageBoxType -> MessageBoxType -> [MessageBoxType]
enumFromThenTo :: MessageBoxType
-> MessageBoxType -> MessageBoxType -> [MessageBoxType]
Enum,MessageBoxType -> MessageBoxType -> Bool
(MessageBoxType -> MessageBoxType -> Bool)
-> (MessageBoxType -> MessageBoxType -> Bool) -> Eq MessageBoxType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MessageBoxType -> MessageBoxType -> Bool
== :: MessageBoxType -> MessageBoxType -> Bool
$c/= :: MessageBoxType -> MessageBoxType -> Bool
/= :: MessageBoxType -> MessageBoxType -> Bool
Eq,Eq MessageBoxType
Eq MessageBoxType =>
(MessageBoxType -> MessageBoxType -> Ordering)
-> (MessageBoxType -> MessageBoxType -> Bool)
-> (MessageBoxType -> MessageBoxType -> Bool)
-> (MessageBoxType -> MessageBoxType -> Bool)
-> (MessageBoxType -> MessageBoxType -> Bool)
-> (MessageBoxType -> MessageBoxType -> MessageBoxType)
-> (MessageBoxType -> MessageBoxType -> MessageBoxType)
-> Ord MessageBoxType
MessageBoxType -> MessageBoxType -> Bool
MessageBoxType -> MessageBoxType -> Ordering
MessageBoxType -> MessageBoxType -> MessageBoxType
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
$ccompare :: MessageBoxType -> MessageBoxType -> Ordering
compare :: MessageBoxType -> MessageBoxType -> Ordering
$c< :: MessageBoxType -> MessageBoxType -> Bool
< :: MessageBoxType -> MessageBoxType -> Bool
$c<= :: MessageBoxType -> MessageBoxType -> Bool
<= :: MessageBoxType -> MessageBoxType -> Bool
$c> :: MessageBoxType -> MessageBoxType -> Bool
> :: MessageBoxType -> MessageBoxType -> Bool
$c>= :: MessageBoxType -> MessageBoxType -> Bool
>= :: MessageBoxType -> MessageBoxType -> Bool
$cmax :: MessageBoxType -> MessageBoxType -> MessageBoxType
max :: MessageBoxType -> MessageBoxType -> MessageBoxType
$cmin :: MessageBoxType -> MessageBoxType -> MessageBoxType
min :: MessageBoxType -> MessageBoxType -> MessageBoxType
Ord)
instance Default MessageBoxType where def :: MessageBoxType
def = MessageBoxType
MB_ICONINFORMATION


data Page
    = Welcome
    | License FilePath
    | Components
    | Directory
    | InstFiles
    | Confirm
    | Finish FinishOptions
     deriving (Int -> Page -> ShowS
[Page] -> ShowS
Page -> String
(Int -> Page -> ShowS)
-> (Page -> String) -> ([Page] -> ShowS) -> Show Page
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Page -> ShowS
showsPrec :: Int -> Page -> ShowS
$cshow :: Page -> String
show :: Page -> String
$cshowList :: [Page] -> ShowS
showList :: [Page] -> ShowS
Show,Typeable Page
Typeable Page =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Page -> c Page)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Page)
-> (Page -> Constr)
-> (Page -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Page))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Page))
-> ((forall b. Data b => b -> b) -> Page -> Page)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Page -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Page -> r)
-> (forall u. (forall d. Data d => d -> u) -> Page -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Page -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Page -> m Page)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Page -> m Page)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Page -> m Page)
-> Data Page
Page -> Constr
Page -> DataType
(forall b. Data b => b -> b) -> Page -> Page
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Page -> u
forall u. (forall d. Data d => d -> u) -> Page -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Page -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Page -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Page -> m Page
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Page -> m Page
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Page
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Page -> c Page
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Page)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Page)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Page -> c Page
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Page -> c Page
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Page
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Page
$ctoConstr :: Page -> Constr
toConstr :: Page -> Constr
$cdataTypeOf :: Page -> DataType
dataTypeOf :: Page -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Page)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Page)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Page)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Page)
$cgmapT :: (forall b. Data b => b -> b) -> Page -> Page
gmapT :: (forall b. Data b => b -> b) -> Page -> Page
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Page -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Page -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Page -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Page -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Page -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Page -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Page -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Page -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Page -> m Page
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Page -> m Page
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Page -> m Page
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Page -> m Page
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Page -> m Page
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Page -> m Page
Data,Typeable,Page -> Page -> Bool
(Page -> Page -> Bool) -> (Page -> Page -> Bool) -> Eq Page
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Page -> Page -> Bool
== :: Page -> Page -> Bool
$c/= :: Page -> Page -> Bool
/= :: Page -> Page -> Bool
Eq)

data FinishOptions = FinishOptions
    {FinishOptions -> String
finRun :: String
    ,FinishOptions -> String
finRunText :: String
    ,FinishOptions -> String
finRunParamters :: String
    ,FinishOptions -> Bool
finRunChecked :: Bool
    ,FinishOptions -> String
finReadme :: String
    ,FinishOptions -> String
finReadmeText :: String
    ,FinishOptions -> Bool
finReadmeChecked :: Bool
    ,FinishOptions -> String
finLink :: String
    ,FinishOptions -> String
finLinkText :: String
    } deriving (Typeable FinishOptions
Typeable FinishOptions =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> FinishOptions -> c FinishOptions)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c FinishOptions)
-> (FinishOptions -> Constr)
-> (FinishOptions -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c FinishOptions))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c FinishOptions))
-> ((forall b. Data b => b -> b) -> FinishOptions -> FinishOptions)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FinishOptions -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FinishOptions -> r)
-> (forall u. (forall d. Data d => d -> u) -> FinishOptions -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> FinishOptions -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> FinishOptions -> m FinishOptions)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FinishOptions -> m FinishOptions)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FinishOptions -> m FinishOptions)
-> Data FinishOptions
FinishOptions -> Constr
FinishOptions -> DataType
(forall b. Data b => b -> b) -> FinishOptions -> FinishOptions
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> FinishOptions -> u
forall u. (forall d. Data d => d -> u) -> FinishOptions -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FinishOptions -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FinishOptions -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FinishOptions -> m FinishOptions
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FinishOptions -> m FinishOptions
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FinishOptions
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FinishOptions -> c FinishOptions
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FinishOptions)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c FinishOptions)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FinishOptions -> c FinishOptions
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FinishOptions -> c FinishOptions
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FinishOptions
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FinishOptions
$ctoConstr :: FinishOptions -> Constr
toConstr :: FinishOptions -> Constr
$cdataTypeOf :: FinishOptions -> DataType
dataTypeOf :: FinishOptions -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FinishOptions)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FinishOptions)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c FinishOptions)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c FinishOptions)
$cgmapT :: (forall b. Data b => b -> b) -> FinishOptions -> FinishOptions
gmapT :: (forall b. Data b => b -> b) -> FinishOptions -> FinishOptions
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FinishOptions -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FinishOptions -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FinishOptions -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FinishOptions -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> FinishOptions -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> FinishOptions -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> FinishOptions -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> FinishOptions -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FinishOptions -> m FinishOptions
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FinishOptions -> m FinishOptions
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FinishOptions -> m FinishOptions
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FinishOptions -> m FinishOptions
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FinishOptions -> m FinishOptions
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FinishOptions -> m FinishOptions
Data,Typeable,Int -> FinishOptions -> ShowS
[FinishOptions] -> ShowS
FinishOptions -> String
(Int -> FinishOptions -> ShowS)
-> (FinishOptions -> String)
-> ([FinishOptions] -> ShowS)
-> Show FinishOptions
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> FinishOptions -> ShowS
showsPrec :: Int -> FinishOptions -> ShowS
$cshow :: FinishOptions -> String
show :: FinishOptions -> String
$cshowList :: [FinishOptions] -> ShowS
showList :: [FinishOptions] -> ShowS
Show,FinishOptions -> FinishOptions -> Bool
(FinishOptions -> FinishOptions -> Bool)
-> (FinishOptions -> FinishOptions -> Bool) -> Eq FinishOptions
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FinishOptions -> FinishOptions -> Bool
== :: FinishOptions -> FinishOptions -> Bool
$c/= :: FinishOptions -> FinishOptions -> Bool
/= :: FinishOptions -> FinishOptions -> Bool
Eq)

instance Default FinishOptions where def :: FinishOptions
def = String
-> String
-> String
-> Bool
-> String
-> String
-> Bool
-> String
-> String
-> FinishOptions
FinishOptions String
"" String
"" String
"" Bool
True String
"" String
"" Bool
True String
"" String
""


showPageCtor :: Page -> String
showPageCtor :: Page -> String
showPageCtor (License String
_) = String
"License"
showPageCtor (Finish FinishOptions
_) = String
"Finish"
showPageCtor Page
x = Page -> String
forall a. Show a => a -> String
show Page
x

data Level = None | User | Highest | Admin
     deriving (Int -> Level -> ShowS
[Level] -> ShowS
Level -> String
(Int -> Level -> ShowS)
-> (Level -> String) -> ([Level] -> ShowS) -> Show Level
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Level -> ShowS
showsPrec :: Int -> Level -> ShowS
$cshow :: Level -> String
show :: Level -> String
$cshowList :: [Level] -> ShowS
showList :: [Level] -> ShowS
Show,Typeable Level
Typeable Level =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Level -> c Level)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Level)
-> (Level -> Constr)
-> (Level -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Level))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Level))
-> ((forall b. Data b => b -> b) -> Level -> Level)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Level -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Level -> r)
-> (forall u. (forall d. Data d => d -> u) -> Level -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Level -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Level -> m Level)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Level -> m Level)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Level -> m Level)
-> Data Level
Level -> Constr
Level -> DataType
(forall b. Data b => b -> b) -> Level -> Level
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Level -> u
forall u. (forall d. Data d => d -> u) -> Level -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Level -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Level -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Level -> m Level
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Level -> m Level
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Level
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Level -> c Level
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Level)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Level)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Level -> c Level
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Level -> c Level
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Level
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Level
$ctoConstr :: Level -> Constr
toConstr :: Level -> Constr
$cdataTypeOf :: Level -> DataType
dataTypeOf :: Level -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Level)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Level)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Level)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Level)
$cgmapT :: (forall b. Data b => b -> b) -> Level -> Level
gmapT :: (forall b. Data b => b -> b) -> Level -> Level
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Level -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Level -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Level -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Level -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Level -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Level -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Level -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Level -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Level -> m Level
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Level -> m Level
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Level -> m Level
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Level -> m Level
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Level -> m Level
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Level -> m Level
Data,Typeable,ReadPrec [Level]
ReadPrec Level
Int -> ReadS Level
ReadS [Level]
(Int -> ReadS Level)
-> ReadS [Level]
-> ReadPrec Level
-> ReadPrec [Level]
-> Read Level
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Level
readsPrec :: Int -> ReadS Level
$creadList :: ReadS [Level]
readList :: ReadS [Level]
$creadPrec :: ReadPrec Level
readPrec :: ReadPrec Level
$creadListPrec :: ReadPrec [Level]
readListPrec :: ReadPrec [Level]
Read,Level
Level -> Level -> Bounded Level
forall a. a -> a -> Bounded a
$cminBound :: Level
minBound :: Level
$cmaxBound :: Level
maxBound :: Level
Bounded,Int -> Level
Level -> Int
Level -> [Level]
Level -> Level
Level -> Level -> [Level]
Level -> Level -> Level -> [Level]
(Level -> Level)
-> (Level -> Level)
-> (Int -> Level)
-> (Level -> Int)
-> (Level -> [Level])
-> (Level -> Level -> [Level])
-> (Level -> Level -> [Level])
-> (Level -> Level -> Level -> [Level])
-> Enum Level
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: Level -> Level
succ :: Level -> Level
$cpred :: Level -> Level
pred :: Level -> Level
$ctoEnum :: Int -> Level
toEnum :: Int -> Level
$cfromEnum :: Level -> Int
fromEnum :: Level -> Int
$cenumFrom :: Level -> [Level]
enumFrom :: Level -> [Level]
$cenumFromThen :: Level -> Level -> [Level]
enumFromThen :: Level -> Level -> [Level]
$cenumFromTo :: Level -> Level -> [Level]
enumFromTo :: Level -> Level -> [Level]
$cenumFromThenTo :: Level -> Level -> Level -> [Level]
enumFromThenTo :: Level -> Level -> Level -> [Level]
Enum,Level -> Level -> Bool
(Level -> Level -> Bool) -> (Level -> Level -> Bool) -> Eq Level
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Level -> Level -> Bool
== :: Level -> Level -> Bool
$c/= :: Level -> Level -> Bool
/= :: Level -> Level -> Bool
Eq,Eq Level
Eq Level =>
(Level -> Level -> Ordering)
-> (Level -> Level -> Bool)
-> (Level -> Level -> Bool)
-> (Level -> Level -> Bool)
-> (Level -> Level -> Bool)
-> (Level -> Level -> Level)
-> (Level -> Level -> Level)
-> Ord Level
Level -> Level -> Bool
Level -> Level -> Ordering
Level -> Level -> Level
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
$ccompare :: Level -> Level -> Ordering
compare :: Level -> Level -> Ordering
$c< :: Level -> Level -> Bool
< :: Level -> Level -> Bool
$c<= :: Level -> Level -> Bool
<= :: Level -> Level -> Bool
$c> :: Level -> Level -> Bool
> :: Level -> Level -> Bool
$c>= :: Level -> Level -> Bool
>= :: Level -> Level -> Bool
$cmax :: Level -> Level -> Level
max :: Level -> Level -> Level
$cmin :: Level -> Level -> Level
min :: Level -> Level -> Level
Ord)

data Target = AMD64Unicode | X86ANSI | X86Unicode
     deriving (Typeable Target
Typeable Target =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Target -> c Target)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Target)
-> (Target -> Constr)
-> (Target -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Target))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Target))
-> ((forall b. Data b => b -> b) -> Target -> Target)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Target -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Target -> r)
-> (forall u. (forall d. Data d => d -> u) -> Target -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Target -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Target -> m Target)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Target -> m Target)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Target -> m Target)
-> Data Target
Target -> Constr
Target -> DataType
(forall b. Data b => b -> b) -> Target -> Target
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Target -> u
forall u. (forall d. Data d => d -> u) -> Target -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Target -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Target -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Target -> m Target
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Target -> m Target
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Target
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Target -> c Target
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Target)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Target)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Target -> c Target
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Target -> c Target
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Target
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Target
$ctoConstr :: Target -> Constr
toConstr :: Target -> Constr
$cdataTypeOf :: Target -> DataType
dataTypeOf :: Target -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Target)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Target)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Target)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Target)
$cgmapT :: (forall b. Data b => b -> b) -> Target -> Target
gmapT :: (forall b. Data b => b -> b) -> Target -> Target
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Target -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Target -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Target -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Target -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Target -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Target -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Target -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Target -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Target -> m Target
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Target -> m Target
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Target -> m Target
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Target -> m Target
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Target -> m Target
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Target -> m Target
Data,Typeable,ReadPrec [Target]
ReadPrec Target
Int -> ReadS Target
ReadS [Target]
(Int -> ReadS Target)
-> ReadS [Target]
-> ReadPrec Target
-> ReadPrec [Target]
-> Read Target
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Target
readsPrec :: Int -> ReadS Target
$creadList :: ReadS [Target]
readList :: ReadS [Target]
$creadPrec :: ReadPrec Target
readPrec :: ReadPrec Target
$creadListPrec :: ReadPrec [Target]
readListPrec :: ReadPrec [Target]
Read,Target
Target -> Target -> Bounded Target
forall a. a -> a -> Bounded a
$cminBound :: Target
minBound :: Target
$cmaxBound :: Target
maxBound :: Target
Bounded,Int -> Target
Target -> Int
Target -> [Target]
Target -> Target
Target -> Target -> [Target]
Target -> Target -> Target -> [Target]
(Target -> Target)
-> (Target -> Target)
-> (Int -> Target)
-> (Target -> Int)
-> (Target -> [Target])
-> (Target -> Target -> [Target])
-> (Target -> Target -> [Target])
-> (Target -> Target -> Target -> [Target])
-> Enum Target
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: Target -> Target
succ :: Target -> Target
$cpred :: Target -> Target
pred :: Target -> Target
$ctoEnum :: Int -> Target
toEnum :: Int -> Target
$cfromEnum :: Target -> Int
fromEnum :: Target -> Int
$cenumFrom :: Target -> [Target]
enumFrom :: Target -> [Target]
$cenumFromThen :: Target -> Target -> [Target]
enumFromThen :: Target -> Target -> [Target]
$cenumFromTo :: Target -> Target -> [Target]
enumFromTo :: Target -> Target -> [Target]
$cenumFromThenTo :: Target -> Target -> Target -> [Target]
enumFromThenTo :: Target -> Target -> Target -> [Target]
Enum,Target -> Target -> Bool
(Target -> Target -> Bool)
-> (Target -> Target -> Bool) -> Eq Target
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Target -> Target -> Bool
== :: Target -> Target -> Bool
$c/= :: Target -> Target -> Bool
/= :: Target -> Target -> Bool
Eq,Eq Target
Eq Target =>
(Target -> Target -> Ordering)
-> (Target -> Target -> Bool)
-> (Target -> Target -> Bool)
-> (Target -> Target -> Bool)
-> (Target -> Target -> Bool)
-> (Target -> Target -> Target)
-> (Target -> Target -> Target)
-> Ord Target
Target -> Target -> Bool
Target -> Target -> Ordering
Target -> Target -> Target
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
$ccompare :: Target -> Target -> Ordering
compare :: Target -> Target -> Ordering
$c< :: Target -> Target -> Bool
< :: Target -> Target -> Bool
$c<= :: Target -> Target -> Bool
<= :: Target -> Target -> Bool
$c> :: Target -> Target -> Bool
> :: Target -> Target -> Bool
$c>= :: Target -> Target -> Bool
>= :: Target -> Target -> Bool
$cmax :: Target -> Target -> Target
max :: Target -> Target -> Target
$cmin :: Target -> Target -> Target
min :: Target -> Target -> Target
Ord)

instance Show Target where
    show :: Target -> String
show Target
AMD64Unicode = String
"amd64-unicode"
    show Target
X86ANSI = String
"x86-ansi"
    show Target
X86Unicode = String
"x86-unicode"

data Visibility = Hide | Show | NeverShow
     deriving (Int -> Visibility -> ShowS
[Visibility] -> ShowS
Visibility -> String
(Int -> Visibility -> ShowS)
-> (Visibility -> String)
-> ([Visibility] -> ShowS)
-> Show Visibility
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Visibility -> ShowS
showsPrec :: Int -> Visibility -> ShowS
$cshow :: Visibility -> String
show :: Visibility -> String
$cshowList :: [Visibility] -> ShowS
showList :: [Visibility] -> ShowS
Show,Typeable Visibility
Typeable Visibility =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Visibility -> c Visibility)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Visibility)
-> (Visibility -> Constr)
-> (Visibility -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Visibility))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c Visibility))
-> ((forall b. Data b => b -> b) -> Visibility -> Visibility)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Visibility -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Visibility -> r)
-> (forall u. (forall d. Data d => d -> u) -> Visibility -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Visibility -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Visibility -> m Visibility)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Visibility -> m Visibility)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Visibility -> m Visibility)
-> Data Visibility
Visibility -> Constr
Visibility -> DataType
(forall b. Data b => b -> b) -> Visibility -> Visibility
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Visibility -> u
forall u. (forall d. Data d => d -> u) -> Visibility -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Visibility -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Visibility -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Visibility -> m Visibility
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Visibility -> m Visibility
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Visibility
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Visibility -> c Visibility
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Visibility)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Visibility)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Visibility -> c Visibility
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Visibility -> c Visibility
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Visibility
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Visibility
$ctoConstr :: Visibility -> Constr
toConstr :: Visibility -> Constr
$cdataTypeOf :: Visibility -> DataType
dataTypeOf :: Visibility -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Visibility)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Visibility)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Visibility)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Visibility)
$cgmapT :: (forall b. Data b => b -> b) -> Visibility -> Visibility
gmapT :: (forall b. Data b => b -> b) -> Visibility -> Visibility
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Visibility -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Visibility -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Visibility -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Visibility -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Visibility -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Visibility -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Visibility -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Visibility -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Visibility -> m Visibility
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Visibility -> m Visibility
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Visibility -> m Visibility
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Visibility -> m Visibility
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Visibility -> m Visibility
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Visibility -> m Visibility
Data,Typeable,ReadPrec [Visibility]
ReadPrec Visibility
Int -> ReadS Visibility
ReadS [Visibility]
(Int -> ReadS Visibility)
-> ReadS [Visibility]
-> ReadPrec Visibility
-> ReadPrec [Visibility]
-> Read Visibility
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Visibility
readsPrec :: Int -> ReadS Visibility
$creadList :: ReadS [Visibility]
readList :: ReadS [Visibility]
$creadPrec :: ReadPrec Visibility
readPrec :: ReadPrec Visibility
$creadListPrec :: ReadPrec [Visibility]
readListPrec :: ReadPrec [Visibility]
Read,Visibility
Visibility -> Visibility -> Bounded Visibility
forall a. a -> a -> Bounded a
$cminBound :: Visibility
minBound :: Visibility
$cmaxBound :: Visibility
maxBound :: Visibility
Bounded,Int -> Visibility
Visibility -> Int
Visibility -> [Visibility]
Visibility -> Visibility
Visibility -> Visibility -> [Visibility]
Visibility -> Visibility -> Visibility -> [Visibility]
(Visibility -> Visibility)
-> (Visibility -> Visibility)
-> (Int -> Visibility)
-> (Visibility -> Int)
-> (Visibility -> [Visibility])
-> (Visibility -> Visibility -> [Visibility])
-> (Visibility -> Visibility -> [Visibility])
-> (Visibility -> Visibility -> Visibility -> [Visibility])
-> Enum Visibility
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: Visibility -> Visibility
succ :: Visibility -> Visibility
$cpred :: Visibility -> Visibility
pred :: Visibility -> Visibility
$ctoEnum :: Int -> Visibility
toEnum :: Int -> Visibility
$cfromEnum :: Visibility -> Int
fromEnum :: Visibility -> Int
$cenumFrom :: Visibility -> [Visibility]
enumFrom :: Visibility -> [Visibility]
$cenumFromThen :: Visibility -> Visibility -> [Visibility]
enumFromThen :: Visibility -> Visibility -> [Visibility]
$cenumFromTo :: Visibility -> Visibility -> [Visibility]
enumFromTo :: Visibility -> Visibility -> [Visibility]
$cenumFromThenTo :: Visibility -> Visibility -> Visibility -> [Visibility]
enumFromThenTo :: Visibility -> Visibility -> Visibility -> [Visibility]
Enum,Visibility -> Visibility -> Bool
(Visibility -> Visibility -> Bool)
-> (Visibility -> Visibility -> Bool) -> Eq Visibility
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Visibility -> Visibility -> Bool
== :: Visibility -> Visibility -> Bool
$c/= :: Visibility -> Visibility -> Bool
/= :: Visibility -> Visibility -> Bool
Eq,Eq Visibility
Eq Visibility =>
(Visibility -> Visibility -> Ordering)
-> (Visibility -> Visibility -> Bool)
-> (Visibility -> Visibility -> Bool)
-> (Visibility -> Visibility -> Bool)
-> (Visibility -> Visibility -> Bool)
-> (Visibility -> Visibility -> Visibility)
-> (Visibility -> Visibility -> Visibility)
-> Ord Visibility
Visibility -> Visibility -> Bool
Visibility -> Visibility -> Ordering
Visibility -> Visibility -> Visibility
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
$ccompare :: Visibility -> Visibility -> Ordering
compare :: Visibility -> Visibility -> Ordering
$c< :: Visibility -> Visibility -> Bool
< :: Visibility -> Visibility -> Bool
$c<= :: Visibility -> Visibility -> Bool
<= :: Visibility -> Visibility -> Bool
$c> :: Visibility -> Visibility -> Bool
> :: Visibility -> Visibility -> Bool
$c>= :: Visibility -> Visibility -> Bool
>= :: Visibility -> Visibility -> Bool
$cmax :: Visibility -> Visibility -> Visibility
max :: Visibility -> Visibility -> Visibility
$cmin :: Visibility -> Visibility -> Visibility
min :: Visibility -> Visibility -> Visibility
Ord)