{-# LANGUAGE CPP, DeriveDataTypeable,
DeriveGeneric, FlexibleInstances, DefaultSignatures,
RankNTypes, RoleAnnotations, ScopedTypeVariables,
MagicHash, KindSignatures, PolyKinds, TypeApplications, DataKinds,
GADTs, UnboxedTuples, UnboxedSums, TypeInType,
Trustworthy #-}
{-# OPTIONS_GHC -fno-warn-inline-rule-shadowing #-}
module Language.Haskell.TH.Syntax
( module Language.Haskell.TH.Syntax
, module Language.Haskell.TH.LanguageExtensions
, ForeignSrcLang(..)
) where
import Data.Data hiding (Fixity(..))
import Data.IORef
import System.IO.Unsafe ( unsafePerformIO )
import Control.Monad (liftM)
import Control.Monad.IO.Class (MonadIO (..))
import System.IO ( hPutStrLn, stderr )
import Data.Char ( isAlpha, isAlphaNum, isUpper, ord )
import Data.Int
import Data.List.NonEmpty ( NonEmpty(..) )
import Data.Void ( Void, absurd )
import Data.Word
import Data.Ratio
import GHC.CString ( unpackCString# )
import GHC.Generics ( Generic )
import GHC.Types ( Int(..), Word(..), Char(..), Double(..), Float(..),
TYPE, RuntimeRep(..) )
import GHC.Prim ( Int#, Word#, Char#, Double#, Float#, Addr# )
import GHC.Lexeme ( startsVarSym, startsVarId )
import GHC.ForeignSrcLang.Type
import Language.Haskell.TH.LanguageExtensions
import Numeric.Natural
import Prelude
import Foreign.ForeignPtr
import qualified Control.Monad.Fail as Fail
class (MonadIO m, Fail.MonadFail m) => Quasi m where
qNewName :: String -> m Name
qReport :: Bool -> String -> m ()
qRecover :: m a
-> m a
-> m a
qLookupName :: Bool -> String -> m (Maybe Name)
qReify :: Name -> m Info
qReifyFixity :: Name -> m (Maybe Fixity)
qReifyType :: Name -> m Type
qReifyInstances :: Name -> [Type] -> m [Dec]
qReifyRoles :: Name -> m [Role]
qReifyAnnotations :: Data a => AnnLookup -> m [a]
qReifyModule :: Module -> m ModuleInfo
qReifyConStrictness :: Name -> m [DecidedStrictness]
qLocation :: m Loc
qRunIO :: IO a -> m a
qRunIO = IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO
qAddDependentFile :: FilePath -> m ()
qAddTempFile :: String -> m FilePath
qAddTopDecls :: [Dec] -> m ()
qAddForeignFilePath :: ForeignSrcLang -> String -> m ()
qAddModFinalizer :: Q () -> m ()
qAddCorePlugin :: String -> m ()
qGetQ :: Typeable a => m (Maybe a)
qPutQ :: Typeable a => a -> m ()
qIsExtEnabled :: Extension -> m Bool
qExtsEnabled :: m [Extension]
instance Quasi IO where
qNewName :: String -> IO Name
qNewName String
s = do { Uniq
n <- IORef Uniq -> (Uniq -> (Uniq, Uniq)) -> IO Uniq
forall a b. IORef a -> (a -> (a, b)) -> IO b
atomicModifyIORef' IORef Uniq
counter (\Uniq
x -> (Uniq
x Uniq -> Uniq -> Uniq
forall a. Num a => a -> a -> a
+ Uniq
1, Uniq
x))
; Name -> IO Name
forall (f :: * -> *) a. Applicative f => a -> f a
pure (String -> Uniq -> Name
mkNameU String
s Uniq
n) }
qReport :: Bool -> String -> IO ()
qReport Bool
True String
msg = Handle -> String -> IO ()
hPutStrLn Handle
stderr (String
"Template Haskell error: " String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
msg)
qReport Bool
False String
msg = Handle -> String -> IO ()
hPutStrLn Handle
stderr (String
"Template Haskell error: " String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
msg)
qLookupName :: Bool -> String -> IO (Maybe Name)
qLookupName Bool
_ String
_ = String -> IO (Maybe Name)
forall a. String -> IO a
badIO String
"lookupName"
qReify :: Name -> IO Info
qReify Name
_ = String -> IO Info
forall a. String -> IO a
badIO String
"reify"
qReifyFixity :: Name -> IO (Maybe Fixity)
qReifyFixity Name
_ = String -> IO (Maybe Fixity)
forall a. String -> IO a
badIO String
"reifyFixity"
qReifyType :: Name -> IO Type
qReifyType Name
_ = String -> IO Type
forall a. String -> IO a
badIO String
"reifyFixity"
qReifyInstances :: Name -> [Type] -> IO [Dec]
qReifyInstances Name
_ [Type]
_ = String -> IO [Dec]
forall a. String -> IO a
badIO String
"reifyInstances"
qReifyRoles :: Name -> IO [Role]
qReifyRoles Name
_ = String -> IO [Role]
forall a. String -> IO a
badIO String
"reifyRoles"
qReifyAnnotations :: AnnLookup -> IO [a]
qReifyAnnotations AnnLookup
_ = String -> IO [a]
forall a. String -> IO a
badIO String
"reifyAnnotations"
qReifyModule :: Module -> IO ModuleInfo
qReifyModule Module
_ = String -> IO ModuleInfo
forall a. String -> IO a
badIO String
"reifyModule"
qReifyConStrictness :: Name -> IO [DecidedStrictness]
qReifyConStrictness Name
_ = String -> IO [DecidedStrictness]
forall a. String -> IO a
badIO String
"reifyConStrictness"
qLocation :: IO Loc
qLocation = String -> IO Loc
forall a. String -> IO a
badIO String
"currentLocation"
qRecover :: IO a -> IO a -> IO a
qRecover IO a
_ IO a
_ = String -> IO a
forall a. String -> IO a
badIO String
"recover"
qAddDependentFile :: String -> IO ()
qAddDependentFile String
_ = String -> IO ()
forall a. String -> IO a
badIO String
"addDependentFile"
qAddTempFile :: String -> IO String
qAddTempFile String
_ = String -> IO String
forall a. String -> IO a
badIO String
"addTempFile"
qAddTopDecls :: [Dec] -> IO ()
qAddTopDecls [Dec]
_ = String -> IO ()
forall a. String -> IO a
badIO String
"addTopDecls"
qAddForeignFilePath :: ForeignSrcLang -> String -> IO ()
qAddForeignFilePath ForeignSrcLang
_ String
_ = String -> IO ()
forall a. String -> IO a
badIO String
"addForeignFilePath"
qAddModFinalizer :: Q () -> IO ()
qAddModFinalizer Q ()
_ = String -> IO ()
forall a. String -> IO a
badIO String
"addModFinalizer"
qAddCorePlugin :: String -> IO ()
qAddCorePlugin String
_ = String -> IO ()
forall a. String -> IO a
badIO String
"addCorePlugin"
qGetQ :: IO (Maybe a)
qGetQ = String -> IO (Maybe a)
forall a. String -> IO a
badIO String
"getQ"
qPutQ :: a -> IO ()
qPutQ a
_ = String -> IO ()
forall a. String -> IO a
badIO String
"putQ"
qIsExtEnabled :: Extension -> IO Bool
qIsExtEnabled Extension
_ = String -> IO Bool
forall a. String -> IO a
badIO String
"isExtEnabled"
qExtsEnabled :: IO [Extension]
qExtsEnabled = String -> IO [Extension]
forall a. String -> IO a
badIO String
"extsEnabled"
badIO :: String -> IO a
badIO :: String -> IO a
badIO String
op = do { Bool -> String -> IO ()
forall (m :: * -> *). Quasi m => Bool -> String -> m ()
qReport Bool
True (String
"Can't do `" String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
op String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"' in the IO monad")
; String -> IO a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"Template Haskell failure" }
counter :: IORef Uniq
{-# NOINLINE counter #-}
counter :: IORef Uniq
counter = IO (IORef Uniq) -> IORef Uniq
forall a. IO a -> a
unsafePerformIO (Uniq -> IO (IORef Uniq)
forall a. a -> IO (IORef a)
newIORef Uniq
0)
newtype Q a = Q { Q a -> forall (m :: * -> *). Quasi m => m a
unQ :: forall m. Quasi m => m a }
runQ :: Quasi m => Q a -> m a
runQ :: Q a -> m a
runQ (Q forall (m :: * -> *). Quasi m => m a
m) = m a
forall (m :: * -> *). Quasi m => m a
m
instance Monad Q where
Q forall (m :: * -> *). Quasi m => m a
m >>= :: Q a -> (a -> Q b) -> Q b
>>= a -> Q b
k = (forall (m :: * -> *). Quasi m => m b) -> Q b
forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
Q (m a
forall (m :: * -> *). Quasi m => m a
m m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \a
x -> Q b -> forall (m :: * -> *). Quasi m => m b
forall a. Q a -> forall (m :: * -> *). Quasi m => m a
unQ (a -> Q b
k a
x))
>> :: Q a -> Q b -> Q b
(>>) = Q a -> Q b -> Q b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
(*>)
#if !MIN_VERSION_base(4,13,0)
fail = Fail.fail
#endif
instance Fail.MonadFail Q where
fail :: String -> Q a
fail String
s = Bool -> String -> Q ()
report Bool
True String
s Q () -> Q a -> Q a
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (forall (m :: * -> *). Quasi m => m a) -> Q a
forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
Q (String -> m a
forall (m :: * -> *) a. MonadFail m => String -> m a
Fail.fail String
"Q monad failure")
instance Functor Q where
fmap :: (a -> b) -> Q a -> Q b
fmap a -> b
f (Q forall (m :: * -> *). Quasi m => m a
x) = (forall (m :: * -> *). Quasi m => m b) -> Q b
forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
Q ((a -> b) -> m a -> m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f m a
forall (m :: * -> *). Quasi m => m a
x)
instance Applicative Q where
pure :: a -> Q a
pure a
x = (forall (m :: * -> *). Quasi m => m a) -> Q a
forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
Q (a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure a
x)
Q forall (m :: * -> *). Quasi m => m (a -> b)
f <*> :: Q (a -> b) -> Q a -> Q b
<*> Q forall (m :: * -> *). Quasi m => m a
x = (forall (m :: * -> *). Quasi m => m b) -> Q b
forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
Q (m (a -> b)
forall (m :: * -> *). Quasi m => m (a -> b)
f m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m a
forall (m :: * -> *). Quasi m => m a
x)
Q forall (m :: * -> *). Quasi m => m a
m *> :: Q a -> Q b -> Q b
*> Q forall (m :: * -> *). Quasi m => m b
n = (forall (m :: * -> *). Quasi m => m b) -> Q b
forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
Q (m a
forall (m :: * -> *). Quasi m => m a
m m a -> m b -> m b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> m b
forall (m :: * -> *). Quasi m => m b
n)
type role TExp nominal
newtype TExp (a :: TYPE (r :: RuntimeRep)) = TExp
{ TExp a -> Exp
unType :: Exp
}
unTypeQ :: forall (r :: RuntimeRep) (a :: TYPE r). Q (TExp a) -> Q Exp
unTypeQ :: Q (TExp a) -> Q Exp
unTypeQ Q (TExp a)
m = do { TExp Exp
e <- Q (TExp a)
m
; Exp -> Q Exp
forall (m :: * -> *) a. Monad m => a -> m a
return Exp
e }
unsafeTExpCoerce :: forall (r :: RuntimeRep) (a :: TYPE r). Q Exp -> Q (TExp a)
unsafeTExpCoerce :: Q Exp -> Q (TExp a)
unsafeTExpCoerce Q Exp
m = do { Exp
e <- Q Exp
m
; TExp a -> Q (TExp a)
forall (m :: * -> *) a. Monad m => a -> m a
return (Exp -> TExp a
forall a. Exp -> TExp a
TExp Exp
e) }
newName :: String -> Q Name
newName :: String -> Q Name
newName String
s = (forall (m :: * -> *). Quasi m => m Name) -> Q Name
forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
Q (String -> m Name
forall (m :: * -> *). Quasi m => String -> m Name
qNewName String
s)
report :: Bool -> String -> Q ()
report :: Bool -> String -> Q ()
report Bool
b String
s = (forall (m :: * -> *). Quasi m => m ()) -> Q ()
forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
Q (Bool -> String -> m ()
forall (m :: * -> *). Quasi m => Bool -> String -> m ()
qReport Bool
b String
s)
{-# DEPRECATED report "Use reportError or reportWarning instead" #-}
reportError :: String -> Q ()
reportError :: String -> Q ()
reportError = Bool -> String -> Q ()
report Bool
True
reportWarning :: String -> Q ()
reportWarning :: String -> Q ()
reportWarning = Bool -> String -> Q ()
report Bool
False
recover :: Q a
-> Q a
-> Q a
recover :: Q a -> Q a -> Q a
recover (Q forall (m :: * -> *). Quasi m => m a
r) (Q forall (m :: * -> *). Quasi m => m a
m) = (forall (m :: * -> *). Quasi m => m a) -> Q a
forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
Q (m a -> m a -> m a
forall (m :: * -> *) a. Quasi m => m a -> m a -> m a
qRecover m a
forall (m :: * -> *). Quasi m => m a
r m a
forall (m :: * -> *). Quasi m => m a
m)
lookupName :: Bool -> String -> Q (Maybe Name)
lookupName :: Bool -> String -> Q (Maybe Name)
lookupName Bool
ns String
s = (forall (m :: * -> *). Quasi m => m (Maybe Name)) -> Q (Maybe Name)
forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
Q (Bool -> String -> m (Maybe Name)
forall (m :: * -> *). Quasi m => Bool -> String -> m (Maybe Name)
qLookupName Bool
ns String
s)
lookupTypeName :: String -> Q (Maybe Name)
lookupTypeName :: String -> Q (Maybe Name)
lookupTypeName String
s = (forall (m :: * -> *). Quasi m => m (Maybe Name)) -> Q (Maybe Name)
forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
Q (Bool -> String -> m (Maybe Name)
forall (m :: * -> *). Quasi m => Bool -> String -> m (Maybe Name)
qLookupName Bool
True String
s)
lookupValueName :: String -> Q (Maybe Name)
lookupValueName :: String -> Q (Maybe Name)
lookupValueName String
s = (forall (m :: * -> *). Quasi m => m (Maybe Name)) -> Q (Maybe Name)
forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
Q (Bool -> String -> m (Maybe Name)
forall (m :: * -> *). Quasi m => Bool -> String -> m (Maybe Name)
qLookupName Bool
False String
s)
reify :: Name -> Q Info
reify :: Name -> Q Info
reify Name
v = (forall (m :: * -> *). Quasi m => m Info) -> Q Info
forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
Q (Name -> m Info
forall (m :: * -> *). Quasi m => Name -> m Info
qReify Name
v)
reifyFixity :: Name -> Q (Maybe Fixity)
reifyFixity :: Name -> Q (Maybe Fixity)
reifyFixity Name
nm = (forall (m :: * -> *). Quasi m => m (Maybe Fixity))
-> Q (Maybe Fixity)
forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
Q (Name -> m (Maybe Fixity)
forall (m :: * -> *). Quasi m => Name -> m (Maybe Fixity)
qReifyFixity Name
nm)
reifyType :: Name -> Q Type
reifyType :: Name -> Q Type
reifyType Name
nm = (forall (m :: * -> *). Quasi m => m Type) -> Q Type
forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
Q (Name -> m Type
forall (m :: * -> *). Quasi m => Name -> m Type
qReifyType Name
nm)
reifyInstances :: Name -> [Type] -> Q [InstanceDec]
reifyInstances :: Name -> [Type] -> Q [Dec]
reifyInstances Name
cls [Type]
tys = (forall (m :: * -> *). Quasi m => m [Dec]) -> Q [Dec]
forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
Q (Name -> [Type] -> m [Dec]
forall (m :: * -> *). Quasi m => Name -> [Type] -> m [Dec]
qReifyInstances Name
cls [Type]
tys)
reifyRoles :: Name -> Q [Role]
reifyRoles :: Name -> Q [Role]
reifyRoles Name
nm = (forall (m :: * -> *). Quasi m => m [Role]) -> Q [Role]
forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
Q (Name -> m [Role]
forall (m :: * -> *). Quasi m => Name -> m [Role]
qReifyRoles Name
nm)
reifyAnnotations :: Data a => AnnLookup -> Q [a]
reifyAnnotations :: AnnLookup -> Q [a]
reifyAnnotations AnnLookup
an = (forall (m :: * -> *). Quasi m => m [a]) -> Q [a]
forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
Q (AnnLookup -> m [a]
forall (m :: * -> *) a. (Quasi m, Data a) => AnnLookup -> m [a]
qReifyAnnotations AnnLookup
an)
reifyModule :: Module -> Q ModuleInfo
reifyModule :: Module -> Q ModuleInfo
reifyModule Module
m = (forall (m :: * -> *). Quasi m => m ModuleInfo) -> Q ModuleInfo
forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
Q (Module -> m ModuleInfo
forall (m :: * -> *). Quasi m => Module -> m ModuleInfo
qReifyModule Module
m)
reifyConStrictness :: Name -> Q [DecidedStrictness]
reifyConStrictness :: Name -> Q [DecidedStrictness]
reifyConStrictness Name
n = (forall (m :: * -> *). Quasi m => m [DecidedStrictness])
-> Q [DecidedStrictness]
forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
Q (Name -> m [DecidedStrictness]
forall (m :: * -> *). Quasi m => Name -> m [DecidedStrictness]
qReifyConStrictness Name
n)
isInstance :: Name -> [Type] -> Q Bool
isInstance :: Name -> [Type] -> Q Bool
isInstance Name
nm [Type]
tys = do { [Dec]
decs <- Name -> [Type] -> Q [Dec]
reifyInstances Name
nm [Type]
tys
; Bool -> Q Bool
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool -> Bool
not ([Dec] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Dec]
decs)) }
location :: Q Loc
location :: Q Loc
location = (forall (m :: * -> *). Quasi m => m Loc) -> Q Loc
forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
Q forall (m :: * -> *). Quasi m => m Loc
qLocation
runIO :: IO a -> Q a
runIO :: IO a -> Q a
runIO IO a
m = (forall (m :: * -> *). Quasi m => m a) -> Q a
forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
Q (IO a -> m a
forall (m :: * -> *) a. Quasi m => IO a -> m a
qRunIO IO a
m)
addDependentFile :: FilePath -> Q ()
addDependentFile :: String -> Q ()
addDependentFile String
fp = (forall (m :: * -> *). Quasi m => m ()) -> Q ()
forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
Q (String -> m ()
forall (m :: * -> *). Quasi m => String -> m ()
qAddDependentFile String
fp)
addTempFile :: String -> Q FilePath
addTempFile :: String -> Q String
addTempFile String
suffix = (forall (m :: * -> *). Quasi m => m String) -> Q String
forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
Q (String -> m String
forall (m :: * -> *). Quasi m => String -> m String
qAddTempFile String
suffix)
addTopDecls :: [Dec] -> Q ()
addTopDecls :: [Dec] -> Q ()
addTopDecls [Dec]
ds = (forall (m :: * -> *). Quasi m => m ()) -> Q ()
forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
Q ([Dec] -> m ()
forall (m :: * -> *). Quasi m => [Dec] -> m ()
qAddTopDecls [Dec]
ds)
addForeignFile :: ForeignSrcLang -> String -> Q ()
addForeignFile :: ForeignSrcLang -> String -> Q ()
addForeignFile = ForeignSrcLang -> String -> Q ()
addForeignSource
{-# DEPRECATED addForeignFile
"Use 'Language.Haskell.TH.Syntax.addForeignSource' instead"
#-}
addForeignSource :: ForeignSrcLang -> String -> Q ()
addForeignSource :: ForeignSrcLang -> String -> Q ()
addForeignSource ForeignSrcLang
lang String
src = do
let suffix :: String
suffix = case ForeignSrcLang
lang of
ForeignSrcLang
LangC -> String
"c"
ForeignSrcLang
LangCxx -> String
"cpp"
ForeignSrcLang
LangObjc -> String
"m"
ForeignSrcLang
LangObjcxx -> String
"mm"
ForeignSrcLang
LangAsm -> String
"s"
ForeignSrcLang
RawObject -> String
"a"
String
path <- String -> Q String
addTempFile String
suffix
IO () -> Q ()
forall a. IO a -> Q a
runIO (IO () -> Q ()) -> IO () -> Q ()
forall a b. (a -> b) -> a -> b
$ String -> String -> IO ()
writeFile String
path String
src
ForeignSrcLang -> String -> Q ()
addForeignFilePath ForeignSrcLang
lang String
path
addForeignFilePath :: ForeignSrcLang -> FilePath -> Q ()
addForeignFilePath :: ForeignSrcLang -> String -> Q ()
addForeignFilePath ForeignSrcLang
lang String
fp = (forall (m :: * -> *). Quasi m => m ()) -> Q ()
forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
Q (ForeignSrcLang -> String -> m ()
forall (m :: * -> *). Quasi m => ForeignSrcLang -> String -> m ()
qAddForeignFilePath ForeignSrcLang
lang String
fp)
addModFinalizer :: Q () -> Q ()
addModFinalizer :: Q () -> Q ()
addModFinalizer Q ()
act = (forall (m :: * -> *). Quasi m => m ()) -> Q ()
forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
Q (Q () -> m ()
forall (m :: * -> *). Quasi m => Q () -> m ()
qAddModFinalizer (Q () -> forall (m :: * -> *). Quasi m => m ()
forall a. Q a -> forall (m :: * -> *). Quasi m => m a
unQ Q ()
act))
addCorePlugin :: String -> Q ()
addCorePlugin :: String -> Q ()
addCorePlugin String
plugin = (forall (m :: * -> *). Quasi m => m ()) -> Q ()
forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
Q (String -> m ()
forall (m :: * -> *). Quasi m => String -> m ()
qAddCorePlugin String
plugin)
getQ :: Typeable a => Q (Maybe a)
getQ :: Q (Maybe a)
getQ = (forall (m :: * -> *). Quasi m => m (Maybe a)) -> Q (Maybe a)
forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
Q forall (m :: * -> *). Quasi m => m (Maybe a)
forall (m :: * -> *) a. (Quasi m, Typeable a) => m (Maybe a)
qGetQ
putQ :: Typeable a => a -> Q ()
putQ :: a -> Q ()
putQ a
x = (forall (m :: * -> *). Quasi m => m ()) -> Q ()
forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
Q (a -> m ()
forall (m :: * -> *) a. (Quasi m, Typeable a) => a -> m ()
qPutQ a
x)
isExtEnabled :: Extension -> Q Bool
isExtEnabled :: Extension -> Q Bool
isExtEnabled Extension
ext = (forall (m :: * -> *). Quasi m => m Bool) -> Q Bool
forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
Q (Extension -> m Bool
forall (m :: * -> *). Quasi m => Extension -> m Bool
qIsExtEnabled Extension
ext)
extsEnabled :: Q [Extension]
extsEnabled :: Q [Extension]
extsEnabled = (forall (m :: * -> *). Quasi m => m [Extension]) -> Q [Extension]
forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
Q forall (m :: * -> *). Quasi m => m [Extension]
qExtsEnabled
instance MonadIO Q where
liftIO :: IO a -> Q a
liftIO = IO a -> Q a
forall a. IO a -> Q a
runIO
instance Quasi Q where
qNewName :: String -> Q Name
qNewName = String -> Q Name
newName
qReport :: Bool -> String -> Q ()
qReport = Bool -> String -> Q ()
report
qRecover :: Q a -> Q a -> Q a
qRecover = Q a -> Q a -> Q a
forall a. Q a -> Q a -> Q a
recover
qReify :: Name -> Q Info
qReify = Name -> Q Info
reify
qReifyFixity :: Name -> Q (Maybe Fixity)
qReifyFixity = Name -> Q (Maybe Fixity)
reifyFixity
qReifyType :: Name -> Q Type
qReifyType = Name -> Q Type
reifyType
qReifyInstances :: Name -> [Type] -> Q [Dec]
qReifyInstances = Name -> [Type] -> Q [Dec]
reifyInstances
qReifyRoles :: Name -> Q [Role]
qReifyRoles = Name -> Q [Role]
reifyRoles
qReifyAnnotations :: AnnLookup -> Q [a]
qReifyAnnotations = AnnLookup -> Q [a]
forall a. Data a => AnnLookup -> Q [a]
reifyAnnotations
qReifyModule :: Module -> Q ModuleInfo
qReifyModule = Module -> Q ModuleInfo
reifyModule
qReifyConStrictness :: Name -> Q [DecidedStrictness]
qReifyConStrictness = Name -> Q [DecidedStrictness]
reifyConStrictness
qLookupName :: Bool -> String -> Q (Maybe Name)
qLookupName = Bool -> String -> Q (Maybe Name)
lookupName
qLocation :: Q Loc
qLocation = Q Loc
location
qAddDependentFile :: String -> Q ()
qAddDependentFile = String -> Q ()
addDependentFile
qAddTempFile :: String -> Q String
qAddTempFile = String -> Q String
addTempFile
qAddTopDecls :: [Dec] -> Q ()
qAddTopDecls = [Dec] -> Q ()
addTopDecls
qAddForeignFilePath :: ForeignSrcLang -> String -> Q ()
qAddForeignFilePath = ForeignSrcLang -> String -> Q ()
addForeignFilePath
qAddModFinalizer :: Q () -> Q ()
qAddModFinalizer = Q () -> Q ()
addModFinalizer
qAddCorePlugin :: String -> Q ()
qAddCorePlugin = String -> Q ()
addCorePlugin
qGetQ :: Q (Maybe a)
qGetQ = Q (Maybe a)
forall a. Typeable a => Q (Maybe a)
getQ
qPutQ :: a -> Q ()
qPutQ = a -> Q ()
forall a. Typeable a => a -> Q ()
putQ
qIsExtEnabled :: Extension -> Q Bool
qIsExtEnabled = Extension -> Q Bool
isExtEnabled
qExtsEnabled :: Q [Extension]
qExtsEnabled = Q [Extension]
extsEnabled
returnQ :: a -> Q a
returnQ :: a -> Q a
returnQ = a -> Q a
forall (m :: * -> *) a. Monad m => a -> m a
return
bindQ :: Q a -> (a -> Q b) -> Q b
bindQ :: Q a -> (a -> Q b) -> Q b
bindQ = Q a -> (a -> Q b) -> Q b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
(>>=)
sequenceQ :: [Q a] -> Q [a]
sequenceQ :: [Q a] -> Q [a]
sequenceQ = [Q a] -> Q [a]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence
class Lift (t :: TYPE r) where
lift :: t -> Q Exp
default lift :: (r ~ 'LiftedRep) => t -> Q Exp
lift = Q (TExp t) -> Q Exp
forall a. Q (TExp a) -> Q Exp
unTypeQ (Q (TExp t) -> Q Exp) -> (t -> Q (TExp t)) -> t -> Q Exp
forall b c a. (b -> c) -> (a -> b) -> a -> c
. t -> Q (TExp t)
forall t. Lift t => t -> Q (TExp t)
liftTyped
liftTyped :: t -> Q (TExp t)
instance Lift Integer where
liftTyped :: Uniq -> Q (TExp Uniq)
liftTyped Uniq
x = Q Exp -> Q (TExp Uniq)
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce (Uniq -> Q Exp
forall t. Lift t => t -> Q Exp
lift Uniq
x)
lift :: Uniq -> Q Exp
lift Uniq
x = Exp -> Q Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Lit -> Exp
LitE (Uniq -> Lit
IntegerL Uniq
x))
instance Lift Int where
liftTyped :: Int -> Q (TExp Int)
liftTyped Int
x = Q Exp -> Q (TExp Int)
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce (Int -> Q Exp
forall t. Lift t => t -> Q Exp
lift Int
x)
lift :: Int -> Q Exp
lift Int
x = Exp -> Q Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Lit -> Exp
LitE (Uniq -> Lit
IntegerL (Int -> Uniq
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
x)))
instance Lift Int# where
liftTyped :: Int# -> Q (TExp Int#)
liftTyped Int#
x = Q Exp -> Q (TExp Int#)
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce (Int# -> Q Exp
forall t. Lift t => t -> Q Exp
lift Int#
x)
lift :: Int# -> Q Exp
lift Int#
x = Exp -> Q Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Lit -> Exp
LitE (Uniq -> Lit
IntPrimL (Int -> Uniq
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int# -> Int
I# Int#
x))))
instance Lift Int8 where
liftTyped :: Int8 -> Q (TExp Int8)
liftTyped Int8
x = Q Exp -> Q (TExp Int8)
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce (Int8 -> Q Exp
forall t. Lift t => t -> Q Exp
lift Int8
x)
lift :: Int8 -> Q Exp
lift Int8
x = Exp -> Q Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Lit -> Exp
LitE (Uniq -> Lit
IntegerL (Int8 -> Uniq
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int8
x)))
instance Lift Int16 where
liftTyped :: Int16 -> Q (TExp Int16)
liftTyped Int16
x = Q Exp -> Q (TExp Int16)
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce (Int16 -> Q Exp
forall t. Lift t => t -> Q Exp
lift Int16
x)
lift :: Int16 -> Q Exp
lift Int16
x = Exp -> Q Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Lit -> Exp
LitE (Uniq -> Lit
IntegerL (Int16 -> Uniq
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int16
x)))
instance Lift Int32 where
liftTyped :: Int32 -> Q (TExp Int32)
liftTyped Int32
x = Q Exp -> Q (TExp Int32)
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce (Int32 -> Q Exp
forall t. Lift t => t -> Q Exp
lift Int32
x)
lift :: Int32 -> Q Exp
lift Int32
x = Exp -> Q Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Lit -> Exp
LitE (Uniq -> Lit
IntegerL (Int32 -> Uniq
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int32
x)))
instance Lift Int64 where
liftTyped :: Int64 -> Q (TExp Int64)
liftTyped Int64
x = Q Exp -> Q (TExp Int64)
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce (Int64 -> Q Exp
forall t. Lift t => t -> Q Exp
lift Int64
x)
lift :: Int64 -> Q Exp
lift Int64
x = Exp -> Q Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Lit -> Exp
LitE (Uniq -> Lit
IntegerL (Int64 -> Uniq
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int64
x)))
instance Lift Word# where
liftTyped :: Word# -> Q (TExp Word#)
liftTyped Word#
x = Q Exp -> Q (TExp Word#)
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce (Word# -> Q Exp
forall t. Lift t => t -> Q Exp
lift Word#
x)
lift :: Word# -> Q Exp
lift Word#
x = Exp -> Q Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Lit -> Exp
LitE (Uniq -> Lit
WordPrimL (Word -> Uniq
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word# -> Word
W# Word#
x))))
instance Lift Word where
liftTyped :: Word -> Q (TExp Word)
liftTyped Word
x = Q Exp -> Q (TExp Word)
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce (Word -> Q Exp
forall t. Lift t => t -> Q Exp
lift Word
x)
lift :: Word -> Q Exp
lift Word
x = Exp -> Q Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Lit -> Exp
LitE (Uniq -> Lit
IntegerL (Word -> Uniq
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word
x)))
instance Lift Word8 where
liftTyped :: Word8 -> Q (TExp Word8)
liftTyped Word8
x = Q Exp -> Q (TExp Word8)
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce (Word8 -> Q Exp
forall t. Lift t => t -> Q Exp
lift Word8
x)
lift :: Word8 -> Q Exp
lift Word8
x = Exp -> Q Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Lit -> Exp
LitE (Uniq -> Lit
IntegerL (Word8 -> Uniq
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word8
x)))
instance Lift Word16 where
liftTyped :: Word16 -> Q (TExp Word16)
liftTyped Word16
x = Q Exp -> Q (TExp Word16)
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce (Word16 -> Q Exp
forall t. Lift t => t -> Q Exp
lift Word16
x)
lift :: Word16 -> Q Exp
lift Word16
x = Exp -> Q Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Lit -> Exp
LitE (Uniq -> Lit
IntegerL (Word16 -> Uniq
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word16
x)))
instance Lift Word32 where
liftTyped :: Word32 -> Q (TExp Word32)
liftTyped Word32
x = Q Exp -> Q (TExp Word32)
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce (Word32 -> Q Exp
forall t. Lift t => t -> Q Exp
lift Word32
x)
lift :: Word32 -> Q Exp
lift Word32
x = Exp -> Q Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Lit -> Exp
LitE (Uniq -> Lit
IntegerL (Word32 -> Uniq
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word32
x)))
instance Lift Word64 where
liftTyped :: Word64 -> Q (TExp Word64)
liftTyped Word64
x = Q Exp -> Q (TExp Word64)
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce (Word64 -> Q Exp
forall t. Lift t => t -> Q Exp
lift Word64
x)
lift :: Word64 -> Q Exp
lift Word64
x = Exp -> Q Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Lit -> Exp
LitE (Uniq -> Lit
IntegerL (Word64 -> Uniq
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word64
x)))
instance Lift Natural where
liftTyped :: Natural -> Q (TExp Natural)
liftTyped Natural
x = Q Exp -> Q (TExp Natural)
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce (Natural -> Q Exp
forall t. Lift t => t -> Q Exp
lift Natural
x)
lift :: Natural -> Q Exp
lift Natural
x = Exp -> Q Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Lit -> Exp
LitE (Uniq -> Lit
IntegerL (Natural -> Uniq
forall a b. (Integral a, Num b) => a -> b
fromIntegral Natural
x)))
instance Integral a => Lift (Ratio a) where
liftTyped :: Ratio a -> Q (TExp (Ratio a))
liftTyped Ratio a
x = Q Exp -> Q (TExp (Ratio a))
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce (Ratio a -> Q Exp
forall t. Lift t => t -> Q Exp
lift Ratio a
x)
lift :: Ratio a -> Q Exp
lift Ratio a
x = Exp -> Q Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Lit -> Exp
LitE (Rational -> Lit
RationalL (Ratio a -> Rational
forall a. Real a => a -> Rational
toRational Ratio a
x)))
instance Lift Float where
liftTyped :: Float -> Q (TExp Float)
liftTyped Float
x = Q Exp -> Q (TExp Float)
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce (Float -> Q Exp
forall t. Lift t => t -> Q Exp
lift Float
x)
lift :: Float -> Q Exp
lift Float
x = Exp -> Q Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Lit -> Exp
LitE (Rational -> Lit
RationalL (Float -> Rational
forall a. Real a => a -> Rational
toRational Float
x)))
instance Lift Float# where
liftTyped :: Float# -> Q (TExp Float#)
liftTyped Float#
x = Q Exp -> Q (TExp Float#)
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce (Float# -> Q Exp
forall t. Lift t => t -> Q Exp
lift Float#
x)
lift :: Float# -> Q Exp
lift Float#
x = Exp -> Q Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Lit -> Exp
LitE (Rational -> Lit
FloatPrimL (Float -> Rational
forall a. Real a => a -> Rational
toRational (Float# -> Float
F# Float#
x))))
instance Lift Double where
liftTyped :: Double -> Q (TExp Double)
liftTyped Double
x = Q Exp -> Q (TExp Double)
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce (Double -> Q Exp
forall t. Lift t => t -> Q Exp
lift Double
x)
lift :: Double -> Q Exp
lift Double
x = Exp -> Q Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Lit -> Exp
LitE (Rational -> Lit
RationalL (Double -> Rational
forall a. Real a => a -> Rational
toRational Double
x)))
instance Lift Double# where
liftTyped :: Double# -> Q (TExp Double#)
liftTyped Double#
x = Q Exp -> Q (TExp Double#)
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce (Double# -> Q Exp
forall t. Lift t => t -> Q Exp
lift Double#
x)
lift :: Double# -> Q Exp
lift Double#
x = Exp -> Q Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Lit -> Exp
LitE (Rational -> Lit
DoublePrimL (Double -> Rational
forall a. Real a => a -> Rational
toRational (Double# -> Double
D# Double#
x))))
instance Lift Char where
liftTyped :: Char -> Q (TExp Char)
liftTyped Char
x = Q Exp -> Q (TExp Char)
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce (Char -> Q Exp
forall t. Lift t => t -> Q Exp
lift Char
x)
lift :: Char -> Q Exp
lift Char
x = Exp -> Q Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Lit -> Exp
LitE (Char -> Lit
CharL Char
x))
instance Lift Char# where
liftTyped :: Char# -> Q (TExp Char#)
liftTyped Char#
x = Q Exp -> Q (TExp Char#)
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce (Char# -> Q Exp
forall t. Lift t => t -> Q Exp
lift Char#
x)
lift :: Char# -> Q Exp
lift Char#
x = Exp -> Q Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Lit -> Exp
LitE (Char -> Lit
CharPrimL (Char# -> Char
C# Char#
x)))
instance Lift Bool where
liftTyped :: Bool -> Q (TExp Bool)
liftTyped Bool
x = Q Exp -> Q (TExp Bool)
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce (Bool -> Q Exp
forall t. Lift t => t -> Q Exp
lift Bool
x)
lift :: Bool -> Q Exp
lift Bool
True = Exp -> Q Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Name -> Exp
ConE Name
trueName)
lift Bool
False = Exp -> Q Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Name -> Exp
ConE Name
falseName)
instance Lift Addr# where
liftTyped :: Addr# -> Q (TExp Addr#)
liftTyped Addr#
x = Q Exp -> Q (TExp Addr#)
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce (Addr# -> Q Exp
forall t. Lift t => t -> Q Exp
lift Addr#
x)
lift :: Addr# -> Q Exp
lift Addr#
x
= Exp -> Q Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Lit -> Exp
LitE ([Word8] -> Lit
StringPrimL ((Char -> Word8) -> String -> [Word8]
forall a b. (a -> b) -> [a] -> [b]
map (Int -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Word8) -> (Char -> Int) -> Char -> Word8
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Int
ord) (Addr# -> String
unpackCString# Addr#
x))))
instance Lift a => Lift (Maybe a) where
liftTyped :: Maybe a -> Q (TExp (Maybe a))
liftTyped Maybe a
x = Q Exp -> Q (TExp (Maybe a))
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce (Maybe a -> Q Exp
forall t. Lift t => t -> Q Exp
lift Maybe a
x)
lift :: Maybe a -> Q Exp
lift Maybe a
Nothing = Exp -> Q Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Name -> Exp
ConE Name
nothingName)
lift (Just a
x) = (Exp -> Exp) -> Q Exp -> Q Exp
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM (Name -> Exp
ConE Name
justName Exp -> Exp -> Exp
`AppE`) (a -> Q Exp
forall t. Lift t => t -> Q Exp
lift a
x)
instance (Lift a, Lift b) => Lift (Either a b) where
liftTyped :: Either a b -> Q (TExp (Either a b))
liftTyped Either a b
x = Q Exp -> Q (TExp (Either a b))
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce (Either a b -> Q Exp
forall t. Lift t => t -> Q Exp
lift Either a b
x)
lift :: Either a b -> Q Exp
lift (Left a
x) = (Exp -> Exp) -> Q Exp -> Q Exp
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM (Name -> Exp
ConE Name
leftName Exp -> Exp -> Exp
`AppE`) (a -> Q Exp
forall t. Lift t => t -> Q Exp
lift a
x)
lift (Right b
y) = (Exp -> Exp) -> Q Exp -> Q Exp
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM (Name -> Exp
ConE Name
rightName Exp -> Exp -> Exp
`AppE`) (b -> Q Exp
forall t. Lift t => t -> Q Exp
lift b
y)
instance Lift a => Lift [a] where
liftTyped :: [a] -> Q (TExp [a])
liftTyped [a]
x = Q Exp -> Q (TExp [a])
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce ([a] -> Q Exp
forall t. Lift t => t -> Q Exp
lift [a]
x)
lift :: [a] -> Q Exp
lift [a]
xs = do { [Exp]
xs' <- (a -> Q Exp) -> [a] -> Q [Exp]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM a -> Q Exp
forall t. Lift t => t -> Q Exp
lift [a]
xs; Exp -> Q Exp
forall (m :: * -> *) a. Monad m => a -> m a
return ([Exp] -> Exp
ListE [Exp]
xs') }
liftString :: String -> Q Exp
liftString :: String -> Q Exp
liftString String
s = Exp -> Q Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Lit -> Exp
LitE (String -> Lit
StringL String
s))
instance Lift a => Lift (NonEmpty a) where
liftTyped :: NonEmpty a -> Q (TExp (NonEmpty a))
liftTyped NonEmpty a
x = Q Exp -> Q (TExp (NonEmpty a))
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce (NonEmpty a -> Q Exp
forall t. Lift t => t -> Q Exp
lift NonEmpty a
x)
lift :: NonEmpty a -> Q Exp
lift (a
x :| [a]
xs) = do
Exp
x' <- a -> Q Exp
forall t. Lift t => t -> Q Exp
lift a
x
Exp
xs' <- [a] -> Q Exp
forall t. Lift t => t -> Q Exp
lift [a]
xs
Exp -> Q Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe Exp -> Exp -> Maybe Exp -> Exp
InfixE (Exp -> Maybe Exp
forall a. a -> Maybe a
Just Exp
x') (Name -> Exp
ConE Name
nonemptyName) (Exp -> Maybe Exp
forall a. a -> Maybe a
Just Exp
xs'))
instance Lift Void where
liftTyped :: Void -> Q (TExp Void)
liftTyped = TExp Void -> Q (TExp Void)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TExp Void -> Q (TExp Void))
-> (Void -> TExp Void) -> Void -> Q (TExp Void)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Void -> TExp Void
forall a. Void -> a
absurd
lift :: Void -> Q Exp
lift = Exp -> Q Exp
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Exp -> Q Exp) -> (Void -> Exp) -> Void -> Q Exp
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Void -> Exp
forall a. Void -> a
absurd
instance Lift () where
liftTyped :: () -> Q (TExp ())
liftTyped ()
x = Q Exp -> Q (TExp ())
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce (() -> Q Exp
forall t. Lift t => t -> Q Exp
lift ()
x)
lift :: () -> Q Exp
lift () = Exp -> Q Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Name -> Exp
ConE (Int -> Name
tupleDataName Int
0))
instance (Lift a, Lift b) => Lift (a, b) where
liftTyped :: (a, b) -> Q (TExp (a, b))
liftTyped (a, b)
x = Q Exp -> Q (TExp (a, b))
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce ((a, b) -> Q Exp
forall t. Lift t => t -> Q Exp
lift (a, b)
x)
lift :: (a, b) -> Q Exp
lift (a
a, b
b)
= ([Maybe Exp] -> Exp) -> Q [Maybe Exp] -> Q Exp
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM [Maybe Exp] -> Exp
TupE (Q [Maybe Exp] -> Q Exp) -> Q [Maybe Exp] -> Q Exp
forall a b. (a -> b) -> a -> b
$ [Q (Maybe Exp)] -> Q [Maybe Exp]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence ([Q (Maybe Exp)] -> Q [Maybe Exp])
-> [Q (Maybe Exp)] -> Q [Maybe Exp]
forall a b. (a -> b) -> a -> b
$ (Q Exp -> Q (Maybe Exp)) -> [Q Exp] -> [Q (Maybe Exp)]
forall a b. (a -> b) -> [a] -> [b]
map ((Exp -> Maybe Exp) -> Q Exp -> Q (Maybe Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Exp -> Maybe Exp
forall a. a -> Maybe a
Just) [a -> Q Exp
forall t. Lift t => t -> Q Exp
lift a
a, b -> Q Exp
forall t. Lift t => t -> Q Exp
lift b
b]
instance (Lift a, Lift b, Lift c) => Lift (a, b, c) where
liftTyped :: (a, b, c) -> Q (TExp (a, b, c))
liftTyped (a, b, c)
x = Q Exp -> Q (TExp (a, b, c))
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce ((a, b, c) -> Q Exp
forall t. Lift t => t -> Q Exp
lift (a, b, c)
x)
lift :: (a, b, c) -> Q Exp
lift (a
a, b
b, c
c)
= ([Maybe Exp] -> Exp) -> Q [Maybe Exp] -> Q Exp
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM [Maybe Exp] -> Exp
TupE (Q [Maybe Exp] -> Q Exp) -> Q [Maybe Exp] -> Q Exp
forall a b. (a -> b) -> a -> b
$ [Q (Maybe Exp)] -> Q [Maybe Exp]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence ([Q (Maybe Exp)] -> Q [Maybe Exp])
-> [Q (Maybe Exp)] -> Q [Maybe Exp]
forall a b. (a -> b) -> a -> b
$ (Q Exp -> Q (Maybe Exp)) -> [Q Exp] -> [Q (Maybe Exp)]
forall a b. (a -> b) -> [a] -> [b]
map ((Exp -> Maybe Exp) -> Q Exp -> Q (Maybe Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Exp -> Maybe Exp
forall a. a -> Maybe a
Just) [a -> Q Exp
forall t. Lift t => t -> Q Exp
lift a
a, b -> Q Exp
forall t. Lift t => t -> Q Exp
lift b
b, c -> Q Exp
forall t. Lift t => t -> Q Exp
lift c
c]
instance (Lift a, Lift b, Lift c, Lift d) => Lift (a, b, c, d) where
liftTyped :: (a, b, c, d) -> Q (TExp (a, b, c, d))
liftTyped (a, b, c, d)
x = Q Exp -> Q (TExp (a, b, c, d))
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce ((a, b, c, d) -> Q Exp
forall t. Lift t => t -> Q Exp
lift (a, b, c, d)
x)
lift :: (a, b, c, d) -> Q Exp
lift (a
a, b
b, c
c, d
d)
= ([Maybe Exp] -> Exp) -> Q [Maybe Exp] -> Q Exp
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM [Maybe Exp] -> Exp
TupE (Q [Maybe Exp] -> Q Exp) -> Q [Maybe Exp] -> Q Exp
forall a b. (a -> b) -> a -> b
$ [Q (Maybe Exp)] -> Q [Maybe Exp]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence ([Q (Maybe Exp)] -> Q [Maybe Exp])
-> [Q (Maybe Exp)] -> Q [Maybe Exp]
forall a b. (a -> b) -> a -> b
$ (Q Exp -> Q (Maybe Exp)) -> [Q Exp] -> [Q (Maybe Exp)]
forall a b. (a -> b) -> [a] -> [b]
map ((Exp -> Maybe Exp) -> Q Exp -> Q (Maybe Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Exp -> Maybe Exp
forall a. a -> Maybe a
Just) [a -> Q Exp
forall t. Lift t => t -> Q Exp
lift a
a, b -> Q Exp
forall t. Lift t => t -> Q Exp
lift b
b, c -> Q Exp
forall t. Lift t => t -> Q Exp
lift c
c, d -> Q Exp
forall t. Lift t => t -> Q Exp
lift d
d]
instance (Lift a, Lift b, Lift c, Lift d, Lift e)
=> Lift (a, b, c, d, e) where
liftTyped :: (a, b, c, d, e) -> Q (TExp (a, b, c, d, e))
liftTyped (a, b, c, d, e)
x = Q Exp -> Q (TExp (a, b, c, d, e))
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce ((a, b, c, d, e) -> Q Exp
forall t. Lift t => t -> Q Exp
lift (a, b, c, d, e)
x)
lift :: (a, b, c, d, e) -> Q Exp
lift (a
a, b
b, c
c, d
d, e
e)
= ([Maybe Exp] -> Exp) -> Q [Maybe Exp] -> Q Exp
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM [Maybe Exp] -> Exp
TupE (Q [Maybe Exp] -> Q Exp) -> Q [Maybe Exp] -> Q Exp
forall a b. (a -> b) -> a -> b
$ [Q (Maybe Exp)] -> Q [Maybe Exp]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence ([Q (Maybe Exp)] -> Q [Maybe Exp])
-> [Q (Maybe Exp)] -> Q [Maybe Exp]
forall a b. (a -> b) -> a -> b
$ (Q Exp -> Q (Maybe Exp)) -> [Q Exp] -> [Q (Maybe Exp)]
forall a b. (a -> b) -> [a] -> [b]
map ((Exp -> Maybe Exp) -> Q Exp -> Q (Maybe Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Exp -> Maybe Exp
forall a. a -> Maybe a
Just) [ a -> Q Exp
forall t. Lift t => t -> Q Exp
lift a
a, b -> Q Exp
forall t. Lift t => t -> Q Exp
lift b
b
, c -> Q Exp
forall t. Lift t => t -> Q Exp
lift c
c, d -> Q Exp
forall t. Lift t => t -> Q Exp
lift d
d, e -> Q Exp
forall t. Lift t => t -> Q Exp
lift e
e ]
instance (Lift a, Lift b, Lift c, Lift d, Lift e, Lift f)
=> Lift (a, b, c, d, e, f) where
liftTyped :: (a, b, c, d, e, f) -> Q (TExp (a, b, c, d, e, f))
liftTyped (a, b, c, d, e, f)
x = Q Exp -> Q (TExp (a, b, c, d, e, f))
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce ((a, b, c, d, e, f) -> Q Exp
forall t. Lift t => t -> Q Exp
lift (a, b, c, d, e, f)
x)
lift :: (a, b, c, d, e, f) -> Q Exp
lift (a
a, b
b, c
c, d
d, e
e, f
f)
= ([Maybe Exp] -> Exp) -> Q [Maybe Exp] -> Q Exp
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM [Maybe Exp] -> Exp
TupE (Q [Maybe Exp] -> Q Exp) -> Q [Maybe Exp] -> Q Exp
forall a b. (a -> b) -> a -> b
$ [Q (Maybe Exp)] -> Q [Maybe Exp]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence ([Q (Maybe Exp)] -> Q [Maybe Exp])
-> [Q (Maybe Exp)] -> Q [Maybe Exp]
forall a b. (a -> b) -> a -> b
$ (Q Exp -> Q (Maybe Exp)) -> [Q Exp] -> [Q (Maybe Exp)]
forall a b. (a -> b) -> [a] -> [b]
map ((Exp -> Maybe Exp) -> Q Exp -> Q (Maybe Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Exp -> Maybe Exp
forall a. a -> Maybe a
Just) [ a -> Q Exp
forall t. Lift t => t -> Q Exp
lift a
a, b -> Q Exp
forall t. Lift t => t -> Q Exp
lift b
b, c -> Q Exp
forall t. Lift t => t -> Q Exp
lift c
c
, d -> Q Exp
forall t. Lift t => t -> Q Exp
lift d
d, e -> Q Exp
forall t. Lift t => t -> Q Exp
lift e
e, f -> Q Exp
forall t. Lift t => t -> Q Exp
lift f
f ]
instance (Lift a, Lift b, Lift c, Lift d, Lift e, Lift f, Lift g)
=> Lift (a, b, c, d, e, f, g) where
liftTyped :: (a, b, c, d, e, f, g) -> Q (TExp (a, b, c, d, e, f, g))
liftTyped (a, b, c, d, e, f, g)
x = Q Exp -> Q (TExp (a, b, c, d, e, f, g))
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce ((a, b, c, d, e, f, g) -> Q Exp
forall t. Lift t => t -> Q Exp
lift (a, b, c, d, e, f, g)
x)
lift :: (a, b, c, d, e, f, g) -> Q Exp
lift (a
a, b
b, c
c, d
d, e
e, f
f, g
g)
= ([Maybe Exp] -> Exp) -> Q [Maybe Exp] -> Q Exp
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM [Maybe Exp] -> Exp
TupE (Q [Maybe Exp] -> Q Exp) -> Q [Maybe Exp] -> Q Exp
forall a b. (a -> b) -> a -> b
$ [Q (Maybe Exp)] -> Q [Maybe Exp]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence ([Q (Maybe Exp)] -> Q [Maybe Exp])
-> [Q (Maybe Exp)] -> Q [Maybe Exp]
forall a b. (a -> b) -> a -> b
$ (Q Exp -> Q (Maybe Exp)) -> [Q Exp] -> [Q (Maybe Exp)]
forall a b. (a -> b) -> [a] -> [b]
map ((Exp -> Maybe Exp) -> Q Exp -> Q (Maybe Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Exp -> Maybe Exp
forall a. a -> Maybe a
Just) [ a -> Q Exp
forall t. Lift t => t -> Q Exp
lift a
a, b -> Q Exp
forall t. Lift t => t -> Q Exp
lift b
b, c -> Q Exp
forall t. Lift t => t -> Q Exp
lift c
c
, d -> Q Exp
forall t. Lift t => t -> Q Exp
lift d
d, e -> Q Exp
forall t. Lift t => t -> Q Exp
lift e
e, f -> Q Exp
forall t. Lift t => t -> Q Exp
lift f
f, g -> Q Exp
forall t. Lift t => t -> Q Exp
lift g
g ]
instance Lift (# #) where
liftTyped :: (# #) -> Q (TExp (# #))
liftTyped (# #)
x = Q Exp -> Q (TExp (# #))
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce ((# #) -> Q Exp
forall t. Lift t => t -> Q Exp
lift (# #)
x)
lift :: (# #) -> Q Exp
lift (# #) = Exp -> Q Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Name -> Exp
ConE (Int -> Name
unboxedTupleTypeName Int
0))
instance (Lift a) => Lift (# a #) where
liftTyped :: (# a #) -> Q (TExp (# a #))
liftTyped (# a #)
x = Q Exp -> Q (TExp (# a #))
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce ((# a #) -> Q Exp
forall t. Lift t => t -> Q Exp
lift (# a #)
x)
lift :: (# a #) -> Q Exp
lift (# a
a #)
= ([Maybe Exp] -> Exp) -> Q [Maybe Exp] -> Q Exp
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM [Maybe Exp] -> Exp
UnboxedTupE (Q [Maybe Exp] -> Q Exp) -> Q [Maybe Exp] -> Q Exp
forall a b. (a -> b) -> a -> b
$ [Q (Maybe Exp)] -> Q [Maybe Exp]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence ([Q (Maybe Exp)] -> Q [Maybe Exp])
-> [Q (Maybe Exp)] -> Q [Maybe Exp]
forall a b. (a -> b) -> a -> b
$ (Q Exp -> Q (Maybe Exp)) -> [Q Exp] -> [Q (Maybe Exp)]
forall a b. (a -> b) -> [a] -> [b]
map ((Exp -> Maybe Exp) -> Q Exp -> Q (Maybe Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Exp -> Maybe Exp
forall a. a -> Maybe a
Just) [a -> Q Exp
forall t. Lift t => t -> Q Exp
lift a
a]
instance (Lift a, Lift b) => Lift (# a, b #) where
liftTyped :: (# a, b #) -> Q (TExp (# a, b #))
liftTyped (# a, b #)
x = Q Exp -> Q (TExp (# a, b #))
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce ((# a, b #) -> Q Exp
forall t. Lift t => t -> Q Exp
lift (# a, b #)
x)
lift :: (# a, b #) -> Q Exp
lift (# a
a, b
b #)
= ([Maybe Exp] -> Exp) -> Q [Maybe Exp] -> Q Exp
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM [Maybe Exp] -> Exp
UnboxedTupE (Q [Maybe Exp] -> Q Exp) -> Q [Maybe Exp] -> Q Exp
forall a b. (a -> b) -> a -> b
$ [Q (Maybe Exp)] -> Q [Maybe Exp]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence ([Q (Maybe Exp)] -> Q [Maybe Exp])
-> [Q (Maybe Exp)] -> Q [Maybe Exp]
forall a b. (a -> b) -> a -> b
$ (Q Exp -> Q (Maybe Exp)) -> [Q Exp] -> [Q (Maybe Exp)]
forall a b. (a -> b) -> [a] -> [b]
map ((Exp -> Maybe Exp) -> Q Exp -> Q (Maybe Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Exp -> Maybe Exp
forall a. a -> Maybe a
Just) [a -> Q Exp
forall t. Lift t => t -> Q Exp
lift a
a, b -> Q Exp
forall t. Lift t => t -> Q Exp
lift b
b]
instance (Lift a, Lift b, Lift c)
=> Lift (# a, b, c #) where
liftTyped :: (# a, b, c #) -> Q (TExp (# a, b, c #))
liftTyped (# a, b, c #)
x = Q Exp -> Q (TExp (# a, b, c #))
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce ((# a, b, c #) -> Q Exp
forall t. Lift t => t -> Q Exp
lift (# a, b, c #)
x)
lift :: (# a, b, c #) -> Q Exp
lift (# a
a, b
b, c
c #)
= ([Maybe Exp] -> Exp) -> Q [Maybe Exp] -> Q Exp
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM [Maybe Exp] -> Exp
UnboxedTupE (Q [Maybe Exp] -> Q Exp) -> Q [Maybe Exp] -> Q Exp
forall a b. (a -> b) -> a -> b
$ [Q (Maybe Exp)] -> Q [Maybe Exp]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence ([Q (Maybe Exp)] -> Q [Maybe Exp])
-> [Q (Maybe Exp)] -> Q [Maybe Exp]
forall a b. (a -> b) -> a -> b
$ (Q Exp -> Q (Maybe Exp)) -> [Q Exp] -> [Q (Maybe Exp)]
forall a b. (a -> b) -> [a] -> [b]
map ((Exp -> Maybe Exp) -> Q Exp -> Q (Maybe Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Exp -> Maybe Exp
forall a. a -> Maybe a
Just) [a -> Q Exp
forall t. Lift t => t -> Q Exp
lift a
a, b -> Q Exp
forall t. Lift t => t -> Q Exp
lift b
b, c -> Q Exp
forall t. Lift t => t -> Q Exp
lift c
c]
instance (Lift a, Lift b, Lift c, Lift d)
=> Lift (# a, b, c, d #) where
liftTyped :: (# a, b, c, d #) -> Q (TExp (# a, b, c, d #))
liftTyped (# a, b, c, d #)
x = Q Exp -> Q (TExp (# a, b, c, d #))
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce ((# a, b, c, d #) -> Q Exp
forall t. Lift t => t -> Q Exp
lift (# a, b, c, d #)
x)
lift :: (# a, b, c, d #) -> Q Exp
lift (# a
a, b
b, c
c, d
d #)
= ([Maybe Exp] -> Exp) -> Q [Maybe Exp] -> Q Exp
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM [Maybe Exp] -> Exp
UnboxedTupE (Q [Maybe Exp] -> Q Exp) -> Q [Maybe Exp] -> Q Exp
forall a b. (a -> b) -> a -> b
$ [Q (Maybe Exp)] -> Q [Maybe Exp]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence ([Q (Maybe Exp)] -> Q [Maybe Exp])
-> [Q (Maybe Exp)] -> Q [Maybe Exp]
forall a b. (a -> b) -> a -> b
$ (Q Exp -> Q (Maybe Exp)) -> [Q Exp] -> [Q (Maybe Exp)]
forall a b. (a -> b) -> [a] -> [b]
map ((Exp -> Maybe Exp) -> Q Exp -> Q (Maybe Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Exp -> Maybe Exp
forall a. a -> Maybe a
Just) [ a -> Q Exp
forall t. Lift t => t -> Q Exp
lift a
a, b -> Q Exp
forall t. Lift t => t -> Q Exp
lift b
b
, c -> Q Exp
forall t. Lift t => t -> Q Exp
lift c
c, d -> Q Exp
forall t. Lift t => t -> Q Exp
lift d
d ]
instance (Lift a, Lift b, Lift c, Lift d, Lift e)
=> Lift (# a, b, c, d, e #) where
liftTyped :: (# a, b, c, d, e #) -> Q (TExp (# a, b, c, d, e #))
liftTyped (# a, b, c, d, e #)
x = Q Exp -> Q (TExp (# a, b, c, d, e #))
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce ((# a, b, c, d, e #) -> Q Exp
forall t. Lift t => t -> Q Exp
lift (# a, b, c, d, e #)
x)
lift :: (# a, b, c, d, e #) -> Q Exp
lift (# a
a, b
b, c
c, d
d, e
e #)
= ([Maybe Exp] -> Exp) -> Q [Maybe Exp] -> Q Exp
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM [Maybe Exp] -> Exp
UnboxedTupE (Q [Maybe Exp] -> Q Exp) -> Q [Maybe Exp] -> Q Exp
forall a b. (a -> b) -> a -> b
$ [Q (Maybe Exp)] -> Q [Maybe Exp]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence ([Q (Maybe Exp)] -> Q [Maybe Exp])
-> [Q (Maybe Exp)] -> Q [Maybe Exp]
forall a b. (a -> b) -> a -> b
$ (Q Exp -> Q (Maybe Exp)) -> [Q Exp] -> [Q (Maybe Exp)]
forall a b. (a -> b) -> [a] -> [b]
map ((Exp -> Maybe Exp) -> Q Exp -> Q (Maybe Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Exp -> Maybe Exp
forall a. a -> Maybe a
Just) [ a -> Q Exp
forall t. Lift t => t -> Q Exp
lift a
a, b -> Q Exp
forall t. Lift t => t -> Q Exp
lift b
b
, c -> Q Exp
forall t. Lift t => t -> Q Exp
lift c
c, d -> Q Exp
forall t. Lift t => t -> Q Exp
lift d
d, e -> Q Exp
forall t. Lift t => t -> Q Exp
lift e
e ]
instance (Lift a, Lift b, Lift c, Lift d, Lift e, Lift f)
=> Lift (# a, b, c, d, e, f #) where
liftTyped :: (# a, b, c, d, e, f #) -> Q (TExp (# a, b, c, d, e, f #))
liftTyped (# a, b, c, d, e, f #)
x = Q Exp -> Q (TExp (# a, b, c, d, e, f #))
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce ((# a, b, c, d, e, f #) -> Q Exp
forall t. Lift t => t -> Q Exp
lift (# a, b, c, d, e, f #)
x)
lift :: (# a, b, c, d, e, f #) -> Q Exp
lift (# a
a, b
b, c
c, d
d, e
e, f
f #)
= ([Maybe Exp] -> Exp) -> Q [Maybe Exp] -> Q Exp
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM [Maybe Exp] -> Exp
UnboxedTupE (Q [Maybe Exp] -> Q Exp) -> Q [Maybe Exp] -> Q Exp
forall a b. (a -> b) -> a -> b
$ [Q (Maybe Exp)] -> Q [Maybe Exp]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence ([Q (Maybe Exp)] -> Q [Maybe Exp])
-> [Q (Maybe Exp)] -> Q [Maybe Exp]
forall a b. (a -> b) -> a -> b
$ (Q Exp -> Q (Maybe Exp)) -> [Q Exp] -> [Q (Maybe Exp)]
forall a b. (a -> b) -> [a] -> [b]
map ((Exp -> Maybe Exp) -> Q Exp -> Q (Maybe Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Exp -> Maybe Exp
forall a. a -> Maybe a
Just) [ a -> Q Exp
forall t. Lift t => t -> Q Exp
lift a
a, b -> Q Exp
forall t. Lift t => t -> Q Exp
lift b
b, c -> Q Exp
forall t. Lift t => t -> Q Exp
lift c
c
, d -> Q Exp
forall t. Lift t => t -> Q Exp
lift d
d, e -> Q Exp
forall t. Lift t => t -> Q Exp
lift e
e, f -> Q Exp
forall t. Lift t => t -> Q Exp
lift f
f ]
instance (Lift a, Lift b, Lift c, Lift d, Lift e, Lift f, Lift g)
=> Lift (# a, b, c, d, e, f, g #) where
liftTyped :: (# a, b, c, d, e, f, g #) -> Q (TExp (# a, b, c, d, e, f, g #))
liftTyped (# a, b, c, d, e, f, g #)
x = Q Exp -> Q (TExp (# a, b, c, d, e, f, g #))
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce ((# a, b, c, d, e, f, g #) -> Q Exp
forall t. Lift t => t -> Q Exp
lift (# a, b, c, d, e, f, g #)
x)
lift :: (# a, b, c, d, e, f, g #) -> Q Exp
lift (# a
a, b
b, c
c, d
d, e
e, f
f, g
g #)
= ([Maybe Exp] -> Exp) -> Q [Maybe Exp] -> Q Exp
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM [Maybe Exp] -> Exp
UnboxedTupE (Q [Maybe Exp] -> Q Exp) -> Q [Maybe Exp] -> Q Exp
forall a b. (a -> b) -> a -> b
$ [Q (Maybe Exp)] -> Q [Maybe Exp]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence ([Q (Maybe Exp)] -> Q [Maybe Exp])
-> [Q (Maybe Exp)] -> Q [Maybe Exp]
forall a b. (a -> b) -> a -> b
$ (Q Exp -> Q (Maybe Exp)) -> [Q Exp] -> [Q (Maybe Exp)]
forall a b. (a -> b) -> [a] -> [b]
map ((Exp -> Maybe Exp) -> Q Exp -> Q (Maybe Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Exp -> Maybe Exp
forall a. a -> Maybe a
Just) [ a -> Q Exp
forall t. Lift t => t -> Q Exp
lift a
a, b -> Q Exp
forall t. Lift t => t -> Q Exp
lift b
b, c -> Q Exp
forall t. Lift t => t -> Q Exp
lift c
c
, d -> Q Exp
forall t. Lift t => t -> Q Exp
lift d
d, e -> Q Exp
forall t. Lift t => t -> Q Exp
lift e
e, f -> Q Exp
forall t. Lift t => t -> Q Exp
lift f
f
, g -> Q Exp
forall t. Lift t => t -> Q Exp
lift g
g ]
instance (Lift a, Lift b) => Lift (# a | b #) where
liftTyped :: (# a | b #) -> Q (TExp (# a | b #))
liftTyped (# a | b #)
x = Q Exp -> Q (TExp (# a | b #))
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce ((# a | b #) -> Q Exp
forall t. Lift t => t -> Q Exp
lift (# a | b #)
x)
lift :: (# a | b #) -> Q Exp
lift (# a | b #)
x
= case (# a | b #)
x of
(# a
y | #) -> Exp -> Int -> Int -> Exp
UnboxedSumE (Exp -> Int -> Int -> Exp) -> Q Exp -> Q (Int -> Int -> Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> Q Exp
forall t. Lift t => t -> Q Exp
lift a
y Q (Int -> Int -> Exp) -> Q Int -> Q (Int -> Exp)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
1 Q (Int -> Exp) -> Q Int -> Q Exp
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
2
(# | b
y #) -> Exp -> Int -> Int -> Exp
UnboxedSumE (Exp -> Int -> Int -> Exp) -> Q Exp -> Q (Int -> Int -> Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> b -> Q Exp
forall t. Lift t => t -> Q Exp
lift b
y Q (Int -> Int -> Exp) -> Q Int -> Q (Int -> Exp)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
2 Q (Int -> Exp) -> Q Int -> Q Exp
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
2
instance (Lift a, Lift b, Lift c)
=> Lift (# a | b | c #) where
liftTyped :: (# a | b | c #) -> Q (TExp (# a | b | c #))
liftTyped (# a | b | c #)
x = Q Exp -> Q (TExp (# a | b | c #))
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce ((# a | b | c #) -> Q Exp
forall t. Lift t => t -> Q Exp
lift (# a | b | c #)
x)
lift :: (# a | b | c #) -> Q Exp
lift (# a | b | c #)
x
= case (# a | b | c #)
x of
(# a
y | | #) -> Exp -> Int -> Int -> Exp
UnboxedSumE (Exp -> Int -> Int -> Exp) -> Q Exp -> Q (Int -> Int -> Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> Q Exp
forall t. Lift t => t -> Q Exp
lift a
y Q (Int -> Int -> Exp) -> Q Int -> Q (Int -> Exp)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
1 Q (Int -> Exp) -> Q Int -> Q Exp
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
3
(# | b
y | #) -> Exp -> Int -> Int -> Exp
UnboxedSumE (Exp -> Int -> Int -> Exp) -> Q Exp -> Q (Int -> Int -> Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> b -> Q Exp
forall t. Lift t => t -> Q Exp
lift b
y Q (Int -> Int -> Exp) -> Q Int -> Q (Int -> Exp)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
2 Q (Int -> Exp) -> Q Int -> Q Exp
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
3
(# | | c
y #) -> Exp -> Int -> Int -> Exp
UnboxedSumE (Exp -> Int -> Int -> Exp) -> Q Exp -> Q (Int -> Int -> Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> c -> Q Exp
forall t. Lift t => t -> Q Exp
lift c
y Q (Int -> Int -> Exp) -> Q Int -> Q (Int -> Exp)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
3 Q (Int -> Exp) -> Q Int -> Q Exp
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
3
instance (Lift a, Lift b, Lift c, Lift d)
=> Lift (# a | b | c | d #) where
liftTyped :: (# a | b | c | d #) -> Q (TExp (# a | b | c | d #))
liftTyped (# a | b | c | d #)
x = Q Exp -> Q (TExp (# a | b | c | d #))
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce ((# a | b | c | d #) -> Q Exp
forall t. Lift t => t -> Q Exp
lift (# a | b | c | d #)
x)
lift :: (# a | b | c | d #) -> Q Exp
lift (# a | b | c | d #)
x
= case (# a | b | c | d #)
x of
(# a
y | | | #) -> Exp -> Int -> Int -> Exp
UnboxedSumE (Exp -> Int -> Int -> Exp) -> Q Exp -> Q (Int -> Int -> Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> Q Exp
forall t. Lift t => t -> Q Exp
lift a
y Q (Int -> Int -> Exp) -> Q Int -> Q (Int -> Exp)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
1 Q (Int -> Exp) -> Q Int -> Q Exp
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
4
(# | b
y | | #) -> Exp -> Int -> Int -> Exp
UnboxedSumE (Exp -> Int -> Int -> Exp) -> Q Exp -> Q (Int -> Int -> Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> b -> Q Exp
forall t. Lift t => t -> Q Exp
lift b
y Q (Int -> Int -> Exp) -> Q Int -> Q (Int -> Exp)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
2 Q (Int -> Exp) -> Q Int -> Q Exp
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
4
(# | | c
y | #) -> Exp -> Int -> Int -> Exp
UnboxedSumE (Exp -> Int -> Int -> Exp) -> Q Exp -> Q (Int -> Int -> Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> c -> Q Exp
forall t. Lift t => t -> Q Exp
lift c
y Q (Int -> Int -> Exp) -> Q Int -> Q (Int -> Exp)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
3 Q (Int -> Exp) -> Q Int -> Q Exp
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
4
(# | | | d
y #) -> Exp -> Int -> Int -> Exp
UnboxedSumE (Exp -> Int -> Int -> Exp) -> Q Exp -> Q (Int -> Int -> Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> d -> Q Exp
forall t. Lift t => t -> Q Exp
lift d
y Q (Int -> Int -> Exp) -> Q Int -> Q (Int -> Exp)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
4 Q (Int -> Exp) -> Q Int -> Q Exp
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
4
instance (Lift a, Lift b, Lift c, Lift d, Lift e)
=> Lift (# a | b | c | d | e #) where
liftTyped :: (# a | b | c | d | e #) -> Q (TExp (# a | b | c | d | e #))
liftTyped (# a | b | c | d | e #)
x = Q Exp -> Q (TExp (# a | b | c | d | e #))
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce ((# a | b | c | d | e #) -> Q Exp
forall t. Lift t => t -> Q Exp
lift (# a | b | c | d | e #)
x)
lift :: (# a | b | c | d | e #) -> Q Exp
lift (# a | b | c | d | e #)
x
= case (# a | b | c | d | e #)
x of
(# a
y | | | | #) -> Exp -> Int -> Int -> Exp
UnboxedSumE (Exp -> Int -> Int -> Exp) -> Q Exp -> Q (Int -> Int -> Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> Q Exp
forall t. Lift t => t -> Q Exp
lift a
y Q (Int -> Int -> Exp) -> Q Int -> Q (Int -> Exp)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
1 Q (Int -> Exp) -> Q Int -> Q Exp
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
5
(# | b
y | | | #) -> Exp -> Int -> Int -> Exp
UnboxedSumE (Exp -> Int -> Int -> Exp) -> Q Exp -> Q (Int -> Int -> Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> b -> Q Exp
forall t. Lift t => t -> Q Exp
lift b
y Q (Int -> Int -> Exp) -> Q Int -> Q (Int -> Exp)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
2 Q (Int -> Exp) -> Q Int -> Q Exp
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
5
(# | | c
y | | #) -> Exp -> Int -> Int -> Exp
UnboxedSumE (Exp -> Int -> Int -> Exp) -> Q Exp -> Q (Int -> Int -> Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> c -> Q Exp
forall t. Lift t => t -> Q Exp
lift c
y Q (Int -> Int -> Exp) -> Q Int -> Q (Int -> Exp)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
3 Q (Int -> Exp) -> Q Int -> Q Exp
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
5
(# | | | d
y | #) -> Exp -> Int -> Int -> Exp
UnboxedSumE (Exp -> Int -> Int -> Exp) -> Q Exp -> Q (Int -> Int -> Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> d -> Q Exp
forall t. Lift t => t -> Q Exp
lift d
y Q (Int -> Int -> Exp) -> Q Int -> Q (Int -> Exp)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
4 Q (Int -> Exp) -> Q Int -> Q Exp
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
5
(# | | | | e
y #) -> Exp -> Int -> Int -> Exp
UnboxedSumE (Exp -> Int -> Int -> Exp) -> Q Exp -> Q (Int -> Int -> Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> e -> Q Exp
forall t. Lift t => t -> Q Exp
lift e
y Q (Int -> Int -> Exp) -> Q Int -> Q (Int -> Exp)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
5 Q (Int -> Exp) -> Q Int -> Q Exp
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
5
instance (Lift a, Lift b, Lift c, Lift d, Lift e, Lift f)
=> Lift (# a | b | c | d | e | f #) where
liftTyped :: (# a | b | c | d | e | f #) -> Q (TExp (# a | b | c | d | e | f #))
liftTyped (# a | b | c | d | e | f #)
x = Q Exp -> Q (TExp (# a | b | c | d | e | f #))
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce ((# a | b | c | d | e | f #) -> Q Exp
forall t. Lift t => t -> Q Exp
lift (# a | b | c | d | e | f #)
x)
lift :: (# a | b | c | d | e | f #) -> Q Exp
lift (# a | b | c | d | e | f #)
x
= case (# a | b | c | d | e | f #)
x of
(# a
y | | | | | #) -> Exp -> Int -> Int -> Exp
UnboxedSumE (Exp -> Int -> Int -> Exp) -> Q Exp -> Q (Int -> Int -> Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> Q Exp
forall t. Lift t => t -> Q Exp
lift a
y Q (Int -> Int -> Exp) -> Q Int -> Q (Int -> Exp)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
1 Q (Int -> Exp) -> Q Int -> Q Exp
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
6
(# | b
y | | | | #) -> Exp -> Int -> Int -> Exp
UnboxedSumE (Exp -> Int -> Int -> Exp) -> Q Exp -> Q (Int -> Int -> Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> b -> Q Exp
forall t. Lift t => t -> Q Exp
lift b
y Q (Int -> Int -> Exp) -> Q Int -> Q (Int -> Exp)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
2 Q (Int -> Exp) -> Q Int -> Q Exp
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
6
(# | | c
y | | | #) -> Exp -> Int -> Int -> Exp
UnboxedSumE (Exp -> Int -> Int -> Exp) -> Q Exp -> Q (Int -> Int -> Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> c -> Q Exp
forall t. Lift t => t -> Q Exp
lift c
y Q (Int -> Int -> Exp) -> Q Int -> Q (Int -> Exp)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
3 Q (Int -> Exp) -> Q Int -> Q Exp
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
6
(# | | | d
y | | #) -> Exp -> Int -> Int -> Exp
UnboxedSumE (Exp -> Int -> Int -> Exp) -> Q Exp -> Q (Int -> Int -> Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> d -> Q Exp
forall t. Lift t => t -> Q Exp
lift d
y Q (Int -> Int -> Exp) -> Q Int -> Q (Int -> Exp)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
4 Q (Int -> Exp) -> Q Int -> Q Exp
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
6
(# | | | | e
y | #) -> Exp -> Int -> Int -> Exp
UnboxedSumE (Exp -> Int -> Int -> Exp) -> Q Exp -> Q (Int -> Int -> Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> e -> Q Exp
forall t. Lift t => t -> Q Exp
lift e
y Q (Int -> Int -> Exp) -> Q Int -> Q (Int -> Exp)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
5 Q (Int -> Exp) -> Q Int -> Q Exp
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
6
(# | | | | | f
y #) -> Exp -> Int -> Int -> Exp
UnboxedSumE (Exp -> Int -> Int -> Exp) -> Q Exp -> Q (Int -> Int -> Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> f -> Q Exp
forall t. Lift t => t -> Q Exp
lift f
y Q (Int -> Int -> Exp) -> Q Int -> Q (Int -> Exp)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
6 Q (Int -> Exp) -> Q Int -> Q Exp
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
6
instance (Lift a, Lift b, Lift c, Lift d, Lift e, Lift f, Lift g)
=> Lift (# a | b | c | d | e | f | g #) where
liftTyped :: (# a | b | c | d | e | f | g #)
-> Q (TExp (# a | b | c | d | e | f | g #))
liftTyped (# a | b | c | d | e | f | g #)
x = Q Exp -> Q (TExp (# a | b | c | d | e | f | g #))
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce ((# a | b | c | d | e | f | g #) -> Q Exp
forall t. Lift t => t -> Q Exp
lift (# a | b | c | d | e | f | g #)
x)
lift :: (# a | b | c | d | e | f | g #) -> Q Exp
lift (# a | b | c | d | e | f | g #)
x
= case (# a | b | c | d | e | f | g #)
x of
(# a
y | | | | | | #) -> Exp -> Int -> Int -> Exp
UnboxedSumE (Exp -> Int -> Int -> Exp) -> Q Exp -> Q (Int -> Int -> Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> Q Exp
forall t. Lift t => t -> Q Exp
lift a
y Q (Int -> Int -> Exp) -> Q Int -> Q (Int -> Exp)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
1 Q (Int -> Exp) -> Q Int -> Q Exp
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
7
(# | b
y | | | | | #) -> Exp -> Int -> Int -> Exp
UnboxedSumE (Exp -> Int -> Int -> Exp) -> Q Exp -> Q (Int -> Int -> Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> b -> Q Exp
forall t. Lift t => t -> Q Exp
lift b
y Q (Int -> Int -> Exp) -> Q Int -> Q (Int -> Exp)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
2 Q (Int -> Exp) -> Q Int -> Q Exp
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
7
(# | | c
y | | | | #) -> Exp -> Int -> Int -> Exp
UnboxedSumE (Exp -> Int -> Int -> Exp) -> Q Exp -> Q (Int -> Int -> Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> c -> Q Exp
forall t. Lift t => t -> Q Exp
lift c
y Q (Int -> Int -> Exp) -> Q Int -> Q (Int -> Exp)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
3 Q (Int -> Exp) -> Q Int -> Q Exp
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
7
(# | | | d
y | | | #) -> Exp -> Int -> Int -> Exp
UnboxedSumE (Exp -> Int -> Int -> Exp) -> Q Exp -> Q (Int -> Int -> Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> d -> Q Exp
forall t. Lift t => t -> Q Exp
lift d
y Q (Int -> Int -> Exp) -> Q Int -> Q (Int -> Exp)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
4 Q (Int -> Exp) -> Q Int -> Q Exp
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
7
(# | | | | e
y | | #) -> Exp -> Int -> Int -> Exp
UnboxedSumE (Exp -> Int -> Int -> Exp) -> Q Exp -> Q (Int -> Int -> Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> e -> Q Exp
forall t. Lift t => t -> Q Exp
lift e
y Q (Int -> Int -> Exp) -> Q Int -> Q (Int -> Exp)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
5 Q (Int -> Exp) -> Q Int -> Q Exp
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
7
(# | | | | | f
y | #) -> Exp -> Int -> Int -> Exp
UnboxedSumE (Exp -> Int -> Int -> Exp) -> Q Exp -> Q (Int -> Int -> Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> f -> Q Exp
forall t. Lift t => t -> Q Exp
lift f
y Q (Int -> Int -> Exp) -> Q Int -> Q (Int -> Exp)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
6 Q (Int -> Exp) -> Q Int -> Q Exp
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
7
(# | | | | | | g
y #) -> Exp -> Int -> Int -> Exp
UnboxedSumE (Exp -> Int -> Int -> Exp) -> Q Exp -> Q (Int -> Int -> Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> g -> Q Exp
forall t. Lift t => t -> Q Exp
lift g
y Q (Int -> Int -> Exp) -> Q Int -> Q (Int -> Exp)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
7 Q (Int -> Exp) -> Q Int -> Q Exp
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
7
{-# RULES "TH:liftString" lift = \s -> return (LitE (StringL s)) #-}
trueName, falseName :: Name
trueName :: Name
trueName = NameSpace -> String -> String -> String -> Name
mkNameG NameSpace
DataName String
"ghc-prim" String
"GHC.Types" String
"True"
falseName :: Name
falseName = NameSpace -> String -> String -> String -> Name
mkNameG NameSpace
DataName String
"ghc-prim" String
"GHC.Types" String
"False"
nothingName, justName :: Name
nothingName :: Name
nothingName = NameSpace -> String -> String -> String -> Name
mkNameG NameSpace
DataName String
"base" String
"GHC.Maybe" String
"Nothing"
justName :: Name
justName = NameSpace -> String -> String -> String -> Name
mkNameG NameSpace
DataName String
"base" String
"GHC.Maybe" String
"Just"
leftName, rightName :: Name
leftName :: Name
leftName = NameSpace -> String -> String -> String -> Name
mkNameG NameSpace
DataName String
"base" String
"Data.Either" String
"Left"
rightName :: Name
rightName = NameSpace -> String -> String -> String -> Name
mkNameG NameSpace
DataName String
"base" String
"Data.Either" String
"Right"
nonemptyName :: Name
nonemptyName :: Name
nonemptyName = NameSpace -> String -> String -> String -> Name
mkNameG NameSpace
DataName String
"base" String
"GHC.Base" String
":|"
dataToQa :: forall a k q. Data a
=> (Name -> k)
-> (Lit -> Q q)
-> (k -> [Q q] -> Q q)
-> (forall b . Data b => b -> Maybe (Q q))
-> a
-> Q q
dataToQa :: (Name -> k)
-> (Lit -> Q q)
-> (k -> [Q q] -> Q q)
-> (forall b. Data b => b -> Maybe (Q q))
-> a
-> Q q
dataToQa Name -> k
mkCon Lit -> Q q
mkLit k -> [Q q] -> Q q
appCon forall b. Data b => b -> Maybe (Q q)
antiQ a
t =
case a -> Maybe (Q q)
forall b. Data b => b -> Maybe (Q q)
antiQ a
t of
Maybe (Q q)
Nothing ->
case Constr -> ConstrRep
constrRep Constr
constr of
AlgConstr Int
_ ->
k -> [Q q] -> Q q
appCon (Name -> k
mkCon Name
funOrConName) [Q q]
conArgs
where
funOrConName :: Name
funOrConName :: Name
funOrConName =
case Constr -> String
showConstr Constr
constr of
String
"(:)" -> OccName -> NameFlavour -> Name
Name (String -> OccName
mkOccName String
":")
(NameSpace -> PkgName -> ModName -> NameFlavour
NameG NameSpace
DataName
(String -> PkgName
mkPkgName String
"ghc-prim")
(String -> ModName
mkModName String
"GHC.Types"))
con :: String
con@String
"[]" -> OccName -> NameFlavour -> Name
Name (String -> OccName
mkOccName String
con)
(NameSpace -> PkgName -> ModName -> NameFlavour
NameG NameSpace
DataName
(String -> PkgName
mkPkgName String
"ghc-prim")
(String -> ModName
mkModName String
"GHC.Types"))
con :: String
con@(Char
'(':String
_) -> OccName -> NameFlavour -> Name
Name (String -> OccName
mkOccName String
con)
(NameSpace -> PkgName -> ModName -> NameFlavour
NameG NameSpace
DataName
(String -> PkgName
mkPkgName String
"ghc-prim")
(String -> ModName
mkModName String
"GHC.Tuple"))
fun :: String
fun@(Char
x:String
_) | Char -> Bool
startsVarSym Char
x Bool -> Bool -> Bool
|| Char -> Bool
startsVarId Char
x
-> String -> String -> String -> Name
mkNameG_v String
tyconPkg String
tyconMod String
fun
String
con -> String -> String -> String -> Name
mkNameG_d String
tyconPkg String
tyconMod String
con
where
tycon :: TyCon
tycon :: TyCon
tycon = (TypeRep -> TyCon
typeRepTyCon (TypeRep -> TyCon) -> (a -> TypeRep) -> a -> TyCon
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> TypeRep
forall a. Typeable a => a -> TypeRep
typeOf) a
t
tyconPkg, tyconMod :: String
tyconPkg :: String
tyconPkg = TyCon -> String
tyConPackage TyCon
tycon
tyconMod :: String
tyconMod = TyCon -> String
tyConModule TyCon
tycon
conArgs :: [Q q]
conArgs :: [Q q]
conArgs = (forall d. Data d => d -> Q q) -> a -> [Q q]
forall a u. Data a => (forall d. Data d => d -> u) -> a -> [u]
gmapQ ((Name -> k)
-> (Lit -> Q q)
-> (k -> [Q q] -> Q q)
-> (forall b. Data b => b -> Maybe (Q q))
-> d
-> Q q
forall a k q.
Data a =>
(Name -> k)
-> (Lit -> Q q)
-> (k -> [Q q] -> Q q)
-> (forall b. Data b => b -> Maybe (Q q))
-> a
-> Q q
dataToQa Name -> k
mkCon Lit -> Q q
mkLit k -> [Q q] -> Q q
appCon forall b. Data b => b -> Maybe (Q q)
antiQ) a
t
IntConstr Uniq
n ->
Lit -> Q q
mkLit (Lit -> Q q) -> Lit -> Q q
forall a b. (a -> b) -> a -> b
$ Uniq -> Lit
IntegerL Uniq
n
FloatConstr Rational
n ->
Lit -> Q q
mkLit (Lit -> Q q) -> Lit -> Q q
forall a b. (a -> b) -> a -> b
$ Rational -> Lit
RationalL Rational
n
CharConstr Char
c ->
Lit -> Q q
mkLit (Lit -> Q q) -> Lit -> Q q
forall a b. (a -> b) -> a -> b
$ Char -> Lit
CharL Char
c
where
constr :: Constr
constr :: Constr
constr = a -> Constr
forall a. Data a => a -> Constr
toConstr a
t
Just Q q
y -> Q q
y
dataToExpQ :: Data a
=> (forall b . Data b => b -> Maybe (Q Exp))
-> a
-> Q Exp
dataToExpQ :: (forall b. Data b => b -> Maybe (Q Exp)) -> a -> Q Exp
dataToExpQ = (Name -> Q Exp)
-> (Lit -> Q Exp)
-> (Q Exp -> [Q Exp] -> Q Exp)
-> (forall b. Data b => b -> Maybe (Q Exp))
-> a
-> Q Exp
forall a k q.
Data a =>
(Name -> k)
-> (Lit -> Q q)
-> (k -> [Q q] -> Q q)
-> (forall b. Data b => b -> Maybe (Q q))
-> a
-> Q q
dataToQa Name -> Q Exp
forall (m :: * -> *). MonadFail m => Name -> m Exp
varOrConE Lit -> Q Exp
forall (m :: * -> *). Monad m => Lit -> m Exp
litE ((Q Exp -> Q Exp -> Q Exp) -> Q Exp -> [Q Exp] -> Q Exp
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl Q Exp -> Q Exp -> Q Exp
forall (m :: * -> *). Monad m => m Exp -> m Exp -> m Exp
appE)
where
varOrConE :: Name -> m Exp
varOrConE Name
s =
case Name -> Maybe NameSpace
nameSpace Name
s of
Just NameSpace
VarName -> Exp -> m Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Name -> Exp
VarE Name
s)
Just NameSpace
DataName -> Exp -> m Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Name -> Exp
ConE Name
s)
Maybe NameSpace
_ -> String -> m Exp
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> m Exp) -> String -> m Exp
forall a b. (a -> b) -> a -> b
$ String
"Can't construct an expression from name "
String -> String -> String
forall a. [a] -> [a] -> [a]
++ Name -> String
showName Name
s
appE :: m Exp -> m Exp -> m Exp
appE m Exp
x m Exp
y = do { Exp
a <- m Exp
x; Exp
b <- m Exp
y; Exp -> m Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Exp -> Exp -> Exp
AppE Exp
a Exp
b)}
litE :: Lit -> m Exp
litE Lit
c = Exp -> m Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Lit -> Exp
LitE Lit
c)
liftData :: Data a => a -> Q Exp
liftData :: a -> Q Exp
liftData = (forall b. Data b => b -> Maybe (Q Exp)) -> a -> Q Exp
forall a.
Data a =>
(forall b. Data b => b -> Maybe (Q Exp)) -> a -> Q Exp
dataToExpQ (Maybe (Q Exp) -> b -> Maybe (Q Exp)
forall a b. a -> b -> a
const Maybe (Q Exp)
forall a. Maybe a
Nothing)
dataToPatQ :: Data a
=> (forall b . Data b => b -> Maybe (Q Pat))
-> a
-> Q Pat
dataToPatQ :: (forall b. Data b => b -> Maybe (Q Pat)) -> a -> Q Pat
dataToPatQ = (Name -> Name)
-> (Lit -> Q Pat)
-> (Name -> [Q Pat] -> Q Pat)
-> (forall b. Data b => b -> Maybe (Q Pat))
-> a
-> Q Pat
forall a k q.
Data a =>
(Name -> k)
-> (Lit -> Q q)
-> (k -> [Q q] -> Q q)
-> (forall b. Data b => b -> Maybe (Q q))
-> a
-> Q q
dataToQa Name -> Name
forall a. a -> a
id Lit -> Q Pat
forall (m :: * -> *). Monad m => Lit -> m Pat
litP Name -> [Q Pat] -> Q Pat
forall (m :: * -> *). MonadFail m => Name -> [m Pat] -> m Pat
conP
where litP :: Lit -> m Pat
litP Lit
l = Pat -> m Pat
forall (m :: * -> *) a. Monad m => a -> m a
return (Lit -> Pat
LitP Lit
l)
conP :: Name -> [m Pat] -> m Pat
conP Name
n [m Pat]
ps =
case Name -> Maybe NameSpace
nameSpace Name
n of
Just NameSpace
DataName -> do
[Pat]
ps' <- [m Pat] -> m [Pat]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence [m Pat]
ps
Pat -> m Pat
forall (m :: * -> *) a. Monad m => a -> m a
return (Name -> [Pat] -> Pat
ConP Name
n [Pat]
ps')
Maybe NameSpace
_ -> String -> m Pat
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> m Pat) -> String -> m Pat
forall a b. (a -> b) -> a -> b
$ String
"Can't construct a pattern from name "
String -> String -> String
forall a. [a] -> [a] -> [a]
++ Name -> String
showName Name
n
newtype ModName = ModName String
deriving (Int -> ModName -> String -> String
[ModName] -> String -> String
ModName -> String
(Int -> ModName -> String -> String)
-> (ModName -> String)
-> ([ModName] -> String -> String)
-> Show ModName
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [ModName] -> String -> String
$cshowList :: [ModName] -> String -> String
show :: ModName -> String
$cshow :: ModName -> String
showsPrec :: Int -> ModName -> String -> String
$cshowsPrec :: Int -> ModName -> String -> String
Show,ModName -> ModName -> Bool
(ModName -> ModName -> Bool)
-> (ModName -> ModName -> Bool) -> Eq ModName
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ModName -> ModName -> Bool
$c/= :: ModName -> ModName -> Bool
== :: ModName -> ModName -> Bool
$c== :: ModName -> ModName -> Bool
Eq,Eq ModName
Eq ModName
-> (ModName -> ModName -> Ordering)
-> (ModName -> ModName -> Bool)
-> (ModName -> ModName -> Bool)
-> (ModName -> ModName -> Bool)
-> (ModName -> ModName -> Bool)
-> (ModName -> ModName -> ModName)
-> (ModName -> ModName -> ModName)
-> Ord ModName
ModName -> ModName -> Bool
ModName -> ModName -> Ordering
ModName -> ModName -> ModName
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: ModName -> ModName -> ModName
$cmin :: ModName -> ModName -> ModName
max :: ModName -> ModName -> ModName
$cmax :: ModName -> ModName -> ModName
>= :: ModName -> ModName -> Bool
$c>= :: ModName -> ModName -> Bool
> :: ModName -> ModName -> Bool
$c> :: ModName -> ModName -> Bool
<= :: ModName -> ModName -> Bool
$c<= :: ModName -> ModName -> Bool
< :: ModName -> ModName -> Bool
$c< :: ModName -> ModName -> Bool
compare :: ModName -> ModName -> Ordering
$ccompare :: ModName -> ModName -> Ordering
$cp1Ord :: Eq ModName
Ord,Typeable ModName
DataType
Constr
Typeable ModName
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ModName -> c ModName)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ModName)
-> (ModName -> Constr)
-> (ModName -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ModName))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ModName))
-> ((forall b. Data b => b -> b) -> ModName -> ModName)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ModName -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ModName -> r)
-> (forall u. (forall d. Data d => d -> u) -> ModName -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> ModName -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ModName -> m ModName)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ModName -> m ModName)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ModName -> m ModName)
-> Data ModName
ModName -> DataType
ModName -> Constr
(forall b. Data b => b -> b) -> ModName -> ModName
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ModName -> c ModName
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ModName
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) -> ModName -> u
forall u. (forall d. Data d => d -> u) -> ModName -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ModName -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ModName -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ModName -> m ModName
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ModName -> m ModName
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ModName
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ModName -> c ModName
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ModName)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ModName)
$cModName :: Constr
$tModName :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> ModName -> m ModName
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ModName -> m ModName
gmapMp :: (forall d. Data d => d -> m d) -> ModName -> m ModName
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ModName -> m ModName
gmapM :: (forall d. Data d => d -> m d) -> ModName -> m ModName
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ModName -> m ModName
gmapQi :: Int -> (forall d. Data d => d -> u) -> ModName -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ModName -> u
gmapQ :: (forall d. Data d => d -> u) -> ModName -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ModName -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ModName -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ModName -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ModName -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ModName -> r
gmapT :: (forall b. Data b => b -> b) -> ModName -> ModName
$cgmapT :: (forall b. Data b => b -> b) -> ModName -> ModName
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ModName)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ModName)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c ModName)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ModName)
dataTypeOf :: ModName -> DataType
$cdataTypeOf :: ModName -> DataType
toConstr :: ModName -> Constr
$ctoConstr :: ModName -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ModName
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ModName
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ModName -> c ModName
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ModName -> c ModName
$cp1Data :: Typeable ModName
Data,(forall x. ModName -> Rep ModName x)
-> (forall x. Rep ModName x -> ModName) -> Generic ModName
forall x. Rep ModName x -> ModName
forall x. ModName -> Rep ModName x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ModName x -> ModName
$cfrom :: forall x. ModName -> Rep ModName x
Generic)
newtype PkgName = PkgName String
deriving (Int -> PkgName -> String -> String
[PkgName] -> String -> String
PkgName -> String
(Int -> PkgName -> String -> String)
-> (PkgName -> String)
-> ([PkgName] -> String -> String)
-> Show PkgName
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [PkgName] -> String -> String
$cshowList :: [PkgName] -> String -> String
show :: PkgName -> String
$cshow :: PkgName -> String
showsPrec :: Int -> PkgName -> String -> String
$cshowsPrec :: Int -> PkgName -> String -> String
Show,PkgName -> PkgName -> Bool
(PkgName -> PkgName -> Bool)
-> (PkgName -> PkgName -> Bool) -> Eq PkgName
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PkgName -> PkgName -> Bool
$c/= :: PkgName -> PkgName -> Bool
== :: PkgName -> PkgName -> Bool
$c== :: PkgName -> PkgName -> Bool
Eq,Eq PkgName
Eq PkgName
-> (PkgName -> PkgName -> Ordering)
-> (PkgName -> PkgName -> Bool)
-> (PkgName -> PkgName -> Bool)
-> (PkgName -> PkgName -> Bool)
-> (PkgName -> PkgName -> Bool)
-> (PkgName -> PkgName -> PkgName)
-> (PkgName -> PkgName -> PkgName)
-> Ord PkgName
PkgName -> PkgName -> Bool
PkgName -> PkgName -> Ordering
PkgName -> PkgName -> PkgName
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: PkgName -> PkgName -> PkgName
$cmin :: PkgName -> PkgName -> PkgName
max :: PkgName -> PkgName -> PkgName
$cmax :: PkgName -> PkgName -> PkgName
>= :: PkgName -> PkgName -> Bool
$c>= :: PkgName -> PkgName -> Bool
> :: PkgName -> PkgName -> Bool
$c> :: PkgName -> PkgName -> Bool
<= :: PkgName -> PkgName -> Bool
$c<= :: PkgName -> PkgName -> Bool
< :: PkgName -> PkgName -> Bool
$c< :: PkgName -> PkgName -> Bool
compare :: PkgName -> PkgName -> Ordering
$ccompare :: PkgName -> PkgName -> Ordering
$cp1Ord :: Eq PkgName
Ord,Typeable PkgName
DataType
Constr
Typeable PkgName
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PkgName -> c PkgName)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PkgName)
-> (PkgName -> Constr)
-> (PkgName -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PkgName))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PkgName))
-> ((forall b. Data b => b -> b) -> PkgName -> PkgName)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PkgName -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PkgName -> r)
-> (forall u. (forall d. Data d => d -> u) -> PkgName -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> PkgName -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PkgName -> m PkgName)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PkgName -> m PkgName)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PkgName -> m PkgName)
-> Data PkgName
PkgName -> DataType
PkgName -> Constr
(forall b. Data b => b -> b) -> PkgName -> PkgName
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PkgName -> c PkgName
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PkgName
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) -> PkgName -> u
forall u. (forall d. Data d => d -> u) -> PkgName -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PkgName -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PkgName -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PkgName -> m PkgName
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PkgName -> m PkgName
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PkgName
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PkgName -> c PkgName
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PkgName)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PkgName)
$cPkgName :: Constr
$tPkgName :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> PkgName -> m PkgName
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PkgName -> m PkgName
gmapMp :: (forall d. Data d => d -> m d) -> PkgName -> m PkgName
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PkgName -> m PkgName
gmapM :: (forall d. Data d => d -> m d) -> PkgName -> m PkgName
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PkgName -> m PkgName
gmapQi :: Int -> (forall d. Data d => d -> u) -> PkgName -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> PkgName -> u
gmapQ :: (forall d. Data d => d -> u) -> PkgName -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> PkgName -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PkgName -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PkgName -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PkgName -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PkgName -> r
gmapT :: (forall b. Data b => b -> b) -> PkgName -> PkgName
$cgmapT :: (forall b. Data b => b -> b) -> PkgName -> PkgName
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PkgName)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PkgName)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c PkgName)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PkgName)
dataTypeOf :: PkgName -> DataType
$cdataTypeOf :: PkgName -> DataType
toConstr :: PkgName -> Constr
$ctoConstr :: PkgName -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PkgName
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PkgName
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PkgName -> c PkgName
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PkgName -> c PkgName
$cp1Data :: Typeable PkgName
Data,(forall x. PkgName -> Rep PkgName x)
-> (forall x. Rep PkgName x -> PkgName) -> Generic PkgName
forall x. Rep PkgName x -> PkgName
forall x. PkgName -> Rep PkgName x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep PkgName x -> PkgName
$cfrom :: forall x. PkgName -> Rep PkgName x
Generic)
data Module = Module PkgName ModName
deriving (Int -> Module -> String -> String
[Module] -> String -> String
Module -> String
(Int -> Module -> String -> String)
-> (Module -> String)
-> ([Module] -> String -> String)
-> Show Module
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [Module] -> String -> String
$cshowList :: [Module] -> String -> String
show :: Module -> String
$cshow :: Module -> String
showsPrec :: Int -> Module -> String -> String
$cshowsPrec :: Int -> Module -> String -> String
Show,Module -> Module -> Bool
(Module -> Module -> Bool)
-> (Module -> Module -> Bool) -> Eq Module
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Module -> Module -> Bool
$c/= :: Module -> Module -> Bool
== :: Module -> Module -> Bool
$c== :: Module -> Module -> Bool
Eq,Eq Module
Eq Module
-> (Module -> Module -> Ordering)
-> (Module -> Module -> Bool)
-> (Module -> Module -> Bool)
-> (Module -> Module -> Bool)
-> (Module -> Module -> Bool)
-> (Module -> Module -> Module)
-> (Module -> Module -> Module)
-> Ord Module
Module -> Module -> Bool
Module -> Module -> Ordering
Module -> Module -> Module
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Module -> Module -> Module
$cmin :: Module -> Module -> Module
max :: Module -> Module -> Module
$cmax :: Module -> Module -> Module
>= :: Module -> Module -> Bool
$c>= :: Module -> Module -> Bool
> :: Module -> Module -> Bool
$c> :: Module -> Module -> Bool
<= :: Module -> Module -> Bool
$c<= :: Module -> Module -> Bool
< :: Module -> Module -> Bool
$c< :: Module -> Module -> Bool
compare :: Module -> Module -> Ordering
$ccompare :: Module -> Module -> Ordering
$cp1Ord :: Eq Module
Ord,Typeable Module
DataType
Constr
Typeable Module
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Module -> c Module)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Module)
-> (Module -> Constr)
-> (Module -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Module))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Module))
-> ((forall b. Data b => b -> b) -> Module -> Module)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Module -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Module -> r)
-> (forall u. (forall d. Data d => d -> u) -> Module -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Module -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Module -> m Module)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Module -> m Module)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Module -> m Module)
-> Data Module
Module -> DataType
Module -> Constr
(forall b. Data b => b -> b) -> Module -> Module
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Module -> c Module
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Module
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) -> Module -> u
forall u. (forall d. Data d => d -> u) -> Module -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Module -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Module -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Module -> m Module
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Module -> m Module
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Module
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Module -> c Module
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Module)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Module)
$cModule :: Constr
$tModule :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Module -> m Module
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Module -> m Module
gmapMp :: (forall d. Data d => d -> m d) -> Module -> m Module
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Module -> m Module
gmapM :: (forall d. Data d => d -> m d) -> Module -> m Module
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Module -> m Module
gmapQi :: Int -> (forall d. Data d => d -> u) -> Module -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Module -> u
gmapQ :: (forall d. Data d => d -> u) -> Module -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Module -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Module -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Module -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Module -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Module -> r
gmapT :: (forall b. Data b => b -> b) -> Module -> Module
$cgmapT :: (forall b. Data b => b -> b) -> Module -> Module
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Module)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Module)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Module)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Module)
dataTypeOf :: Module -> DataType
$cdataTypeOf :: Module -> DataType
toConstr :: Module -> Constr
$ctoConstr :: Module -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Module
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Module
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Module -> c Module
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Module -> c Module
$cp1Data :: Typeable Module
Data,(forall x. Module -> Rep Module x)
-> (forall x. Rep Module x -> Module) -> Generic Module
forall x. Rep Module x -> Module
forall x. Module -> Rep Module x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Module x -> Module
$cfrom :: forall x. Module -> Rep Module x
Generic)
newtype OccName = OccName String
deriving (Int -> OccName -> String -> String
[OccName] -> String -> String
OccName -> String
(Int -> OccName -> String -> String)
-> (OccName -> String)
-> ([OccName] -> String -> String)
-> Show OccName
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [OccName] -> String -> String
$cshowList :: [OccName] -> String -> String
show :: OccName -> String
$cshow :: OccName -> String
showsPrec :: Int -> OccName -> String -> String
$cshowsPrec :: Int -> OccName -> String -> String
Show,OccName -> OccName -> Bool
(OccName -> OccName -> Bool)
-> (OccName -> OccName -> Bool) -> Eq OccName
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: OccName -> OccName -> Bool
$c/= :: OccName -> OccName -> Bool
== :: OccName -> OccName -> Bool
$c== :: OccName -> OccName -> Bool
Eq,Eq OccName
Eq OccName
-> (OccName -> OccName -> Ordering)
-> (OccName -> OccName -> Bool)
-> (OccName -> OccName -> Bool)
-> (OccName -> OccName -> Bool)
-> (OccName -> OccName -> Bool)
-> (OccName -> OccName -> OccName)
-> (OccName -> OccName -> OccName)
-> Ord OccName
OccName -> OccName -> Bool
OccName -> OccName -> Ordering
OccName -> OccName -> OccName
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: OccName -> OccName -> OccName
$cmin :: OccName -> OccName -> OccName
max :: OccName -> OccName -> OccName
$cmax :: OccName -> OccName -> OccName
>= :: OccName -> OccName -> Bool
$c>= :: OccName -> OccName -> Bool
> :: OccName -> OccName -> Bool
$c> :: OccName -> OccName -> Bool
<= :: OccName -> OccName -> Bool
$c<= :: OccName -> OccName -> Bool
< :: OccName -> OccName -> Bool
$c< :: OccName -> OccName -> Bool
compare :: OccName -> OccName -> Ordering
$ccompare :: OccName -> OccName -> Ordering
$cp1Ord :: Eq OccName
Ord,Typeable OccName
DataType
Constr
Typeable OccName
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OccName -> c OccName)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c OccName)
-> (OccName -> Constr)
-> (OccName -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c OccName))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OccName))
-> ((forall b. Data b => b -> b) -> OccName -> OccName)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> OccName -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> OccName -> r)
-> (forall u. (forall d. Data d => d -> u) -> OccName -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> OccName -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> OccName -> m OccName)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> OccName -> m OccName)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> OccName -> m OccName)
-> Data OccName
OccName -> DataType
OccName -> Constr
(forall b. Data b => b -> b) -> OccName -> OccName
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OccName -> c OccName
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c OccName
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) -> OccName -> u
forall u. (forall d. Data d => d -> u) -> OccName -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> OccName -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> OccName -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> OccName -> m OccName
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> OccName -> m OccName
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c OccName
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OccName -> c OccName
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c OccName)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OccName)
$cOccName :: Constr
$tOccName :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> OccName -> m OccName
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> OccName -> m OccName
gmapMp :: (forall d. Data d => d -> m d) -> OccName -> m OccName
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> OccName -> m OccName
gmapM :: (forall d. Data d => d -> m d) -> OccName -> m OccName
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> OccName -> m OccName
gmapQi :: Int -> (forall d. Data d => d -> u) -> OccName -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> OccName -> u
gmapQ :: (forall d. Data d => d -> u) -> OccName -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> OccName -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> OccName -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> OccName -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> OccName -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> OccName -> r
gmapT :: (forall b. Data b => b -> b) -> OccName -> OccName
$cgmapT :: (forall b. Data b => b -> b) -> OccName -> OccName
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OccName)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OccName)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c OccName)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c OccName)
dataTypeOf :: OccName -> DataType
$cdataTypeOf :: OccName -> DataType
toConstr :: OccName -> Constr
$ctoConstr :: OccName -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c OccName
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c OccName
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OccName -> c OccName
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OccName -> c OccName
$cp1Data :: Typeable OccName
Data,(forall x. OccName -> Rep OccName x)
-> (forall x. Rep OccName x -> OccName) -> Generic OccName
forall x. Rep OccName x -> OccName
forall x. OccName -> Rep OccName x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep OccName x -> OccName
$cfrom :: forall x. OccName -> Rep OccName x
Generic)
mkModName :: String -> ModName
mkModName :: String -> ModName
mkModName String
s = String -> ModName
ModName String
s
modString :: ModName -> String
modString :: ModName -> String
modString (ModName String
m) = String
m
mkPkgName :: String -> PkgName
mkPkgName :: String -> PkgName
mkPkgName String
s = String -> PkgName
PkgName String
s
pkgString :: PkgName -> String
pkgString :: PkgName -> String
pkgString (PkgName String
m) = String
m
mkOccName :: String -> OccName
mkOccName :: String -> OccName
mkOccName String
s = String -> OccName
OccName String
s
occString :: OccName -> String
occString :: OccName -> String
occString (OccName String
occ) = String
occ
data Name = Name OccName NameFlavour deriving (Typeable Name
DataType
Constr
Typeable Name
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Name -> c Name)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Name)
-> (Name -> Constr)
-> (Name -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Name))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Name))
-> ((forall b. Data b => b -> b) -> Name -> Name)
-> (forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r)
-> (forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r)
-> (forall u. (forall d. Data d => d -> u) -> Name -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Name -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Name -> m Name)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Name -> m Name)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Name -> m Name)
-> Data Name
Name -> DataType
Name -> Constr
(forall b. Data b => b -> b) -> Name -> Name
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Name -> c Name
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Name
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) -> Name -> u
forall u. (forall d. Data d => d -> u) -> Name -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Name -> m Name
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Name -> m Name
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Name
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Name -> c Name
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Name)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Name)
$cName :: Constr
$tName :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Name -> m Name
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Name -> m Name
gmapMp :: (forall d. Data d => d -> m d) -> Name -> m Name
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Name -> m Name
gmapM :: (forall d. Data d => d -> m d) -> Name -> m Name
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Name -> m Name
gmapQi :: Int -> (forall d. Data d => d -> u) -> Name -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Name -> u
gmapQ :: (forall d. Data d => d -> u) -> Name -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Name -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r
gmapT :: (forall b. Data b => b -> b) -> Name -> Name
$cgmapT :: (forall b. Data b => b -> b) -> Name -> Name
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Name)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Name)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Name)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Name)
dataTypeOf :: Name -> DataType
$cdataTypeOf :: Name -> DataType
toConstr :: Name -> Constr
$ctoConstr :: Name -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Name
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Name
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Name -> c Name
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Name -> c Name
$cp1Data :: Typeable Name
Data, Name -> Name -> Bool
(Name -> Name -> Bool) -> (Name -> Name -> Bool) -> Eq Name
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Name -> Name -> Bool
$c/= :: Name -> Name -> Bool
== :: Name -> Name -> Bool
$c== :: Name -> Name -> Bool
Eq, (forall x. Name -> Rep Name x)
-> (forall x. Rep Name x -> Name) -> Generic Name
forall x. Rep Name x -> Name
forall x. Name -> Rep Name x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Name x -> Name
$cfrom :: forall x. Name -> Rep Name x
Generic)
instance Ord Name where
(Name OccName
o1 NameFlavour
f1) compare :: Name -> Name -> Ordering
`compare` (Name OccName
o2 NameFlavour
f2) = (NameFlavour
f1 NameFlavour -> NameFlavour -> Ordering
forall a. Ord a => a -> a -> Ordering
`compare` NameFlavour
f2) Ordering -> Ordering -> Ordering
`thenCmp`
(OccName
o1 OccName -> OccName -> Ordering
forall a. Ord a => a -> a -> Ordering
`compare` OccName
o2)
data NameFlavour
= NameS
| NameQ ModName
| NameU !Uniq
| NameL !Uniq
| NameG NameSpace PkgName ModName
deriving ( Typeable NameFlavour
DataType
Constr
Typeable NameFlavour
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NameFlavour -> c NameFlavour)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NameFlavour)
-> (NameFlavour -> Constr)
-> (NameFlavour -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NameFlavour))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c NameFlavour))
-> ((forall b. Data b => b -> b) -> NameFlavour -> NameFlavour)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NameFlavour -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NameFlavour -> r)
-> (forall u. (forall d. Data d => d -> u) -> NameFlavour -> [u])
-> (forall u.
Int -> (forall d. Data d => d -> u) -> NameFlavour -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NameFlavour -> m NameFlavour)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NameFlavour -> m NameFlavour)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NameFlavour -> m NameFlavour)
-> Data NameFlavour
NameFlavour -> DataType
NameFlavour -> Constr
(forall b. Data b => b -> b) -> NameFlavour -> NameFlavour
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NameFlavour -> c NameFlavour
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NameFlavour
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) -> NameFlavour -> u
forall u. (forall d. Data d => d -> u) -> NameFlavour -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NameFlavour -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NameFlavour -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NameFlavour -> m NameFlavour
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NameFlavour -> m NameFlavour
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NameFlavour
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NameFlavour -> c NameFlavour
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NameFlavour)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c NameFlavour)
$cNameG :: Constr
$cNameL :: Constr
$cNameU :: Constr
$cNameQ :: Constr
$cNameS :: Constr
$tNameFlavour :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> NameFlavour -> m NameFlavour
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NameFlavour -> m NameFlavour
gmapMp :: (forall d. Data d => d -> m d) -> NameFlavour -> m NameFlavour
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NameFlavour -> m NameFlavour
gmapM :: (forall d. Data d => d -> m d) -> NameFlavour -> m NameFlavour
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NameFlavour -> m NameFlavour
gmapQi :: Int -> (forall d. Data d => d -> u) -> NameFlavour -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> NameFlavour -> u
gmapQ :: (forall d. Data d => d -> u) -> NameFlavour -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> NameFlavour -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NameFlavour -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NameFlavour -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NameFlavour -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NameFlavour -> r
gmapT :: (forall b. Data b => b -> b) -> NameFlavour -> NameFlavour
$cgmapT :: (forall b. Data b => b -> b) -> NameFlavour -> NameFlavour
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c NameFlavour)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c NameFlavour)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c NameFlavour)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NameFlavour)
dataTypeOf :: NameFlavour -> DataType
$cdataTypeOf :: NameFlavour -> DataType
toConstr :: NameFlavour -> Constr
$ctoConstr :: NameFlavour -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NameFlavour
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NameFlavour
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NameFlavour -> c NameFlavour
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NameFlavour -> c NameFlavour
$cp1Data :: Typeable NameFlavour
Data, NameFlavour -> NameFlavour -> Bool
(NameFlavour -> NameFlavour -> Bool)
-> (NameFlavour -> NameFlavour -> Bool) -> Eq NameFlavour
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NameFlavour -> NameFlavour -> Bool
$c/= :: NameFlavour -> NameFlavour -> Bool
== :: NameFlavour -> NameFlavour -> Bool
$c== :: NameFlavour -> NameFlavour -> Bool
Eq, Eq NameFlavour
Eq NameFlavour
-> (NameFlavour -> NameFlavour -> Ordering)
-> (NameFlavour -> NameFlavour -> Bool)
-> (NameFlavour -> NameFlavour -> Bool)
-> (NameFlavour -> NameFlavour -> Bool)
-> (NameFlavour -> NameFlavour -> Bool)
-> (NameFlavour -> NameFlavour -> NameFlavour)
-> (NameFlavour -> NameFlavour -> NameFlavour)
-> Ord NameFlavour
NameFlavour -> NameFlavour -> Bool
NameFlavour -> NameFlavour -> Ordering
NameFlavour -> NameFlavour -> NameFlavour
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: NameFlavour -> NameFlavour -> NameFlavour
$cmin :: NameFlavour -> NameFlavour -> NameFlavour
max :: NameFlavour -> NameFlavour -> NameFlavour
$cmax :: NameFlavour -> NameFlavour -> NameFlavour
>= :: NameFlavour -> NameFlavour -> Bool
$c>= :: NameFlavour -> NameFlavour -> Bool
> :: NameFlavour -> NameFlavour -> Bool
$c> :: NameFlavour -> NameFlavour -> Bool
<= :: NameFlavour -> NameFlavour -> Bool
$c<= :: NameFlavour -> NameFlavour -> Bool
< :: NameFlavour -> NameFlavour -> Bool
$c< :: NameFlavour -> NameFlavour -> Bool
compare :: NameFlavour -> NameFlavour -> Ordering
$ccompare :: NameFlavour -> NameFlavour -> Ordering
$cp1Ord :: Eq NameFlavour
Ord, Int -> NameFlavour -> String -> String
[NameFlavour] -> String -> String
NameFlavour -> String
(Int -> NameFlavour -> String -> String)
-> (NameFlavour -> String)
-> ([NameFlavour] -> String -> String)
-> Show NameFlavour
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [NameFlavour] -> String -> String
$cshowList :: [NameFlavour] -> String -> String
show :: NameFlavour -> String
$cshow :: NameFlavour -> String
showsPrec :: Int -> NameFlavour -> String -> String
$cshowsPrec :: Int -> NameFlavour -> String -> String
Show, (forall x. NameFlavour -> Rep NameFlavour x)
-> (forall x. Rep NameFlavour x -> NameFlavour)
-> Generic NameFlavour
forall x. Rep NameFlavour x -> NameFlavour
forall x. NameFlavour -> Rep NameFlavour x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep NameFlavour x -> NameFlavour
$cfrom :: forall x. NameFlavour -> Rep NameFlavour x
Generic )
data NameSpace = VarName
| DataName
| TcClsName
deriving( NameSpace -> NameSpace -> Bool
(NameSpace -> NameSpace -> Bool)
-> (NameSpace -> NameSpace -> Bool) -> Eq NameSpace
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NameSpace -> NameSpace -> Bool
$c/= :: NameSpace -> NameSpace -> Bool
== :: NameSpace -> NameSpace -> Bool
$c== :: NameSpace -> NameSpace -> Bool
Eq, Eq NameSpace
Eq NameSpace
-> (NameSpace -> NameSpace -> Ordering)
-> (NameSpace -> NameSpace -> Bool)
-> (NameSpace -> NameSpace -> Bool)
-> (NameSpace -> NameSpace -> Bool)
-> (NameSpace -> NameSpace -> Bool)
-> (NameSpace -> NameSpace -> NameSpace)
-> (NameSpace -> NameSpace -> NameSpace)
-> Ord NameSpace
NameSpace -> NameSpace -> Bool
NameSpace -> NameSpace -> Ordering
NameSpace -> NameSpace -> NameSpace
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: NameSpace -> NameSpace -> NameSpace
$cmin :: NameSpace -> NameSpace -> NameSpace
max :: NameSpace -> NameSpace -> NameSpace
$cmax :: NameSpace -> NameSpace -> NameSpace
>= :: NameSpace -> NameSpace -> Bool
$c>= :: NameSpace -> NameSpace -> Bool
> :: NameSpace -> NameSpace -> Bool
$c> :: NameSpace -> NameSpace -> Bool
<= :: NameSpace -> NameSpace -> Bool
$c<= :: NameSpace -> NameSpace -> Bool
< :: NameSpace -> NameSpace -> Bool
$c< :: NameSpace -> NameSpace -> Bool
compare :: NameSpace -> NameSpace -> Ordering
$ccompare :: NameSpace -> NameSpace -> Ordering
$cp1Ord :: Eq NameSpace
Ord, Int -> NameSpace -> String -> String
[NameSpace] -> String -> String
NameSpace -> String
(Int -> NameSpace -> String -> String)
-> (NameSpace -> String)
-> ([NameSpace] -> String -> String)
-> Show NameSpace
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [NameSpace] -> String -> String
$cshowList :: [NameSpace] -> String -> String
show :: NameSpace -> String
$cshow :: NameSpace -> String
showsPrec :: Int -> NameSpace -> String -> String
$cshowsPrec :: Int -> NameSpace -> String -> String
Show, Typeable NameSpace
DataType
Constr
Typeable NameSpace
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NameSpace -> c NameSpace)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NameSpace)
-> (NameSpace -> Constr)
-> (NameSpace -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NameSpace))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NameSpace))
-> ((forall b. Data b => b -> b) -> NameSpace -> NameSpace)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NameSpace -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NameSpace -> r)
-> (forall u. (forall d. Data d => d -> u) -> NameSpace -> [u])
-> (forall u.
Int -> (forall d. Data d => d -> u) -> NameSpace -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NameSpace -> m NameSpace)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NameSpace -> m NameSpace)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NameSpace -> m NameSpace)
-> Data NameSpace
NameSpace -> DataType
NameSpace -> Constr
(forall b. Data b => b -> b) -> NameSpace -> NameSpace
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NameSpace -> c NameSpace
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NameSpace
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) -> NameSpace -> u
forall u. (forall d. Data d => d -> u) -> NameSpace -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NameSpace -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NameSpace -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NameSpace -> m NameSpace
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NameSpace -> m NameSpace
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NameSpace
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NameSpace -> c NameSpace
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NameSpace)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NameSpace)
$cTcClsName :: Constr
$cDataName :: Constr
$cVarName :: Constr
$tNameSpace :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> NameSpace -> m NameSpace
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NameSpace -> m NameSpace
gmapMp :: (forall d. Data d => d -> m d) -> NameSpace -> m NameSpace
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NameSpace -> m NameSpace
gmapM :: (forall d. Data d => d -> m d) -> NameSpace -> m NameSpace
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NameSpace -> m NameSpace
gmapQi :: Int -> (forall d. Data d => d -> u) -> NameSpace -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> NameSpace -> u
gmapQ :: (forall d. Data d => d -> u) -> NameSpace -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> NameSpace -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NameSpace -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NameSpace -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NameSpace -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NameSpace -> r
gmapT :: (forall b. Data b => b -> b) -> NameSpace -> NameSpace
$cgmapT :: (forall b. Data b => b -> b) -> NameSpace -> NameSpace
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NameSpace)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NameSpace)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c NameSpace)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NameSpace)
dataTypeOf :: NameSpace -> DataType
$cdataTypeOf :: NameSpace -> DataType
toConstr :: NameSpace -> Constr
$ctoConstr :: NameSpace -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NameSpace
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NameSpace
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NameSpace -> c NameSpace
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NameSpace -> c NameSpace
$cp1Data :: Typeable NameSpace
Data, (forall x. NameSpace -> Rep NameSpace x)
-> (forall x. Rep NameSpace x -> NameSpace) -> Generic NameSpace
forall x. Rep NameSpace x -> NameSpace
forall x. NameSpace -> Rep NameSpace x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep NameSpace x -> NameSpace
$cfrom :: forall x. NameSpace -> Rep NameSpace x
Generic )
type Uniq = Integer
nameBase :: Name -> String
nameBase :: Name -> String
nameBase (Name OccName
occ NameFlavour
_) = OccName -> String
occString OccName
occ
nameModule :: Name -> Maybe String
nameModule :: Name -> Maybe String
nameModule (Name OccName
_ (NameQ ModName
m)) = String -> Maybe String
forall a. a -> Maybe a
Just (ModName -> String
modString ModName
m)
nameModule (Name OccName
_ (NameG NameSpace
_ PkgName
_ ModName
m)) = String -> Maybe String
forall a. a -> Maybe a
Just (ModName -> String
modString ModName
m)
nameModule Name
_ = Maybe String
forall a. Maybe a
Nothing
namePackage :: Name -> Maybe String
namePackage :: Name -> Maybe String
namePackage (Name OccName
_ (NameG NameSpace
_ PkgName
p ModName
_)) = String -> Maybe String
forall a. a -> Maybe a
Just (PkgName -> String
pkgString PkgName
p)
namePackage Name
_ = Maybe String
forall a. Maybe a
Nothing
nameSpace :: Name -> Maybe NameSpace
nameSpace :: Name -> Maybe NameSpace
nameSpace (Name OccName
_ (NameG NameSpace
ns PkgName
_ ModName
_)) = NameSpace -> Maybe NameSpace
forall a. a -> Maybe a
Just NameSpace
ns
nameSpace Name
_ = Maybe NameSpace
forall a. Maybe a
Nothing
mkName :: String -> Name
mkName :: String -> Name
mkName String
str
= String -> String -> Name
split [] (String -> String
forall a. [a] -> [a]
reverse String
str)
where
split :: String -> String -> Name
split String
occ [] = OccName -> NameFlavour -> Name
Name (String -> OccName
mkOccName String
occ) NameFlavour
NameS
split String
occ (Char
'.':String
rev) | Bool -> Bool
not (String -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null String
occ)
, String -> Bool
is_rev_mod_name String
rev
= OccName -> NameFlavour -> Name
Name (String -> OccName
mkOccName String
occ) (ModName -> NameFlavour
NameQ (String -> ModName
mkModName (String -> String
forall a. [a] -> [a]
reverse String
rev)))
split String
occ (Char
c:String
rev) = String -> String -> Name
split (Char
cChar -> String -> String
forall a. a -> [a] -> [a]
:String
occ) String
rev
is_rev_mod_name :: String -> Bool
is_rev_mod_name String
rev_mod_str
| (String
compt, String
rest) <- (Char -> Bool) -> String -> (String, String)
forall a. (a -> Bool) -> [a] -> ([a], [a])
break (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'.') String
rev_mod_str
, Bool -> Bool
not (String -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null String
compt), Char -> Bool
isUpper (String -> Char
forall a. [a] -> a
last String
compt), (Char -> Bool) -> String -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all Char -> Bool
is_mod_char String
compt
= case String
rest of
[] -> Bool
True
(Char
_dot : String
rest') -> String -> Bool
is_rev_mod_name String
rest'
| Bool
otherwise
= Bool
False
is_mod_char :: Char -> Bool
is_mod_char Char
c = Char -> Bool
isAlphaNum Char
c Bool -> Bool -> Bool
|| Char
c Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'_' Bool -> Bool -> Bool
|| Char
c Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'\''
mkNameU :: String -> Uniq -> Name
mkNameU :: String -> Uniq -> Name
mkNameU String
s Uniq
u = OccName -> NameFlavour -> Name
Name (String -> OccName
mkOccName String
s) (Uniq -> NameFlavour
NameU Uniq
u)
mkNameL :: String -> Uniq -> Name
mkNameL :: String -> Uniq -> Name
mkNameL String
s Uniq
u = OccName -> NameFlavour -> Name
Name (String -> OccName
mkOccName String
s) (Uniq -> NameFlavour
NameL Uniq
u)
mkNameG :: NameSpace -> String -> String -> String -> Name
mkNameG :: NameSpace -> String -> String -> String -> Name
mkNameG NameSpace
ns String
pkg String
modu String
occ
= OccName -> NameFlavour -> Name
Name (String -> OccName
mkOccName String
occ) (NameSpace -> PkgName -> ModName -> NameFlavour
NameG NameSpace
ns (String -> PkgName
mkPkgName String
pkg) (String -> ModName
mkModName String
modu))
mkNameS :: String -> Name
mkNameS :: String -> Name
mkNameS String
n = OccName -> NameFlavour -> Name
Name (String -> OccName
mkOccName String
n) NameFlavour
NameS
mkNameG_v, mkNameG_tc, mkNameG_d :: String -> String -> String -> Name
mkNameG_v :: String -> String -> String -> Name
mkNameG_v = NameSpace -> String -> String -> String -> Name
mkNameG NameSpace
VarName
mkNameG_tc :: String -> String -> String -> Name
mkNameG_tc = NameSpace -> String -> String -> String -> Name
mkNameG NameSpace
TcClsName
mkNameG_d :: String -> String -> String -> Name
mkNameG_d = NameSpace -> String -> String -> String -> Name
mkNameG NameSpace
DataName
data NameIs = Alone | Applied | Infix
showName :: Name -> String
showName :: Name -> String
showName = NameIs -> Name -> String
showName' NameIs
Alone
showName' :: NameIs -> Name -> String
showName' :: NameIs -> Name -> String
showName' NameIs
ni Name
nm
= case NameIs
ni of
NameIs
Alone -> String
nms
NameIs
Applied
| Bool
pnam -> String
nms
| Bool
otherwise -> String
"(" String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
nms String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
")"
NameIs
Infix
| Bool
pnam -> String
"`" String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
nms String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"`"
| Bool
otherwise -> String
nms
where
nms :: String
nms = case Name
nm of
Name OccName
occ NameFlavour
NameS -> OccName -> String
occString OccName
occ
Name OccName
occ (NameQ ModName
m) -> ModName -> String
modString ModName
m String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"." String -> String -> String
forall a. [a] -> [a] -> [a]
++ OccName -> String
occString OccName
occ
Name OccName
occ (NameG NameSpace
_ PkgName
_ ModName
m) -> ModName -> String
modString ModName
m String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"." String -> String -> String
forall a. [a] -> [a] -> [a]
++ OccName -> String
occString OccName
occ
Name OccName
occ (NameU Uniq
u) -> OccName -> String
occString OccName
occ String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"_" String -> String -> String
forall a. [a] -> [a] -> [a]
++ Uniq -> String
forall a. Show a => a -> String
show Uniq
u
Name OccName
occ (NameL Uniq
u) -> OccName -> String
occString OccName
occ String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"_" String -> String -> String
forall a. [a] -> [a] -> [a]
++ Uniq -> String
forall a. Show a => a -> String
show Uniq
u
pnam :: Bool
pnam = String -> Bool
classify String
nms
classify :: String -> Bool
classify String
"" = Bool
False
classify (Char
x:String
xs) | Char -> Bool
isAlpha Char
x Bool -> Bool -> Bool
|| (Char
x Char -> String -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` String
"_[]()") =
case (Char -> Bool) -> String -> String
forall a. (a -> Bool) -> [a] -> [a]
dropWhile (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
/=Char
'.') String
xs of
(Char
_:String
xs') -> String -> Bool
classify String
xs'
[] -> Bool
True
| Bool
otherwise = Bool
False
instance Show Name where
show :: Name -> String
show = Name -> String
showName
tupleDataName :: Int -> Name
tupleTypeName :: Int -> Name
tupleDataName :: Int -> Name
tupleDataName Int
n = Int -> NameSpace -> Bool -> Name
mk_tup_name Int
n NameSpace
DataName Bool
True
tupleTypeName :: Int -> Name
tupleTypeName Int
n = Int -> NameSpace -> Bool -> Name
mk_tup_name Int
n NameSpace
TcClsName Bool
True
unboxedTupleDataName :: Int -> Name
unboxedTupleTypeName :: Int -> Name
unboxedTupleDataName :: Int -> Name
unboxedTupleDataName Int
n = Int -> NameSpace -> Bool -> Name
mk_tup_name Int
n NameSpace
DataName Bool
False
unboxedTupleTypeName :: Int -> Name
unboxedTupleTypeName Int
n = Int -> NameSpace -> Bool -> Name
mk_tup_name Int
n NameSpace
TcClsName Bool
False
mk_tup_name :: Int -> NameSpace -> Bool -> Name
mk_tup_name :: Int -> NameSpace -> Bool -> Name
mk_tup_name Int
n NameSpace
space Bool
boxed
= OccName -> NameFlavour -> Name
Name (String -> OccName
mkOccName String
tup_occ) (NameSpace -> PkgName -> ModName -> NameFlavour
NameG NameSpace
space (String -> PkgName
mkPkgName String
"ghc-prim") ModName
tup_mod)
where
withParens :: String -> String
withParens String
thing
| Bool
boxed = String
"(" String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
thing String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
")"
| Bool
otherwise = String
"(#" String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
thing String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"#)"
tup_occ :: String
tup_occ | Int
n Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
1 = if Bool
boxed then String
"Unit" else String
"Unit#"
| Bool
otherwise = String -> String
withParens (Int -> Char -> String
forall a. Int -> a -> [a]
replicate Int
n_commas Char
',')
n_commas :: Int
n_commas = Int
n Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1
tup_mod :: ModName
tup_mod = String -> ModName
mkModName String
"GHC.Tuple"
unboxedSumDataName :: SumAlt -> SumArity -> Name
unboxedSumTypeName :: SumArity -> Name
unboxedSumDataName :: Int -> Int -> Name
unboxedSumDataName Int
alt Int
arity
| Int
alt Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
arity
= String -> Name
forall a. HasCallStack => String -> a
error (String -> Name) -> String -> Name
forall a b. (a -> b) -> a -> b
$ String
prefix String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"Index out of bounds." String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
debug_info
| Int
alt Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
0
= String -> Name
forall a. HasCallStack => String -> a
error (String -> Name) -> String -> Name
forall a b. (a -> b) -> a -> b
$ String
prefix String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"Alt must be > 0." String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
debug_info
| Int
arity Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
2
= String -> Name
forall a. HasCallStack => String -> a
error (String -> Name) -> String -> Name
forall a b. (a -> b) -> a -> b
$ String
prefix String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"Arity must be >= 2." String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
debug_info
| Bool
otherwise
= OccName -> NameFlavour -> Name
Name (String -> OccName
mkOccName String
sum_occ)
(NameSpace -> PkgName -> ModName -> NameFlavour
NameG NameSpace
DataName (String -> PkgName
mkPkgName String
"ghc-prim") (String -> ModName
mkModName String
"GHC.Prim"))
where
prefix :: String
prefix = String
"unboxedSumDataName: "
debug_info :: String
debug_info = String
" (alt: " String -> String -> String
forall a. [a] -> [a] -> [a]
++ Int -> String
forall a. Show a => a -> String
show Int
alt String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
", arity: " String -> String -> String
forall a. [a] -> [a] -> [a]
++ Int -> String
forall a. Show a => a -> String
show Int
arity String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
")"
sum_occ :: String
sum_occ = Char
'(' Char -> String -> String
forall a. a -> [a] -> [a]
: Char
'#' Char -> String -> String
forall a. a -> [a] -> [a]
: Int -> String
bars Int
nbars_before String -> String -> String
forall a. [a] -> [a] -> [a]
++ Char
'_' Char -> String -> String
forall a. a -> [a] -> [a]
: Int -> String
bars Int
nbars_after String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"#)"
bars :: Int -> String
bars Int
i = Int -> Char -> String
forall a. Int -> a -> [a]
replicate Int
i Char
'|'
nbars_before :: Int
nbars_before = Int
alt Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1
nbars_after :: Int
nbars_after = Int
arity Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
alt
unboxedSumTypeName :: Int -> Name
unboxedSumTypeName Int
arity
| Int
arity Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
2
= String -> Name
forall a. HasCallStack => String -> a
error (String -> Name) -> String -> Name
forall a b. (a -> b) -> a -> b
$ String
"unboxedSumTypeName: Arity must be >= 2."
String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" (arity: " String -> String -> String
forall a. [a] -> [a] -> [a]
++ Int -> String
forall a. Show a => a -> String
show Int
arity String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
")"
| Bool
otherwise
= OccName -> NameFlavour -> Name
Name (String -> OccName
mkOccName String
sum_occ)
(NameSpace -> PkgName -> ModName -> NameFlavour
NameG NameSpace
TcClsName (String -> PkgName
mkPkgName String
"ghc-prim") (String -> ModName
mkModName String
"GHC.Prim"))
where
sum_occ :: String
sum_occ = Char
'(' Char -> String -> String
forall a. a -> [a] -> [a]
: Char
'#' Char -> String -> String
forall a. a -> [a] -> [a]
: Int -> Char -> String
forall a. Int -> a -> [a]
replicate (Int
arity Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1) Char
'|' String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"#)"
data Loc
= Loc { Loc -> String
loc_filename :: String
, Loc -> String
loc_package :: String
, Loc -> String
loc_module :: String
, Loc -> CharPos
loc_start :: CharPos
, Loc -> CharPos
loc_end :: CharPos }
deriving( Int -> Loc -> String -> String
[Loc] -> String -> String
Loc -> String
(Int -> Loc -> String -> String)
-> (Loc -> String) -> ([Loc] -> String -> String) -> Show Loc
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [Loc] -> String -> String
$cshowList :: [Loc] -> String -> String
show :: Loc -> String
$cshow :: Loc -> String
showsPrec :: Int -> Loc -> String -> String
$cshowsPrec :: Int -> Loc -> String -> String
Show, Loc -> Loc -> Bool
(Loc -> Loc -> Bool) -> (Loc -> Loc -> Bool) -> Eq Loc
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Loc -> Loc -> Bool
$c/= :: Loc -> Loc -> Bool
== :: Loc -> Loc -> Bool
$c== :: Loc -> Loc -> Bool
Eq, Eq Loc
Eq Loc
-> (Loc -> Loc -> Ordering)
-> (Loc -> Loc -> Bool)
-> (Loc -> Loc -> Bool)
-> (Loc -> Loc -> Bool)
-> (Loc -> Loc -> Bool)
-> (Loc -> Loc -> Loc)
-> (Loc -> Loc -> Loc)
-> Ord Loc
Loc -> Loc -> Bool
Loc -> Loc -> Ordering
Loc -> Loc -> Loc
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Loc -> Loc -> Loc
$cmin :: Loc -> Loc -> Loc
max :: Loc -> Loc -> Loc
$cmax :: Loc -> Loc -> Loc
>= :: Loc -> Loc -> Bool
$c>= :: Loc -> Loc -> Bool
> :: Loc -> Loc -> Bool
$c> :: Loc -> Loc -> Bool
<= :: Loc -> Loc -> Bool
$c<= :: Loc -> Loc -> Bool
< :: Loc -> Loc -> Bool
$c< :: Loc -> Loc -> Bool
compare :: Loc -> Loc -> Ordering
$ccompare :: Loc -> Loc -> Ordering
$cp1Ord :: Eq Loc
Ord, Typeable Loc
DataType
Constr
Typeable Loc
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Loc -> c Loc)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Loc)
-> (Loc -> Constr)
-> (Loc -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Loc))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Loc))
-> ((forall b. Data b => b -> b) -> Loc -> Loc)
-> (forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Loc -> r)
-> (forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Loc -> r)
-> (forall u. (forall d. Data d => d -> u) -> Loc -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Loc -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Loc -> m Loc)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Loc -> m Loc)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Loc -> m Loc)
-> Data Loc
Loc -> DataType
Loc -> Constr
(forall b. Data b => b -> b) -> Loc -> Loc
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Loc -> c Loc
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Loc
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) -> Loc -> u
forall u. (forall d. Data d => d -> u) -> Loc -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Loc -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Loc -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Loc -> m Loc
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Loc -> m Loc
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Loc
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Loc -> c Loc
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Loc)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Loc)
$cLoc :: Constr
$tLoc :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Loc -> m Loc
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Loc -> m Loc
gmapMp :: (forall d. Data d => d -> m d) -> Loc -> m Loc
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Loc -> m Loc
gmapM :: (forall d. Data d => d -> m d) -> Loc -> m Loc
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Loc -> m Loc
gmapQi :: Int -> (forall d. Data d => d -> u) -> Loc -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Loc -> u
gmapQ :: (forall d. Data d => d -> u) -> Loc -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Loc -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Loc -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Loc -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Loc -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Loc -> r
gmapT :: (forall b. Data b => b -> b) -> Loc -> Loc
$cgmapT :: (forall b. Data b => b -> b) -> Loc -> Loc
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Loc)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Loc)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Loc)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Loc)
dataTypeOf :: Loc -> DataType
$cdataTypeOf :: Loc -> DataType
toConstr :: Loc -> Constr
$ctoConstr :: Loc -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Loc
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Loc
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Loc -> c Loc
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Loc -> c Loc
$cp1Data :: Typeable Loc
Data, (forall x. Loc -> Rep Loc x)
-> (forall x. Rep Loc x -> Loc) -> Generic Loc
forall x. Rep Loc x -> Loc
forall x. Loc -> Rep Loc x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Loc x -> Loc
$cfrom :: forall x. Loc -> Rep Loc x
Generic )
type CharPos = (Int, Int)
data Info
=
ClassI
Dec
[InstanceDec]
| ClassOpI
Name
Type
ParentName
| TyConI
Dec
| FamilyI
Dec
[InstanceDec]
| PrimTyConI
Name
Arity
Unlifted
| DataConI
Name
Type
ParentName
| PatSynI
Name
PatSynType
| VarI
Name
Type
(Maybe Dec)
| TyVarI
Name
Type
deriving( Int -> Info -> String -> String
[Info] -> String -> String
Info -> String
(Int -> Info -> String -> String)
-> (Info -> String) -> ([Info] -> String -> String) -> Show Info
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [Info] -> String -> String
$cshowList :: [Info] -> String -> String
show :: Info -> String
$cshow :: Info -> String
showsPrec :: Int -> Info -> String -> String
$cshowsPrec :: Int -> Info -> String -> String
Show, Info -> Info -> Bool
(Info -> Info -> Bool) -> (Info -> Info -> Bool) -> Eq Info
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Info -> Info -> Bool
$c/= :: Info -> Info -> Bool
== :: Info -> Info -> Bool
$c== :: Info -> Info -> Bool
Eq, Eq Info
Eq Info
-> (Info -> Info -> Ordering)
-> (Info -> Info -> Bool)
-> (Info -> Info -> Bool)
-> (Info -> Info -> Bool)
-> (Info -> Info -> Bool)
-> (Info -> Info -> Info)
-> (Info -> Info -> Info)
-> Ord Info
Info -> Info -> Bool
Info -> Info -> Ordering
Info -> Info -> Info
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Info -> Info -> Info
$cmin :: Info -> Info -> Info
max :: Info -> Info -> Info
$cmax :: Info -> Info -> Info
>= :: Info -> Info -> Bool
$c>= :: Info -> Info -> Bool
> :: Info -> Info -> Bool
$c> :: Info -> Info -> Bool
<= :: Info -> Info -> Bool
$c<= :: Info -> Info -> Bool
< :: Info -> Info -> Bool
$c< :: Info -> Info -> Bool
compare :: Info -> Info -> Ordering
$ccompare :: Info -> Info -> Ordering
$cp1Ord :: Eq Info
Ord, Typeable Info
DataType
Constr
Typeable Info
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Info -> c Info)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Info)
-> (Info -> Constr)
-> (Info -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Info))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Info))
-> ((forall b. Data b => b -> b) -> Info -> Info)
-> (forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Info -> r)
-> (forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Info -> r)
-> (forall u. (forall d. Data d => d -> u) -> Info -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Info -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Info -> m Info)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Info -> m Info)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Info -> m Info)
-> Data Info
Info -> DataType
Info -> Constr
(forall b. Data b => b -> b) -> Info -> Info
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Info -> c Info
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Info
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) -> Info -> u
forall u. (forall d. Data d => d -> u) -> Info -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Info -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Info -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Info -> m Info
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Info -> m Info
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Info
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Info -> c Info
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Info)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Info)
$cTyVarI :: Constr
$cVarI :: Constr
$cPatSynI :: Constr
$cDataConI :: Constr
$cPrimTyConI :: Constr
$cFamilyI :: Constr
$cTyConI :: Constr
$cClassOpI :: Constr
$cClassI :: Constr
$tInfo :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Info -> m Info
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Info -> m Info
gmapMp :: (forall d. Data d => d -> m d) -> Info -> m Info
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Info -> m Info
gmapM :: (forall d. Data d => d -> m d) -> Info -> m Info
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Info -> m Info
gmapQi :: Int -> (forall d. Data d => d -> u) -> Info -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Info -> u
gmapQ :: (forall d. Data d => d -> u) -> Info -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Info -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Info -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Info -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Info -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Info -> r
gmapT :: (forall b. Data b => b -> b) -> Info -> Info
$cgmapT :: (forall b. Data b => b -> b) -> Info -> Info
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Info)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Info)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Info)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Info)
dataTypeOf :: Info -> DataType
$cdataTypeOf :: Info -> DataType
toConstr :: Info -> Constr
$ctoConstr :: Info -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Info
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Info
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Info -> c Info
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Info -> c Info
$cp1Data :: Typeable Info
Data, (forall x. Info -> Rep Info x)
-> (forall x. Rep Info x -> Info) -> Generic Info
forall x. Rep Info x -> Info
forall x. Info -> Rep Info x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Info x -> Info
$cfrom :: forall x. Info -> Rep Info x
Generic )
data ModuleInfo =
ModuleInfo [Module]
deriving( Int -> ModuleInfo -> String -> String
[ModuleInfo] -> String -> String
ModuleInfo -> String
(Int -> ModuleInfo -> String -> String)
-> (ModuleInfo -> String)
-> ([ModuleInfo] -> String -> String)
-> Show ModuleInfo
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [ModuleInfo] -> String -> String
$cshowList :: [ModuleInfo] -> String -> String
show :: ModuleInfo -> String
$cshow :: ModuleInfo -> String
showsPrec :: Int -> ModuleInfo -> String -> String
$cshowsPrec :: Int -> ModuleInfo -> String -> String
Show, ModuleInfo -> ModuleInfo -> Bool
(ModuleInfo -> ModuleInfo -> Bool)
-> (ModuleInfo -> ModuleInfo -> Bool) -> Eq ModuleInfo
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ModuleInfo -> ModuleInfo -> Bool
$c/= :: ModuleInfo -> ModuleInfo -> Bool
== :: ModuleInfo -> ModuleInfo -> Bool
$c== :: ModuleInfo -> ModuleInfo -> Bool
Eq, Eq ModuleInfo
Eq ModuleInfo
-> (ModuleInfo -> ModuleInfo -> Ordering)
-> (ModuleInfo -> ModuleInfo -> Bool)
-> (ModuleInfo -> ModuleInfo -> Bool)
-> (ModuleInfo -> ModuleInfo -> Bool)
-> (ModuleInfo -> ModuleInfo -> Bool)
-> (ModuleInfo -> ModuleInfo -> ModuleInfo)
-> (ModuleInfo -> ModuleInfo -> ModuleInfo)
-> Ord ModuleInfo
ModuleInfo -> ModuleInfo -> Bool
ModuleInfo -> ModuleInfo -> Ordering
ModuleInfo -> ModuleInfo -> ModuleInfo
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: ModuleInfo -> ModuleInfo -> ModuleInfo
$cmin :: ModuleInfo -> ModuleInfo -> ModuleInfo
max :: ModuleInfo -> ModuleInfo -> ModuleInfo
$cmax :: ModuleInfo -> ModuleInfo -> ModuleInfo
>= :: ModuleInfo -> ModuleInfo -> Bool
$c>= :: ModuleInfo -> ModuleInfo -> Bool
> :: ModuleInfo -> ModuleInfo -> Bool
$c> :: ModuleInfo -> ModuleInfo -> Bool
<= :: ModuleInfo -> ModuleInfo -> Bool
$c<= :: ModuleInfo -> ModuleInfo -> Bool
< :: ModuleInfo -> ModuleInfo -> Bool
$c< :: ModuleInfo -> ModuleInfo -> Bool
compare :: ModuleInfo -> ModuleInfo -> Ordering
$ccompare :: ModuleInfo -> ModuleInfo -> Ordering
$cp1Ord :: Eq ModuleInfo
Ord, Typeable ModuleInfo
DataType
Constr
Typeable ModuleInfo
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ModuleInfo -> c ModuleInfo)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ModuleInfo)
-> (ModuleInfo -> Constr)
-> (ModuleInfo -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ModuleInfo))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ModuleInfo))
-> ((forall b. Data b => b -> b) -> ModuleInfo -> ModuleInfo)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ModuleInfo -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ModuleInfo -> r)
-> (forall u. (forall d. Data d => d -> u) -> ModuleInfo -> [u])
-> (forall u.
Int -> (forall d. Data d => d -> u) -> ModuleInfo -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ModuleInfo -> m ModuleInfo)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ModuleInfo -> m ModuleInfo)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ModuleInfo -> m ModuleInfo)
-> Data ModuleInfo
ModuleInfo -> DataType
ModuleInfo -> Constr
(forall b. Data b => b -> b) -> ModuleInfo -> ModuleInfo
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ModuleInfo -> c ModuleInfo
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ModuleInfo
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) -> ModuleInfo -> u
forall u. (forall d. Data d => d -> u) -> ModuleInfo -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ModuleInfo -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ModuleInfo -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ModuleInfo -> m ModuleInfo
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ModuleInfo -> m ModuleInfo
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ModuleInfo
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ModuleInfo -> c ModuleInfo
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ModuleInfo)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ModuleInfo)
$cModuleInfo :: Constr
$tModuleInfo :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> ModuleInfo -> m ModuleInfo
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ModuleInfo -> m ModuleInfo
gmapMp :: (forall d. Data d => d -> m d) -> ModuleInfo -> m ModuleInfo
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ModuleInfo -> m ModuleInfo
gmapM :: (forall d. Data d => d -> m d) -> ModuleInfo -> m ModuleInfo
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ModuleInfo -> m ModuleInfo
gmapQi :: Int -> (forall d. Data d => d -> u) -> ModuleInfo -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ModuleInfo -> u
gmapQ :: (forall d. Data d => d -> u) -> ModuleInfo -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ModuleInfo -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ModuleInfo -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ModuleInfo -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ModuleInfo -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ModuleInfo -> r
gmapT :: (forall b. Data b => b -> b) -> ModuleInfo -> ModuleInfo
$cgmapT :: (forall b. Data b => b -> b) -> ModuleInfo -> ModuleInfo
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ModuleInfo)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ModuleInfo)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c ModuleInfo)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ModuleInfo)
dataTypeOf :: ModuleInfo -> DataType
$cdataTypeOf :: ModuleInfo -> DataType
toConstr :: ModuleInfo -> Constr
$ctoConstr :: ModuleInfo -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ModuleInfo
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ModuleInfo
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ModuleInfo -> c ModuleInfo
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ModuleInfo -> c ModuleInfo
$cp1Data :: Typeable ModuleInfo
Data, (forall x. ModuleInfo -> Rep ModuleInfo x)
-> (forall x. Rep ModuleInfo x -> ModuleInfo) -> Generic ModuleInfo
forall x. Rep ModuleInfo x -> ModuleInfo
forall x. ModuleInfo -> Rep ModuleInfo x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ModuleInfo x -> ModuleInfo
$cfrom :: forall x. ModuleInfo -> Rep ModuleInfo x
Generic )
type ParentName = Name
type SumAlt = Int
type SumArity = Int
type Arity = Int
type Unlifted = Bool
type InstanceDec = Dec
data Fixity = Fixity Int FixityDirection
deriving( Fixity -> Fixity -> Bool
(Fixity -> Fixity -> Bool)
-> (Fixity -> Fixity -> Bool) -> Eq Fixity
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Fixity -> Fixity -> Bool
$c/= :: Fixity -> Fixity -> Bool
== :: Fixity -> Fixity -> Bool
$c== :: Fixity -> Fixity -> Bool
Eq, Eq Fixity
Eq Fixity
-> (Fixity -> Fixity -> Ordering)
-> (Fixity -> Fixity -> Bool)
-> (Fixity -> Fixity -> Bool)
-> (Fixity -> Fixity -> Bool)
-> (Fixity -> Fixity -> Bool)
-> (Fixity -> Fixity -> Fixity)
-> (Fixity -> Fixity -> Fixity)
-> Ord Fixity
Fixity -> Fixity -> Bool
Fixity -> Fixity -> Ordering
Fixity -> Fixity -> Fixity
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Fixity -> Fixity -> Fixity
$cmin :: Fixity -> Fixity -> Fixity
max :: Fixity -> Fixity -> Fixity
$cmax :: Fixity -> Fixity -> Fixity
>= :: Fixity -> Fixity -> Bool
$c>= :: Fixity -> Fixity -> Bool
> :: Fixity -> Fixity -> Bool
$c> :: Fixity -> Fixity -> Bool
<= :: Fixity -> Fixity -> Bool
$c<= :: Fixity -> Fixity -> Bool
< :: Fixity -> Fixity -> Bool
$c< :: Fixity -> Fixity -> Bool
compare :: Fixity -> Fixity -> Ordering
$ccompare :: Fixity -> Fixity -> Ordering
$cp1Ord :: Eq Fixity
Ord, Int -> Fixity -> String -> String
[Fixity] -> String -> String
Fixity -> String
(Int -> Fixity -> String -> String)
-> (Fixity -> String)
-> ([Fixity] -> String -> String)
-> Show Fixity
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [Fixity] -> String -> String
$cshowList :: [Fixity] -> String -> String
show :: Fixity -> String
$cshow :: Fixity -> String
showsPrec :: Int -> Fixity -> String -> String
$cshowsPrec :: Int -> Fixity -> String -> String
Show, Typeable Fixity
DataType
Constr
Typeable Fixity
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Fixity -> c Fixity)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Fixity)
-> (Fixity -> Constr)
-> (Fixity -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Fixity))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Fixity))
-> ((forall b. Data b => b -> b) -> Fixity -> Fixity)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Fixity -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Fixity -> r)
-> (forall u. (forall d. Data d => d -> u) -> Fixity -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Fixity -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Fixity -> m Fixity)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Fixity -> m Fixity)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Fixity -> m Fixity)
-> Data Fixity
Fixity -> DataType
Fixity -> Constr
(forall b. Data b => b -> b) -> Fixity -> Fixity
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Fixity -> c Fixity
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Fixity
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) -> Fixity -> u
forall u. (forall d. Data d => d -> u) -> Fixity -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Fixity -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Fixity -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Fixity -> m Fixity
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Fixity -> m Fixity
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Fixity
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Fixity -> c Fixity
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Fixity)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Fixity)
$cFixity :: Constr
$tFixity :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Fixity -> m Fixity
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Fixity -> m Fixity
gmapMp :: (forall d. Data d => d -> m d) -> Fixity -> m Fixity
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Fixity -> m Fixity
gmapM :: (forall d. Data d => d -> m d) -> Fixity -> m Fixity
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Fixity -> m Fixity
gmapQi :: Int -> (forall d. Data d => d -> u) -> Fixity -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Fixity -> u
gmapQ :: (forall d. Data d => d -> u) -> Fixity -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Fixity -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Fixity -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Fixity -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Fixity -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Fixity -> r
gmapT :: (forall b. Data b => b -> b) -> Fixity -> Fixity
$cgmapT :: (forall b. Data b => b -> b) -> Fixity -> Fixity
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Fixity)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Fixity)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Fixity)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Fixity)
dataTypeOf :: Fixity -> DataType
$cdataTypeOf :: Fixity -> DataType
toConstr :: Fixity -> Constr
$ctoConstr :: Fixity -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Fixity
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Fixity
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Fixity -> c Fixity
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Fixity -> c Fixity
$cp1Data :: Typeable Fixity
Data, (forall x. Fixity -> Rep Fixity x)
-> (forall x. Rep Fixity x -> Fixity) -> Generic Fixity
forall x. Rep Fixity x -> Fixity
forall x. Fixity -> Rep Fixity x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Fixity x -> Fixity
$cfrom :: forall x. Fixity -> Rep Fixity x
Generic )
data FixityDirection = InfixL | InfixR | InfixN
deriving( FixityDirection -> FixityDirection -> Bool
(FixityDirection -> FixityDirection -> Bool)
-> (FixityDirection -> FixityDirection -> Bool)
-> Eq FixityDirection
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FixityDirection -> FixityDirection -> Bool
$c/= :: FixityDirection -> FixityDirection -> Bool
== :: FixityDirection -> FixityDirection -> Bool
$c== :: FixityDirection -> FixityDirection -> Bool
Eq, Eq FixityDirection
Eq FixityDirection
-> (FixityDirection -> FixityDirection -> Ordering)
-> (FixityDirection -> FixityDirection -> Bool)
-> (FixityDirection -> FixityDirection -> Bool)
-> (FixityDirection -> FixityDirection -> Bool)
-> (FixityDirection -> FixityDirection -> Bool)
-> (FixityDirection -> FixityDirection -> FixityDirection)
-> (FixityDirection -> FixityDirection -> FixityDirection)
-> Ord FixityDirection
FixityDirection -> FixityDirection -> Bool
FixityDirection -> FixityDirection -> Ordering
FixityDirection -> FixityDirection -> FixityDirection
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: FixityDirection -> FixityDirection -> FixityDirection
$cmin :: FixityDirection -> FixityDirection -> FixityDirection
max :: FixityDirection -> FixityDirection -> FixityDirection
$cmax :: FixityDirection -> FixityDirection -> FixityDirection
>= :: FixityDirection -> FixityDirection -> Bool
$c>= :: FixityDirection -> FixityDirection -> Bool
> :: FixityDirection -> FixityDirection -> Bool
$c> :: FixityDirection -> FixityDirection -> Bool
<= :: FixityDirection -> FixityDirection -> Bool
$c<= :: FixityDirection -> FixityDirection -> Bool
< :: FixityDirection -> FixityDirection -> Bool
$c< :: FixityDirection -> FixityDirection -> Bool
compare :: FixityDirection -> FixityDirection -> Ordering
$ccompare :: FixityDirection -> FixityDirection -> Ordering
$cp1Ord :: Eq FixityDirection
Ord, Int -> FixityDirection -> String -> String
[FixityDirection] -> String -> String
FixityDirection -> String
(Int -> FixityDirection -> String -> String)
-> (FixityDirection -> String)
-> ([FixityDirection] -> String -> String)
-> Show FixityDirection
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [FixityDirection] -> String -> String
$cshowList :: [FixityDirection] -> String -> String
show :: FixityDirection -> String
$cshow :: FixityDirection -> String
showsPrec :: Int -> FixityDirection -> String -> String
$cshowsPrec :: Int -> FixityDirection -> String -> String
Show, Typeable FixityDirection
DataType
Constr
Typeable FixityDirection
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FixityDirection -> c FixityDirection)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FixityDirection)
-> (FixityDirection -> Constr)
-> (FixityDirection -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FixityDirection))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c FixityDirection))
-> ((forall b. Data b => b -> b)
-> FixityDirection -> FixityDirection)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FixityDirection -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FixityDirection -> r)
-> (forall u.
(forall d. Data d => d -> u) -> FixityDirection -> [u])
-> (forall u.
Int -> (forall d. Data d => d -> u) -> FixityDirection -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> FixityDirection -> m FixityDirection)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> FixityDirection -> m FixityDirection)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> FixityDirection -> m FixityDirection)
-> Data FixityDirection
FixityDirection -> DataType
FixityDirection -> Constr
(forall b. Data b => b -> b) -> FixityDirection -> FixityDirection
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FixityDirection -> c FixityDirection
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FixityDirection
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) -> FixityDirection -> u
forall u. (forall d. Data d => d -> u) -> FixityDirection -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FixityDirection -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FixityDirection -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> FixityDirection -> m FixityDirection
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> FixityDirection -> m FixityDirection
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FixityDirection
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FixityDirection -> c FixityDirection
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FixityDirection)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c FixityDirection)
$cInfixN :: Constr
$cInfixR :: Constr
$cInfixL :: Constr
$tFixityDirection :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> FixityDirection -> m FixityDirection
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> FixityDirection -> m FixityDirection
gmapMp :: (forall d. Data d => d -> m d)
-> FixityDirection -> m FixityDirection
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> FixityDirection -> m FixityDirection
gmapM :: (forall d. Data d => d -> m d)
-> FixityDirection -> m FixityDirection
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> FixityDirection -> m FixityDirection
gmapQi :: Int -> (forall d. Data d => d -> u) -> FixityDirection -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> FixityDirection -> u
gmapQ :: (forall d. Data d => d -> u) -> FixityDirection -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> FixityDirection -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FixityDirection -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FixityDirection -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FixityDirection -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FixityDirection -> r
gmapT :: (forall b. Data b => b -> b) -> FixityDirection -> FixityDirection
$cgmapT :: (forall b. Data b => b -> b) -> FixityDirection -> FixityDirection
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c FixityDirection)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c FixityDirection)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c FixityDirection)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FixityDirection)
dataTypeOf :: FixityDirection -> DataType
$cdataTypeOf :: FixityDirection -> DataType
toConstr :: FixityDirection -> Constr
$ctoConstr :: FixityDirection -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FixityDirection
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FixityDirection
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FixityDirection -> c FixityDirection
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FixityDirection -> c FixityDirection
$cp1Data :: Typeable FixityDirection
Data, (forall x. FixityDirection -> Rep FixityDirection x)
-> (forall x. Rep FixityDirection x -> FixityDirection)
-> Generic FixityDirection
forall x. Rep FixityDirection x -> FixityDirection
forall x. FixityDirection -> Rep FixityDirection x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep FixityDirection x -> FixityDirection
$cfrom :: forall x. FixityDirection -> Rep FixityDirection x
Generic )
maxPrecedence :: Int
maxPrecedence :: Int
maxPrecedence = (Int
9::Int)
defaultFixity :: Fixity
defaultFixity :: Fixity
defaultFixity = Int -> FixityDirection -> Fixity
Fixity Int
maxPrecedence FixityDirection
InfixL
data Lit = CharL Char
| StringL String
| IntegerL Integer
| RationalL Rational
| IntPrimL Integer
| WordPrimL Integer
| FloatPrimL Rational
| DoublePrimL Rational
| StringPrimL [Word8]
| BytesPrimL Bytes
| CharPrimL Char
deriving( Int -> Lit -> String -> String
[Lit] -> String -> String
Lit -> String
(Int -> Lit -> String -> String)
-> (Lit -> String) -> ([Lit] -> String -> String) -> Show Lit
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [Lit] -> String -> String
$cshowList :: [Lit] -> String -> String
show :: Lit -> String
$cshow :: Lit -> String
showsPrec :: Int -> Lit -> String -> String
$cshowsPrec :: Int -> Lit -> String -> String
Show, Lit -> Lit -> Bool
(Lit -> Lit -> Bool) -> (Lit -> Lit -> Bool) -> Eq Lit
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Lit -> Lit -> Bool
$c/= :: Lit -> Lit -> Bool
== :: Lit -> Lit -> Bool
$c== :: Lit -> Lit -> Bool
Eq, Eq Lit
Eq Lit
-> (Lit -> Lit -> Ordering)
-> (Lit -> Lit -> Bool)
-> (Lit -> Lit -> Bool)
-> (Lit -> Lit -> Bool)
-> (Lit -> Lit -> Bool)
-> (Lit -> Lit -> Lit)
-> (Lit -> Lit -> Lit)
-> Ord Lit
Lit -> Lit -> Bool
Lit -> Lit -> Ordering
Lit -> Lit -> Lit
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Lit -> Lit -> Lit
$cmin :: Lit -> Lit -> Lit
max :: Lit -> Lit -> Lit
$cmax :: Lit -> Lit -> Lit
>= :: Lit -> Lit -> Bool
$c>= :: Lit -> Lit -> Bool
> :: Lit -> Lit -> Bool
$c> :: Lit -> Lit -> Bool
<= :: Lit -> Lit -> Bool
$c<= :: Lit -> Lit -> Bool
< :: Lit -> Lit -> Bool
$c< :: Lit -> Lit -> Bool
compare :: Lit -> Lit -> Ordering
$ccompare :: Lit -> Lit -> Ordering
$cp1Ord :: Eq Lit
Ord, Typeable Lit
DataType
Constr
Typeable Lit
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Lit -> c Lit)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Lit)
-> (Lit -> Constr)
-> (Lit -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Lit))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Lit))
-> ((forall b. Data b => b -> b) -> Lit -> Lit)
-> (forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Lit -> r)
-> (forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Lit -> r)
-> (forall u. (forall d. Data d => d -> u) -> Lit -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Lit -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Lit -> m Lit)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Lit -> m Lit)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Lit -> m Lit)
-> Data Lit
Lit -> DataType
Lit -> Constr
(forall b. Data b => b -> b) -> Lit -> Lit
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Lit -> c Lit
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Lit
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) -> Lit -> u
forall u. (forall d. Data d => d -> u) -> Lit -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Lit -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Lit -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Lit -> m Lit
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Lit -> m Lit
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Lit
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Lit -> c Lit
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Lit)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Lit)
$cCharPrimL :: Constr
$cBytesPrimL :: Constr
$cStringPrimL :: Constr
$cDoublePrimL :: Constr
$cFloatPrimL :: Constr
$cWordPrimL :: Constr
$cIntPrimL :: Constr
$cRationalL :: Constr
$cIntegerL :: Constr
$cStringL :: Constr
$cCharL :: Constr
$tLit :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Lit -> m Lit
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Lit -> m Lit
gmapMp :: (forall d. Data d => d -> m d) -> Lit -> m Lit
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Lit -> m Lit
gmapM :: (forall d. Data d => d -> m d) -> Lit -> m Lit
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Lit -> m Lit
gmapQi :: Int -> (forall d. Data d => d -> u) -> Lit -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Lit -> u
gmapQ :: (forall d. Data d => d -> u) -> Lit -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Lit -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Lit -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Lit -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Lit -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Lit -> r
gmapT :: (forall b. Data b => b -> b) -> Lit -> Lit
$cgmapT :: (forall b. Data b => b -> b) -> Lit -> Lit
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Lit)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Lit)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Lit)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Lit)
dataTypeOf :: Lit -> DataType
$cdataTypeOf :: Lit -> DataType
toConstr :: Lit -> Constr
$ctoConstr :: Lit -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Lit
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Lit
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Lit -> c Lit
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Lit -> c Lit
$cp1Data :: Typeable Lit
Data, (forall x. Lit -> Rep Lit x)
-> (forall x. Rep Lit x -> Lit) -> Generic Lit
forall x. Rep Lit x -> Lit
forall x. Lit -> Rep Lit x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Lit x -> Lit
$cfrom :: forall x. Lit -> Rep Lit x
Generic )
data Bytes = Bytes
{ Bytes -> ForeignPtr Word8
bytesPtr :: ForeignPtr Word8
, Bytes -> Word
bytesOffset :: Word
, Bytes -> Word
bytesSize :: Word
}
deriving (Bytes -> Bytes -> Bool
(Bytes -> Bytes -> Bool) -> (Bytes -> Bytes -> Bool) -> Eq Bytes
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Bytes -> Bytes -> Bool
$c/= :: Bytes -> Bytes -> Bool
== :: Bytes -> Bytes -> Bool
$c== :: Bytes -> Bytes -> Bool
Eq,Eq Bytes
Eq Bytes
-> (Bytes -> Bytes -> Ordering)
-> (Bytes -> Bytes -> Bool)
-> (Bytes -> Bytes -> Bool)
-> (Bytes -> Bytes -> Bool)
-> (Bytes -> Bytes -> Bool)
-> (Bytes -> Bytes -> Bytes)
-> (Bytes -> Bytes -> Bytes)
-> Ord Bytes
Bytes -> Bytes -> Bool
Bytes -> Bytes -> Ordering
Bytes -> Bytes -> Bytes
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Bytes -> Bytes -> Bytes
$cmin :: Bytes -> Bytes -> Bytes
max :: Bytes -> Bytes -> Bytes
$cmax :: Bytes -> Bytes -> Bytes
>= :: Bytes -> Bytes -> Bool
$c>= :: Bytes -> Bytes -> Bool
> :: Bytes -> Bytes -> Bool
$c> :: Bytes -> Bytes -> Bool
<= :: Bytes -> Bytes -> Bool
$c<= :: Bytes -> Bytes -> Bool
< :: Bytes -> Bytes -> Bool
$c< :: Bytes -> Bytes -> Bool
compare :: Bytes -> Bytes -> Ordering
$ccompare :: Bytes -> Bytes -> Ordering
$cp1Ord :: Eq Bytes
Ord,Typeable Bytes
DataType
Constr
Typeable Bytes
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Bytes -> c Bytes)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Bytes)
-> (Bytes -> Constr)
-> (Bytes -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Bytes))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Bytes))
-> ((forall b. Data b => b -> b) -> Bytes -> Bytes)
-> (forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Bytes -> r)
-> (forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Bytes -> r)
-> (forall u. (forall d. Data d => d -> u) -> Bytes -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Bytes -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Bytes -> m Bytes)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Bytes -> m Bytes)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Bytes -> m Bytes)
-> Data Bytes
Bytes -> DataType
Bytes -> Constr
(forall b. Data b => b -> b) -> Bytes -> Bytes
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Bytes -> c Bytes
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Bytes
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) -> Bytes -> u
forall u. (forall d. Data d => d -> u) -> Bytes -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Bytes -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Bytes -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Bytes -> m Bytes
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Bytes -> m Bytes
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Bytes
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Bytes -> c Bytes
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Bytes)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Bytes)
$cBytes :: Constr
$tBytes :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Bytes -> m Bytes
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Bytes -> m Bytes
gmapMp :: (forall d. Data d => d -> m d) -> Bytes -> m Bytes
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Bytes -> m Bytes
gmapM :: (forall d. Data d => d -> m d) -> Bytes -> m Bytes
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Bytes -> m Bytes
gmapQi :: Int -> (forall d. Data d => d -> u) -> Bytes -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Bytes -> u
gmapQ :: (forall d. Data d => d -> u) -> Bytes -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Bytes -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Bytes -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Bytes -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Bytes -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Bytes -> r
gmapT :: (forall b. Data b => b -> b) -> Bytes -> Bytes
$cgmapT :: (forall b. Data b => b -> b) -> Bytes -> Bytes
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Bytes)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Bytes)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Bytes)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Bytes)
dataTypeOf :: Bytes -> DataType
$cdataTypeOf :: Bytes -> DataType
toConstr :: Bytes -> Constr
$ctoConstr :: Bytes -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Bytes
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Bytes
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Bytes -> c Bytes
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Bytes -> c Bytes
$cp1Data :: Typeable Bytes
Data,(forall x. Bytes -> Rep Bytes x)
-> (forall x. Rep Bytes x -> Bytes) -> Generic Bytes
forall x. Rep Bytes x -> Bytes
forall x. Bytes -> Rep Bytes x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Bytes x -> Bytes
$cfrom :: forall x. Bytes -> Rep Bytes x
Generic,Int -> Bytes -> String -> String
[Bytes] -> String -> String
Bytes -> String
(Int -> Bytes -> String -> String)
-> (Bytes -> String) -> ([Bytes] -> String -> String) -> Show Bytes
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [Bytes] -> String -> String
$cshowList :: [Bytes] -> String -> String
show :: Bytes -> String
$cshow :: Bytes -> String
showsPrec :: Int -> Bytes -> String -> String
$cshowsPrec :: Int -> Bytes -> String -> String
Show)
data Pat
= LitP Lit
| VarP Name
| TupP [Pat]
| UnboxedTupP [Pat]
| UnboxedSumP Pat SumAlt SumArity
| ConP Name [Pat]
| InfixP Pat Name Pat
| UInfixP Pat Name Pat
| ParensP Pat
| TildeP Pat
| BangP Pat
| AsP Name Pat
| WildP
| RecP Name [FieldPat]
| ListP [ Pat ]
| SigP Pat Type
| ViewP Exp Pat
deriving( Int -> Pat -> String -> String
[Pat] -> String -> String
Pat -> String
(Int -> Pat -> String -> String)
-> (Pat -> String) -> ([Pat] -> String -> String) -> Show Pat
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [Pat] -> String -> String
$cshowList :: [Pat] -> String -> String
show :: Pat -> String
$cshow :: Pat -> String
showsPrec :: Int -> Pat -> String -> String
$cshowsPrec :: Int -> Pat -> String -> String
Show, Pat -> Pat -> Bool
(Pat -> Pat -> Bool) -> (Pat -> Pat -> Bool) -> Eq Pat
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Pat -> Pat -> Bool
$c/= :: Pat -> Pat -> Bool
== :: Pat -> Pat -> Bool
$c== :: Pat -> Pat -> Bool
Eq, Eq Pat
Eq Pat
-> (Pat -> Pat -> Ordering)
-> (Pat -> Pat -> Bool)
-> (Pat -> Pat -> Bool)
-> (Pat -> Pat -> Bool)
-> (Pat -> Pat -> Bool)
-> (Pat -> Pat -> Pat)
-> (Pat -> Pat -> Pat)
-> Ord Pat
Pat -> Pat -> Bool
Pat -> Pat -> Ordering
Pat -> Pat -> Pat
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Pat -> Pat -> Pat
$cmin :: Pat -> Pat -> Pat
max :: Pat -> Pat -> Pat
$cmax :: Pat -> Pat -> Pat
>= :: Pat -> Pat -> Bool
$c>= :: Pat -> Pat -> Bool
> :: Pat -> Pat -> Bool
$c> :: Pat -> Pat -> Bool
<= :: Pat -> Pat -> Bool
$c<= :: Pat -> Pat -> Bool
< :: Pat -> Pat -> Bool
$c< :: Pat -> Pat -> Bool
compare :: Pat -> Pat -> Ordering
$ccompare :: Pat -> Pat -> Ordering
$cp1Ord :: Eq Pat
Ord, Typeable Pat
DataType
Constr
Typeable Pat
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Pat -> c Pat)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Pat)
-> (Pat -> Constr)
-> (Pat -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Pat))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Pat))
-> ((forall b. Data b => b -> b) -> Pat -> Pat)
-> (forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Pat -> r)
-> (forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Pat -> r)
-> (forall u. (forall d. Data d => d -> u) -> Pat -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Pat -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Pat -> m Pat)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Pat -> m Pat)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Pat -> m Pat)
-> Data Pat
Pat -> DataType
Pat -> Constr
(forall b. Data b => b -> b) -> Pat -> Pat
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Pat -> c Pat
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Pat
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) -> Pat -> u
forall u. (forall d. Data d => d -> u) -> Pat -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Pat -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Pat -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Pat -> m Pat
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Pat -> m Pat
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Pat
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Pat -> c Pat
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Pat)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Pat)
$cViewP :: Constr
$cSigP :: Constr
$cListP :: Constr
$cRecP :: Constr
$cWildP :: Constr
$cAsP :: Constr
$cBangP :: Constr
$cTildeP :: Constr
$cParensP :: Constr
$cUInfixP :: Constr
$cInfixP :: Constr
$cConP :: Constr
$cUnboxedSumP :: Constr
$cUnboxedTupP :: Constr
$cTupP :: Constr
$cVarP :: Constr
$cLitP :: Constr
$tPat :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Pat -> m Pat
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Pat -> m Pat
gmapMp :: (forall d. Data d => d -> m d) -> Pat -> m Pat
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Pat -> m Pat
gmapM :: (forall d. Data d => d -> m d) -> Pat -> m Pat
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Pat -> m Pat
gmapQi :: Int -> (forall d. Data d => d -> u) -> Pat -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Pat -> u
gmapQ :: (forall d. Data d => d -> u) -> Pat -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Pat -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Pat -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Pat -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Pat -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Pat -> r
gmapT :: (forall b. Data b => b -> b) -> Pat -> Pat
$cgmapT :: (forall b. Data b => b -> b) -> Pat -> Pat
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Pat)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Pat)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Pat)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Pat)
dataTypeOf :: Pat -> DataType
$cdataTypeOf :: Pat -> DataType
toConstr :: Pat -> Constr
$ctoConstr :: Pat -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Pat
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Pat
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Pat -> c Pat
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Pat -> c Pat
$cp1Data :: Typeable Pat
Data, (forall x. Pat -> Rep Pat x)
-> (forall x. Rep Pat x -> Pat) -> Generic Pat
forall x. Rep Pat x -> Pat
forall x. Pat -> Rep Pat x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Pat x -> Pat
$cfrom :: forall x. Pat -> Rep Pat x
Generic )
type FieldPat = (Name,Pat)
data Match = Match Pat Body [Dec]
deriving( Int -> Match -> String -> String
[Match] -> String -> String
Match -> String
(Int -> Match -> String -> String)
-> (Match -> String) -> ([Match] -> String -> String) -> Show Match
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [Match] -> String -> String
$cshowList :: [Match] -> String -> String
show :: Match -> String
$cshow :: Match -> String
showsPrec :: Int -> Match -> String -> String
$cshowsPrec :: Int -> Match -> String -> String
Show, Match -> Match -> Bool
(Match -> Match -> Bool) -> (Match -> Match -> Bool) -> Eq Match
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Match -> Match -> Bool
$c/= :: Match -> Match -> Bool
== :: Match -> Match -> Bool
$c== :: Match -> Match -> Bool
Eq, Eq Match
Eq Match
-> (Match -> Match -> Ordering)
-> (Match -> Match -> Bool)
-> (Match -> Match -> Bool)
-> (Match -> Match -> Bool)
-> (Match -> Match -> Bool)
-> (Match -> Match -> Match)
-> (Match -> Match -> Match)
-> Ord Match
Match -> Match -> Bool
Match -> Match -> Ordering
Match -> Match -> Match
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Match -> Match -> Match
$cmin :: Match -> Match -> Match
max :: Match -> Match -> Match
$cmax :: Match -> Match -> Match
>= :: Match -> Match -> Bool
$c>= :: Match -> Match -> Bool
> :: Match -> Match -> Bool
$c> :: Match -> Match -> Bool
<= :: Match -> Match -> Bool
$c<= :: Match -> Match -> Bool
< :: Match -> Match -> Bool
$c< :: Match -> Match -> Bool
compare :: Match -> Match -> Ordering
$ccompare :: Match -> Match -> Ordering
$cp1Ord :: Eq Match
Ord, Typeable Match
DataType
Constr
Typeable Match
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Match -> c Match)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Match)
-> (Match -> Constr)
-> (Match -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Match))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Match))
-> ((forall b. Data b => b -> b) -> Match -> Match)
-> (forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Match -> r)
-> (forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Match -> r)
-> (forall u. (forall d. Data d => d -> u) -> Match -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Match -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Match -> m Match)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Match -> m Match)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Match -> m Match)
-> Data Match
Match -> DataType
Match -> Constr
(forall b. Data b => b -> b) -> Match -> Match
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Match -> c Match
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Match
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) -> Match -> u
forall u. (forall d. Data d => d -> u) -> Match -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Match -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Match -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Match -> m Match
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Match -> m Match
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Match
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Match -> c Match
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Match)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Match)
$cMatch :: Constr
$tMatch :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Match -> m Match
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Match -> m Match
gmapMp :: (forall d. Data d => d -> m d) -> Match -> m Match
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Match -> m Match
gmapM :: (forall d. Data d => d -> m d) -> Match -> m Match
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Match -> m Match
gmapQi :: Int -> (forall d. Data d => d -> u) -> Match -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Match -> u
gmapQ :: (forall d. Data d => d -> u) -> Match -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Match -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Match -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Match -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Match -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Match -> r
gmapT :: (forall b. Data b => b -> b) -> Match -> Match
$cgmapT :: (forall b. Data b => b -> b) -> Match -> Match
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Match)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Match)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Match)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Match)
dataTypeOf :: Match -> DataType
$cdataTypeOf :: Match -> DataType
toConstr :: Match -> Constr
$ctoConstr :: Match -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Match
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Match
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Match -> c Match
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Match -> c Match
$cp1Data :: Typeable Match
Data, (forall x. Match -> Rep Match x)
-> (forall x. Rep Match x -> Match) -> Generic Match
forall x. Rep Match x -> Match
forall x. Match -> Rep Match x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Match x -> Match
$cfrom :: forall x. Match -> Rep Match x
Generic )
data Clause = Clause [Pat] Body [Dec]
deriving( Int -> Clause -> String -> String
[Clause] -> String -> String
Clause -> String
(Int -> Clause -> String -> String)
-> (Clause -> String)
-> ([Clause] -> String -> String)
-> Show Clause
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [Clause] -> String -> String
$cshowList :: [Clause] -> String -> String
show :: Clause -> String
$cshow :: Clause -> String
showsPrec :: Int -> Clause -> String -> String
$cshowsPrec :: Int -> Clause -> String -> String
Show, Clause -> Clause -> Bool
(Clause -> Clause -> Bool)
-> (Clause -> Clause -> Bool) -> Eq Clause
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Clause -> Clause -> Bool
$c/= :: Clause -> Clause -> Bool
== :: Clause -> Clause -> Bool
$c== :: Clause -> Clause -> Bool
Eq, Eq Clause
Eq Clause
-> (Clause -> Clause -> Ordering)
-> (Clause -> Clause -> Bool)
-> (Clause -> Clause -> Bool)
-> (Clause -> Clause -> Bool)
-> (Clause -> Clause -> Bool)
-> (Clause -> Clause -> Clause)
-> (Clause -> Clause -> Clause)
-> Ord Clause
Clause -> Clause -> Bool
Clause -> Clause -> Ordering
Clause -> Clause -> Clause
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Clause -> Clause -> Clause
$cmin :: Clause -> Clause -> Clause
max :: Clause -> Clause -> Clause
$cmax :: Clause -> Clause -> Clause
>= :: Clause -> Clause -> Bool
$c>= :: Clause -> Clause -> Bool
> :: Clause -> Clause -> Bool
$c> :: Clause -> Clause -> Bool
<= :: Clause -> Clause -> Bool
$c<= :: Clause -> Clause -> Bool
< :: Clause -> Clause -> Bool
$c< :: Clause -> Clause -> Bool
compare :: Clause -> Clause -> Ordering
$ccompare :: Clause -> Clause -> Ordering
$cp1Ord :: Eq Clause
Ord, Typeable Clause
DataType
Constr
Typeable Clause
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Clause -> c Clause)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Clause)
-> (Clause -> Constr)
-> (Clause -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Clause))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Clause))
-> ((forall b. Data b => b -> b) -> Clause -> Clause)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Clause -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Clause -> r)
-> (forall u. (forall d. Data d => d -> u) -> Clause -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Clause -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Clause -> m Clause)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Clause -> m Clause)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Clause -> m Clause)
-> Data Clause
Clause -> DataType
Clause -> Constr
(forall b. Data b => b -> b) -> Clause -> Clause
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Clause -> c Clause
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Clause
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) -> Clause -> u
forall u. (forall d. Data d => d -> u) -> Clause -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Clause -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Clause -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Clause -> m Clause
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Clause -> m Clause
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Clause
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Clause -> c Clause
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Clause)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Clause)
$cClause :: Constr
$tClause :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Clause -> m Clause
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Clause -> m Clause
gmapMp :: (forall d. Data d => d -> m d) -> Clause -> m Clause
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Clause -> m Clause
gmapM :: (forall d. Data d => d -> m d) -> Clause -> m Clause
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Clause -> m Clause
gmapQi :: Int -> (forall d. Data d => d -> u) -> Clause -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Clause -> u
gmapQ :: (forall d. Data d => d -> u) -> Clause -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Clause -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Clause -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Clause -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Clause -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Clause -> r
gmapT :: (forall b. Data b => b -> b) -> Clause -> Clause
$cgmapT :: (forall b. Data b => b -> b) -> Clause -> Clause
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Clause)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Clause)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Clause)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Clause)
dataTypeOf :: Clause -> DataType
$cdataTypeOf :: Clause -> DataType
toConstr :: Clause -> Constr
$ctoConstr :: Clause -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Clause
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Clause
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Clause -> c Clause
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Clause -> c Clause
$cp1Data :: Typeable Clause
Data, (forall x. Clause -> Rep Clause x)
-> (forall x. Rep Clause x -> Clause) -> Generic Clause
forall x. Rep Clause x -> Clause
forall x. Clause -> Rep Clause x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Clause x -> Clause
$cfrom :: forall x. Clause -> Rep Clause x
Generic )
data Exp
= VarE Name
| ConE Name
| LitE Lit
| AppE Exp Exp
| AppTypeE Exp Type
| InfixE (Maybe Exp) Exp (Maybe Exp)
| UInfixE Exp Exp Exp
| ParensE Exp
| LamE [Pat] Exp
| LamCaseE [Match]
| TupE [Maybe Exp]
| UnboxedTupE [Maybe Exp]
| UnboxedSumE Exp SumAlt SumArity
| CondE Exp Exp Exp
| MultiIfE [(Guard, Exp)]
| LetE [Dec] Exp
| CaseE Exp [Match]
| DoE [Stmt]
| MDoE [Stmt]
| CompE [Stmt]
| ArithSeqE Range
| ListE [ Exp ]
| SigE Exp Type
| RecConE Name [FieldExp]
| RecUpdE Exp [FieldExp]
| StaticE Exp
| UnboundVarE Name
| LabelE String
| ImplicitParamVarE String
deriving( Int -> Exp -> String -> String
[Exp] -> String -> String
Exp -> String
(Int -> Exp -> String -> String)
-> (Exp -> String) -> ([Exp] -> String -> String) -> Show Exp
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [Exp] -> String -> String
$cshowList :: [Exp] -> String -> String
show :: Exp -> String
$cshow :: Exp -> String
showsPrec :: Int -> Exp -> String -> String
$cshowsPrec :: Int -> Exp -> String -> String
Show, Exp -> Exp -> Bool
(Exp -> Exp -> Bool) -> (Exp -> Exp -> Bool) -> Eq Exp
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Exp -> Exp -> Bool
$c/= :: Exp -> Exp -> Bool
== :: Exp -> Exp -> Bool
$c== :: Exp -> Exp -> Bool
Eq, Eq Exp
Eq Exp
-> (Exp -> Exp -> Ordering)
-> (Exp -> Exp -> Bool)
-> (Exp -> Exp -> Bool)
-> (Exp -> Exp -> Bool)
-> (Exp -> Exp -> Bool)
-> (Exp -> Exp -> Exp)
-> (Exp -> Exp -> Exp)
-> Ord Exp
Exp -> Exp -> Bool
Exp -> Exp -> Ordering
Exp -> Exp -> Exp
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Exp -> Exp -> Exp
$cmin :: Exp -> Exp -> Exp
max :: Exp -> Exp -> Exp
$cmax :: Exp -> Exp -> Exp
>= :: Exp -> Exp -> Bool
$c>= :: Exp -> Exp -> Bool
> :: Exp -> Exp -> Bool
$c> :: Exp -> Exp -> Bool
<= :: Exp -> Exp -> Bool
$c<= :: Exp -> Exp -> Bool
< :: Exp -> Exp -> Bool
$c< :: Exp -> Exp -> Bool
compare :: Exp -> Exp -> Ordering
$ccompare :: Exp -> Exp -> Ordering
$cp1Ord :: Eq Exp
Ord, Typeable Exp
DataType
Constr
Typeable Exp
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Exp -> c Exp)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Exp)
-> (Exp -> Constr)
-> (Exp -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Exp))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Exp))
-> ((forall b. Data b => b -> b) -> Exp -> Exp)
-> (forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Exp -> r)
-> (forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Exp -> r)
-> (forall u. (forall d. Data d => d -> u) -> Exp -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Exp -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Exp -> m Exp)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Exp -> m Exp)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Exp -> m Exp)
-> Data Exp
Exp -> DataType
Exp -> Constr
(forall b. Data b => b -> b) -> Exp -> Exp
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Exp -> c Exp
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Exp
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) -> Exp -> u
forall u. (forall d. Data d => d -> u) -> Exp -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Exp -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Exp -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Exp -> m Exp
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Exp -> m Exp
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Exp
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Exp -> c Exp
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Exp)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Exp)
$cImplicitParamVarE :: Constr
$cLabelE :: Constr
$cUnboundVarE :: Constr
$cStaticE :: Constr
$cRecUpdE :: Constr
$cRecConE :: Constr
$cSigE :: Constr
$cListE :: Constr
$cArithSeqE :: Constr
$cCompE :: Constr
$cMDoE :: Constr
$cDoE :: Constr
$cCaseE :: Constr
$cLetE :: Constr
$cMultiIfE :: Constr
$cCondE :: Constr
$cUnboxedSumE :: Constr
$cUnboxedTupE :: Constr
$cTupE :: Constr
$cLamCaseE :: Constr
$cLamE :: Constr
$cParensE :: Constr
$cUInfixE :: Constr
$cInfixE :: Constr
$cAppTypeE :: Constr
$cAppE :: Constr
$cLitE :: Constr
$cConE :: Constr
$cVarE :: Constr
$tExp :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Exp -> m Exp
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Exp -> m Exp
gmapMp :: (forall d. Data d => d -> m d) -> Exp -> m Exp
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Exp -> m Exp
gmapM :: (forall d. Data d => d -> m d) -> Exp -> m Exp
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Exp -> m Exp
gmapQi :: Int -> (forall d. Data d => d -> u) -> Exp -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Exp -> u
gmapQ :: (forall d. Data d => d -> u) -> Exp -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Exp -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Exp -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Exp -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Exp -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Exp -> r
gmapT :: (forall b. Data b => b -> b) -> Exp -> Exp
$cgmapT :: (forall b. Data b => b -> b) -> Exp -> Exp
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Exp)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Exp)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Exp)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Exp)
dataTypeOf :: Exp -> DataType
$cdataTypeOf :: Exp -> DataType
toConstr :: Exp -> Constr
$ctoConstr :: Exp -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Exp
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Exp
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Exp -> c Exp
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Exp -> c Exp
$cp1Data :: Typeable Exp
Data, (forall x. Exp -> Rep Exp x)
-> (forall x. Rep Exp x -> Exp) -> Generic Exp
forall x. Rep Exp x -> Exp
forall x. Exp -> Rep Exp x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Exp x -> Exp
$cfrom :: forall x. Exp -> Rep Exp x
Generic )
type FieldExp = (Name,Exp)
data Body
= GuardedB [(Guard,Exp)]
| NormalB Exp
deriving( Int -> Body -> String -> String
[Body] -> String -> String
Body -> String
(Int -> Body -> String -> String)
-> (Body -> String) -> ([Body] -> String -> String) -> Show Body
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [Body] -> String -> String
$cshowList :: [Body] -> String -> String
show :: Body -> String
$cshow :: Body -> String
showsPrec :: Int -> Body -> String -> String
$cshowsPrec :: Int -> Body -> String -> String
Show, Body -> Body -> Bool
(Body -> Body -> Bool) -> (Body -> Body -> Bool) -> Eq Body
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Body -> Body -> Bool
$c/= :: Body -> Body -> Bool
== :: Body -> Body -> Bool
$c== :: Body -> Body -> Bool
Eq, Eq Body
Eq Body
-> (Body -> Body -> Ordering)
-> (Body -> Body -> Bool)
-> (Body -> Body -> Bool)
-> (Body -> Body -> Bool)
-> (Body -> Body -> Bool)
-> (Body -> Body -> Body)
-> (Body -> Body -> Body)
-> Ord Body
Body -> Body -> Bool
Body -> Body -> Ordering
Body -> Body -> Body
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Body -> Body -> Body
$cmin :: Body -> Body -> Body
max :: Body -> Body -> Body
$cmax :: Body -> Body -> Body
>= :: Body -> Body -> Bool
$c>= :: Body -> Body -> Bool
> :: Body -> Body -> Bool
$c> :: Body -> Body -> Bool
<= :: Body -> Body -> Bool
$c<= :: Body -> Body -> Bool
< :: Body -> Body -> Bool
$c< :: Body -> Body -> Bool
compare :: Body -> Body -> Ordering
$ccompare :: Body -> Body -> Ordering
$cp1Ord :: Eq Body
Ord, Typeable Body
DataType
Constr
Typeable Body
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Body -> c Body)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Body)
-> (Body -> Constr)
-> (Body -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Body))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Body))
-> ((forall b. Data b => b -> b) -> Body -> Body)
-> (forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Body -> r)
-> (forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Body -> r)
-> (forall u. (forall d. Data d => d -> u) -> Body -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Body -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Body -> m Body)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Body -> m Body)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Body -> m Body)
-> Data Body
Body -> DataType
Body -> Constr
(forall b. Data b => b -> b) -> Body -> Body
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Body -> c Body
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Body
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) -> Body -> u
forall u. (forall d. Data d => d -> u) -> Body -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Body -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Body -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Body -> m Body
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Body -> m Body
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Body
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Body -> c Body
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Body)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Body)
$cNormalB :: Constr
$cGuardedB :: Constr
$tBody :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Body -> m Body
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Body -> m Body
gmapMp :: (forall d. Data d => d -> m d) -> Body -> m Body
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Body -> m Body
gmapM :: (forall d. Data d => d -> m d) -> Body -> m Body
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Body -> m Body
gmapQi :: Int -> (forall d. Data d => d -> u) -> Body -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Body -> u
gmapQ :: (forall d. Data d => d -> u) -> Body -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Body -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Body -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Body -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Body -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Body -> r
gmapT :: (forall b. Data b => b -> b) -> Body -> Body
$cgmapT :: (forall b. Data b => b -> b) -> Body -> Body
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Body)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Body)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Body)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Body)
dataTypeOf :: Body -> DataType
$cdataTypeOf :: Body -> DataType
toConstr :: Body -> Constr
$ctoConstr :: Body -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Body
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Body
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Body -> c Body
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Body -> c Body
$cp1Data :: Typeable Body
Data, (forall x. Body -> Rep Body x)
-> (forall x. Rep Body x -> Body) -> Generic Body
forall x. Rep Body x -> Body
forall x. Body -> Rep Body x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Body x -> Body
$cfrom :: forall x. Body -> Rep Body x
Generic )
data Guard
= NormalG Exp
| PatG [Stmt]
deriving( Int -> Guard -> String -> String
[Guard] -> String -> String
Guard -> String
(Int -> Guard -> String -> String)
-> (Guard -> String) -> ([Guard] -> String -> String) -> Show Guard
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [Guard] -> String -> String
$cshowList :: [Guard] -> String -> String
show :: Guard -> String
$cshow :: Guard -> String
showsPrec :: Int -> Guard -> String -> String
$cshowsPrec :: Int -> Guard -> String -> String
Show, Guard -> Guard -> Bool
(Guard -> Guard -> Bool) -> (Guard -> Guard -> Bool) -> Eq Guard
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Guard -> Guard -> Bool
$c/= :: Guard -> Guard -> Bool
== :: Guard -> Guard -> Bool
$c== :: Guard -> Guard -> Bool
Eq, Eq Guard
Eq Guard
-> (Guard -> Guard -> Ordering)
-> (Guard -> Guard -> Bool)
-> (Guard -> Guard -> Bool)
-> (Guard -> Guard -> Bool)
-> (Guard -> Guard -> Bool)
-> (Guard -> Guard -> Guard)
-> (Guard -> Guard -> Guard)
-> Ord Guard
Guard -> Guard -> Bool
Guard -> Guard -> Ordering
Guard -> Guard -> Guard
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Guard -> Guard -> Guard
$cmin :: Guard -> Guard -> Guard
max :: Guard -> Guard -> Guard
$cmax :: Guard -> Guard -> Guard
>= :: Guard -> Guard -> Bool
$c>= :: Guard -> Guard -> Bool
> :: Guard -> Guard -> Bool
$c> :: Guard -> Guard -> Bool
<= :: Guard -> Guard -> Bool
$c<= :: Guard -> Guard -> Bool
< :: Guard -> Guard -> Bool
$c< :: Guard -> Guard -> Bool
compare :: Guard -> Guard -> Ordering
$ccompare :: Guard -> Guard -> Ordering
$cp1Ord :: Eq Guard
Ord, Typeable Guard
DataType
Constr
Typeable Guard
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Guard -> c Guard)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Guard)
-> (Guard -> Constr)
-> (Guard -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Guard))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Guard))
-> ((forall b. Data b => b -> b) -> Guard -> Guard)
-> (forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Guard -> r)
-> (forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Guard -> r)
-> (forall u. (forall d. Data d => d -> u) -> Guard -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Guard -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Guard -> m Guard)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Guard -> m Guard)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Guard -> m Guard)
-> Data Guard
Guard -> DataType
Guard -> Constr
(forall b. Data b => b -> b) -> Guard -> Guard
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Guard -> c Guard
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Guard
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) -> Guard -> u
forall u. (forall d. Data d => d -> u) -> Guard -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Guard -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Guard -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Guard -> m Guard
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Guard -> m Guard
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Guard
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Guard -> c Guard
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Guard)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Guard)
$cPatG :: Constr
$cNormalG :: Constr
$tGuard :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Guard -> m Guard
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Guard -> m Guard
gmapMp :: (forall d. Data d => d -> m d) -> Guard -> m Guard
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Guard -> m Guard
gmapM :: (forall d. Data d => d -> m d) -> Guard -> m Guard
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Guard -> m Guard
gmapQi :: Int -> (forall d. Data d => d -> u) -> Guard -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Guard -> u
gmapQ :: (forall d. Data d => d -> u) -> Guard -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Guard -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Guard -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Guard -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Guard -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Guard -> r
gmapT :: (forall b. Data b => b -> b) -> Guard -> Guard
$cgmapT :: (forall b. Data b => b -> b) -> Guard -> Guard
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Guard)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Guard)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Guard)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Guard)
dataTypeOf :: Guard -> DataType
$cdataTypeOf :: Guard -> DataType
toConstr :: Guard -> Constr
$ctoConstr :: Guard -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Guard
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Guard
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Guard -> c Guard
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Guard -> c Guard
$cp1Data :: Typeable Guard
Data, (forall x. Guard -> Rep Guard x)
-> (forall x. Rep Guard x -> Guard) -> Generic Guard
forall x. Rep Guard x -> Guard
forall x. Guard -> Rep Guard x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Guard x -> Guard
$cfrom :: forall x. Guard -> Rep Guard x
Generic )
data Stmt
= BindS Pat Exp
| LetS [ Dec ]
| NoBindS Exp
| ParS [[Stmt]]
| RecS [Stmt]
deriving( Int -> Stmt -> String -> String
[Stmt] -> String -> String
Stmt -> String
(Int -> Stmt -> String -> String)
-> (Stmt -> String) -> ([Stmt] -> String -> String) -> Show Stmt
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [Stmt] -> String -> String
$cshowList :: [Stmt] -> String -> String
show :: Stmt -> String
$cshow :: Stmt -> String
showsPrec :: Int -> Stmt -> String -> String
$cshowsPrec :: Int -> Stmt -> String -> String
Show, Stmt -> Stmt -> Bool
(Stmt -> Stmt -> Bool) -> (Stmt -> Stmt -> Bool) -> Eq Stmt
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Stmt -> Stmt -> Bool
$c/= :: Stmt -> Stmt -> Bool
== :: Stmt -> Stmt -> Bool
$c== :: Stmt -> Stmt -> Bool
Eq, Eq Stmt
Eq Stmt
-> (Stmt -> Stmt -> Ordering)
-> (Stmt -> Stmt -> Bool)
-> (Stmt -> Stmt -> Bool)
-> (Stmt -> Stmt -> Bool)
-> (Stmt -> Stmt -> Bool)
-> (Stmt -> Stmt -> Stmt)
-> (Stmt -> Stmt -> Stmt)
-> Ord Stmt
Stmt -> Stmt -> Bool
Stmt -> Stmt -> Ordering
Stmt -> Stmt -> Stmt
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Stmt -> Stmt -> Stmt
$cmin :: Stmt -> Stmt -> Stmt
max :: Stmt -> Stmt -> Stmt
$cmax :: Stmt -> Stmt -> Stmt
>= :: Stmt -> Stmt -> Bool
$c>= :: Stmt -> Stmt -> Bool
> :: Stmt -> Stmt -> Bool
$c> :: Stmt -> Stmt -> Bool
<= :: Stmt -> Stmt -> Bool
$c<= :: Stmt -> Stmt -> Bool
< :: Stmt -> Stmt -> Bool
$c< :: Stmt -> Stmt -> Bool
compare :: Stmt -> Stmt -> Ordering
$ccompare :: Stmt -> Stmt -> Ordering
$cp1Ord :: Eq Stmt
Ord, Typeable Stmt
DataType
Constr
Typeable Stmt
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Stmt -> c Stmt)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Stmt)
-> (Stmt -> Constr)
-> (Stmt -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Stmt))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Stmt))
-> ((forall b. Data b => b -> b) -> Stmt -> Stmt)
-> (forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Stmt -> r)
-> (forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Stmt -> r)
-> (forall u. (forall d. Data d => d -> u) -> Stmt -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Stmt -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Stmt -> m Stmt)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Stmt -> m Stmt)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Stmt -> m Stmt)
-> Data Stmt
Stmt -> DataType
Stmt -> Constr
(forall b. Data b => b -> b) -> Stmt -> Stmt
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Stmt -> c Stmt
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Stmt
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) -> Stmt -> u
forall u. (forall d. Data d => d -> u) -> Stmt -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Stmt -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Stmt -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Stmt -> m Stmt
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Stmt -> m Stmt
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Stmt
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Stmt -> c Stmt
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Stmt)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Stmt)
$cRecS :: Constr
$cParS :: Constr
$cNoBindS :: Constr
$cLetS :: Constr
$cBindS :: Constr
$tStmt :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Stmt -> m Stmt
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Stmt -> m Stmt
gmapMp :: (forall d. Data d => d -> m d) -> Stmt -> m Stmt
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Stmt -> m Stmt
gmapM :: (forall d. Data d => d -> m d) -> Stmt -> m Stmt
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Stmt -> m Stmt
gmapQi :: Int -> (forall d. Data d => d -> u) -> Stmt -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Stmt -> u
gmapQ :: (forall d. Data d => d -> u) -> Stmt -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Stmt -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Stmt -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Stmt -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Stmt -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Stmt -> r
gmapT :: (forall b. Data b => b -> b) -> Stmt -> Stmt
$cgmapT :: (forall b. Data b => b -> b) -> Stmt -> Stmt
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Stmt)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Stmt)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Stmt)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Stmt)
dataTypeOf :: Stmt -> DataType
$cdataTypeOf :: Stmt -> DataType
toConstr :: Stmt -> Constr
$ctoConstr :: Stmt -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Stmt
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Stmt
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Stmt -> c Stmt
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Stmt -> c Stmt
$cp1Data :: Typeable Stmt
Data, (forall x. Stmt -> Rep Stmt x)
-> (forall x. Rep Stmt x -> Stmt) -> Generic Stmt
forall x. Rep Stmt x -> Stmt
forall x. Stmt -> Rep Stmt x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Stmt x -> Stmt
$cfrom :: forall x. Stmt -> Rep Stmt x
Generic )
data Range = FromR Exp | FromThenR Exp Exp
| FromToR Exp Exp | FromThenToR Exp Exp Exp
deriving( Int -> Range -> String -> String
[Range] -> String -> String
Range -> String
(Int -> Range -> String -> String)
-> (Range -> String) -> ([Range] -> String -> String) -> Show Range
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [Range] -> String -> String
$cshowList :: [Range] -> String -> String
show :: Range -> String
$cshow :: Range -> String
showsPrec :: Int -> Range -> String -> String
$cshowsPrec :: Int -> Range -> String -> String
Show, Range -> Range -> Bool
(Range -> Range -> Bool) -> (Range -> Range -> Bool) -> Eq Range
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Range -> Range -> Bool
$c/= :: Range -> Range -> Bool
== :: Range -> Range -> Bool
$c== :: Range -> Range -> Bool
Eq, Eq Range
Eq Range
-> (Range -> Range -> Ordering)
-> (Range -> Range -> Bool)
-> (Range -> Range -> Bool)
-> (Range -> Range -> Bool)
-> (Range -> Range -> Bool)
-> (Range -> Range -> Range)
-> (Range -> Range -> Range)
-> Ord Range
Range -> Range -> Bool
Range -> Range -> Ordering
Range -> Range -> Range
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Range -> Range -> Range
$cmin :: Range -> Range -> Range
max :: Range -> Range -> Range
$cmax :: Range -> Range -> Range
>= :: Range -> Range -> Bool
$c>= :: Range -> Range -> Bool
> :: Range -> Range -> Bool
$c> :: Range -> Range -> Bool
<= :: Range -> Range -> Bool
$c<= :: Range -> Range -> Bool
< :: Range -> Range -> Bool
$c< :: Range -> Range -> Bool
compare :: Range -> Range -> Ordering
$ccompare :: Range -> Range -> Ordering
$cp1Ord :: Eq Range
Ord, Typeable Range
DataType
Constr
Typeable Range
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Range -> c Range)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Range)
-> (Range -> Constr)
-> (Range -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Range))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Range))
-> ((forall b. Data b => b -> b) -> Range -> Range)
-> (forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Range -> r)
-> (forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Range -> r)
-> (forall u. (forall d. Data d => d -> u) -> Range -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Range -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Range -> m Range)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Range -> m Range)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Range -> m Range)
-> Data Range
Range -> DataType
Range -> Constr
(forall b. Data b => b -> b) -> Range -> Range
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Range -> c Range
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Range
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) -> Range -> u
forall u. (forall d. Data d => d -> u) -> Range -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Range -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Range -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Range -> m Range
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Range -> m Range
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Range
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Range -> c Range
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Range)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Range)
$cFromThenToR :: Constr
$cFromToR :: Constr
$cFromThenR :: Constr
$cFromR :: Constr
$tRange :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Range -> m Range
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Range -> m Range
gmapMp :: (forall d. Data d => d -> m d) -> Range -> m Range
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Range -> m Range
gmapM :: (forall d. Data d => d -> m d) -> Range -> m Range
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Range -> m Range
gmapQi :: Int -> (forall d. Data d => d -> u) -> Range -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Range -> u
gmapQ :: (forall d. Data d => d -> u) -> Range -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Range -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Range -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Range -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Range -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Range -> r
gmapT :: (forall b. Data b => b -> b) -> Range -> Range
$cgmapT :: (forall b. Data b => b -> b) -> Range -> Range
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Range)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Range)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Range)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Range)
dataTypeOf :: Range -> DataType
$cdataTypeOf :: Range -> DataType
toConstr :: Range -> Constr
$ctoConstr :: Range -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Range
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Range
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Range -> c Range
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Range -> c Range
$cp1Data :: Typeable Range
Data, (forall x. Range -> Rep Range x)
-> (forall x. Rep Range x -> Range) -> Generic Range
forall x. Rep Range x -> Range
forall x. Range -> Rep Range x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Range x -> Range
$cfrom :: forall x. Range -> Rep Range x
Generic )
data Dec
= FunD Name [Clause]
| ValD Pat Body [Dec]
| DataD Cxt Name [TyVarBndr]
(Maybe Kind)
[Con] [DerivClause]
| NewtypeD Cxt Name [TyVarBndr]
(Maybe Kind)
Con [DerivClause]
| TySynD Name [TyVarBndr] Type
| ClassD Cxt Name [TyVarBndr]
[FunDep] [Dec]
| InstanceD (Maybe Overlap) Cxt Type [Dec]
| SigD Name Type
| KiSigD Name Kind
| ForeignD Foreign
| InfixD Fixity Name
| PragmaD Pragma
| DataFamilyD Name [TyVarBndr]
(Maybe Kind)
| DataInstD Cxt (Maybe [TyVarBndr]) Type
(Maybe Kind)
[Con] [DerivClause]
| NewtypeInstD Cxt (Maybe [TyVarBndr]) Type
(Maybe Kind)
Con [DerivClause]
| TySynInstD TySynEqn
| OpenTypeFamilyD TypeFamilyHead
| ClosedTypeFamilyD TypeFamilyHead [TySynEqn]
| RoleAnnotD Name [Role]
| StandaloneDerivD (Maybe DerivStrategy) Cxt Type
| DefaultSigD Name Type
| PatSynD Name PatSynArgs PatSynDir Pat
| PatSynSigD Name PatSynType
| ImplicitParamBindD String Exp
deriving( Int -> Dec -> String -> String
[Dec] -> String -> String
Dec -> String
(Int -> Dec -> String -> String)
-> (Dec -> String) -> ([Dec] -> String -> String) -> Show Dec
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [Dec] -> String -> String
$cshowList :: [Dec] -> String -> String
show :: Dec -> String
$cshow :: Dec -> String
showsPrec :: Int -> Dec -> String -> String
$cshowsPrec :: Int -> Dec -> String -> String
Show, Dec -> Dec -> Bool
(Dec -> Dec -> Bool) -> (Dec -> Dec -> Bool) -> Eq Dec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Dec -> Dec -> Bool
$c/= :: Dec -> Dec -> Bool
== :: Dec -> Dec -> Bool
$c== :: Dec -> Dec -> Bool
Eq, Eq Dec
Eq Dec
-> (Dec -> Dec -> Ordering)
-> (Dec -> Dec -> Bool)
-> (Dec -> Dec -> Bool)
-> (Dec -> Dec -> Bool)
-> (Dec -> Dec -> Bool)
-> (Dec -> Dec -> Dec)
-> (Dec -> Dec -> Dec)
-> Ord Dec
Dec -> Dec -> Bool
Dec -> Dec -> Ordering
Dec -> Dec -> Dec
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Dec -> Dec -> Dec
$cmin :: Dec -> Dec -> Dec
max :: Dec -> Dec -> Dec
$cmax :: Dec -> Dec -> Dec
>= :: Dec -> Dec -> Bool
$c>= :: Dec -> Dec -> Bool
> :: Dec -> Dec -> Bool
$c> :: Dec -> Dec -> Bool
<= :: Dec -> Dec -> Bool
$c<= :: Dec -> Dec -> Bool
< :: Dec -> Dec -> Bool
$c< :: Dec -> Dec -> Bool
compare :: Dec -> Dec -> Ordering
$ccompare :: Dec -> Dec -> Ordering
$cp1Ord :: Eq Dec
Ord, Typeable Dec
DataType
Constr
Typeable Dec
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Dec -> c Dec)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Dec)
-> (Dec -> Constr)
-> (Dec -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Dec))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Dec))
-> ((forall b. Data b => b -> b) -> Dec -> Dec)
-> (forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Dec -> r)
-> (forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Dec -> r)
-> (forall u. (forall d. Data d => d -> u) -> Dec -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Dec -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Dec -> m Dec)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Dec -> m Dec)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Dec -> m Dec)
-> Data Dec
Dec -> DataType
Dec -> Constr
(forall b. Data b => b -> b) -> Dec -> Dec
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Dec -> c Dec
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Dec
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) -> Dec -> u
forall u. (forall d. Data d => d -> u) -> Dec -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Dec -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Dec -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Dec -> m Dec
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Dec -> m Dec
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Dec
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Dec -> c Dec
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Dec)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Dec)
$cImplicitParamBindD :: Constr
$cPatSynSigD :: Constr
$cPatSynD :: Constr
$cDefaultSigD :: Constr
$cStandaloneDerivD :: Constr
$cRoleAnnotD :: Constr
$cClosedTypeFamilyD :: Constr
$cOpenTypeFamilyD :: Constr
$cTySynInstD :: Constr
$cNewtypeInstD :: Constr
$cDataInstD :: Constr
$cDataFamilyD :: Constr
$cPragmaD :: Constr
$cInfixD :: Constr
$cForeignD :: Constr
$cKiSigD :: Constr
$cSigD :: Constr
$cInstanceD :: Constr
$cClassD :: Constr
$cTySynD :: Constr
$cNewtypeD :: Constr
$cDataD :: Constr
$cValD :: Constr
$cFunD :: Constr
$tDec :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Dec -> m Dec
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Dec -> m Dec
gmapMp :: (forall d. Data d => d -> m d) -> Dec -> m Dec
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Dec -> m Dec
gmapM :: (forall d. Data d => d -> m d) -> Dec -> m Dec
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Dec -> m Dec
gmapQi :: Int -> (forall d. Data d => d -> u) -> Dec -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Dec -> u
gmapQ :: (forall d. Data d => d -> u) -> Dec -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Dec -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Dec -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Dec -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Dec -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Dec -> r
gmapT :: (forall b. Data b => b -> b) -> Dec -> Dec
$cgmapT :: (forall b. Data b => b -> b) -> Dec -> Dec
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Dec)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Dec)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Dec)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Dec)
dataTypeOf :: Dec -> DataType
$cdataTypeOf :: Dec -> DataType
toConstr :: Dec -> Constr
$ctoConstr :: Dec -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Dec
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Dec
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Dec -> c Dec
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Dec -> c Dec
$cp1Data :: Typeable Dec
Data, (forall x. Dec -> Rep Dec x)
-> (forall x. Rep Dec x -> Dec) -> Generic Dec
forall x. Rep Dec x -> Dec
forall x. Dec -> Rep Dec x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Dec x -> Dec
$cfrom :: forall x. Dec -> Rep Dec x
Generic )
data Overlap = Overlappable
| Overlapping
| Overlaps
| Incoherent
deriving( Int -> Overlap -> String -> String
[Overlap] -> String -> String
Overlap -> String
(Int -> Overlap -> String -> String)
-> (Overlap -> String)
-> ([Overlap] -> String -> String)
-> Show Overlap
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [Overlap] -> String -> String
$cshowList :: [Overlap] -> String -> String
show :: Overlap -> String
$cshow :: Overlap -> String
showsPrec :: Int -> Overlap -> String -> String
$cshowsPrec :: Int -> Overlap -> String -> String
Show, Overlap -> Overlap -> Bool
(Overlap -> Overlap -> Bool)
-> (Overlap -> Overlap -> Bool) -> Eq Overlap
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Overlap -> Overlap -> Bool
$c/= :: Overlap -> Overlap -> Bool
== :: Overlap -> Overlap -> Bool
$c== :: Overlap -> Overlap -> Bool
Eq, Eq Overlap
Eq Overlap
-> (Overlap -> Overlap -> Ordering)
-> (Overlap -> Overlap -> Bool)
-> (Overlap -> Overlap -> Bool)
-> (Overlap -> Overlap -> Bool)
-> (Overlap -> Overlap -> Bool)
-> (Overlap -> Overlap -> Overlap)
-> (Overlap -> Overlap -> Overlap)
-> Ord Overlap
Overlap -> Overlap -> Bool
Overlap -> Overlap -> Ordering
Overlap -> Overlap -> Overlap
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Overlap -> Overlap -> Overlap
$cmin :: Overlap -> Overlap -> Overlap
max :: Overlap -> Overlap -> Overlap
$cmax :: Overlap -> Overlap -> Overlap
>= :: Overlap -> Overlap -> Bool
$c>= :: Overlap -> Overlap -> Bool
> :: Overlap -> Overlap -> Bool
$c> :: Overlap -> Overlap -> Bool
<= :: Overlap -> Overlap -> Bool
$c<= :: Overlap -> Overlap -> Bool
< :: Overlap -> Overlap -> Bool
$c< :: Overlap -> Overlap -> Bool
compare :: Overlap -> Overlap -> Ordering
$ccompare :: Overlap -> Overlap -> Ordering
$cp1Ord :: Eq Overlap
Ord, Typeable Overlap
DataType
Constr
Typeable Overlap
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Overlap -> c Overlap)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Overlap)
-> (Overlap -> Constr)
-> (Overlap -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Overlap))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Overlap))
-> ((forall b. Data b => b -> b) -> Overlap -> Overlap)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Overlap -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Overlap -> r)
-> (forall u. (forall d. Data d => d -> u) -> Overlap -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Overlap -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Overlap -> m Overlap)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Overlap -> m Overlap)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Overlap -> m Overlap)
-> Data Overlap
Overlap -> DataType
Overlap -> Constr
(forall b. Data b => b -> b) -> Overlap -> Overlap
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Overlap -> c Overlap
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Overlap
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) -> Overlap -> u
forall u. (forall d. Data d => d -> u) -> Overlap -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Overlap -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Overlap -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Overlap -> m Overlap
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Overlap -> m Overlap
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Overlap
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Overlap -> c Overlap
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Overlap)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Overlap)
$cIncoherent :: Constr
$cOverlaps :: Constr
$cOverlapping :: Constr
$cOverlappable :: Constr
$tOverlap :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Overlap -> m Overlap
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Overlap -> m Overlap
gmapMp :: (forall d. Data d => d -> m d) -> Overlap -> m Overlap
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Overlap -> m Overlap
gmapM :: (forall d. Data d => d -> m d) -> Overlap -> m Overlap
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Overlap -> m Overlap
gmapQi :: Int -> (forall d. Data d => d -> u) -> Overlap -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Overlap -> u
gmapQ :: (forall d. Data d => d -> u) -> Overlap -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Overlap -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Overlap -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Overlap -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Overlap -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Overlap -> r
gmapT :: (forall b. Data b => b -> b) -> Overlap -> Overlap
$cgmapT :: (forall b. Data b => b -> b) -> Overlap -> Overlap
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Overlap)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Overlap)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Overlap)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Overlap)
dataTypeOf :: Overlap -> DataType
$cdataTypeOf :: Overlap -> DataType
toConstr :: Overlap -> Constr
$ctoConstr :: Overlap -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Overlap
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Overlap
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Overlap -> c Overlap
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Overlap -> c Overlap
$cp1Data :: Typeable Overlap
Data, (forall x. Overlap -> Rep Overlap x)
-> (forall x. Rep Overlap x -> Overlap) -> Generic Overlap
forall x. Rep Overlap x -> Overlap
forall x. Overlap -> Rep Overlap x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Overlap x -> Overlap
$cfrom :: forall x. Overlap -> Rep Overlap x
Generic )
data DerivClause = DerivClause (Maybe DerivStrategy) Cxt
deriving( Int -> DerivClause -> String -> String
[DerivClause] -> String -> String
DerivClause -> String
(Int -> DerivClause -> String -> String)
-> (DerivClause -> String)
-> ([DerivClause] -> String -> String)
-> Show DerivClause
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [DerivClause] -> String -> String
$cshowList :: [DerivClause] -> String -> String
show :: DerivClause -> String
$cshow :: DerivClause -> String
showsPrec :: Int -> DerivClause -> String -> String
$cshowsPrec :: Int -> DerivClause -> String -> String
Show, DerivClause -> DerivClause -> Bool
(DerivClause -> DerivClause -> Bool)
-> (DerivClause -> DerivClause -> Bool) -> Eq DerivClause
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DerivClause -> DerivClause -> Bool
$c/= :: DerivClause -> DerivClause -> Bool
== :: DerivClause -> DerivClause -> Bool
$c== :: DerivClause -> DerivClause -> Bool
Eq, Eq DerivClause
Eq DerivClause
-> (DerivClause -> DerivClause -> Ordering)
-> (DerivClause -> DerivClause -> Bool)
-> (DerivClause -> DerivClause -> Bool)
-> (DerivClause -> DerivClause -> Bool)
-> (DerivClause -> DerivClause -> Bool)
-> (DerivClause -> DerivClause -> DerivClause)
-> (DerivClause -> DerivClause -> DerivClause)
-> Ord DerivClause
DerivClause -> DerivClause -> Bool
DerivClause -> DerivClause -> Ordering
DerivClause -> DerivClause -> DerivClause
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: DerivClause -> DerivClause -> DerivClause
$cmin :: DerivClause -> DerivClause -> DerivClause
max :: DerivClause -> DerivClause -> DerivClause
$cmax :: DerivClause -> DerivClause -> DerivClause
>= :: DerivClause -> DerivClause -> Bool
$c>= :: DerivClause -> DerivClause -> Bool
> :: DerivClause -> DerivClause -> Bool
$c> :: DerivClause -> DerivClause -> Bool
<= :: DerivClause -> DerivClause -> Bool
$c<= :: DerivClause -> DerivClause -> Bool
< :: DerivClause -> DerivClause -> Bool
$c< :: DerivClause -> DerivClause -> Bool
compare :: DerivClause -> DerivClause -> Ordering
$ccompare :: DerivClause -> DerivClause -> Ordering
$cp1Ord :: Eq DerivClause
Ord, Typeable DerivClause
DataType
Constr
Typeable DerivClause
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DerivClause -> c DerivClause)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DerivClause)
-> (DerivClause -> Constr)
-> (DerivClause -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DerivClause))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DerivClause))
-> ((forall b. Data b => b -> b) -> DerivClause -> DerivClause)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DerivClause -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DerivClause -> r)
-> (forall u. (forall d. Data d => d -> u) -> DerivClause -> [u])
-> (forall u.
Int -> (forall d. Data d => d -> u) -> DerivClause -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DerivClause -> m DerivClause)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DerivClause -> m DerivClause)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DerivClause -> m DerivClause)
-> Data DerivClause
DerivClause -> DataType
DerivClause -> Constr
(forall b. Data b => b -> b) -> DerivClause -> DerivClause
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DerivClause -> c DerivClause
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DerivClause
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) -> DerivClause -> u
forall u. (forall d. Data d => d -> u) -> DerivClause -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DerivClause -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DerivClause -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DerivClause -> m DerivClause
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DerivClause -> m DerivClause
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DerivClause
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DerivClause -> c DerivClause
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DerivClause)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DerivClause)
$cDerivClause :: Constr
$tDerivClause :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> DerivClause -> m DerivClause
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DerivClause -> m DerivClause
gmapMp :: (forall d. Data d => d -> m d) -> DerivClause -> m DerivClause
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DerivClause -> m DerivClause
gmapM :: (forall d. Data d => d -> m d) -> DerivClause -> m DerivClause
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DerivClause -> m DerivClause
gmapQi :: Int -> (forall d. Data d => d -> u) -> DerivClause -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DerivClause -> u
gmapQ :: (forall d. Data d => d -> u) -> DerivClause -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DerivClause -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DerivClause -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DerivClause -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DerivClause -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DerivClause -> r
gmapT :: (forall b. Data b => b -> b) -> DerivClause -> DerivClause
$cgmapT :: (forall b. Data b => b -> b) -> DerivClause -> DerivClause
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DerivClause)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DerivClause)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c DerivClause)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DerivClause)
dataTypeOf :: DerivClause -> DataType
$cdataTypeOf :: DerivClause -> DataType
toConstr :: DerivClause -> Constr
$ctoConstr :: DerivClause -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DerivClause
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DerivClause
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DerivClause -> c DerivClause
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DerivClause -> c DerivClause
$cp1Data :: Typeable DerivClause
Data, (forall x. DerivClause -> Rep DerivClause x)
-> (forall x. Rep DerivClause x -> DerivClause)
-> Generic DerivClause
forall x. Rep DerivClause x -> DerivClause
forall x. DerivClause -> Rep DerivClause x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DerivClause x -> DerivClause
$cfrom :: forall x. DerivClause -> Rep DerivClause x
Generic )
data DerivStrategy = StockStrategy
| AnyclassStrategy
| NewtypeStrategy
| ViaStrategy Type
deriving( Int -> DerivStrategy -> String -> String
[DerivStrategy] -> String -> String
DerivStrategy -> String
(Int -> DerivStrategy -> String -> String)
-> (DerivStrategy -> String)
-> ([DerivStrategy] -> String -> String)
-> Show DerivStrategy
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [DerivStrategy] -> String -> String
$cshowList :: [DerivStrategy] -> String -> String
show :: DerivStrategy -> String
$cshow :: DerivStrategy -> String
showsPrec :: Int -> DerivStrategy -> String -> String
$cshowsPrec :: Int -> DerivStrategy -> String -> String
Show, DerivStrategy -> DerivStrategy -> Bool
(DerivStrategy -> DerivStrategy -> Bool)
-> (DerivStrategy -> DerivStrategy -> Bool) -> Eq DerivStrategy
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DerivStrategy -> DerivStrategy -> Bool
$c/= :: DerivStrategy -> DerivStrategy -> Bool
== :: DerivStrategy -> DerivStrategy -> Bool
$c== :: DerivStrategy -> DerivStrategy -> Bool
Eq, Eq DerivStrategy
Eq DerivStrategy
-> (DerivStrategy -> DerivStrategy -> Ordering)
-> (DerivStrategy -> DerivStrategy -> Bool)
-> (DerivStrategy -> DerivStrategy -> Bool)
-> (DerivStrategy -> DerivStrategy -> Bool)
-> (DerivStrategy -> DerivStrategy -> Bool)
-> (DerivStrategy -> DerivStrategy -> DerivStrategy)
-> (DerivStrategy -> DerivStrategy -> DerivStrategy)
-> Ord DerivStrategy
DerivStrategy -> DerivStrategy -> Bool
DerivStrategy -> DerivStrategy -> Ordering
DerivStrategy -> DerivStrategy -> DerivStrategy
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: DerivStrategy -> DerivStrategy -> DerivStrategy
$cmin :: DerivStrategy -> DerivStrategy -> DerivStrategy
max :: DerivStrategy -> DerivStrategy -> DerivStrategy
$cmax :: DerivStrategy -> DerivStrategy -> DerivStrategy
>= :: DerivStrategy -> DerivStrategy -> Bool
$c>= :: DerivStrategy -> DerivStrategy -> Bool
> :: DerivStrategy -> DerivStrategy -> Bool
$c> :: DerivStrategy -> DerivStrategy -> Bool
<= :: DerivStrategy -> DerivStrategy -> Bool
$c<= :: DerivStrategy -> DerivStrategy -> Bool
< :: DerivStrategy -> DerivStrategy -> Bool
$c< :: DerivStrategy -> DerivStrategy -> Bool
compare :: DerivStrategy -> DerivStrategy -> Ordering
$ccompare :: DerivStrategy -> DerivStrategy -> Ordering
$cp1Ord :: Eq DerivStrategy
Ord, Typeable DerivStrategy
DataType
Constr
Typeable DerivStrategy
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DerivStrategy -> c DerivStrategy)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DerivStrategy)
-> (DerivStrategy -> Constr)
-> (DerivStrategy -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DerivStrategy))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DerivStrategy))
-> ((forall b. Data b => b -> b) -> DerivStrategy -> DerivStrategy)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DerivStrategy -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DerivStrategy -> r)
-> (forall u. (forall d. Data d => d -> u) -> DerivStrategy -> [u])
-> (forall u.
Int -> (forall d. Data d => d -> u) -> DerivStrategy -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DerivStrategy -> m DerivStrategy)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DerivStrategy -> m DerivStrategy)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DerivStrategy -> m DerivStrategy)
-> Data DerivStrategy
DerivStrategy -> DataType
DerivStrategy -> Constr
(forall b. Data b => b -> b) -> DerivStrategy -> DerivStrategy
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DerivStrategy -> c DerivStrategy
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DerivStrategy
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) -> DerivStrategy -> u
forall u. (forall d. Data d => d -> u) -> DerivStrategy -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DerivStrategy -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DerivStrategy -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DerivStrategy -> m DerivStrategy
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DerivStrategy -> m DerivStrategy
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DerivStrategy
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DerivStrategy -> c DerivStrategy
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DerivStrategy)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DerivStrategy)
$cViaStrategy :: Constr
$cNewtypeStrategy :: Constr
$cAnyclassStrategy :: Constr
$cStockStrategy :: Constr
$tDerivStrategy :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> DerivStrategy -> m DerivStrategy
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DerivStrategy -> m DerivStrategy
gmapMp :: (forall d. Data d => d -> m d) -> DerivStrategy -> m DerivStrategy
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DerivStrategy -> m DerivStrategy
gmapM :: (forall d. Data d => d -> m d) -> DerivStrategy -> m DerivStrategy
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DerivStrategy -> m DerivStrategy
gmapQi :: Int -> (forall d. Data d => d -> u) -> DerivStrategy -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DerivStrategy -> u
gmapQ :: (forall d. Data d => d -> u) -> DerivStrategy -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DerivStrategy -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DerivStrategy -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DerivStrategy -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DerivStrategy -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DerivStrategy -> r
gmapT :: (forall b. Data b => b -> b) -> DerivStrategy -> DerivStrategy
$cgmapT :: (forall b. Data b => b -> b) -> DerivStrategy -> DerivStrategy
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DerivStrategy)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DerivStrategy)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c DerivStrategy)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DerivStrategy)
dataTypeOf :: DerivStrategy -> DataType
$cdataTypeOf :: DerivStrategy -> DataType
toConstr :: DerivStrategy -> Constr
$ctoConstr :: DerivStrategy -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DerivStrategy
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DerivStrategy
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DerivStrategy -> c DerivStrategy
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DerivStrategy -> c DerivStrategy
$cp1Data :: Typeable DerivStrategy
Data, (forall x. DerivStrategy -> Rep DerivStrategy x)
-> (forall x. Rep DerivStrategy x -> DerivStrategy)
-> Generic DerivStrategy
forall x. Rep DerivStrategy x -> DerivStrategy
forall x. DerivStrategy -> Rep DerivStrategy x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DerivStrategy x -> DerivStrategy
$cfrom :: forall x. DerivStrategy -> Rep DerivStrategy x
Generic )
type PatSynType = Type
data TypeFamilyHead =
TypeFamilyHead Name [TyVarBndr] FamilyResultSig (Maybe InjectivityAnn)
deriving( Int -> TypeFamilyHead -> String -> String
[TypeFamilyHead] -> String -> String
TypeFamilyHead -> String
(Int -> TypeFamilyHead -> String -> String)
-> (TypeFamilyHead -> String)
-> ([TypeFamilyHead] -> String -> String)
-> Show TypeFamilyHead
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [TypeFamilyHead] -> String -> String
$cshowList :: [TypeFamilyHead] -> String -> String
show :: TypeFamilyHead -> String
$cshow :: TypeFamilyHead -> String
showsPrec :: Int -> TypeFamilyHead -> String -> String
$cshowsPrec :: Int -> TypeFamilyHead -> String -> String
Show, TypeFamilyHead -> TypeFamilyHead -> Bool
(TypeFamilyHead -> TypeFamilyHead -> Bool)
-> (TypeFamilyHead -> TypeFamilyHead -> Bool) -> Eq TypeFamilyHead
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TypeFamilyHead -> TypeFamilyHead -> Bool
$c/= :: TypeFamilyHead -> TypeFamilyHead -> Bool
== :: TypeFamilyHead -> TypeFamilyHead -> Bool
$c== :: TypeFamilyHead -> TypeFamilyHead -> Bool
Eq, Eq TypeFamilyHead
Eq TypeFamilyHead
-> (TypeFamilyHead -> TypeFamilyHead -> Ordering)
-> (TypeFamilyHead -> TypeFamilyHead -> Bool)
-> (TypeFamilyHead -> TypeFamilyHead -> Bool)
-> (TypeFamilyHead -> TypeFamilyHead -> Bool)
-> (TypeFamilyHead -> TypeFamilyHead -> Bool)
-> (TypeFamilyHead -> TypeFamilyHead -> TypeFamilyHead)
-> (TypeFamilyHead -> TypeFamilyHead -> TypeFamilyHead)
-> Ord TypeFamilyHead
TypeFamilyHead -> TypeFamilyHead -> Bool
TypeFamilyHead -> TypeFamilyHead -> Ordering
TypeFamilyHead -> TypeFamilyHead -> TypeFamilyHead
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: TypeFamilyHead -> TypeFamilyHead -> TypeFamilyHead
$cmin :: TypeFamilyHead -> TypeFamilyHead -> TypeFamilyHead
max :: TypeFamilyHead -> TypeFamilyHead -> TypeFamilyHead
$cmax :: TypeFamilyHead -> TypeFamilyHead -> TypeFamilyHead
>= :: TypeFamilyHead -> TypeFamilyHead -> Bool
$c>= :: TypeFamilyHead -> TypeFamilyHead -> Bool
> :: TypeFamilyHead -> TypeFamilyHead -> Bool
$c> :: TypeFamilyHead -> TypeFamilyHead -> Bool
<= :: TypeFamilyHead -> TypeFamilyHead -> Bool
$c<= :: TypeFamilyHead -> TypeFamilyHead -> Bool
< :: TypeFamilyHead -> TypeFamilyHead -> Bool
$c< :: TypeFamilyHead -> TypeFamilyHead -> Bool
compare :: TypeFamilyHead -> TypeFamilyHead -> Ordering
$ccompare :: TypeFamilyHead -> TypeFamilyHead -> Ordering
$cp1Ord :: Eq TypeFamilyHead
Ord, Typeable TypeFamilyHead
DataType
Constr
Typeable TypeFamilyHead
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypeFamilyHead -> c TypeFamilyHead)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TypeFamilyHead)
-> (TypeFamilyHead -> Constr)
-> (TypeFamilyHead -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TypeFamilyHead))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TypeFamilyHead))
-> ((forall b. Data b => b -> b)
-> TypeFamilyHead -> TypeFamilyHead)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TypeFamilyHead -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TypeFamilyHead -> r)
-> (forall u.
(forall d. Data d => d -> u) -> TypeFamilyHead -> [u])
-> (forall u.
Int -> (forall d. Data d => d -> u) -> TypeFamilyHead -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> TypeFamilyHead -> m TypeFamilyHead)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> TypeFamilyHead -> m TypeFamilyHead)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> TypeFamilyHead -> m TypeFamilyHead)
-> Data TypeFamilyHead
TypeFamilyHead -> DataType
TypeFamilyHead -> Constr
(forall b. Data b => b -> b) -> TypeFamilyHead -> TypeFamilyHead
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypeFamilyHead -> c TypeFamilyHead
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TypeFamilyHead
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) -> TypeFamilyHead -> u
forall u. (forall d. Data d => d -> u) -> TypeFamilyHead -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TypeFamilyHead -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TypeFamilyHead -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> TypeFamilyHead -> m TypeFamilyHead
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> TypeFamilyHead -> m TypeFamilyHead
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TypeFamilyHead
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypeFamilyHead -> c TypeFamilyHead
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TypeFamilyHead)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TypeFamilyHead)
$cTypeFamilyHead :: Constr
$tTypeFamilyHead :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> TypeFamilyHead -> m TypeFamilyHead
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> TypeFamilyHead -> m TypeFamilyHead
gmapMp :: (forall d. Data d => d -> m d)
-> TypeFamilyHead -> m TypeFamilyHead
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> TypeFamilyHead -> m TypeFamilyHead
gmapM :: (forall d. Data d => d -> m d)
-> TypeFamilyHead -> m TypeFamilyHead
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> TypeFamilyHead -> m TypeFamilyHead
gmapQi :: Int -> (forall d. Data d => d -> u) -> TypeFamilyHead -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> TypeFamilyHead -> u
gmapQ :: (forall d. Data d => d -> u) -> TypeFamilyHead -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> TypeFamilyHead -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TypeFamilyHead -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TypeFamilyHead -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TypeFamilyHead -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TypeFamilyHead -> r
gmapT :: (forall b. Data b => b -> b) -> TypeFamilyHead -> TypeFamilyHead
$cgmapT :: (forall b. Data b => b -> b) -> TypeFamilyHead -> TypeFamilyHead
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TypeFamilyHead)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TypeFamilyHead)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c TypeFamilyHead)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TypeFamilyHead)
dataTypeOf :: TypeFamilyHead -> DataType
$cdataTypeOf :: TypeFamilyHead -> DataType
toConstr :: TypeFamilyHead -> Constr
$ctoConstr :: TypeFamilyHead -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TypeFamilyHead
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TypeFamilyHead
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypeFamilyHead -> c TypeFamilyHead
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypeFamilyHead -> c TypeFamilyHead
$cp1Data :: Typeable TypeFamilyHead
Data, (forall x. TypeFamilyHead -> Rep TypeFamilyHead x)
-> (forall x. Rep TypeFamilyHead x -> TypeFamilyHead)
-> Generic TypeFamilyHead
forall x. Rep TypeFamilyHead x -> TypeFamilyHead
forall x. TypeFamilyHead -> Rep TypeFamilyHead x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep TypeFamilyHead x -> TypeFamilyHead
$cfrom :: forall x. TypeFamilyHead -> Rep TypeFamilyHead x
Generic )
data TySynEqn = TySynEqn (Maybe [TyVarBndr]) Type Type
deriving( Int -> TySynEqn -> String -> String
[TySynEqn] -> String -> String
TySynEqn -> String
(Int -> TySynEqn -> String -> String)
-> (TySynEqn -> String)
-> ([TySynEqn] -> String -> String)
-> Show TySynEqn
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [TySynEqn] -> String -> String
$cshowList :: [TySynEqn] -> String -> String
show :: TySynEqn -> String
$cshow :: TySynEqn -> String
showsPrec :: Int -> TySynEqn -> String -> String
$cshowsPrec :: Int -> TySynEqn -> String -> String
Show, TySynEqn -> TySynEqn -> Bool
(TySynEqn -> TySynEqn -> Bool)
-> (TySynEqn -> TySynEqn -> Bool) -> Eq TySynEqn
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TySynEqn -> TySynEqn -> Bool
$c/= :: TySynEqn -> TySynEqn -> Bool
== :: TySynEqn -> TySynEqn -> Bool
$c== :: TySynEqn -> TySynEqn -> Bool
Eq, Eq TySynEqn
Eq TySynEqn
-> (TySynEqn -> TySynEqn -> Ordering)
-> (TySynEqn -> TySynEqn -> Bool)
-> (TySynEqn -> TySynEqn -> Bool)
-> (TySynEqn -> TySynEqn -> Bool)
-> (TySynEqn -> TySynEqn -> Bool)
-> (TySynEqn -> TySynEqn -> TySynEqn)
-> (TySynEqn -> TySynEqn -> TySynEqn)
-> Ord TySynEqn
TySynEqn -> TySynEqn -> Bool
TySynEqn -> TySynEqn -> Ordering
TySynEqn -> TySynEqn -> TySynEqn
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: TySynEqn -> TySynEqn -> TySynEqn
$cmin :: TySynEqn -> TySynEqn -> TySynEqn
max :: TySynEqn -> TySynEqn -> TySynEqn
$cmax :: TySynEqn -> TySynEqn -> TySynEqn
>= :: TySynEqn -> TySynEqn -> Bool
$c>= :: TySynEqn -> TySynEqn -> Bool
> :: TySynEqn -> TySynEqn -> Bool
$c> :: TySynEqn -> TySynEqn -> Bool
<= :: TySynEqn -> TySynEqn -> Bool
$c<= :: TySynEqn -> TySynEqn -> Bool
< :: TySynEqn -> TySynEqn -> Bool
$c< :: TySynEqn -> TySynEqn -> Bool
compare :: TySynEqn -> TySynEqn -> Ordering
$ccompare :: TySynEqn -> TySynEqn -> Ordering
$cp1Ord :: Eq TySynEqn
Ord, Typeable TySynEqn
DataType
Constr
Typeable TySynEqn
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TySynEqn -> c TySynEqn)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TySynEqn)
-> (TySynEqn -> Constr)
-> (TySynEqn -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TySynEqn))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TySynEqn))
-> ((forall b. Data b => b -> b) -> TySynEqn -> TySynEqn)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TySynEqn -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TySynEqn -> r)
-> (forall u. (forall d. Data d => d -> u) -> TySynEqn -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> TySynEqn -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TySynEqn -> m TySynEqn)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TySynEqn -> m TySynEqn)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TySynEqn -> m TySynEqn)
-> Data TySynEqn
TySynEqn -> DataType
TySynEqn -> Constr
(forall b. Data b => b -> b) -> TySynEqn -> TySynEqn
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TySynEqn -> c TySynEqn
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TySynEqn
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) -> TySynEqn -> u
forall u. (forall d. Data d => d -> u) -> TySynEqn -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TySynEqn -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TySynEqn -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TySynEqn -> m TySynEqn
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TySynEqn -> m TySynEqn
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TySynEqn
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TySynEqn -> c TySynEqn
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TySynEqn)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TySynEqn)
$cTySynEqn :: Constr
$tTySynEqn :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> TySynEqn -> m TySynEqn
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TySynEqn -> m TySynEqn
gmapMp :: (forall d. Data d => d -> m d) -> TySynEqn -> m TySynEqn
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TySynEqn -> m TySynEqn
gmapM :: (forall d. Data d => d -> m d) -> TySynEqn -> m TySynEqn
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TySynEqn -> m TySynEqn
gmapQi :: Int -> (forall d. Data d => d -> u) -> TySynEqn -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TySynEqn -> u
gmapQ :: (forall d. Data d => d -> u) -> TySynEqn -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> TySynEqn -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TySynEqn -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TySynEqn -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TySynEqn -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TySynEqn -> r
gmapT :: (forall b. Data b => b -> b) -> TySynEqn -> TySynEqn
$cgmapT :: (forall b. Data b => b -> b) -> TySynEqn -> TySynEqn
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TySynEqn)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TySynEqn)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c TySynEqn)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TySynEqn)
dataTypeOf :: TySynEqn -> DataType
$cdataTypeOf :: TySynEqn -> DataType
toConstr :: TySynEqn -> Constr
$ctoConstr :: TySynEqn -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TySynEqn
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TySynEqn
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TySynEqn -> c TySynEqn
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TySynEqn -> c TySynEqn
$cp1Data :: Typeable TySynEqn
Data, (forall x. TySynEqn -> Rep TySynEqn x)
-> (forall x. Rep TySynEqn x -> TySynEqn) -> Generic TySynEqn
forall x. Rep TySynEqn x -> TySynEqn
forall x. TySynEqn -> Rep TySynEqn x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep TySynEqn x -> TySynEqn
$cfrom :: forall x. TySynEqn -> Rep TySynEqn x
Generic )
data FunDep = FunDep [Name] [Name]
deriving( Int -> FunDep -> String -> String
[FunDep] -> String -> String
FunDep -> String
(Int -> FunDep -> String -> String)
-> (FunDep -> String)
-> ([FunDep] -> String -> String)
-> Show FunDep
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [FunDep] -> String -> String
$cshowList :: [FunDep] -> String -> String
show :: FunDep -> String
$cshow :: FunDep -> String
showsPrec :: Int -> FunDep -> String -> String
$cshowsPrec :: Int -> FunDep -> String -> String
Show, FunDep -> FunDep -> Bool
(FunDep -> FunDep -> Bool)
-> (FunDep -> FunDep -> Bool) -> Eq FunDep
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FunDep -> FunDep -> Bool
$c/= :: FunDep -> FunDep -> Bool
== :: FunDep -> FunDep -> Bool
$c== :: FunDep -> FunDep -> Bool
Eq, Eq FunDep
Eq FunDep
-> (FunDep -> FunDep -> Ordering)
-> (FunDep -> FunDep -> Bool)
-> (FunDep -> FunDep -> Bool)
-> (FunDep -> FunDep -> Bool)
-> (FunDep -> FunDep -> Bool)
-> (FunDep -> FunDep -> FunDep)
-> (FunDep -> FunDep -> FunDep)
-> Ord FunDep
FunDep -> FunDep -> Bool
FunDep -> FunDep -> Ordering
FunDep -> FunDep -> FunDep
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: FunDep -> FunDep -> FunDep
$cmin :: FunDep -> FunDep -> FunDep
max :: FunDep -> FunDep -> FunDep
$cmax :: FunDep -> FunDep -> FunDep
>= :: FunDep -> FunDep -> Bool
$c>= :: FunDep -> FunDep -> Bool
> :: FunDep -> FunDep -> Bool
$c> :: FunDep -> FunDep -> Bool
<= :: FunDep -> FunDep -> Bool
$c<= :: FunDep -> FunDep -> Bool
< :: FunDep -> FunDep -> Bool
$c< :: FunDep -> FunDep -> Bool
compare :: FunDep -> FunDep -> Ordering
$ccompare :: FunDep -> FunDep -> Ordering
$cp1Ord :: Eq FunDep
Ord, Typeable FunDep
DataType
Constr
Typeable FunDep
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FunDep -> c FunDep)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FunDep)
-> (FunDep -> Constr)
-> (FunDep -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FunDep))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FunDep))
-> ((forall b. Data b => b -> b) -> FunDep -> FunDep)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FunDep -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FunDep -> r)
-> (forall u. (forall d. Data d => d -> u) -> FunDep -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> FunDep -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FunDep -> m FunDep)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FunDep -> m FunDep)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FunDep -> m FunDep)
-> Data FunDep
FunDep -> DataType
FunDep -> Constr
(forall b. Data b => b -> b) -> FunDep -> FunDep
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FunDep -> c FunDep
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FunDep
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) -> FunDep -> u
forall u. (forall d. Data d => d -> u) -> FunDep -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FunDep -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FunDep -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FunDep -> m FunDep
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FunDep -> m FunDep
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FunDep
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FunDep -> c FunDep
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FunDep)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FunDep)
$cFunDep :: Constr
$tFunDep :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> FunDep -> m FunDep
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FunDep -> m FunDep
gmapMp :: (forall d. Data d => d -> m d) -> FunDep -> m FunDep
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FunDep -> m FunDep
gmapM :: (forall d. Data d => d -> m d) -> FunDep -> m FunDep
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FunDep -> m FunDep
gmapQi :: Int -> (forall d. Data d => d -> u) -> FunDep -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> FunDep -> u
gmapQ :: (forall d. Data d => d -> u) -> FunDep -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> FunDep -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FunDep -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FunDep -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FunDep -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FunDep -> r
gmapT :: (forall b. Data b => b -> b) -> FunDep -> FunDep
$cgmapT :: (forall b. Data b => b -> b) -> FunDep -> FunDep
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FunDep)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FunDep)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c FunDep)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FunDep)
dataTypeOf :: FunDep -> DataType
$cdataTypeOf :: FunDep -> DataType
toConstr :: FunDep -> Constr
$ctoConstr :: FunDep -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FunDep
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FunDep
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FunDep -> c FunDep
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FunDep -> c FunDep
$cp1Data :: Typeable FunDep
Data, (forall x. FunDep -> Rep FunDep x)
-> (forall x. Rep FunDep x -> FunDep) -> Generic FunDep
forall x. Rep FunDep x -> FunDep
forall x. FunDep -> Rep FunDep x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep FunDep x -> FunDep
$cfrom :: forall x. FunDep -> Rep FunDep x
Generic )
data Foreign = ImportF Callconv Safety String Name Type
| ExportF Callconv String Name Type
deriving( Int -> Foreign -> String -> String
[Foreign] -> String -> String
Foreign -> String
(Int -> Foreign -> String -> String)
-> (Foreign -> String)
-> ([Foreign] -> String -> String)
-> Show Foreign
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [Foreign] -> String -> String
$cshowList :: [Foreign] -> String -> String
show :: Foreign -> String
$cshow :: Foreign -> String
showsPrec :: Int -> Foreign -> String -> String
$cshowsPrec :: Int -> Foreign -> String -> String
Show, Foreign -> Foreign -> Bool
(Foreign -> Foreign -> Bool)
-> (Foreign -> Foreign -> Bool) -> Eq Foreign
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Foreign -> Foreign -> Bool
$c/= :: Foreign -> Foreign -> Bool
== :: Foreign -> Foreign -> Bool
$c== :: Foreign -> Foreign -> Bool
Eq, Eq Foreign
Eq Foreign
-> (Foreign -> Foreign -> Ordering)
-> (Foreign -> Foreign -> Bool)
-> (Foreign -> Foreign -> Bool)
-> (Foreign -> Foreign -> Bool)
-> (Foreign -> Foreign -> Bool)
-> (Foreign -> Foreign -> Foreign)
-> (Foreign -> Foreign -> Foreign)
-> Ord Foreign
Foreign -> Foreign -> Bool
Foreign -> Foreign -> Ordering
Foreign -> Foreign -> Foreign
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Foreign -> Foreign -> Foreign
$cmin :: Foreign -> Foreign -> Foreign
max :: Foreign -> Foreign -> Foreign
$cmax :: Foreign -> Foreign -> Foreign
>= :: Foreign -> Foreign -> Bool
$c>= :: Foreign -> Foreign -> Bool
> :: Foreign -> Foreign -> Bool
$c> :: Foreign -> Foreign -> Bool
<= :: Foreign -> Foreign -> Bool
$c<= :: Foreign -> Foreign -> Bool
< :: Foreign -> Foreign -> Bool
$c< :: Foreign -> Foreign -> Bool
compare :: Foreign -> Foreign -> Ordering
$ccompare :: Foreign -> Foreign -> Ordering
$cp1Ord :: Eq Foreign
Ord, Typeable Foreign
DataType
Constr
Typeable Foreign
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Foreign -> c Foreign)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Foreign)
-> (Foreign -> Constr)
-> (Foreign -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Foreign))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Foreign))
-> ((forall b. Data b => b -> b) -> Foreign -> Foreign)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Foreign -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Foreign -> r)
-> (forall u. (forall d. Data d => d -> u) -> Foreign -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Foreign -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Foreign -> m Foreign)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Foreign -> m Foreign)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Foreign -> m Foreign)
-> Data Foreign
Foreign -> DataType
Foreign -> Constr
(forall b. Data b => b -> b) -> Foreign -> Foreign
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Foreign -> c Foreign
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Foreign
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) -> Foreign -> u
forall u. (forall d. Data d => d -> u) -> Foreign -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Foreign -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Foreign -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Foreign -> m Foreign
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Foreign -> m Foreign
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Foreign
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Foreign -> c Foreign
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Foreign)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Foreign)
$cExportF :: Constr
$cImportF :: Constr
$tForeign :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Foreign -> m Foreign
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Foreign -> m Foreign
gmapMp :: (forall d. Data d => d -> m d) -> Foreign -> m Foreign
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Foreign -> m Foreign
gmapM :: (forall d. Data d => d -> m d) -> Foreign -> m Foreign
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Foreign -> m Foreign
gmapQi :: Int -> (forall d. Data d => d -> u) -> Foreign -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Foreign -> u
gmapQ :: (forall d. Data d => d -> u) -> Foreign -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Foreign -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Foreign -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Foreign -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Foreign -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Foreign -> r
gmapT :: (forall b. Data b => b -> b) -> Foreign -> Foreign
$cgmapT :: (forall b. Data b => b -> b) -> Foreign -> Foreign
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Foreign)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Foreign)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Foreign)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Foreign)
dataTypeOf :: Foreign -> DataType
$cdataTypeOf :: Foreign -> DataType
toConstr :: Foreign -> Constr
$ctoConstr :: Foreign -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Foreign
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Foreign
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Foreign -> c Foreign
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Foreign -> c Foreign
$cp1Data :: Typeable Foreign
Data, (forall x. Foreign -> Rep Foreign x)
-> (forall x. Rep Foreign x -> Foreign) -> Generic Foreign
forall x. Rep Foreign x -> Foreign
forall x. Foreign -> Rep Foreign x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Foreign x -> Foreign
$cfrom :: forall x. Foreign -> Rep Foreign x
Generic )
data Callconv = CCall | StdCall | CApi | Prim | JavaScript
deriving( Int -> Callconv -> String -> String
[Callconv] -> String -> String
Callconv -> String
(Int -> Callconv -> String -> String)
-> (Callconv -> String)
-> ([Callconv] -> String -> String)
-> Show Callconv
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [Callconv] -> String -> String
$cshowList :: [Callconv] -> String -> String
show :: Callconv -> String
$cshow :: Callconv -> String
showsPrec :: Int -> Callconv -> String -> String
$cshowsPrec :: Int -> Callconv -> String -> String
Show, Callconv -> Callconv -> Bool
(Callconv -> Callconv -> Bool)
-> (Callconv -> Callconv -> Bool) -> Eq Callconv
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Callconv -> Callconv -> Bool
$c/= :: Callconv -> Callconv -> Bool
== :: Callconv -> Callconv -> Bool
$c== :: Callconv -> Callconv -> Bool
Eq, Eq Callconv
Eq Callconv
-> (Callconv -> Callconv -> Ordering)
-> (Callconv -> Callconv -> Bool)
-> (Callconv -> Callconv -> Bool)
-> (Callconv -> Callconv -> Bool)
-> (Callconv -> Callconv -> Bool)
-> (Callconv -> Callconv -> Callconv)
-> (Callconv -> Callconv -> Callconv)
-> Ord Callconv
Callconv -> Callconv -> Bool
Callconv -> Callconv -> Ordering
Callconv -> Callconv -> Callconv
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Callconv -> Callconv -> Callconv
$cmin :: Callconv -> Callconv -> Callconv
max :: Callconv -> Callconv -> Callconv
$cmax :: Callconv -> Callconv -> Callconv
>= :: Callconv -> Callconv -> Bool
$c>= :: Callconv -> Callconv -> Bool
> :: Callconv -> Callconv -> Bool
$c> :: Callconv -> Callconv -> Bool
<= :: Callconv -> Callconv -> Bool
$c<= :: Callconv -> Callconv -> Bool
< :: Callconv -> Callconv -> Bool
$c< :: Callconv -> Callconv -> Bool
compare :: Callconv -> Callconv -> Ordering
$ccompare :: Callconv -> Callconv -> Ordering
$cp1Ord :: Eq Callconv
Ord, Typeable Callconv
DataType
Constr
Typeable Callconv
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Callconv -> c Callconv)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Callconv)
-> (Callconv -> Constr)
-> (Callconv -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Callconv))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Callconv))
-> ((forall b. Data b => b -> b) -> Callconv -> Callconv)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Callconv -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Callconv -> r)
-> (forall u. (forall d. Data d => d -> u) -> Callconv -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Callconv -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Callconv -> m Callconv)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Callconv -> m Callconv)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Callconv -> m Callconv)
-> Data Callconv
Callconv -> DataType
Callconv -> Constr
(forall b. Data b => b -> b) -> Callconv -> Callconv
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Callconv -> c Callconv
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Callconv
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) -> Callconv -> u
forall u. (forall d. Data d => d -> u) -> Callconv -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Callconv -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Callconv -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Callconv -> m Callconv
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Callconv -> m Callconv
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Callconv
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Callconv -> c Callconv
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Callconv)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Callconv)
$cJavaScript :: Constr
$cPrim :: Constr
$cCApi :: Constr
$cStdCall :: Constr
$cCCall :: Constr
$tCallconv :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Callconv -> m Callconv
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Callconv -> m Callconv
gmapMp :: (forall d. Data d => d -> m d) -> Callconv -> m Callconv
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Callconv -> m Callconv
gmapM :: (forall d. Data d => d -> m d) -> Callconv -> m Callconv
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Callconv -> m Callconv
gmapQi :: Int -> (forall d. Data d => d -> u) -> Callconv -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Callconv -> u
gmapQ :: (forall d. Data d => d -> u) -> Callconv -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Callconv -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Callconv -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Callconv -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Callconv -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Callconv -> r
gmapT :: (forall b. Data b => b -> b) -> Callconv -> Callconv
$cgmapT :: (forall b. Data b => b -> b) -> Callconv -> Callconv
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Callconv)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Callconv)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Callconv)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Callconv)
dataTypeOf :: Callconv -> DataType
$cdataTypeOf :: Callconv -> DataType
toConstr :: Callconv -> Constr
$ctoConstr :: Callconv -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Callconv
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Callconv
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Callconv -> c Callconv
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Callconv -> c Callconv
$cp1Data :: Typeable Callconv
Data, (forall x. Callconv -> Rep Callconv x)
-> (forall x. Rep Callconv x -> Callconv) -> Generic Callconv
forall x. Rep Callconv x -> Callconv
forall x. Callconv -> Rep Callconv x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Callconv x -> Callconv
$cfrom :: forall x. Callconv -> Rep Callconv x
Generic )
data Safety = Unsafe | Safe | Interruptible
deriving( Int -> Safety -> String -> String
[Safety] -> String -> String
Safety -> String
(Int -> Safety -> String -> String)
-> (Safety -> String)
-> ([Safety] -> String -> String)
-> Show Safety
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [Safety] -> String -> String
$cshowList :: [Safety] -> String -> String
show :: Safety -> String
$cshow :: Safety -> String
showsPrec :: Int -> Safety -> String -> String
$cshowsPrec :: Int -> Safety -> String -> String
Show, Safety -> Safety -> Bool
(Safety -> Safety -> Bool)
-> (Safety -> Safety -> Bool) -> Eq Safety
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Safety -> Safety -> Bool
$c/= :: Safety -> Safety -> Bool
== :: Safety -> Safety -> Bool
$c== :: Safety -> Safety -> Bool
Eq, Eq Safety
Eq Safety
-> (Safety -> Safety -> Ordering)
-> (Safety -> Safety -> Bool)
-> (Safety -> Safety -> Bool)
-> (Safety -> Safety -> Bool)
-> (Safety -> Safety -> Bool)
-> (Safety -> Safety -> Safety)
-> (Safety -> Safety -> Safety)
-> Ord Safety
Safety -> Safety -> Bool
Safety -> Safety -> Ordering
Safety -> Safety -> Safety
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Safety -> Safety -> Safety
$cmin :: Safety -> Safety -> Safety
max :: Safety -> Safety -> Safety
$cmax :: Safety -> Safety -> Safety
>= :: Safety -> Safety -> Bool
$c>= :: Safety -> Safety -> Bool
> :: Safety -> Safety -> Bool
$c> :: Safety -> Safety -> Bool
<= :: Safety -> Safety -> Bool
$c<= :: Safety -> Safety -> Bool
< :: Safety -> Safety -> Bool
$c< :: Safety -> Safety -> Bool
compare :: Safety -> Safety -> Ordering
$ccompare :: Safety -> Safety -> Ordering
$cp1Ord :: Eq Safety
Ord, Typeable Safety
DataType
Constr
Typeable Safety
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Safety -> c Safety)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Safety)
-> (Safety -> Constr)
-> (Safety -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Safety))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Safety))
-> ((forall b. Data b => b -> b) -> Safety -> Safety)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Safety -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Safety -> r)
-> (forall u. (forall d. Data d => d -> u) -> Safety -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Safety -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Safety -> m Safety)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Safety -> m Safety)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Safety -> m Safety)
-> Data Safety
Safety -> DataType
Safety -> Constr
(forall b. Data b => b -> b) -> Safety -> Safety
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Safety -> c Safety
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Safety
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) -> Safety -> u
forall u. (forall d. Data d => d -> u) -> Safety -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Safety -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Safety -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Safety -> m Safety
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Safety -> m Safety
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Safety
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Safety -> c Safety
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Safety)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Safety)
$cInterruptible :: Constr
$cSafe :: Constr
$cUnsafe :: Constr
$tSafety :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Safety -> m Safety
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Safety -> m Safety
gmapMp :: (forall d. Data d => d -> m d) -> Safety -> m Safety
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Safety -> m Safety
gmapM :: (forall d. Data d => d -> m d) -> Safety -> m Safety
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Safety -> m Safety
gmapQi :: Int -> (forall d. Data d => d -> u) -> Safety -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Safety -> u
gmapQ :: (forall d. Data d => d -> u) -> Safety -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Safety -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Safety -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Safety -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Safety -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Safety -> r
gmapT :: (forall b. Data b => b -> b) -> Safety -> Safety
$cgmapT :: (forall b. Data b => b -> b) -> Safety -> Safety
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Safety)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Safety)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Safety)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Safety)
dataTypeOf :: Safety -> DataType
$cdataTypeOf :: Safety -> DataType
toConstr :: Safety -> Constr
$ctoConstr :: Safety -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Safety
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Safety
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Safety -> c Safety
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Safety -> c Safety
$cp1Data :: Typeable Safety
Data, (forall x. Safety -> Rep Safety x)
-> (forall x. Rep Safety x -> Safety) -> Generic Safety
forall x. Rep Safety x -> Safety
forall x. Safety -> Rep Safety x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Safety x -> Safety
$cfrom :: forall x. Safety -> Rep Safety x
Generic )
data Pragma = InlineP Name Inline RuleMatch Phases
| SpecialiseP Name Type (Maybe Inline) Phases
| SpecialiseInstP Type
| RuleP String (Maybe [TyVarBndr]) [RuleBndr] Exp Exp Phases
| AnnP AnnTarget Exp
| LineP Int String
| CompleteP [Name] (Maybe Name)
deriving( Int -> Pragma -> String -> String
[Pragma] -> String -> String
Pragma -> String
(Int -> Pragma -> String -> String)
-> (Pragma -> String)
-> ([Pragma] -> String -> String)
-> Show Pragma
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [Pragma] -> String -> String
$cshowList :: [Pragma] -> String -> String
show :: Pragma -> String
$cshow :: Pragma -> String
showsPrec :: Int -> Pragma -> String -> String
$cshowsPrec :: Int -> Pragma -> String -> String
Show, Pragma -> Pragma -> Bool
(Pragma -> Pragma -> Bool)
-> (Pragma -> Pragma -> Bool) -> Eq Pragma
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Pragma -> Pragma -> Bool
$c/= :: Pragma -> Pragma -> Bool
== :: Pragma -> Pragma -> Bool
$c== :: Pragma -> Pragma -> Bool
Eq, Eq Pragma
Eq Pragma
-> (Pragma -> Pragma -> Ordering)
-> (Pragma -> Pragma -> Bool)
-> (Pragma -> Pragma -> Bool)
-> (Pragma -> Pragma -> Bool)
-> (Pragma -> Pragma -> Bool)
-> (Pragma -> Pragma -> Pragma)
-> (Pragma -> Pragma -> Pragma)
-> Ord Pragma
Pragma -> Pragma -> Bool
Pragma -> Pragma -> Ordering
Pragma -> Pragma -> Pragma
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Pragma -> Pragma -> Pragma
$cmin :: Pragma -> Pragma -> Pragma
max :: Pragma -> Pragma -> Pragma
$cmax :: Pragma -> Pragma -> Pragma
>= :: Pragma -> Pragma -> Bool
$c>= :: Pragma -> Pragma -> Bool
> :: Pragma -> Pragma -> Bool
$c> :: Pragma -> Pragma -> Bool
<= :: Pragma -> Pragma -> Bool
$c<= :: Pragma -> Pragma -> Bool
< :: Pragma -> Pragma -> Bool
$c< :: Pragma -> Pragma -> Bool
compare :: Pragma -> Pragma -> Ordering
$ccompare :: Pragma -> Pragma -> Ordering
$cp1Ord :: Eq Pragma
Ord, Typeable Pragma
DataType
Constr
Typeable Pragma
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Pragma -> c Pragma)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Pragma)
-> (Pragma -> Constr)
-> (Pragma -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Pragma))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Pragma))
-> ((forall b. Data b => b -> b) -> Pragma -> Pragma)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Pragma -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Pragma -> r)
-> (forall u. (forall d. Data d => d -> u) -> Pragma -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Pragma -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Pragma -> m Pragma)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Pragma -> m Pragma)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Pragma -> m Pragma)
-> Data Pragma
Pragma -> DataType
Pragma -> Constr
(forall b. Data b => b -> b) -> Pragma -> Pragma
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Pragma -> c Pragma
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Pragma
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) -> Pragma -> u
forall u. (forall d. Data d => d -> u) -> Pragma -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Pragma -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Pragma -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Pragma -> m Pragma
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Pragma -> m Pragma
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Pragma
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Pragma -> c Pragma
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Pragma)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Pragma)
$cCompleteP :: Constr
$cLineP :: Constr
$cAnnP :: Constr
$cRuleP :: Constr
$cSpecialiseInstP :: Constr
$cSpecialiseP :: Constr
$cInlineP :: Constr
$tPragma :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Pragma -> m Pragma
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Pragma -> m Pragma
gmapMp :: (forall d. Data d => d -> m d) -> Pragma -> m Pragma
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Pragma -> m Pragma
gmapM :: (forall d. Data d => d -> m d) -> Pragma -> m Pragma
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Pragma -> m Pragma
gmapQi :: Int -> (forall d. Data d => d -> u) -> Pragma -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Pragma -> u
gmapQ :: (forall d. Data d => d -> u) -> Pragma -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Pragma -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Pragma -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Pragma -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Pragma -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Pragma -> r
gmapT :: (forall b. Data b => b -> b) -> Pragma -> Pragma
$cgmapT :: (forall b. Data b => b -> b) -> Pragma -> Pragma
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Pragma)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Pragma)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Pragma)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Pragma)
dataTypeOf :: Pragma -> DataType
$cdataTypeOf :: Pragma -> DataType
toConstr :: Pragma -> Constr
$ctoConstr :: Pragma -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Pragma
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Pragma
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Pragma -> c Pragma
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Pragma -> c Pragma
$cp1Data :: Typeable Pragma
Data, (forall x. Pragma -> Rep Pragma x)
-> (forall x. Rep Pragma x -> Pragma) -> Generic Pragma
forall x. Rep Pragma x -> Pragma
forall x. Pragma -> Rep Pragma x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Pragma x -> Pragma
$cfrom :: forall x. Pragma -> Rep Pragma x
Generic )
data Inline = NoInline
| Inline
| Inlinable
deriving (Int -> Inline -> String -> String
[Inline] -> String -> String
Inline -> String
(Int -> Inline -> String -> String)
-> (Inline -> String)
-> ([Inline] -> String -> String)
-> Show Inline
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [Inline] -> String -> String
$cshowList :: [Inline] -> String -> String
show :: Inline -> String
$cshow :: Inline -> String
showsPrec :: Int -> Inline -> String -> String
$cshowsPrec :: Int -> Inline -> String -> String
Show, Inline -> Inline -> Bool
(Inline -> Inline -> Bool)
-> (Inline -> Inline -> Bool) -> Eq Inline
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Inline -> Inline -> Bool
$c/= :: Inline -> Inline -> Bool
== :: Inline -> Inline -> Bool
$c== :: Inline -> Inline -> Bool
Eq, Eq Inline
Eq Inline
-> (Inline -> Inline -> Ordering)
-> (Inline -> Inline -> Bool)
-> (Inline -> Inline -> Bool)
-> (Inline -> Inline -> Bool)
-> (Inline -> Inline -> Bool)
-> (Inline -> Inline -> Inline)
-> (Inline -> Inline -> Inline)
-> Ord Inline
Inline -> Inline -> Bool
Inline -> Inline -> Ordering
Inline -> Inline -> Inline
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Inline -> Inline -> Inline
$cmin :: Inline -> Inline -> Inline
max :: Inline -> Inline -> Inline
$cmax :: Inline -> Inline -> Inline
>= :: Inline -> Inline -> Bool
$c>= :: Inline -> Inline -> Bool
> :: Inline -> Inline -> Bool
$c> :: Inline -> Inline -> Bool
<= :: Inline -> Inline -> Bool
$c<= :: Inline -> Inline -> Bool
< :: Inline -> Inline -> Bool
$c< :: Inline -> Inline -> Bool
compare :: Inline -> Inline -> Ordering
$ccompare :: Inline -> Inline -> Ordering
$cp1Ord :: Eq Inline
Ord, Typeable Inline
DataType
Constr
Typeable Inline
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Inline -> c Inline)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Inline)
-> (Inline -> Constr)
-> (Inline -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Inline))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Inline))
-> ((forall b. Data b => b -> b) -> Inline -> Inline)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Inline -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Inline -> r)
-> (forall u. (forall d. Data d => d -> u) -> Inline -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Inline -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Inline -> m Inline)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Inline -> m Inline)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Inline -> m Inline)
-> Data Inline
Inline -> DataType
Inline -> Constr
(forall b. Data b => b -> b) -> Inline -> Inline
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Inline -> c Inline
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Inline
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) -> Inline -> u
forall u. (forall d. Data d => d -> u) -> Inline -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Inline -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Inline -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Inline -> m Inline
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Inline -> m Inline
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Inline
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Inline -> c Inline
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Inline)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Inline)
$cInlinable :: Constr
$cInline :: Constr
$cNoInline :: Constr
$tInline :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Inline -> m Inline
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Inline -> m Inline
gmapMp :: (forall d. Data d => d -> m d) -> Inline -> m Inline
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Inline -> m Inline
gmapM :: (forall d. Data d => d -> m d) -> Inline -> m Inline
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Inline -> m Inline
gmapQi :: Int -> (forall d. Data d => d -> u) -> Inline -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Inline -> u
gmapQ :: (forall d. Data d => d -> u) -> Inline -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Inline -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Inline -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Inline -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Inline -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Inline -> r
gmapT :: (forall b. Data b => b -> b) -> Inline -> Inline
$cgmapT :: (forall b. Data b => b -> b) -> Inline -> Inline
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Inline)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Inline)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Inline)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Inline)
dataTypeOf :: Inline -> DataType
$cdataTypeOf :: Inline -> DataType
toConstr :: Inline -> Constr
$ctoConstr :: Inline -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Inline
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Inline
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Inline -> c Inline
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Inline -> c Inline
$cp1Data :: Typeable Inline
Data, (forall x. Inline -> Rep Inline x)
-> (forall x. Rep Inline x -> Inline) -> Generic Inline
forall x. Rep Inline x -> Inline
forall x. Inline -> Rep Inline x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Inline x -> Inline
$cfrom :: forall x. Inline -> Rep Inline x
Generic)
data RuleMatch = ConLike
| FunLike
deriving (Int -> RuleMatch -> String -> String
[RuleMatch] -> String -> String
RuleMatch -> String
(Int -> RuleMatch -> String -> String)
-> (RuleMatch -> String)
-> ([RuleMatch] -> String -> String)
-> Show RuleMatch
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [RuleMatch] -> String -> String
$cshowList :: [RuleMatch] -> String -> String
show :: RuleMatch -> String
$cshow :: RuleMatch -> String
showsPrec :: Int -> RuleMatch -> String -> String
$cshowsPrec :: Int -> RuleMatch -> String -> String
Show, RuleMatch -> RuleMatch -> Bool
(RuleMatch -> RuleMatch -> Bool)
-> (RuleMatch -> RuleMatch -> Bool) -> Eq RuleMatch
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RuleMatch -> RuleMatch -> Bool
$c/= :: RuleMatch -> RuleMatch -> Bool
== :: RuleMatch -> RuleMatch -> Bool
$c== :: RuleMatch -> RuleMatch -> Bool
Eq, Eq RuleMatch
Eq RuleMatch
-> (RuleMatch -> RuleMatch -> Ordering)
-> (RuleMatch -> RuleMatch -> Bool)
-> (RuleMatch -> RuleMatch -> Bool)
-> (RuleMatch -> RuleMatch -> Bool)
-> (RuleMatch -> RuleMatch -> Bool)
-> (RuleMatch -> RuleMatch -> RuleMatch)
-> (RuleMatch -> RuleMatch -> RuleMatch)
-> Ord RuleMatch
RuleMatch -> RuleMatch -> Bool
RuleMatch -> RuleMatch -> Ordering
RuleMatch -> RuleMatch -> RuleMatch
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: RuleMatch -> RuleMatch -> RuleMatch
$cmin :: RuleMatch -> RuleMatch -> RuleMatch
max :: RuleMatch -> RuleMatch -> RuleMatch
$cmax :: RuleMatch -> RuleMatch -> RuleMatch
>= :: RuleMatch -> RuleMatch -> Bool
$c>= :: RuleMatch -> RuleMatch -> Bool
> :: RuleMatch -> RuleMatch -> Bool
$c> :: RuleMatch -> RuleMatch -> Bool
<= :: RuleMatch -> RuleMatch -> Bool
$c<= :: RuleMatch -> RuleMatch -> Bool
< :: RuleMatch -> RuleMatch -> Bool
$c< :: RuleMatch -> RuleMatch -> Bool
compare :: RuleMatch -> RuleMatch -> Ordering
$ccompare :: RuleMatch -> RuleMatch -> Ordering
$cp1Ord :: Eq RuleMatch
Ord, Typeable RuleMatch
DataType
Constr
Typeable RuleMatch
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RuleMatch -> c RuleMatch)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RuleMatch)
-> (RuleMatch -> Constr)
-> (RuleMatch -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RuleMatch))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RuleMatch))
-> ((forall b. Data b => b -> b) -> RuleMatch -> RuleMatch)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RuleMatch -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RuleMatch -> r)
-> (forall u. (forall d. Data d => d -> u) -> RuleMatch -> [u])
-> (forall u.
Int -> (forall d. Data d => d -> u) -> RuleMatch -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RuleMatch -> m RuleMatch)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RuleMatch -> m RuleMatch)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RuleMatch -> m RuleMatch)
-> Data RuleMatch
RuleMatch -> DataType
RuleMatch -> Constr
(forall b. Data b => b -> b) -> RuleMatch -> RuleMatch
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RuleMatch -> c RuleMatch
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RuleMatch
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) -> RuleMatch -> u
forall u. (forall d. Data d => d -> u) -> RuleMatch -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RuleMatch -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RuleMatch -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RuleMatch -> m RuleMatch
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RuleMatch -> m RuleMatch
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RuleMatch
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RuleMatch -> c RuleMatch
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RuleMatch)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RuleMatch)
$cFunLike :: Constr
$cConLike :: Constr
$tRuleMatch :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> RuleMatch -> m RuleMatch
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RuleMatch -> m RuleMatch
gmapMp :: (forall d. Data d => d -> m d) -> RuleMatch -> m RuleMatch
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RuleMatch -> m RuleMatch
gmapM :: (forall d. Data d => d -> m d) -> RuleMatch -> m RuleMatch
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RuleMatch -> m RuleMatch
gmapQi :: Int -> (forall d. Data d => d -> u) -> RuleMatch -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> RuleMatch -> u
gmapQ :: (forall d. Data d => d -> u) -> RuleMatch -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> RuleMatch -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RuleMatch -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RuleMatch -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RuleMatch -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RuleMatch -> r
gmapT :: (forall b. Data b => b -> b) -> RuleMatch -> RuleMatch
$cgmapT :: (forall b. Data b => b -> b) -> RuleMatch -> RuleMatch
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RuleMatch)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RuleMatch)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c RuleMatch)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RuleMatch)
dataTypeOf :: RuleMatch -> DataType
$cdataTypeOf :: RuleMatch -> DataType
toConstr :: RuleMatch -> Constr
$ctoConstr :: RuleMatch -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RuleMatch
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RuleMatch
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RuleMatch -> c RuleMatch
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RuleMatch -> c RuleMatch
$cp1Data :: Typeable RuleMatch
Data, (forall x. RuleMatch -> Rep RuleMatch x)
-> (forall x. Rep RuleMatch x -> RuleMatch) -> Generic RuleMatch
forall x. Rep RuleMatch x -> RuleMatch
forall x. RuleMatch -> Rep RuleMatch x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep RuleMatch x -> RuleMatch
$cfrom :: forall x. RuleMatch -> Rep RuleMatch x
Generic)
data Phases = AllPhases
| FromPhase Int
| BeforePhase Int
deriving (Int -> Phases -> String -> String
[Phases] -> String -> String
Phases -> String
(Int -> Phases -> String -> String)
-> (Phases -> String)
-> ([Phases] -> String -> String)
-> Show Phases
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [Phases] -> String -> String
$cshowList :: [Phases] -> String -> String
show :: Phases -> String
$cshow :: Phases -> String
showsPrec :: Int -> Phases -> String -> String
$cshowsPrec :: Int -> Phases -> String -> String
Show, Phases -> Phases -> Bool
(Phases -> Phases -> Bool)
-> (Phases -> Phases -> Bool) -> Eq Phases
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Phases -> Phases -> Bool
$c/= :: Phases -> Phases -> Bool
== :: Phases -> Phases -> Bool
$c== :: Phases -> Phases -> Bool
Eq, Eq Phases
Eq Phases
-> (Phases -> Phases -> Ordering)
-> (Phases -> Phases -> Bool)
-> (Phases -> Phases -> Bool)
-> (Phases -> Phases -> Bool)
-> (Phases -> Phases -> Bool)
-> (Phases -> Phases -> Phases)
-> (Phases -> Phases -> Phases)
-> Ord Phases
Phases -> Phases -> Bool
Phases -> Phases -> Ordering
Phases -> Phases -> Phases
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Phases -> Phases -> Phases
$cmin :: Phases -> Phases -> Phases
max :: Phases -> Phases -> Phases
$cmax :: Phases -> Phases -> Phases
>= :: Phases -> Phases -> Bool
$c>= :: Phases -> Phases -> Bool
> :: Phases -> Phases -> Bool
$c> :: Phases -> Phases -> Bool
<= :: Phases -> Phases -> Bool
$c<= :: Phases -> Phases -> Bool
< :: Phases -> Phases -> Bool
$c< :: Phases -> Phases -> Bool
compare :: Phases -> Phases -> Ordering
$ccompare :: Phases -> Phases -> Ordering
$cp1Ord :: Eq Phases
Ord, Typeable Phases
DataType
Constr
Typeable Phases
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Phases -> c Phases)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Phases)
-> (Phases -> Constr)
-> (Phases -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Phases))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Phases))
-> ((forall b. Data b => b -> b) -> Phases -> Phases)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Phases -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Phases -> r)
-> (forall u. (forall d. Data d => d -> u) -> Phases -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Phases -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Phases -> m Phases)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Phases -> m Phases)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Phases -> m Phases)
-> Data Phases
Phases -> DataType
Phases -> Constr
(forall b. Data b => b -> b) -> Phases -> Phases
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Phases -> c Phases
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Phases
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) -> Phases -> u
forall u. (forall d. Data d => d -> u) -> Phases -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Phases -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Phases -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Phases -> m Phases
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Phases -> m Phases
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Phases
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Phases -> c Phases
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Phases)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Phases)
$cBeforePhase :: Constr
$cFromPhase :: Constr
$cAllPhases :: Constr
$tPhases :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Phases -> m Phases
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Phases -> m Phases
gmapMp :: (forall d. Data d => d -> m d) -> Phases -> m Phases
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Phases -> m Phases
gmapM :: (forall d. Data d => d -> m d) -> Phases -> m Phases
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Phases -> m Phases
gmapQi :: Int -> (forall d. Data d => d -> u) -> Phases -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Phases -> u
gmapQ :: (forall d. Data d => d -> u) -> Phases -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Phases -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Phases -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Phases -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Phases -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Phases -> r
gmapT :: (forall b. Data b => b -> b) -> Phases -> Phases
$cgmapT :: (forall b. Data b => b -> b) -> Phases -> Phases
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Phases)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Phases)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Phases)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Phases)
dataTypeOf :: Phases -> DataType
$cdataTypeOf :: Phases -> DataType
toConstr :: Phases -> Constr
$ctoConstr :: Phases -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Phases
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Phases
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Phases -> c Phases
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Phases -> c Phases
$cp1Data :: Typeable Phases
Data, (forall x. Phases -> Rep Phases x)
-> (forall x. Rep Phases x -> Phases) -> Generic Phases
forall x. Rep Phases x -> Phases
forall x. Phases -> Rep Phases x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Phases x -> Phases
$cfrom :: forall x. Phases -> Rep Phases x
Generic)
data RuleBndr = RuleVar Name
| TypedRuleVar Name Type
deriving (Int -> RuleBndr -> String -> String
[RuleBndr] -> String -> String
RuleBndr -> String
(Int -> RuleBndr -> String -> String)
-> (RuleBndr -> String)
-> ([RuleBndr] -> String -> String)
-> Show RuleBndr
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [RuleBndr] -> String -> String
$cshowList :: [RuleBndr] -> String -> String
show :: RuleBndr -> String
$cshow :: RuleBndr -> String
showsPrec :: Int -> RuleBndr -> String -> String
$cshowsPrec :: Int -> RuleBndr -> String -> String
Show, RuleBndr -> RuleBndr -> Bool
(RuleBndr -> RuleBndr -> Bool)
-> (RuleBndr -> RuleBndr -> Bool) -> Eq RuleBndr
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RuleBndr -> RuleBndr -> Bool
$c/= :: RuleBndr -> RuleBndr -> Bool
== :: RuleBndr -> RuleBndr -> Bool
$c== :: RuleBndr -> RuleBndr -> Bool
Eq, Eq RuleBndr
Eq RuleBndr
-> (RuleBndr -> RuleBndr -> Ordering)
-> (RuleBndr -> RuleBndr -> Bool)
-> (RuleBndr -> RuleBndr -> Bool)
-> (RuleBndr -> RuleBndr -> Bool)
-> (RuleBndr -> RuleBndr -> Bool)
-> (RuleBndr -> RuleBndr -> RuleBndr)
-> (RuleBndr -> RuleBndr -> RuleBndr)
-> Ord RuleBndr
RuleBndr -> RuleBndr -> Bool
RuleBndr -> RuleBndr -> Ordering
RuleBndr -> RuleBndr -> RuleBndr
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: RuleBndr -> RuleBndr -> RuleBndr
$cmin :: RuleBndr -> RuleBndr -> RuleBndr
max :: RuleBndr -> RuleBndr -> RuleBndr
$cmax :: RuleBndr -> RuleBndr -> RuleBndr
>= :: RuleBndr -> RuleBndr -> Bool
$c>= :: RuleBndr -> RuleBndr -> Bool
> :: RuleBndr -> RuleBndr -> Bool
$c> :: RuleBndr -> RuleBndr -> Bool
<= :: RuleBndr -> RuleBndr -> Bool
$c<= :: RuleBndr -> RuleBndr -> Bool
< :: RuleBndr -> RuleBndr -> Bool
$c< :: RuleBndr -> RuleBndr -> Bool
compare :: RuleBndr -> RuleBndr -> Ordering
$ccompare :: RuleBndr -> RuleBndr -> Ordering
$cp1Ord :: Eq RuleBndr
Ord, Typeable RuleBndr
DataType
Constr
Typeable RuleBndr
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RuleBndr -> c RuleBndr)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RuleBndr)
-> (RuleBndr -> Constr)
-> (RuleBndr -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RuleBndr))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RuleBndr))
-> ((forall b. Data b => b -> b) -> RuleBndr -> RuleBndr)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RuleBndr -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RuleBndr -> r)
-> (forall u. (forall d. Data d => d -> u) -> RuleBndr -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> RuleBndr -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RuleBndr -> m RuleBndr)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RuleBndr -> m RuleBndr)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RuleBndr -> m RuleBndr)
-> Data RuleBndr
RuleBndr -> DataType
RuleBndr -> Constr
(forall b. Data b => b -> b) -> RuleBndr -> RuleBndr
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RuleBndr -> c RuleBndr
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RuleBndr
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) -> RuleBndr -> u
forall u. (forall d. Data d => d -> u) -> RuleBndr -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RuleBndr -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RuleBndr -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RuleBndr -> m RuleBndr
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RuleBndr -> m RuleBndr
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RuleBndr
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RuleBndr -> c RuleBndr
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RuleBndr)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RuleBndr)
$cTypedRuleVar :: Constr
$cRuleVar :: Constr
$tRuleBndr :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> RuleBndr -> m RuleBndr
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RuleBndr -> m RuleBndr
gmapMp :: (forall d. Data d => d -> m d) -> RuleBndr -> m RuleBndr
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RuleBndr -> m RuleBndr
gmapM :: (forall d. Data d => d -> m d) -> RuleBndr -> m RuleBndr
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RuleBndr -> m RuleBndr
gmapQi :: Int -> (forall d. Data d => d -> u) -> RuleBndr -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> RuleBndr -> u
gmapQ :: (forall d. Data d => d -> u) -> RuleBndr -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> RuleBndr -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RuleBndr -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RuleBndr -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RuleBndr -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RuleBndr -> r
gmapT :: (forall b. Data b => b -> b) -> RuleBndr -> RuleBndr
$cgmapT :: (forall b. Data b => b -> b) -> RuleBndr -> RuleBndr
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RuleBndr)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RuleBndr)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c RuleBndr)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RuleBndr)
dataTypeOf :: RuleBndr -> DataType
$cdataTypeOf :: RuleBndr -> DataType
toConstr :: RuleBndr -> Constr
$ctoConstr :: RuleBndr -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RuleBndr
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RuleBndr
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RuleBndr -> c RuleBndr
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RuleBndr -> c RuleBndr
$cp1Data :: Typeable RuleBndr
Data, (forall x. RuleBndr -> Rep RuleBndr x)
-> (forall x. Rep RuleBndr x -> RuleBndr) -> Generic RuleBndr
forall x. Rep RuleBndr x -> RuleBndr
forall x. RuleBndr -> Rep RuleBndr x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep RuleBndr x -> RuleBndr
$cfrom :: forall x. RuleBndr -> Rep RuleBndr x
Generic)
data AnnTarget = ModuleAnnotation
| TypeAnnotation Name
| ValueAnnotation Name
deriving (Int -> AnnTarget -> String -> String
[AnnTarget] -> String -> String
AnnTarget -> String
(Int -> AnnTarget -> String -> String)
-> (AnnTarget -> String)
-> ([AnnTarget] -> String -> String)
-> Show AnnTarget
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [AnnTarget] -> String -> String
$cshowList :: [AnnTarget] -> String -> String
show :: AnnTarget -> String
$cshow :: AnnTarget -> String
showsPrec :: Int -> AnnTarget -> String -> String
$cshowsPrec :: Int -> AnnTarget -> String -> String
Show, AnnTarget -> AnnTarget -> Bool
(AnnTarget -> AnnTarget -> Bool)
-> (AnnTarget -> AnnTarget -> Bool) -> Eq AnnTarget
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AnnTarget -> AnnTarget -> Bool
$c/= :: AnnTarget -> AnnTarget -> Bool
== :: AnnTarget -> AnnTarget -> Bool
$c== :: AnnTarget -> AnnTarget -> Bool
Eq, Eq AnnTarget
Eq AnnTarget
-> (AnnTarget -> AnnTarget -> Ordering)
-> (AnnTarget -> AnnTarget -> Bool)
-> (AnnTarget -> AnnTarget -> Bool)
-> (AnnTarget -> AnnTarget -> Bool)
-> (AnnTarget -> AnnTarget -> Bool)
-> (AnnTarget -> AnnTarget -> AnnTarget)
-> (AnnTarget -> AnnTarget -> AnnTarget)
-> Ord AnnTarget
AnnTarget -> AnnTarget -> Bool
AnnTarget -> AnnTarget -> Ordering
AnnTarget -> AnnTarget -> AnnTarget
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: AnnTarget -> AnnTarget -> AnnTarget
$cmin :: AnnTarget -> AnnTarget -> AnnTarget
max :: AnnTarget -> AnnTarget -> AnnTarget
$cmax :: AnnTarget -> AnnTarget -> AnnTarget
>= :: AnnTarget -> AnnTarget -> Bool
$c>= :: AnnTarget -> AnnTarget -> Bool
> :: AnnTarget -> AnnTarget -> Bool
$c> :: AnnTarget -> AnnTarget -> Bool
<= :: AnnTarget -> AnnTarget -> Bool
$c<= :: AnnTarget -> AnnTarget -> Bool
< :: AnnTarget -> AnnTarget -> Bool
$c< :: AnnTarget -> AnnTarget -> Bool
compare :: AnnTarget -> AnnTarget -> Ordering
$ccompare :: AnnTarget -> AnnTarget -> Ordering
$cp1Ord :: Eq AnnTarget
Ord, Typeable AnnTarget
DataType
Constr
Typeable AnnTarget
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AnnTarget -> c AnnTarget)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AnnTarget)
-> (AnnTarget -> Constr)
-> (AnnTarget -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c AnnTarget))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AnnTarget))
-> ((forall b. Data b => b -> b) -> AnnTarget -> AnnTarget)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AnnTarget -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> AnnTarget -> r)
-> (forall u. (forall d. Data d => d -> u) -> AnnTarget -> [u])
-> (forall u.
Int -> (forall d. Data d => d -> u) -> AnnTarget -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> AnnTarget -> m AnnTarget)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AnnTarget -> m AnnTarget)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AnnTarget -> m AnnTarget)
-> Data AnnTarget
AnnTarget -> DataType
AnnTarget -> Constr
(forall b. Data b => b -> b) -> AnnTarget -> AnnTarget
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AnnTarget -> c AnnTarget
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AnnTarget
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) -> AnnTarget -> u
forall u. (forall d. Data d => d -> u) -> AnnTarget -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AnnTarget -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> AnnTarget -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> AnnTarget -> m AnnTarget
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AnnTarget -> m AnnTarget
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AnnTarget
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AnnTarget -> c AnnTarget
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c AnnTarget)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AnnTarget)
$cValueAnnotation :: Constr
$cTypeAnnotation :: Constr
$cModuleAnnotation :: Constr
$tAnnTarget :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> AnnTarget -> m AnnTarget
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AnnTarget -> m AnnTarget
gmapMp :: (forall d. Data d => d -> m d) -> AnnTarget -> m AnnTarget
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AnnTarget -> m AnnTarget
gmapM :: (forall d. Data d => d -> m d) -> AnnTarget -> m AnnTarget
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> AnnTarget -> m AnnTarget
gmapQi :: Int -> (forall d. Data d => d -> u) -> AnnTarget -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> AnnTarget -> u
gmapQ :: (forall d. Data d => d -> u) -> AnnTarget -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> AnnTarget -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> AnnTarget -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> AnnTarget -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AnnTarget -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AnnTarget -> r
gmapT :: (forall b. Data b => b -> b) -> AnnTarget -> AnnTarget
$cgmapT :: (forall b. Data b => b -> b) -> AnnTarget -> AnnTarget
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AnnTarget)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AnnTarget)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c AnnTarget)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c AnnTarget)
dataTypeOf :: AnnTarget -> DataType
$cdataTypeOf :: AnnTarget -> DataType
toConstr :: AnnTarget -> Constr
$ctoConstr :: AnnTarget -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AnnTarget
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AnnTarget
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AnnTarget -> c AnnTarget
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AnnTarget -> c AnnTarget
$cp1Data :: Typeable AnnTarget
Data, (forall x. AnnTarget -> Rep AnnTarget x)
-> (forall x. Rep AnnTarget x -> AnnTarget) -> Generic AnnTarget
forall x. Rep AnnTarget x -> AnnTarget
forall x. AnnTarget -> Rep AnnTarget x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep AnnTarget x -> AnnTarget
$cfrom :: forall x. AnnTarget -> Rep AnnTarget x
Generic)
type Cxt = [Pred]
type Pred = Type
data SourceUnpackedness
= NoSourceUnpackedness
| SourceNoUnpack
| SourceUnpack
deriving (Int -> SourceUnpackedness -> String -> String
[SourceUnpackedness] -> String -> String
SourceUnpackedness -> String
(Int -> SourceUnpackedness -> String -> String)
-> (SourceUnpackedness -> String)
-> ([SourceUnpackedness] -> String -> String)
-> Show SourceUnpackedness
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [SourceUnpackedness] -> String -> String
$cshowList :: [SourceUnpackedness] -> String -> String
show :: SourceUnpackedness -> String
$cshow :: SourceUnpackedness -> String
showsPrec :: Int -> SourceUnpackedness -> String -> String
$cshowsPrec :: Int -> SourceUnpackedness -> String -> String
Show, SourceUnpackedness -> SourceUnpackedness -> Bool
(SourceUnpackedness -> SourceUnpackedness -> Bool)
-> (SourceUnpackedness -> SourceUnpackedness -> Bool)
-> Eq SourceUnpackedness
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SourceUnpackedness -> SourceUnpackedness -> Bool
$c/= :: SourceUnpackedness -> SourceUnpackedness -> Bool
== :: SourceUnpackedness -> SourceUnpackedness -> Bool
$c== :: SourceUnpackedness -> SourceUnpackedness -> Bool
Eq, Eq SourceUnpackedness
Eq SourceUnpackedness
-> (SourceUnpackedness -> SourceUnpackedness -> Ordering)
-> (SourceUnpackedness -> SourceUnpackedness -> Bool)
-> (SourceUnpackedness -> SourceUnpackedness -> Bool)
-> (SourceUnpackedness -> SourceUnpackedness -> Bool)
-> (SourceUnpackedness -> SourceUnpackedness -> Bool)
-> (SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness)
-> (SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness)
-> Ord SourceUnpackedness
SourceUnpackedness -> SourceUnpackedness -> Bool
SourceUnpackedness -> SourceUnpackedness -> Ordering
SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness
$cmin :: SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness
max :: SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness
$cmax :: SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness
>= :: SourceUnpackedness -> SourceUnpackedness -> Bool
$c>= :: SourceUnpackedness -> SourceUnpackedness -> Bool
> :: SourceUnpackedness -> SourceUnpackedness -> Bool
$c> :: SourceUnpackedness -> SourceUnpackedness -> Bool
<= :: SourceUnpackedness -> SourceUnpackedness -> Bool
$c<= :: SourceUnpackedness -> SourceUnpackedness -> Bool
< :: SourceUnpackedness -> SourceUnpackedness -> Bool
$c< :: SourceUnpackedness -> SourceUnpackedness -> Bool
compare :: SourceUnpackedness -> SourceUnpackedness -> Ordering
$ccompare :: SourceUnpackedness -> SourceUnpackedness -> Ordering
$cp1Ord :: Eq SourceUnpackedness
Ord, Typeable SourceUnpackedness
DataType
Constr
Typeable SourceUnpackedness
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> SourceUnpackedness
-> c SourceUnpackedness)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SourceUnpackedness)
-> (SourceUnpackedness -> Constr)
-> (SourceUnpackedness -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SourceUnpackedness))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SourceUnpackedness))
-> ((forall b. Data b => b -> b)
-> SourceUnpackedness -> SourceUnpackedness)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SourceUnpackedness -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SourceUnpackedness -> r)
-> (forall u.
(forall d. Data d => d -> u) -> SourceUnpackedness -> [u])
-> (forall u.
Int -> (forall d. Data d => d -> u) -> SourceUnpackedness -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> SourceUnpackedness -> m SourceUnpackedness)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SourceUnpackedness -> m SourceUnpackedness)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SourceUnpackedness -> m SourceUnpackedness)
-> Data SourceUnpackedness
SourceUnpackedness -> DataType
SourceUnpackedness -> Constr
(forall b. Data b => b -> b)
-> SourceUnpackedness -> SourceUnpackedness
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> SourceUnpackedness
-> c SourceUnpackedness
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SourceUnpackedness
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) -> SourceUnpackedness -> u
forall u. (forall d. Data d => d -> u) -> SourceUnpackedness -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SourceUnpackedness -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SourceUnpackedness -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> SourceUnpackedness -> m SourceUnpackedness
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SourceUnpackedness -> m SourceUnpackedness
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SourceUnpackedness
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> SourceUnpackedness
-> c SourceUnpackedness
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SourceUnpackedness)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SourceUnpackedness)
$cSourceUnpack :: Constr
$cSourceNoUnpack :: Constr
$cNoSourceUnpackedness :: Constr
$tSourceUnpackedness :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> SourceUnpackedness -> m SourceUnpackedness
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SourceUnpackedness -> m SourceUnpackedness
gmapMp :: (forall d. Data d => d -> m d)
-> SourceUnpackedness -> m SourceUnpackedness
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SourceUnpackedness -> m SourceUnpackedness
gmapM :: (forall d. Data d => d -> m d)
-> SourceUnpackedness -> m SourceUnpackedness
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> SourceUnpackedness -> m SourceUnpackedness
gmapQi :: Int -> (forall d. Data d => d -> u) -> SourceUnpackedness -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> SourceUnpackedness -> u
gmapQ :: (forall d. Data d => d -> u) -> SourceUnpackedness -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SourceUnpackedness -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SourceUnpackedness -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SourceUnpackedness -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SourceUnpackedness -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SourceUnpackedness -> r
gmapT :: (forall b. Data b => b -> b)
-> SourceUnpackedness -> SourceUnpackedness
$cgmapT :: (forall b. Data b => b -> b)
-> SourceUnpackedness -> SourceUnpackedness
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SourceUnpackedness)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SourceUnpackedness)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c SourceUnpackedness)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SourceUnpackedness)
dataTypeOf :: SourceUnpackedness -> DataType
$cdataTypeOf :: SourceUnpackedness -> DataType
toConstr :: SourceUnpackedness -> Constr
$ctoConstr :: SourceUnpackedness -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SourceUnpackedness
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SourceUnpackedness
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> SourceUnpackedness
-> c SourceUnpackedness
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> SourceUnpackedness
-> c SourceUnpackedness
$cp1Data :: Typeable SourceUnpackedness
Data, (forall x. SourceUnpackedness -> Rep SourceUnpackedness x)
-> (forall x. Rep SourceUnpackedness x -> SourceUnpackedness)
-> Generic SourceUnpackedness
forall x. Rep SourceUnpackedness x -> SourceUnpackedness
forall x. SourceUnpackedness -> Rep SourceUnpackedness x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep SourceUnpackedness x -> SourceUnpackedness
$cfrom :: forall x. SourceUnpackedness -> Rep SourceUnpackedness x
Generic)
data SourceStrictness = NoSourceStrictness
| SourceLazy
| SourceStrict
deriving (Int -> SourceStrictness -> String -> String
[SourceStrictness] -> String -> String
SourceStrictness -> String
(Int -> SourceStrictness -> String -> String)
-> (SourceStrictness -> String)
-> ([SourceStrictness] -> String -> String)
-> Show SourceStrictness
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [SourceStrictness] -> String -> String
$cshowList :: [SourceStrictness] -> String -> String
show :: SourceStrictness -> String
$cshow :: SourceStrictness -> String
showsPrec :: Int -> SourceStrictness -> String -> String
$cshowsPrec :: Int -> SourceStrictness -> String -> String
Show, SourceStrictness -> SourceStrictness -> Bool
(SourceStrictness -> SourceStrictness -> Bool)
-> (SourceStrictness -> SourceStrictness -> Bool)
-> Eq SourceStrictness
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SourceStrictness -> SourceStrictness -> Bool
$c/= :: SourceStrictness -> SourceStrictness -> Bool
== :: SourceStrictness -> SourceStrictness -> Bool
$c== :: SourceStrictness -> SourceStrictness -> Bool
Eq, Eq SourceStrictness
Eq SourceStrictness
-> (SourceStrictness -> SourceStrictness -> Ordering)
-> (SourceStrictness -> SourceStrictness -> Bool)
-> (SourceStrictness -> SourceStrictness -> Bool)
-> (SourceStrictness -> SourceStrictness -> Bool)
-> (SourceStrictness -> SourceStrictness -> Bool)
-> (SourceStrictness -> SourceStrictness -> SourceStrictness)
-> (SourceStrictness -> SourceStrictness -> SourceStrictness)
-> Ord SourceStrictness
SourceStrictness -> SourceStrictness -> Bool
SourceStrictness -> SourceStrictness -> Ordering
SourceStrictness -> SourceStrictness -> SourceStrictness
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: SourceStrictness -> SourceStrictness -> SourceStrictness
$cmin :: SourceStrictness -> SourceStrictness -> SourceStrictness
max :: SourceStrictness -> SourceStrictness -> SourceStrictness
$cmax :: SourceStrictness -> SourceStrictness -> SourceStrictness
>= :: SourceStrictness -> SourceStrictness -> Bool
$c>= :: SourceStrictness -> SourceStrictness -> Bool
> :: SourceStrictness -> SourceStrictness -> Bool
$c> :: SourceStrictness -> SourceStrictness -> Bool
<= :: SourceStrictness -> SourceStrictness -> Bool
$c<= :: SourceStrictness -> SourceStrictness -> Bool
< :: SourceStrictness -> SourceStrictness -> Bool
$c< :: SourceStrictness -> SourceStrictness -> Bool
compare :: SourceStrictness -> SourceStrictness -> Ordering
$ccompare :: SourceStrictness -> SourceStrictness -> Ordering
$cp1Ord :: Eq SourceStrictness
Ord, Typeable SourceStrictness
DataType
Constr
Typeable SourceStrictness
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SourceStrictness -> c SourceStrictness)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SourceStrictness)
-> (SourceStrictness -> Constr)
-> (SourceStrictness -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SourceStrictness))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SourceStrictness))
-> ((forall b. Data b => b -> b)
-> SourceStrictness -> SourceStrictness)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SourceStrictness -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SourceStrictness -> r)
-> (forall u.
(forall d. Data d => d -> u) -> SourceStrictness -> [u])
-> (forall u.
Int -> (forall d. Data d => d -> u) -> SourceStrictness -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> SourceStrictness -> m SourceStrictness)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SourceStrictness -> m SourceStrictness)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SourceStrictness -> m SourceStrictness)
-> Data SourceStrictness
SourceStrictness -> DataType
SourceStrictness -> Constr
(forall b. Data b => b -> b)
-> SourceStrictness -> SourceStrictness
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SourceStrictness -> c SourceStrictness
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SourceStrictness
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) -> SourceStrictness -> u
forall u. (forall d. Data d => d -> u) -> SourceStrictness -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SourceStrictness -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SourceStrictness -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> SourceStrictness -> m SourceStrictness
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SourceStrictness -> m SourceStrictness
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SourceStrictness
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SourceStrictness -> c SourceStrictness
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SourceStrictness)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SourceStrictness)
$cSourceStrict :: Constr
$cSourceLazy :: Constr
$cNoSourceStrictness :: Constr
$tSourceStrictness :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> SourceStrictness -> m SourceStrictness
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SourceStrictness -> m SourceStrictness
gmapMp :: (forall d. Data d => d -> m d)
-> SourceStrictness -> m SourceStrictness
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SourceStrictness -> m SourceStrictness
gmapM :: (forall d. Data d => d -> m d)
-> SourceStrictness -> m SourceStrictness
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> SourceStrictness -> m SourceStrictness
gmapQi :: Int -> (forall d. Data d => d -> u) -> SourceStrictness -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> SourceStrictness -> u
gmapQ :: (forall d. Data d => d -> u) -> SourceStrictness -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SourceStrictness -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SourceStrictness -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SourceStrictness -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SourceStrictness -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SourceStrictness -> r
gmapT :: (forall b. Data b => b -> b)
-> SourceStrictness -> SourceStrictness
$cgmapT :: (forall b. Data b => b -> b)
-> SourceStrictness -> SourceStrictness
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SourceStrictness)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SourceStrictness)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c SourceStrictness)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SourceStrictness)
dataTypeOf :: SourceStrictness -> DataType
$cdataTypeOf :: SourceStrictness -> DataType
toConstr :: SourceStrictness -> Constr
$ctoConstr :: SourceStrictness -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SourceStrictness
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SourceStrictness
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SourceStrictness -> c SourceStrictness
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SourceStrictness -> c SourceStrictness
$cp1Data :: Typeable SourceStrictness
Data, (forall x. SourceStrictness -> Rep SourceStrictness x)
-> (forall x. Rep SourceStrictness x -> SourceStrictness)
-> Generic SourceStrictness
forall x. Rep SourceStrictness x -> SourceStrictness
forall x. SourceStrictness -> Rep SourceStrictness x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep SourceStrictness x -> SourceStrictness
$cfrom :: forall x. SourceStrictness -> Rep SourceStrictness x
Generic)
data DecidedStrictness = DecidedLazy
| DecidedStrict
| DecidedUnpack
deriving (Int -> DecidedStrictness -> String -> String
[DecidedStrictness] -> String -> String
DecidedStrictness -> String
(Int -> DecidedStrictness -> String -> String)
-> (DecidedStrictness -> String)
-> ([DecidedStrictness] -> String -> String)
-> Show DecidedStrictness
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [DecidedStrictness] -> String -> String
$cshowList :: [DecidedStrictness] -> String -> String
show :: DecidedStrictness -> String
$cshow :: DecidedStrictness -> String
showsPrec :: Int -> DecidedStrictness -> String -> String
$cshowsPrec :: Int -> DecidedStrictness -> String -> String
Show, DecidedStrictness -> DecidedStrictness -> Bool
(DecidedStrictness -> DecidedStrictness -> Bool)
-> (DecidedStrictness -> DecidedStrictness -> Bool)
-> Eq DecidedStrictness
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DecidedStrictness -> DecidedStrictness -> Bool
$c/= :: DecidedStrictness -> DecidedStrictness -> Bool
== :: DecidedStrictness -> DecidedStrictness -> Bool
$c== :: DecidedStrictness -> DecidedStrictness -> Bool
Eq, Eq DecidedStrictness
Eq DecidedStrictness
-> (DecidedStrictness -> DecidedStrictness -> Ordering)
-> (DecidedStrictness -> DecidedStrictness -> Bool)
-> (DecidedStrictness -> DecidedStrictness -> Bool)
-> (DecidedStrictness -> DecidedStrictness -> Bool)
-> (DecidedStrictness -> DecidedStrictness -> Bool)
-> (DecidedStrictness -> DecidedStrictness -> DecidedStrictness)
-> (DecidedStrictness -> DecidedStrictness -> DecidedStrictness)
-> Ord DecidedStrictness
DecidedStrictness -> DecidedStrictness -> Bool
DecidedStrictness -> DecidedStrictness -> Ordering
DecidedStrictness -> DecidedStrictness -> DecidedStrictness
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: DecidedStrictness -> DecidedStrictness -> DecidedStrictness
$cmin :: DecidedStrictness -> DecidedStrictness -> DecidedStrictness
max :: DecidedStrictness -> DecidedStrictness -> DecidedStrictness
$cmax :: DecidedStrictness -> DecidedStrictness -> DecidedStrictness
>= :: DecidedStrictness -> DecidedStrictness -> Bool
$c>= :: DecidedStrictness -> DecidedStrictness -> Bool
> :: DecidedStrictness -> DecidedStrictness -> Bool
$c> :: DecidedStrictness -> DecidedStrictness -> Bool
<= :: DecidedStrictness -> DecidedStrictness -> Bool
$c<= :: DecidedStrictness -> DecidedStrictness -> Bool
< :: DecidedStrictness -> DecidedStrictness -> Bool
$c< :: DecidedStrictness -> DecidedStrictness -> Bool
compare :: DecidedStrictness -> DecidedStrictness -> Ordering
$ccompare :: DecidedStrictness -> DecidedStrictness -> Ordering
$cp1Ord :: Eq DecidedStrictness
Ord, Typeable DecidedStrictness
DataType
Constr
Typeable DecidedStrictness
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DecidedStrictness
-> c DecidedStrictness)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DecidedStrictness)
-> (DecidedStrictness -> Constr)
-> (DecidedStrictness -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DecidedStrictness))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DecidedStrictness))
-> ((forall b. Data b => b -> b)
-> DecidedStrictness -> DecidedStrictness)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DecidedStrictness -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DecidedStrictness -> r)
-> (forall u.
(forall d. Data d => d -> u) -> DecidedStrictness -> [u])
-> (forall u.
Int -> (forall d. Data d => d -> u) -> DecidedStrictness -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DecidedStrictness -> m DecidedStrictness)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DecidedStrictness -> m DecidedStrictness)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DecidedStrictness -> m DecidedStrictness)
-> Data DecidedStrictness
DecidedStrictness -> DataType
DecidedStrictness -> Constr
(forall b. Data b => b -> b)
-> DecidedStrictness -> DecidedStrictness
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DecidedStrictness -> c DecidedStrictness
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DecidedStrictness
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) -> DecidedStrictness -> u
forall u. (forall d. Data d => d -> u) -> DecidedStrictness -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DecidedStrictness -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DecidedStrictness -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DecidedStrictness -> m DecidedStrictness
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DecidedStrictness -> m DecidedStrictness
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DecidedStrictness
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DecidedStrictness -> c DecidedStrictness
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DecidedStrictness)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DecidedStrictness)
$cDecidedUnpack :: Constr
$cDecidedStrict :: Constr
$cDecidedLazy :: Constr
$tDecidedStrictness :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> DecidedStrictness -> m DecidedStrictness
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DecidedStrictness -> m DecidedStrictness
gmapMp :: (forall d. Data d => d -> m d)
-> DecidedStrictness -> m DecidedStrictness
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DecidedStrictness -> m DecidedStrictness
gmapM :: (forall d. Data d => d -> m d)
-> DecidedStrictness -> m DecidedStrictness
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DecidedStrictness -> m DecidedStrictness
gmapQi :: Int -> (forall d. Data d => d -> u) -> DecidedStrictness -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> DecidedStrictness -> u
gmapQ :: (forall d. Data d => d -> u) -> DecidedStrictness -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DecidedStrictness -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DecidedStrictness -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DecidedStrictness -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DecidedStrictness -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DecidedStrictness -> r
gmapT :: (forall b. Data b => b -> b)
-> DecidedStrictness -> DecidedStrictness
$cgmapT :: (forall b. Data b => b -> b)
-> DecidedStrictness -> DecidedStrictness
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DecidedStrictness)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DecidedStrictness)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c DecidedStrictness)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DecidedStrictness)
dataTypeOf :: DecidedStrictness -> DataType
$cdataTypeOf :: DecidedStrictness -> DataType
toConstr :: DecidedStrictness -> Constr
$ctoConstr :: DecidedStrictness -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DecidedStrictness
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DecidedStrictness
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DecidedStrictness -> c DecidedStrictness
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DecidedStrictness -> c DecidedStrictness
$cp1Data :: Typeable DecidedStrictness
Data, (forall x. DecidedStrictness -> Rep DecidedStrictness x)
-> (forall x. Rep DecidedStrictness x -> DecidedStrictness)
-> Generic DecidedStrictness
forall x. Rep DecidedStrictness x -> DecidedStrictness
forall x. DecidedStrictness -> Rep DecidedStrictness x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DecidedStrictness x -> DecidedStrictness
$cfrom :: forall x. DecidedStrictness -> Rep DecidedStrictness x
Generic)
data Con = NormalC Name [BangType]
| RecC Name [VarBangType]
| InfixC BangType Name BangType
| ForallC [TyVarBndr] Cxt Con
| GadtC [Name] [BangType]
Type
| RecGadtC [Name] [VarBangType]
Type
deriving (Int -> Con -> String -> String
[Con] -> String -> String
Con -> String
(Int -> Con -> String -> String)
-> (Con -> String) -> ([Con] -> String -> String) -> Show Con
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [Con] -> String -> String
$cshowList :: [Con] -> String -> String
show :: Con -> String
$cshow :: Con -> String
showsPrec :: Int -> Con -> String -> String
$cshowsPrec :: Int -> Con -> String -> String
Show, Con -> Con -> Bool
(Con -> Con -> Bool) -> (Con -> Con -> Bool) -> Eq Con
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Con -> Con -> Bool
$c/= :: Con -> Con -> Bool
== :: Con -> Con -> Bool
$c== :: Con -> Con -> Bool
Eq, Eq Con
Eq Con
-> (Con -> Con -> Ordering)
-> (Con -> Con -> Bool)
-> (Con -> Con -> Bool)
-> (Con -> Con -> Bool)
-> (Con -> Con -> Bool)
-> (Con -> Con -> Con)
-> (Con -> Con -> Con)
-> Ord Con
Con -> Con -> Bool
Con -> Con -> Ordering
Con -> Con -> Con
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Con -> Con -> Con
$cmin :: Con -> Con -> Con
max :: Con -> Con -> Con
$cmax :: Con -> Con -> Con
>= :: Con -> Con -> Bool
$c>= :: Con -> Con -> Bool
> :: Con -> Con -> Bool
$c> :: Con -> Con -> Bool
<= :: Con -> Con -> Bool
$c<= :: Con -> Con -> Bool
< :: Con -> Con -> Bool
$c< :: Con -> Con -> Bool
compare :: Con -> Con -> Ordering
$ccompare :: Con -> Con -> Ordering
$cp1Ord :: Eq Con
Ord, Typeable Con
DataType
Constr
Typeable Con
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Con -> c Con)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Con)
-> (Con -> Constr)
-> (Con -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Con))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Con))
-> ((forall b. Data b => b -> b) -> Con -> Con)
-> (forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Con -> r)
-> (forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Con -> r)
-> (forall u. (forall d. Data d => d -> u) -> Con -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Con -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Con -> m Con)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Con -> m Con)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Con -> m Con)
-> Data Con
Con -> DataType
Con -> Constr
(forall b. Data b => b -> b) -> Con -> Con
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Con -> c Con
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Con
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) -> Con -> u
forall u. (forall d. Data d => d -> u) -> Con -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Con -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Con -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Con -> m Con
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Con -> m Con
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Con
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Con -> c Con
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Con)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Con)
$cRecGadtC :: Constr
$cGadtC :: Constr
$cForallC :: Constr
$cInfixC :: Constr
$cRecC :: Constr
$cNormalC :: Constr
$tCon :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Con -> m Con
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Con -> m Con
gmapMp :: (forall d. Data d => d -> m d) -> Con -> m Con
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Con -> m Con
gmapM :: (forall d. Data d => d -> m d) -> Con -> m Con
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Con -> m Con
gmapQi :: Int -> (forall d. Data d => d -> u) -> Con -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Con -> u
gmapQ :: (forall d. Data d => d -> u) -> Con -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Con -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Con -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Con -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Con -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Con -> r
gmapT :: (forall b. Data b => b -> b) -> Con -> Con
$cgmapT :: (forall b. Data b => b -> b) -> Con -> Con
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Con)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Con)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Con)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Con)
dataTypeOf :: Con -> DataType
$cdataTypeOf :: Con -> DataType
toConstr :: Con -> Constr
$ctoConstr :: Con -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Con
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Con
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Con -> c Con
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Con -> c Con
$cp1Data :: Typeable Con
Data, (forall x. Con -> Rep Con x)
-> (forall x. Rep Con x -> Con) -> Generic Con
forall x. Rep Con x -> Con
forall x. Con -> Rep Con x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Con x -> Con
$cfrom :: forall x. Con -> Rep Con x
Generic)
data Bang = Bang SourceUnpackedness SourceStrictness
deriving (Int -> Bang -> String -> String
[Bang] -> String -> String
Bang -> String
(Int -> Bang -> String -> String)
-> (Bang -> String) -> ([Bang] -> String -> String) -> Show Bang
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [Bang] -> String -> String
$cshowList :: [Bang] -> String -> String
show :: Bang -> String
$cshow :: Bang -> String
showsPrec :: Int -> Bang -> String -> String
$cshowsPrec :: Int -> Bang -> String -> String
Show, Bang -> Bang -> Bool
(Bang -> Bang -> Bool) -> (Bang -> Bang -> Bool) -> Eq Bang
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Bang -> Bang -> Bool
$c/= :: Bang -> Bang -> Bool
== :: Bang -> Bang -> Bool
$c== :: Bang -> Bang -> Bool
Eq, Eq Bang
Eq Bang
-> (Bang -> Bang -> Ordering)
-> (Bang -> Bang -> Bool)
-> (Bang -> Bang -> Bool)
-> (Bang -> Bang -> Bool)
-> (Bang -> Bang -> Bool)
-> (Bang -> Bang -> Bang)
-> (Bang -> Bang -> Bang)
-> Ord Bang
Bang -> Bang -> Bool
Bang -> Bang -> Ordering
Bang -> Bang -> Bang
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Bang -> Bang -> Bang
$cmin :: Bang -> Bang -> Bang
max :: Bang -> Bang -> Bang
$cmax :: Bang -> Bang -> Bang
>= :: Bang -> Bang -> Bool
$c>= :: Bang -> Bang -> Bool
> :: Bang -> Bang -> Bool
$c> :: Bang -> Bang -> Bool
<= :: Bang -> Bang -> Bool
$c<= :: Bang -> Bang -> Bool
< :: Bang -> Bang -> Bool
$c< :: Bang -> Bang -> Bool
compare :: Bang -> Bang -> Ordering
$ccompare :: Bang -> Bang -> Ordering
$cp1Ord :: Eq Bang
Ord, Typeable Bang
DataType
Constr
Typeable Bang
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Bang -> c Bang)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Bang)
-> (Bang -> Constr)
-> (Bang -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Bang))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Bang))
-> ((forall b. Data b => b -> b) -> Bang -> Bang)
-> (forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Bang -> r)
-> (forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Bang -> r)
-> (forall u. (forall d. Data d => d -> u) -> Bang -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Bang -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Bang -> m Bang)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Bang -> m Bang)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Bang -> m Bang)
-> Data Bang
Bang -> DataType
Bang -> Constr
(forall b. Data b => b -> b) -> Bang -> Bang
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Bang -> c Bang
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Bang
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) -> Bang -> u
forall u. (forall d. Data d => d -> u) -> Bang -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Bang -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Bang -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Bang -> m Bang
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Bang -> m Bang
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Bang
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Bang -> c Bang
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Bang)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Bang)
$cBang :: Constr
$tBang :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Bang -> m Bang
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Bang -> m Bang
gmapMp :: (forall d. Data d => d -> m d) -> Bang -> m Bang
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Bang -> m Bang
gmapM :: (forall d. Data d => d -> m d) -> Bang -> m Bang
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Bang -> m Bang
gmapQi :: Int -> (forall d. Data d => d -> u) -> Bang -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Bang -> u
gmapQ :: (forall d. Data d => d -> u) -> Bang -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Bang -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Bang -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Bang -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Bang -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Bang -> r
gmapT :: (forall b. Data b => b -> b) -> Bang -> Bang
$cgmapT :: (forall b. Data b => b -> b) -> Bang -> Bang
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Bang)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Bang)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Bang)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Bang)
dataTypeOf :: Bang -> DataType
$cdataTypeOf :: Bang -> DataType
toConstr :: Bang -> Constr
$ctoConstr :: Bang -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Bang
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Bang
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Bang -> c Bang
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Bang -> c Bang
$cp1Data :: Typeable Bang
Data, (forall x. Bang -> Rep Bang x)
-> (forall x. Rep Bang x -> Bang) -> Generic Bang
forall x. Rep Bang x -> Bang
forall x. Bang -> Rep Bang x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Bang x -> Bang
$cfrom :: forall x. Bang -> Rep Bang x
Generic)
type BangType = (Bang, Type)
type VarBangType = (Name, Bang, Type)
type Strict = Bang
type StrictType = BangType
type VarStrictType = VarBangType
data PatSynDir
= Unidir
| ImplBidir
| ExplBidir [Clause]
deriving( Int -> PatSynDir -> String -> String
[PatSynDir] -> String -> String
PatSynDir -> String
(Int -> PatSynDir -> String -> String)
-> (PatSynDir -> String)
-> ([PatSynDir] -> String -> String)
-> Show PatSynDir
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [PatSynDir] -> String -> String
$cshowList :: [PatSynDir] -> String -> String
show :: PatSynDir -> String
$cshow :: PatSynDir -> String
showsPrec :: Int -> PatSynDir -> String -> String
$cshowsPrec :: Int -> PatSynDir -> String -> String
Show, PatSynDir -> PatSynDir -> Bool
(PatSynDir -> PatSynDir -> Bool)
-> (PatSynDir -> PatSynDir -> Bool) -> Eq PatSynDir
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PatSynDir -> PatSynDir -> Bool
$c/= :: PatSynDir -> PatSynDir -> Bool
== :: PatSynDir -> PatSynDir -> Bool
$c== :: PatSynDir -> PatSynDir -> Bool
Eq, Eq PatSynDir
Eq PatSynDir
-> (PatSynDir -> PatSynDir -> Ordering)
-> (PatSynDir -> PatSynDir -> Bool)
-> (PatSynDir -> PatSynDir -> Bool)
-> (PatSynDir -> PatSynDir -> Bool)
-> (PatSynDir -> PatSynDir -> Bool)
-> (PatSynDir -> PatSynDir -> PatSynDir)
-> (PatSynDir -> PatSynDir -> PatSynDir)
-> Ord PatSynDir
PatSynDir -> PatSynDir -> Bool
PatSynDir -> PatSynDir -> Ordering
PatSynDir -> PatSynDir -> PatSynDir
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: PatSynDir -> PatSynDir -> PatSynDir
$cmin :: PatSynDir -> PatSynDir -> PatSynDir
max :: PatSynDir -> PatSynDir -> PatSynDir
$cmax :: PatSynDir -> PatSynDir -> PatSynDir
>= :: PatSynDir -> PatSynDir -> Bool
$c>= :: PatSynDir -> PatSynDir -> Bool
> :: PatSynDir -> PatSynDir -> Bool
$c> :: PatSynDir -> PatSynDir -> Bool
<= :: PatSynDir -> PatSynDir -> Bool
$c<= :: PatSynDir -> PatSynDir -> Bool
< :: PatSynDir -> PatSynDir -> Bool
$c< :: PatSynDir -> PatSynDir -> Bool
compare :: PatSynDir -> PatSynDir -> Ordering
$ccompare :: PatSynDir -> PatSynDir -> Ordering
$cp1Ord :: Eq PatSynDir
Ord, Typeable PatSynDir
DataType
Constr
Typeable PatSynDir
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PatSynDir -> c PatSynDir)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PatSynDir)
-> (PatSynDir -> Constr)
-> (PatSynDir -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PatSynDir))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PatSynDir))
-> ((forall b. Data b => b -> b) -> PatSynDir -> PatSynDir)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PatSynDir -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PatSynDir -> r)
-> (forall u. (forall d. Data d => d -> u) -> PatSynDir -> [u])
-> (forall u.
Int -> (forall d. Data d => d -> u) -> PatSynDir -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PatSynDir -> m PatSynDir)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PatSynDir -> m PatSynDir)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PatSynDir -> m PatSynDir)
-> Data PatSynDir
PatSynDir -> DataType
PatSynDir -> Constr
(forall b. Data b => b -> b) -> PatSynDir -> PatSynDir
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PatSynDir -> c PatSynDir
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PatSynDir
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) -> PatSynDir -> u
forall u. (forall d. Data d => d -> u) -> PatSynDir -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PatSynDir -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PatSynDir -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PatSynDir -> m PatSynDir
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PatSynDir -> m PatSynDir
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PatSynDir
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PatSynDir -> c PatSynDir
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PatSynDir)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PatSynDir)
$cExplBidir :: Constr
$cImplBidir :: Constr
$cUnidir :: Constr
$tPatSynDir :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> PatSynDir -> m PatSynDir
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PatSynDir -> m PatSynDir
gmapMp :: (forall d. Data d => d -> m d) -> PatSynDir -> m PatSynDir
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PatSynDir -> m PatSynDir
gmapM :: (forall d. Data d => d -> m d) -> PatSynDir -> m PatSynDir
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PatSynDir -> m PatSynDir
gmapQi :: Int -> (forall d. Data d => d -> u) -> PatSynDir -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> PatSynDir -> u
gmapQ :: (forall d. Data d => d -> u) -> PatSynDir -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> PatSynDir -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PatSynDir -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PatSynDir -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PatSynDir -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PatSynDir -> r
gmapT :: (forall b. Data b => b -> b) -> PatSynDir -> PatSynDir
$cgmapT :: (forall b. Data b => b -> b) -> PatSynDir -> PatSynDir
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PatSynDir)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PatSynDir)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c PatSynDir)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PatSynDir)
dataTypeOf :: PatSynDir -> DataType
$cdataTypeOf :: PatSynDir -> DataType
toConstr :: PatSynDir -> Constr
$ctoConstr :: PatSynDir -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PatSynDir
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PatSynDir
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PatSynDir -> c PatSynDir
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PatSynDir -> c PatSynDir
$cp1Data :: Typeable PatSynDir
Data, (forall x. PatSynDir -> Rep PatSynDir x)
-> (forall x. Rep PatSynDir x -> PatSynDir) -> Generic PatSynDir
forall x. Rep PatSynDir x -> PatSynDir
forall x. PatSynDir -> Rep PatSynDir x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep PatSynDir x -> PatSynDir
$cfrom :: forall x. PatSynDir -> Rep PatSynDir x
Generic )
data PatSynArgs
= PrefixPatSyn [Name]
| InfixPatSyn Name Name
| RecordPatSyn [Name]
deriving( Int -> PatSynArgs -> String -> String
[PatSynArgs] -> String -> String
PatSynArgs -> String
(Int -> PatSynArgs -> String -> String)
-> (PatSynArgs -> String)
-> ([PatSynArgs] -> String -> String)
-> Show PatSynArgs
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [PatSynArgs] -> String -> String
$cshowList :: [PatSynArgs] -> String -> String
show :: PatSynArgs -> String
$cshow :: PatSynArgs -> String
showsPrec :: Int -> PatSynArgs -> String -> String
$cshowsPrec :: Int -> PatSynArgs -> String -> String
Show, PatSynArgs -> PatSynArgs -> Bool
(PatSynArgs -> PatSynArgs -> Bool)
-> (PatSynArgs -> PatSynArgs -> Bool) -> Eq PatSynArgs
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PatSynArgs -> PatSynArgs -> Bool
$c/= :: PatSynArgs -> PatSynArgs -> Bool
== :: PatSynArgs -> PatSynArgs -> Bool
$c== :: PatSynArgs -> PatSynArgs -> Bool
Eq, Eq PatSynArgs
Eq PatSynArgs
-> (PatSynArgs -> PatSynArgs -> Ordering)
-> (PatSynArgs -> PatSynArgs -> Bool)
-> (PatSynArgs -> PatSynArgs -> Bool)
-> (PatSynArgs -> PatSynArgs -> Bool)
-> (PatSynArgs -> PatSynArgs -> Bool)
-> (PatSynArgs -> PatSynArgs -> PatSynArgs)
-> (PatSynArgs -> PatSynArgs -> PatSynArgs)
-> Ord PatSynArgs
PatSynArgs -> PatSynArgs -> Bool
PatSynArgs -> PatSynArgs -> Ordering
PatSynArgs -> PatSynArgs -> PatSynArgs
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: PatSynArgs -> PatSynArgs -> PatSynArgs
$cmin :: PatSynArgs -> PatSynArgs -> PatSynArgs
max :: PatSynArgs -> PatSynArgs -> PatSynArgs
$cmax :: PatSynArgs -> PatSynArgs -> PatSynArgs
>= :: PatSynArgs -> PatSynArgs -> Bool
$c>= :: PatSynArgs -> PatSynArgs -> Bool
> :: PatSynArgs -> PatSynArgs -> Bool
$c> :: PatSynArgs -> PatSynArgs -> Bool
<= :: PatSynArgs -> PatSynArgs -> Bool
$c<= :: PatSynArgs -> PatSynArgs -> Bool
< :: PatSynArgs -> PatSynArgs -> Bool
$c< :: PatSynArgs -> PatSynArgs -> Bool
compare :: PatSynArgs -> PatSynArgs -> Ordering
$ccompare :: PatSynArgs -> PatSynArgs -> Ordering
$cp1Ord :: Eq PatSynArgs
Ord, Typeable PatSynArgs
DataType
Constr
Typeable PatSynArgs
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PatSynArgs -> c PatSynArgs)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PatSynArgs)
-> (PatSynArgs -> Constr)
-> (PatSynArgs -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PatSynArgs))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c PatSynArgs))
-> ((forall b. Data b => b -> b) -> PatSynArgs -> PatSynArgs)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PatSynArgs -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PatSynArgs -> r)
-> (forall u. (forall d. Data d => d -> u) -> PatSynArgs -> [u])
-> (forall u.
Int -> (forall d. Data d => d -> u) -> PatSynArgs -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PatSynArgs -> m PatSynArgs)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PatSynArgs -> m PatSynArgs)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PatSynArgs -> m PatSynArgs)
-> Data PatSynArgs
PatSynArgs -> DataType
PatSynArgs -> Constr
(forall b. Data b => b -> b) -> PatSynArgs -> PatSynArgs
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PatSynArgs -> c PatSynArgs
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PatSynArgs
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) -> PatSynArgs -> u
forall u. (forall d. Data d => d -> u) -> PatSynArgs -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PatSynArgs -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PatSynArgs -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PatSynArgs -> m PatSynArgs
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PatSynArgs -> m PatSynArgs
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PatSynArgs
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PatSynArgs -> c PatSynArgs
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PatSynArgs)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PatSynArgs)
$cRecordPatSyn :: Constr
$cInfixPatSyn :: Constr
$cPrefixPatSyn :: Constr
$tPatSynArgs :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> PatSynArgs -> m PatSynArgs
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PatSynArgs -> m PatSynArgs
gmapMp :: (forall d. Data d => d -> m d) -> PatSynArgs -> m PatSynArgs
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PatSynArgs -> m PatSynArgs
gmapM :: (forall d. Data d => d -> m d) -> PatSynArgs -> m PatSynArgs
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PatSynArgs -> m PatSynArgs
gmapQi :: Int -> (forall d. Data d => d -> u) -> PatSynArgs -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> PatSynArgs -> u
gmapQ :: (forall d. Data d => d -> u) -> PatSynArgs -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> PatSynArgs -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PatSynArgs -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PatSynArgs -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PatSynArgs -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PatSynArgs -> r
gmapT :: (forall b. Data b => b -> b) -> PatSynArgs -> PatSynArgs
$cgmapT :: (forall b. Data b => b -> b) -> PatSynArgs -> PatSynArgs
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PatSynArgs)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PatSynArgs)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c PatSynArgs)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PatSynArgs)
dataTypeOf :: PatSynArgs -> DataType
$cdataTypeOf :: PatSynArgs -> DataType
toConstr :: PatSynArgs -> Constr
$ctoConstr :: PatSynArgs -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PatSynArgs
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PatSynArgs
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PatSynArgs -> c PatSynArgs
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PatSynArgs -> c PatSynArgs
$cp1Data :: Typeable PatSynArgs
Data, (forall x. PatSynArgs -> Rep PatSynArgs x)
-> (forall x. Rep PatSynArgs x -> PatSynArgs) -> Generic PatSynArgs
forall x. Rep PatSynArgs x -> PatSynArgs
forall x. PatSynArgs -> Rep PatSynArgs x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep PatSynArgs x -> PatSynArgs
$cfrom :: forall x. PatSynArgs -> Rep PatSynArgs x
Generic )
data Type = ForallT [TyVarBndr] Cxt Type
| ForallVisT [TyVarBndr] Type
| AppT Type Type
| AppKindT Type Kind
| SigT Type Kind
| VarT Name
| ConT Name
| PromotedT Name
| InfixT Type Name Type
| UInfixT Type Name Type
| ParensT Type
| TupleT Int
| UnboxedTupleT Int
| UnboxedSumT SumArity
| ArrowT
| EqualityT
| ListT
| PromotedTupleT Int
| PromotedNilT
| PromotedConsT
| StarT
| ConstraintT
| LitT TyLit
| WildCardT
| ImplicitParamT String Type
deriving( Int -> Type -> String -> String
[Type] -> String -> String
Type -> String
(Int -> Type -> String -> String)
-> (Type -> String) -> ([Type] -> String -> String) -> Show Type
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [Type] -> String -> String
$cshowList :: [Type] -> String -> String
show :: Type -> String
$cshow :: Type -> String
showsPrec :: Int -> Type -> String -> String
$cshowsPrec :: Int -> Type -> String -> String
Show, Type -> Type -> Bool
(Type -> Type -> Bool) -> (Type -> Type -> Bool) -> Eq Type
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Type -> Type -> Bool
$c/= :: Type -> Type -> Bool
== :: Type -> Type -> Bool
$c== :: Type -> Type -> Bool
Eq, Eq Type
Eq Type
-> (Type -> Type -> Ordering)
-> (Type -> Type -> Bool)
-> (Type -> Type -> Bool)
-> (Type -> Type -> Bool)
-> (Type -> Type -> Bool)
-> (Type -> Type -> Type)
-> (Type -> Type -> Type)
-> Ord Type
Type -> Type -> Bool
Type -> Type -> Ordering
Type -> Type -> Type
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Type -> Type -> Type
$cmin :: Type -> Type -> Type
max :: Type -> Type -> Type
$cmax :: Type -> Type -> Type
>= :: Type -> Type -> Bool
$c>= :: Type -> Type -> Bool
> :: Type -> Type -> Bool
$c> :: Type -> Type -> Bool
<= :: Type -> Type -> Bool
$c<= :: Type -> Type -> Bool
< :: Type -> Type -> Bool
$c< :: Type -> Type -> Bool
compare :: Type -> Type -> Ordering
$ccompare :: Type -> Type -> Ordering
$cp1Ord :: Eq Type
Ord, Typeable Type
DataType
Constr
Typeable Type
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Type -> c Type)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Type)
-> (Type -> Constr)
-> (Type -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Type))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Type))
-> ((forall b. Data b => b -> b) -> Type -> Type)
-> (forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r)
-> (forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r)
-> (forall u. (forall d. Data d => d -> u) -> Type -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Type -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Type -> m Type)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Type -> m Type)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Type -> m Type)
-> Data Type
Type -> DataType
Type -> Constr
(forall b. Data b => b -> b) -> Type -> Type
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Type -> c Type
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Type
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) -> Type -> u
forall u. (forall d. Data d => d -> u) -> Type -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Type -> m Type
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Type -> m Type
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Type
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Type -> c Type
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Type)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Type)
$cImplicitParamT :: Constr
$cWildCardT :: Constr
$cLitT :: Constr
$cConstraintT :: Constr
$cStarT :: Constr
$cPromotedConsT :: Constr
$cPromotedNilT :: Constr
$cPromotedTupleT :: Constr
$cListT :: Constr
$cEqualityT :: Constr
$cArrowT :: Constr
$cUnboxedSumT :: Constr
$cUnboxedTupleT :: Constr
$cTupleT :: Constr
$cParensT :: Constr
$cUInfixT :: Constr
$cInfixT :: Constr
$cPromotedT :: Constr
$cConT :: Constr
$cVarT :: Constr
$cSigT :: Constr
$cAppKindT :: Constr
$cAppT :: Constr
$cForallVisT :: Constr
$cForallT :: Constr
$tType :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Type -> m Type
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Type -> m Type
gmapMp :: (forall d. Data d => d -> m d) -> Type -> m Type
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Type -> m Type
gmapM :: (forall d. Data d => d -> m d) -> Type -> m Type
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Type -> m Type
gmapQi :: Int -> (forall d. Data d => d -> u) -> Type -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Type -> u
gmapQ :: (forall d. Data d => d -> u) -> Type -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Type -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r
gmapT :: (forall b. Data b => b -> b) -> Type -> Type
$cgmapT :: (forall b. Data b => b -> b) -> Type -> Type
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Type)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Type)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Type)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Type)
dataTypeOf :: Type -> DataType
$cdataTypeOf :: Type -> DataType
toConstr :: Type -> Constr
$ctoConstr :: Type -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Type
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Type
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Type -> c Type
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Type -> c Type
$cp1Data :: Typeable Type
Data, (forall x. Type -> Rep Type x)
-> (forall x. Rep Type x -> Type) -> Generic Type
forall x. Rep Type x -> Type
forall x. Type -> Rep Type x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Type x -> Type
$cfrom :: forall x. Type -> Rep Type x
Generic )
data TyVarBndr = PlainTV Name
| KindedTV Name Kind
deriving( Int -> TyVarBndr -> String -> String
[TyVarBndr] -> String -> String
TyVarBndr -> String
(Int -> TyVarBndr -> String -> String)
-> (TyVarBndr -> String)
-> ([TyVarBndr] -> String -> String)
-> Show TyVarBndr
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [TyVarBndr] -> String -> String
$cshowList :: [TyVarBndr] -> String -> String
show :: TyVarBndr -> String
$cshow :: TyVarBndr -> String
showsPrec :: Int -> TyVarBndr -> String -> String
$cshowsPrec :: Int -> TyVarBndr -> String -> String
Show, TyVarBndr -> TyVarBndr -> Bool
(TyVarBndr -> TyVarBndr -> Bool)
-> (TyVarBndr -> TyVarBndr -> Bool) -> Eq TyVarBndr
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TyVarBndr -> TyVarBndr -> Bool
$c/= :: TyVarBndr -> TyVarBndr -> Bool
== :: TyVarBndr -> TyVarBndr -> Bool
$c== :: TyVarBndr -> TyVarBndr -> Bool
Eq, Eq TyVarBndr
Eq TyVarBndr
-> (TyVarBndr -> TyVarBndr -> Ordering)
-> (TyVarBndr -> TyVarBndr -> Bool)
-> (TyVarBndr -> TyVarBndr -> Bool)
-> (TyVarBndr -> TyVarBndr -> Bool)
-> (TyVarBndr -> TyVarBndr -> Bool)
-> (TyVarBndr -> TyVarBndr -> TyVarBndr)
-> (TyVarBndr -> TyVarBndr -> TyVarBndr)
-> Ord TyVarBndr
TyVarBndr -> TyVarBndr -> Bool
TyVarBndr -> TyVarBndr -> Ordering
TyVarBndr -> TyVarBndr -> TyVarBndr
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: TyVarBndr -> TyVarBndr -> TyVarBndr
$cmin :: TyVarBndr -> TyVarBndr -> TyVarBndr
max :: TyVarBndr -> TyVarBndr -> TyVarBndr
$cmax :: TyVarBndr -> TyVarBndr -> TyVarBndr
>= :: TyVarBndr -> TyVarBndr -> Bool
$c>= :: TyVarBndr -> TyVarBndr -> Bool
> :: TyVarBndr -> TyVarBndr -> Bool
$c> :: TyVarBndr -> TyVarBndr -> Bool
<= :: TyVarBndr -> TyVarBndr -> Bool
$c<= :: TyVarBndr -> TyVarBndr -> Bool
< :: TyVarBndr -> TyVarBndr -> Bool
$c< :: TyVarBndr -> TyVarBndr -> Bool
compare :: TyVarBndr -> TyVarBndr -> Ordering
$ccompare :: TyVarBndr -> TyVarBndr -> Ordering
$cp1Ord :: Eq TyVarBndr
Ord, Typeable TyVarBndr
DataType
Constr
Typeable TyVarBndr
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TyVarBndr -> c TyVarBndr)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TyVarBndr)
-> (TyVarBndr -> Constr)
-> (TyVarBndr -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TyVarBndr))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TyVarBndr))
-> ((forall b. Data b => b -> b) -> TyVarBndr -> TyVarBndr)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TyVarBndr -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TyVarBndr -> r)
-> (forall u. (forall d. Data d => d -> u) -> TyVarBndr -> [u])
-> (forall u.
Int -> (forall d. Data d => d -> u) -> TyVarBndr -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TyVarBndr -> m TyVarBndr)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TyVarBndr -> m TyVarBndr)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TyVarBndr -> m TyVarBndr)
-> Data TyVarBndr
TyVarBndr -> DataType
TyVarBndr -> Constr
(forall b. Data b => b -> b) -> TyVarBndr -> TyVarBndr
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TyVarBndr -> c TyVarBndr
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TyVarBndr
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) -> TyVarBndr -> u
forall u. (forall d. Data d => d -> u) -> TyVarBndr -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TyVarBndr -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TyVarBndr -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TyVarBndr -> m TyVarBndr
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TyVarBndr -> m TyVarBndr
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TyVarBndr
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TyVarBndr -> c TyVarBndr
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TyVarBndr)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TyVarBndr)
$cKindedTV :: Constr
$cPlainTV :: Constr
$tTyVarBndr :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> TyVarBndr -> m TyVarBndr
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TyVarBndr -> m TyVarBndr
gmapMp :: (forall d. Data d => d -> m d) -> TyVarBndr -> m TyVarBndr
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TyVarBndr -> m TyVarBndr
gmapM :: (forall d. Data d => d -> m d) -> TyVarBndr -> m TyVarBndr
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TyVarBndr -> m TyVarBndr
gmapQi :: Int -> (forall d. Data d => d -> u) -> TyVarBndr -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TyVarBndr -> u
gmapQ :: (forall d. Data d => d -> u) -> TyVarBndr -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> TyVarBndr -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TyVarBndr -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TyVarBndr -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TyVarBndr -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TyVarBndr -> r
gmapT :: (forall b. Data b => b -> b) -> TyVarBndr -> TyVarBndr
$cgmapT :: (forall b. Data b => b -> b) -> TyVarBndr -> TyVarBndr
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TyVarBndr)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TyVarBndr)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c TyVarBndr)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TyVarBndr)
dataTypeOf :: TyVarBndr -> DataType
$cdataTypeOf :: TyVarBndr -> DataType
toConstr :: TyVarBndr -> Constr
$ctoConstr :: TyVarBndr -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TyVarBndr
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TyVarBndr
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TyVarBndr -> c TyVarBndr
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TyVarBndr -> c TyVarBndr
$cp1Data :: Typeable TyVarBndr
Data, (forall x. TyVarBndr -> Rep TyVarBndr x)
-> (forall x. Rep TyVarBndr x -> TyVarBndr) -> Generic TyVarBndr
forall x. Rep TyVarBndr x -> TyVarBndr
forall x. TyVarBndr -> Rep TyVarBndr x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep TyVarBndr x -> TyVarBndr
$cfrom :: forall x. TyVarBndr -> Rep TyVarBndr x
Generic )
data FamilyResultSig = NoSig
| KindSig Kind
| TyVarSig TyVarBndr
deriving( Int -> FamilyResultSig -> String -> String
[FamilyResultSig] -> String -> String
FamilyResultSig -> String
(Int -> FamilyResultSig -> String -> String)
-> (FamilyResultSig -> String)
-> ([FamilyResultSig] -> String -> String)
-> Show FamilyResultSig
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [FamilyResultSig] -> String -> String
$cshowList :: [FamilyResultSig] -> String -> String
show :: FamilyResultSig -> String
$cshow :: FamilyResultSig -> String
showsPrec :: Int -> FamilyResultSig -> String -> String
$cshowsPrec :: Int -> FamilyResultSig -> String -> String
Show, FamilyResultSig -> FamilyResultSig -> Bool
(FamilyResultSig -> FamilyResultSig -> Bool)
-> (FamilyResultSig -> FamilyResultSig -> Bool)
-> Eq FamilyResultSig
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FamilyResultSig -> FamilyResultSig -> Bool
$c/= :: FamilyResultSig -> FamilyResultSig -> Bool
== :: FamilyResultSig -> FamilyResultSig -> Bool
$c== :: FamilyResultSig -> FamilyResultSig -> Bool
Eq, Eq FamilyResultSig
Eq FamilyResultSig
-> (FamilyResultSig -> FamilyResultSig -> Ordering)
-> (FamilyResultSig -> FamilyResultSig -> Bool)
-> (FamilyResultSig -> FamilyResultSig -> Bool)
-> (FamilyResultSig -> FamilyResultSig -> Bool)
-> (FamilyResultSig -> FamilyResultSig -> Bool)
-> (FamilyResultSig -> FamilyResultSig -> FamilyResultSig)
-> (FamilyResultSig -> FamilyResultSig -> FamilyResultSig)
-> Ord FamilyResultSig
FamilyResultSig -> FamilyResultSig -> Bool
FamilyResultSig -> FamilyResultSig -> Ordering
FamilyResultSig -> FamilyResultSig -> FamilyResultSig
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: FamilyResultSig -> FamilyResultSig -> FamilyResultSig
$cmin :: FamilyResultSig -> FamilyResultSig -> FamilyResultSig
max :: FamilyResultSig -> FamilyResultSig -> FamilyResultSig
$cmax :: FamilyResultSig -> FamilyResultSig -> FamilyResultSig
>= :: FamilyResultSig -> FamilyResultSig -> Bool
$c>= :: FamilyResultSig -> FamilyResultSig -> Bool
> :: FamilyResultSig -> FamilyResultSig -> Bool
$c> :: FamilyResultSig -> FamilyResultSig -> Bool
<= :: FamilyResultSig -> FamilyResultSig -> Bool
$c<= :: FamilyResultSig -> FamilyResultSig -> Bool
< :: FamilyResultSig -> FamilyResultSig -> Bool
$c< :: FamilyResultSig -> FamilyResultSig -> Bool
compare :: FamilyResultSig -> FamilyResultSig -> Ordering
$ccompare :: FamilyResultSig -> FamilyResultSig -> Ordering
$cp1Ord :: Eq FamilyResultSig
Ord, Typeable FamilyResultSig
DataType
Constr
Typeable FamilyResultSig
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FamilyResultSig -> c FamilyResultSig)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FamilyResultSig)
-> (FamilyResultSig -> Constr)
-> (FamilyResultSig -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FamilyResultSig))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c FamilyResultSig))
-> ((forall b. Data b => b -> b)
-> FamilyResultSig -> FamilyResultSig)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FamilyResultSig -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FamilyResultSig -> r)
-> (forall u.
(forall d. Data d => d -> u) -> FamilyResultSig -> [u])
-> (forall u.
Int -> (forall d. Data d => d -> u) -> FamilyResultSig -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> FamilyResultSig -> m FamilyResultSig)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> FamilyResultSig -> m FamilyResultSig)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> FamilyResultSig -> m FamilyResultSig)
-> Data FamilyResultSig
FamilyResultSig -> DataType
FamilyResultSig -> Constr
(forall b. Data b => b -> b) -> FamilyResultSig -> FamilyResultSig
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FamilyResultSig -> c FamilyResultSig
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FamilyResultSig
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) -> FamilyResultSig -> u
forall u. (forall d. Data d => d -> u) -> FamilyResultSig -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FamilyResultSig -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FamilyResultSig -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> FamilyResultSig -> m FamilyResultSig
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> FamilyResultSig -> m FamilyResultSig
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FamilyResultSig
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FamilyResultSig -> c FamilyResultSig
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FamilyResultSig)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c FamilyResultSig)
$cTyVarSig :: Constr
$cKindSig :: Constr
$cNoSig :: Constr
$tFamilyResultSig :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> FamilyResultSig -> m FamilyResultSig
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> FamilyResultSig -> m FamilyResultSig
gmapMp :: (forall d. Data d => d -> m d)
-> FamilyResultSig -> m FamilyResultSig
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> FamilyResultSig -> m FamilyResultSig
gmapM :: (forall d. Data d => d -> m d)
-> FamilyResultSig -> m FamilyResultSig
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> FamilyResultSig -> m FamilyResultSig
gmapQi :: Int -> (forall d. Data d => d -> u) -> FamilyResultSig -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> FamilyResultSig -> u
gmapQ :: (forall d. Data d => d -> u) -> FamilyResultSig -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> FamilyResultSig -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FamilyResultSig -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FamilyResultSig -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FamilyResultSig -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FamilyResultSig -> r
gmapT :: (forall b. Data b => b -> b) -> FamilyResultSig -> FamilyResultSig
$cgmapT :: (forall b. Data b => b -> b) -> FamilyResultSig -> FamilyResultSig
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c FamilyResultSig)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c FamilyResultSig)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c FamilyResultSig)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FamilyResultSig)
dataTypeOf :: FamilyResultSig -> DataType
$cdataTypeOf :: FamilyResultSig -> DataType
toConstr :: FamilyResultSig -> Constr
$ctoConstr :: FamilyResultSig -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FamilyResultSig
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FamilyResultSig
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FamilyResultSig -> c FamilyResultSig
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FamilyResultSig -> c FamilyResultSig
$cp1Data :: Typeable FamilyResultSig
Data, (forall x. FamilyResultSig -> Rep FamilyResultSig x)
-> (forall x. Rep FamilyResultSig x -> FamilyResultSig)
-> Generic FamilyResultSig
forall x. Rep FamilyResultSig x -> FamilyResultSig
forall x. FamilyResultSig -> Rep FamilyResultSig x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep FamilyResultSig x -> FamilyResultSig
$cfrom :: forall x. FamilyResultSig -> Rep FamilyResultSig x
Generic )
data InjectivityAnn = InjectivityAnn Name [Name]
deriving ( Int -> InjectivityAnn -> String -> String
[InjectivityAnn] -> String -> String
InjectivityAnn -> String
(Int -> InjectivityAnn -> String -> String)
-> (InjectivityAnn -> String)
-> ([InjectivityAnn] -> String -> String)
-> Show InjectivityAnn
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [InjectivityAnn] -> String -> String
$cshowList :: [InjectivityAnn] -> String -> String
show :: InjectivityAnn -> String
$cshow :: InjectivityAnn -> String
showsPrec :: Int -> InjectivityAnn -> String -> String
$cshowsPrec :: Int -> InjectivityAnn -> String -> String
Show, InjectivityAnn -> InjectivityAnn -> Bool
(InjectivityAnn -> InjectivityAnn -> Bool)
-> (InjectivityAnn -> InjectivityAnn -> Bool) -> Eq InjectivityAnn
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: InjectivityAnn -> InjectivityAnn -> Bool
$c/= :: InjectivityAnn -> InjectivityAnn -> Bool
== :: InjectivityAnn -> InjectivityAnn -> Bool
$c== :: InjectivityAnn -> InjectivityAnn -> Bool
Eq, Eq InjectivityAnn
Eq InjectivityAnn
-> (InjectivityAnn -> InjectivityAnn -> Ordering)
-> (InjectivityAnn -> InjectivityAnn -> Bool)
-> (InjectivityAnn -> InjectivityAnn -> Bool)
-> (InjectivityAnn -> InjectivityAnn -> Bool)
-> (InjectivityAnn -> InjectivityAnn -> Bool)
-> (InjectivityAnn -> InjectivityAnn -> InjectivityAnn)
-> (InjectivityAnn -> InjectivityAnn -> InjectivityAnn)
-> Ord InjectivityAnn
InjectivityAnn -> InjectivityAnn -> Bool
InjectivityAnn -> InjectivityAnn -> Ordering
InjectivityAnn -> InjectivityAnn -> InjectivityAnn
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: InjectivityAnn -> InjectivityAnn -> InjectivityAnn
$cmin :: InjectivityAnn -> InjectivityAnn -> InjectivityAnn
max :: InjectivityAnn -> InjectivityAnn -> InjectivityAnn
$cmax :: InjectivityAnn -> InjectivityAnn -> InjectivityAnn
>= :: InjectivityAnn -> InjectivityAnn -> Bool
$c>= :: InjectivityAnn -> InjectivityAnn -> Bool
> :: InjectivityAnn -> InjectivityAnn -> Bool
$c> :: InjectivityAnn -> InjectivityAnn -> Bool
<= :: InjectivityAnn -> InjectivityAnn -> Bool
$c<= :: InjectivityAnn -> InjectivityAnn -> Bool
< :: InjectivityAnn -> InjectivityAnn -> Bool
$c< :: InjectivityAnn -> InjectivityAnn -> Bool
compare :: InjectivityAnn -> InjectivityAnn -> Ordering
$ccompare :: InjectivityAnn -> InjectivityAnn -> Ordering
$cp1Ord :: Eq InjectivityAnn
Ord, Typeable InjectivityAnn
DataType
Constr
Typeable InjectivityAnn
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> InjectivityAnn -> c InjectivityAnn)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c InjectivityAnn)
-> (InjectivityAnn -> Constr)
-> (InjectivityAnn -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c InjectivityAnn))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c InjectivityAnn))
-> ((forall b. Data b => b -> b)
-> InjectivityAnn -> InjectivityAnn)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> InjectivityAnn -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> InjectivityAnn -> r)
-> (forall u.
(forall d. Data d => d -> u) -> InjectivityAnn -> [u])
-> (forall u.
Int -> (forall d. Data d => d -> u) -> InjectivityAnn -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> InjectivityAnn -> m InjectivityAnn)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> InjectivityAnn -> m InjectivityAnn)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> InjectivityAnn -> m InjectivityAnn)
-> Data InjectivityAnn
InjectivityAnn -> DataType
InjectivityAnn -> Constr
(forall b. Data b => b -> b) -> InjectivityAnn -> InjectivityAnn
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> InjectivityAnn -> c InjectivityAnn
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c InjectivityAnn
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) -> InjectivityAnn -> u
forall u. (forall d. Data d => d -> u) -> InjectivityAnn -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> InjectivityAnn -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> InjectivityAnn -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> InjectivityAnn -> m InjectivityAnn
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> InjectivityAnn -> m InjectivityAnn
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c InjectivityAnn
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> InjectivityAnn -> c InjectivityAnn
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c InjectivityAnn)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c InjectivityAnn)
$cInjectivityAnn :: Constr
$tInjectivityAnn :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> InjectivityAnn -> m InjectivityAnn
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> InjectivityAnn -> m InjectivityAnn
gmapMp :: (forall d. Data d => d -> m d)
-> InjectivityAnn -> m InjectivityAnn
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> InjectivityAnn -> m InjectivityAnn
gmapM :: (forall d. Data d => d -> m d)
-> InjectivityAnn -> m InjectivityAnn
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> InjectivityAnn -> m InjectivityAnn
gmapQi :: Int -> (forall d. Data d => d -> u) -> InjectivityAnn -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> InjectivityAnn -> u
gmapQ :: (forall d. Data d => d -> u) -> InjectivityAnn -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> InjectivityAnn -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> InjectivityAnn -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> InjectivityAnn -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> InjectivityAnn -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> InjectivityAnn -> r
gmapT :: (forall b. Data b => b -> b) -> InjectivityAnn -> InjectivityAnn
$cgmapT :: (forall b. Data b => b -> b) -> InjectivityAnn -> InjectivityAnn
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c InjectivityAnn)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c InjectivityAnn)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c InjectivityAnn)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c InjectivityAnn)
dataTypeOf :: InjectivityAnn -> DataType
$cdataTypeOf :: InjectivityAnn -> DataType
toConstr :: InjectivityAnn -> Constr
$ctoConstr :: InjectivityAnn -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c InjectivityAnn
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c InjectivityAnn
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> InjectivityAnn -> c InjectivityAnn
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> InjectivityAnn -> c InjectivityAnn
$cp1Data :: Typeable InjectivityAnn
Data, (forall x. InjectivityAnn -> Rep InjectivityAnn x)
-> (forall x. Rep InjectivityAnn x -> InjectivityAnn)
-> Generic InjectivityAnn
forall x. Rep InjectivityAnn x -> InjectivityAnn
forall x. InjectivityAnn -> Rep InjectivityAnn x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep InjectivityAnn x -> InjectivityAnn
$cfrom :: forall x. InjectivityAnn -> Rep InjectivityAnn x
Generic )
data TyLit = NumTyLit Integer
| StrTyLit String
deriving ( Int -> TyLit -> String -> String
[TyLit] -> String -> String
TyLit -> String
(Int -> TyLit -> String -> String)
-> (TyLit -> String) -> ([TyLit] -> String -> String) -> Show TyLit
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [TyLit] -> String -> String
$cshowList :: [TyLit] -> String -> String
show :: TyLit -> String
$cshow :: TyLit -> String
showsPrec :: Int -> TyLit -> String -> String
$cshowsPrec :: Int -> TyLit -> String -> String
Show, TyLit -> TyLit -> Bool
(TyLit -> TyLit -> Bool) -> (TyLit -> TyLit -> Bool) -> Eq TyLit
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TyLit -> TyLit -> Bool
$c/= :: TyLit -> TyLit -> Bool
== :: TyLit -> TyLit -> Bool
$c== :: TyLit -> TyLit -> Bool
Eq, Eq TyLit
Eq TyLit
-> (TyLit -> TyLit -> Ordering)
-> (TyLit -> TyLit -> Bool)
-> (TyLit -> TyLit -> Bool)
-> (TyLit -> TyLit -> Bool)
-> (TyLit -> TyLit -> Bool)
-> (TyLit -> TyLit -> TyLit)
-> (TyLit -> TyLit -> TyLit)
-> Ord TyLit
TyLit -> TyLit -> Bool
TyLit -> TyLit -> Ordering
TyLit -> TyLit -> TyLit
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: TyLit -> TyLit -> TyLit
$cmin :: TyLit -> TyLit -> TyLit
max :: TyLit -> TyLit -> TyLit
$cmax :: TyLit -> TyLit -> TyLit
>= :: TyLit -> TyLit -> Bool
$c>= :: TyLit -> TyLit -> Bool
> :: TyLit -> TyLit -> Bool
$c> :: TyLit -> TyLit -> Bool
<= :: TyLit -> TyLit -> Bool
$c<= :: TyLit -> TyLit -> Bool
< :: TyLit -> TyLit -> Bool
$c< :: TyLit -> TyLit -> Bool
compare :: TyLit -> TyLit -> Ordering
$ccompare :: TyLit -> TyLit -> Ordering
$cp1Ord :: Eq TyLit
Ord, Typeable TyLit
DataType
Constr
Typeable TyLit
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TyLit -> c TyLit)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TyLit)
-> (TyLit -> Constr)
-> (TyLit -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TyLit))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TyLit))
-> ((forall b. Data b => b -> b) -> TyLit -> TyLit)
-> (forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TyLit -> r)
-> (forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TyLit -> r)
-> (forall u. (forall d. Data d => d -> u) -> TyLit -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> TyLit -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TyLit -> m TyLit)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TyLit -> m TyLit)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TyLit -> m TyLit)
-> Data TyLit
TyLit -> DataType
TyLit -> Constr
(forall b. Data b => b -> b) -> TyLit -> TyLit
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TyLit -> c TyLit
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TyLit
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) -> TyLit -> u
forall u. (forall d. Data d => d -> u) -> TyLit -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TyLit -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TyLit -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TyLit -> m TyLit
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TyLit -> m TyLit
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TyLit
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TyLit -> c TyLit
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TyLit)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TyLit)
$cStrTyLit :: Constr
$cNumTyLit :: Constr
$tTyLit :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> TyLit -> m TyLit
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TyLit -> m TyLit
gmapMp :: (forall d. Data d => d -> m d) -> TyLit -> m TyLit
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TyLit -> m TyLit
gmapM :: (forall d. Data d => d -> m d) -> TyLit -> m TyLit
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TyLit -> m TyLit
gmapQi :: Int -> (forall d. Data d => d -> u) -> TyLit -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TyLit -> u
gmapQ :: (forall d. Data d => d -> u) -> TyLit -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> TyLit -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TyLit -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TyLit -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TyLit -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TyLit -> r
gmapT :: (forall b. Data b => b -> b) -> TyLit -> TyLit
$cgmapT :: (forall b. Data b => b -> b) -> TyLit -> TyLit
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TyLit)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TyLit)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c TyLit)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TyLit)
dataTypeOf :: TyLit -> DataType
$cdataTypeOf :: TyLit -> DataType
toConstr :: TyLit -> Constr
$ctoConstr :: TyLit -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TyLit
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TyLit
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TyLit -> c TyLit
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TyLit -> c TyLit
$cp1Data :: Typeable TyLit
Data, (forall x. TyLit -> Rep TyLit x)
-> (forall x. Rep TyLit x -> TyLit) -> Generic TyLit
forall x. Rep TyLit x -> TyLit
forall x. TyLit -> Rep TyLit x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep TyLit x -> TyLit
$cfrom :: forall x. TyLit -> Rep TyLit x
Generic )
data Role = NominalR
| RepresentationalR
| PhantomR
| InferR
deriving( Int -> Role -> String -> String
[Role] -> String -> String
Role -> String
(Int -> Role -> String -> String)
-> (Role -> String) -> ([Role] -> String -> String) -> Show Role
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [Role] -> String -> String
$cshowList :: [Role] -> String -> String
show :: Role -> String
$cshow :: Role -> String
showsPrec :: Int -> Role -> String -> String
$cshowsPrec :: Int -> Role -> String -> String
Show, Role -> Role -> Bool
(Role -> Role -> Bool) -> (Role -> Role -> Bool) -> Eq Role
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Role -> Role -> Bool
$c/= :: Role -> Role -> Bool
== :: Role -> Role -> Bool
$c== :: Role -> Role -> Bool
Eq, Eq Role
Eq Role
-> (Role -> Role -> Ordering)
-> (Role -> Role -> Bool)
-> (Role -> Role -> Bool)
-> (Role -> Role -> Bool)
-> (Role -> Role -> Bool)
-> (Role -> Role -> Role)
-> (Role -> Role -> Role)
-> Ord Role
Role -> Role -> Bool
Role -> Role -> Ordering
Role -> Role -> Role
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Role -> Role -> Role
$cmin :: Role -> Role -> Role
max :: Role -> Role -> Role
$cmax :: Role -> Role -> Role
>= :: Role -> Role -> Bool
$c>= :: Role -> Role -> Bool
> :: Role -> Role -> Bool
$c> :: Role -> Role -> Bool
<= :: Role -> Role -> Bool
$c<= :: Role -> Role -> Bool
< :: Role -> Role -> Bool
$c< :: Role -> Role -> Bool
compare :: Role -> Role -> Ordering
$ccompare :: Role -> Role -> Ordering
$cp1Ord :: Eq Role
Ord, Typeable Role
DataType
Constr
Typeable Role
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Role -> c Role)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Role)
-> (Role -> Constr)
-> (Role -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Role))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Role))
-> ((forall b. Data b => b -> b) -> Role -> Role)
-> (forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Role -> r)
-> (forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Role -> r)
-> (forall u. (forall d. Data d => d -> u) -> Role -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Role -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Role -> m Role)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Role -> m Role)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Role -> m Role)
-> Data Role
Role -> DataType
Role -> Constr
(forall b. Data b => b -> b) -> Role -> Role
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Role -> c Role
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Role
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) -> Role -> u
forall u. (forall d. Data d => d -> u) -> Role -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Role -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Role -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Role -> m Role
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Role -> m Role
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Role
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Role -> c Role
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Role)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Role)
$cInferR :: Constr
$cPhantomR :: Constr
$cRepresentationalR :: Constr
$cNominalR :: Constr
$tRole :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Role -> m Role
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Role -> m Role
gmapMp :: (forall d. Data d => d -> m d) -> Role -> m Role
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Role -> m Role
gmapM :: (forall d. Data d => d -> m d) -> Role -> m Role
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Role -> m Role
gmapQi :: Int -> (forall d. Data d => d -> u) -> Role -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Role -> u
gmapQ :: (forall d. Data d => d -> u) -> Role -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Role -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Role -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Role -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Role -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Role -> r
gmapT :: (forall b. Data b => b -> b) -> Role -> Role
$cgmapT :: (forall b. Data b => b -> b) -> Role -> Role
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Role)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Role)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Role)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Role)
dataTypeOf :: Role -> DataType
$cdataTypeOf :: Role -> DataType
toConstr :: Role -> Constr
$ctoConstr :: Role -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Role
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Role
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Role -> c Role
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Role -> c Role
$cp1Data :: Typeable Role
Data, (forall x. Role -> Rep Role x)
-> (forall x. Rep Role x -> Role) -> Generic Role
forall x. Rep Role x -> Role
forall x. Role -> Rep Role x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Role x -> Role
$cfrom :: forall x. Role -> Rep Role x
Generic )
data AnnLookup = AnnLookupModule Module
| AnnLookupName Name
deriving( Int -> AnnLookup -> String -> String
[AnnLookup] -> String -> String
AnnLookup -> String
(Int -> AnnLookup -> String -> String)
-> (AnnLookup -> String)
-> ([AnnLookup] -> String -> String)
-> Show AnnLookup
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [AnnLookup] -> String -> String
$cshowList :: [AnnLookup] -> String -> String
show :: AnnLookup -> String
$cshow :: AnnLookup -> String
showsPrec :: Int -> AnnLookup -> String -> String
$cshowsPrec :: Int -> AnnLookup -> String -> String
Show, AnnLookup -> AnnLookup -> Bool
(AnnLookup -> AnnLookup -> Bool)
-> (AnnLookup -> AnnLookup -> Bool) -> Eq AnnLookup
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AnnLookup -> AnnLookup -> Bool
$c/= :: AnnLookup -> AnnLookup -> Bool
== :: AnnLookup -> AnnLookup -> Bool
$c== :: AnnLookup -> AnnLookup -> Bool
Eq, Eq AnnLookup
Eq AnnLookup
-> (AnnLookup -> AnnLookup -> Ordering)
-> (AnnLookup -> AnnLookup -> Bool)
-> (AnnLookup -> AnnLookup -> Bool)
-> (AnnLookup -> AnnLookup -> Bool)
-> (AnnLookup -> AnnLookup -> Bool)
-> (AnnLookup -> AnnLookup -> AnnLookup)
-> (AnnLookup -> AnnLookup -> AnnLookup)
-> Ord AnnLookup
AnnLookup -> AnnLookup -> Bool
AnnLookup -> AnnLookup -> Ordering
AnnLookup -> AnnLookup -> AnnLookup
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: AnnLookup -> AnnLookup -> AnnLookup
$cmin :: AnnLookup -> AnnLookup -> AnnLookup
max :: AnnLookup -> AnnLookup -> AnnLookup
$cmax :: AnnLookup -> AnnLookup -> AnnLookup
>= :: AnnLookup -> AnnLookup -> Bool
$c>= :: AnnLookup -> AnnLookup -> Bool
> :: AnnLookup -> AnnLookup -> Bool
$c> :: AnnLookup -> AnnLookup -> Bool
<= :: AnnLookup -> AnnLookup -> Bool
$c<= :: AnnLookup -> AnnLookup -> Bool
< :: AnnLookup -> AnnLookup -> Bool
$c< :: AnnLookup -> AnnLookup -> Bool
compare :: AnnLookup -> AnnLookup -> Ordering
$ccompare :: AnnLookup -> AnnLookup -> Ordering
$cp1Ord :: Eq AnnLookup
Ord, Typeable AnnLookup
DataType
Constr
Typeable AnnLookup
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AnnLookup -> c AnnLookup)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AnnLookup)
-> (AnnLookup -> Constr)
-> (AnnLookup -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c AnnLookup))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AnnLookup))
-> ((forall b. Data b => b -> b) -> AnnLookup -> AnnLookup)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AnnLookup -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> AnnLookup -> r)
-> (forall u. (forall d. Data d => d -> u) -> AnnLookup -> [u])
-> (forall u.
Int -> (forall d. Data d => d -> u) -> AnnLookup -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> AnnLookup -> m AnnLookup)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AnnLookup -> m AnnLookup)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AnnLookup -> m AnnLookup)
-> Data AnnLookup
AnnLookup -> DataType
AnnLookup -> Constr
(forall b. Data b => b -> b) -> AnnLookup -> AnnLookup
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AnnLookup -> c AnnLookup
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AnnLookup
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) -> AnnLookup -> u
forall u. (forall d. Data d => d -> u) -> AnnLookup -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AnnLookup -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> AnnLookup -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> AnnLookup -> m AnnLookup
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AnnLookup -> m AnnLookup
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AnnLookup
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AnnLookup -> c AnnLookup
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c AnnLookup)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AnnLookup)
$cAnnLookupName :: Constr
$cAnnLookupModule :: Constr
$tAnnLookup :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> AnnLookup -> m AnnLookup
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AnnLookup -> m AnnLookup
gmapMp :: (forall d. Data d => d -> m d) -> AnnLookup -> m AnnLookup
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AnnLookup -> m AnnLookup
gmapM :: (forall d. Data d => d -> m d) -> AnnLookup -> m AnnLookup
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> AnnLookup -> m AnnLookup
gmapQi :: Int -> (forall d. Data d => d -> u) -> AnnLookup -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> AnnLookup -> u
gmapQ :: (forall d. Data d => d -> u) -> AnnLookup -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> AnnLookup -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> AnnLookup -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> AnnLookup -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AnnLookup -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AnnLookup -> r
gmapT :: (forall b. Data b => b -> b) -> AnnLookup -> AnnLookup
$cgmapT :: (forall b. Data b => b -> b) -> AnnLookup -> AnnLookup
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AnnLookup)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AnnLookup)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c AnnLookup)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c AnnLookup)
dataTypeOf :: AnnLookup -> DataType
$cdataTypeOf :: AnnLookup -> DataType
toConstr :: AnnLookup -> Constr
$ctoConstr :: AnnLookup -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AnnLookup
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AnnLookup
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AnnLookup -> c AnnLookup
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AnnLookup -> c AnnLookup
$cp1Data :: Typeable AnnLookup
Data, (forall x. AnnLookup -> Rep AnnLookup x)
-> (forall x. Rep AnnLookup x -> AnnLookup) -> Generic AnnLookup
forall x. Rep AnnLookup x -> AnnLookup
forall x. AnnLookup -> Rep AnnLookup x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep AnnLookup x -> AnnLookup
$cfrom :: forall x. AnnLookup -> Rep AnnLookup x
Generic )
type Kind = Type
cmpEq :: Ordering -> Bool
cmpEq :: Ordering -> Bool
cmpEq Ordering
EQ = Bool
True
cmpEq Ordering
_ = Bool
False
thenCmp :: Ordering -> Ordering -> Ordering
thenCmp :: Ordering -> Ordering -> Ordering
thenCmp Ordering
EQ Ordering
o2 = Ordering
o2
thenCmp Ordering
o1 Ordering
_ = Ordering
o1