{-# LANGUAGE CPP, DeriveDataTypeable, DeriveGeneric, FlexibleInstances, DefaultSignatures, RankNTypes, RoleAnnotations, ScopedTypeVariables, Trustworthy #-} {-# OPTIONS_GHC -fno-warn-inline-rule-shadowing #-} ----------------------------------------------------------------------------- -- | -- Module : Language.Haskell.Syntax -- Copyright : (c) The University of Glasgow 2003 -- License : BSD-style (see the file libraries/base/LICENSE) -- -- Maintainer : libraries@haskell.org -- Stability : experimental -- Portability : portable -- -- Abstract syntax definitions for Template Haskell. -- ----------------------------------------------------------------------------- module Language.Haskell.TH.Syntax ( module Language.Haskell.TH.Syntax -- * Language extensions , 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 ) import Data.Int import Data.List.NonEmpty ( NonEmpty(..) ) import Data.Void ( Void, absurd ) import Data.Word import Data.Ratio import GHC.Generics ( Generic ) import GHC.Lexeme ( startsVarSym, startsVarId ) import GHC.ForeignSrcLang.Type import Language.Haskell.TH.LanguageExtensions import Numeric.Natural import Prelude import qualified Control.Monad.Fail as Fail ----------------------------------------------------- -- -- The Quasi class -- ----------------------------------------------------- class (MonadIO m, Fail.MonadFail m) => Quasi m where qNewName :: String -> m Name -- ^ Fresh names -- Error reporting and recovery qReport :: Bool -> String -> m () -- ^ Report an error (True) or warning (False) -- ...but carry on; use 'fail' to stop qRecover :: m a -- ^ the error handler -> m a -- ^ action which may fail -> m a -- ^ Recover from the monadic 'fail' -- Inspect the type-checker's environment qLookupName :: Bool -> String -> m (Maybe Name) -- True <=> type namespace, False <=> value namespace qReify :: Name -> m Info qReifyFixity :: Name -> m (Maybe Fixity) qReifyInstances :: Name -> [Type] -> m [Dec] -- Is (n tys) an instance? -- Returns list of matching instance Decs -- (with empty sub-Decs) -- Works for classes and type functions 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 -- ^ Input/output (dangerous) 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] ----------------------------------------------------- -- The IO instance of Quasi -- -- This instance is used only when running a Q -- computation in the IO monad, usually just to -- print the result. There is no interesting -- type environment, so reification isn't going to -- work. -- ----------------------------------------------------- instance Quasi IO where qNewName :: String -> IO Name qNewName s :: String s = do { Int n <- IORef Int -> (Int -> (Int, Int)) -> IO Int forall a b. IORef a -> (a -> (a, b)) -> IO b atomicModifyIORef' IORef Int counter (\x :: Int x -> (Int x Int -> Int -> Int forall a. Num a => a -> a -> a + 1, Int x)) ; Name -> IO Name forall (f :: * -> *) a. Applicative f => a -> f a pure (String -> Int -> Name mkNameU String s Int n) } qReport :: Bool -> String -> IO () qReport True msg :: String msg = Handle -> String -> IO () hPutStrLn Handle stderr ("Template Haskell error: " String -> String -> String forall a. [a] -> [a] -> [a] ++ String msg) qReport False msg :: String msg = Handle -> String -> IO () hPutStrLn Handle stderr ("Template Haskell error: " String -> String -> String forall a. [a] -> [a] -> [a] ++ String msg) qLookupName :: Bool -> String -> IO (Maybe Name) qLookupName _ _ = String -> IO (Maybe Name) forall a. String -> IO a badIO "lookupName" qReify :: Name -> IO Info qReify _ = String -> IO Info forall a. String -> IO a badIO "reify" qReifyFixity :: Name -> IO (Maybe Fixity) qReifyFixity _ = String -> IO (Maybe Fixity) forall a. String -> IO a badIO "reifyFixity" qReifyInstances :: Name -> [Type] -> IO [Dec] qReifyInstances _ _ = String -> IO [Dec] forall a. String -> IO a badIO "reifyInstances" qReifyRoles :: Name -> IO [Role] qReifyRoles _ = String -> IO [Role] forall a. String -> IO a badIO "reifyRoles" qReifyAnnotations :: AnnLookup -> IO [a] qReifyAnnotations _ = String -> IO [a] forall a. String -> IO a badIO "reifyAnnotations" qReifyModule :: Module -> IO ModuleInfo qReifyModule _ = String -> IO ModuleInfo forall a. String -> IO a badIO "reifyModule" qReifyConStrictness :: Name -> IO [DecidedStrictness] qReifyConStrictness _ = String -> IO [DecidedStrictness] forall a. String -> IO a badIO "reifyConStrictness" qLocation :: IO Loc qLocation = String -> IO Loc forall a. String -> IO a badIO "currentLocation" qRecover :: IO a -> IO a -> IO a qRecover _ _ = String -> IO a forall a. String -> IO a badIO "recover" -- Maybe we could fix this? qAddDependentFile :: String -> IO () qAddDependentFile _ = String -> IO () forall a. String -> IO a badIO "addDependentFile" qAddTempFile :: String -> IO String qAddTempFile _ = String -> IO String forall a. String -> IO a badIO "addTempFile" qAddTopDecls :: [Dec] -> IO () qAddTopDecls _ = String -> IO () forall a. String -> IO a badIO "addTopDecls" qAddForeignFilePath :: ForeignSrcLang -> String -> IO () qAddForeignFilePath _ _ = String -> IO () forall a. String -> IO a badIO "addForeignFilePath" qAddModFinalizer :: Q () -> IO () qAddModFinalizer _ = String -> IO () forall a. String -> IO a badIO "addModFinalizer" qAddCorePlugin :: String -> IO () qAddCorePlugin _ = String -> IO () forall a. String -> IO a badIO "addCorePlugin" qGetQ :: IO (Maybe a) qGetQ = String -> IO (Maybe a) forall a. String -> IO a badIO "getQ" qPutQ :: a -> IO () qPutQ _ = String -> IO () forall a. String -> IO a badIO "putQ" qIsExtEnabled :: Extension -> IO Bool qIsExtEnabled _ = String -> IO Bool forall a. String -> IO a badIO "isExtEnabled" qExtsEnabled :: IO [Extension] qExtsEnabled = String -> IO [Extension] forall a. String -> IO a badIO "extsEnabled" badIO :: String -> IO a badIO :: String -> IO a badIO op :: String op = do { Bool -> String -> IO () forall (m :: * -> *). Quasi m => Bool -> String -> m () qReport Bool True ("Can't do `" String -> String -> String forall a. [a] -> [a] -> [a] ++ String op String -> String -> String forall a. [a] -> [a] -> [a] ++ "' in the IO monad") ; String -> IO a forall (m :: * -> *) a. MonadFail m => String -> m a fail "Template Haskell failure" } -- Global variable to generate unique symbols counter :: IORef Int {-# NOINLINE counter #-} counter :: IORef Int counter = IO (IORef Int) -> IORef Int forall a. IO a -> a unsafePerformIO (Int -> IO (IORef Int) forall a. a -> IO (IORef a) newIORef 0) ----------------------------------------------------- -- -- The Q monad -- ----------------------------------------------------- newtype Q a = Q { Q a -> forall (m :: * -> *). Quasi m => m a unQ :: forall m. Quasi m => m a } -- \"Runs\" the 'Q' monad. Normal users of Template Haskell -- should not need this function, as the splice brackets @$( ... )@ -- are the usual way of running a 'Q' computation. -- -- This function is primarily used in GHC internals, and for debugging -- splices by running them in 'IO'. -- -- Note that many functions in 'Q', such as 'reify' and other compiler -- queries, are not supported when running 'Q' in 'IO'; these operations -- simply fail at runtime. Indeed, the only operations guaranteed to succeed -- are 'newName', 'runIO', 'reportError' and 'reportWarning'. runQ :: Quasi m => Q a -> m a runQ :: Q a -> m a runQ (Q m :: forall (m :: * -> *). Quasi m => m a m) = m a forall (m :: * -> *). Quasi m => m a m instance Monad Q where Q m :: forall (m :: * -> *). Quasi m => m a m >>= :: Q a -> (a -> Q b) -> Q b >>= k :: 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 >>= \x :: 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 s :: 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 "Q monad failure") instance Functor Q where fmap :: (a -> b) -> Q a -> Q b fmap f :: a -> b f (Q x :: 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 x :: 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 f :: forall (m :: * -> *). Quasi m => m (a -> b) f <*> :: Q (a -> b) -> Q a -> Q b <*> Q x :: 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 m :: forall (m :: * -> *). Quasi m => m a m *> :: Q a -> Q b -> Q b *> Q n :: 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) ----------------------------------------------------- -- -- The TExp type -- ----------------------------------------------------- type role TExp nominal -- See Note [Role of TExp] newtype TExp a = TExp { TExp a -> Exp unType :: Exp } unTypeQ :: Q (TExp a) -> Q Exp unTypeQ :: Q (TExp a) -> Q Exp unTypeQ m :: Q (TExp a) m = do { TExp e :: Exp e <- Q (TExp a) m ; Exp -> Q Exp forall (m :: * -> *) a. Monad m => a -> m a return Exp e } unsafeTExpCoerce :: Q Exp -> Q (TExp a) unsafeTExpCoerce :: Q Exp -> Q (TExp a) unsafeTExpCoerce m :: 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) } {- Note [Role of TExp] ~~~~~~~~~~~~~~~~~~~~~~ TExp's argument must have a nominal role, not phantom as would be inferred (Trac #8459). Consider e :: TExp Age e = MkAge 3 foo = $(coerce e) + 4::Int The splice will evaluate to (MkAge 3) and you can't add that to 4::Int. So you can't coerce a (TExp Age) to a (TExp Int). -} ---------------------------------------------------- -- Packaged versions for the programmer, hiding the Quasi-ness {- | Generate a fresh name, which cannot be captured. For example, this: @f = $(do nm1 <- newName \"x\" let nm2 = 'mkName' \"x\" return ('LamE' ['VarP' nm1] (LamE [VarP nm2] ('VarE' nm1))) )@ will produce the splice >f = \x0 -> \x -> x0 In particular, the occurrence @VarE nm1@ refers to the binding @VarP nm1@, and is not captured by the binding @VarP nm2@. Although names generated by @newName@ cannot /be captured/, they can /capture/ other names. For example, this: >g = $(do > nm1 <- newName "x" > let nm2 = mkName "x" > return (LamE [VarP nm2] (LamE [VarP nm1] (VarE nm2))) > ) will produce the splice >g = \x -> \x0 -> x0 since the occurrence @VarE nm2@ is captured by the innermost binding of @x@, namely @VarP nm1@. -} newName :: String -> Q Name newName :: String -> Q Name newName s :: 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 an error (True) or warning (False), -- but carry on; use 'fail' to stop. report :: Bool -> String -> Q () report :: Bool -> String -> Q () report b :: Bool b s :: 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" #-} -- deprecated in 7.6 -- | Report an error to the user, but allow the current splice's computation to carry on. To abort the computation, use 'fail'. reportError :: String -> Q () reportError :: String -> Q () reportError = Bool -> String -> Q () report Bool True -- | Report a warning to the user, and carry on. reportWarning :: String -> Q () reportWarning :: String -> Q () reportWarning = Bool -> String -> Q () report Bool False -- | Recover from errors raised by 'reportError' or 'fail'. recover :: Q a -- ^ handler to invoke on failure -> Q a -- ^ computation to run -> Q a recover :: Q a -> Q a -> Q a recover (Q r :: forall (m :: * -> *). Quasi m => m a r) (Q m :: 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) -- We don't export lookupName; the Bool isn't a great API -- Instead we export lookupTypeName, lookupValueName lookupName :: Bool -> String -> Q (Maybe Name) lookupName :: Bool -> String -> Q (Maybe Name) lookupName ns :: Bool ns s :: 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) -- | Look up the given name in the (type namespace of the) current splice's scope. See "Language.Haskell.TH.Syntax#namelookup" for more details. lookupTypeName :: String -> Q (Maybe Name) lookupTypeName :: String -> Q (Maybe Name) lookupTypeName s :: 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) -- | Look up the given name in the (value namespace of the) current splice's scope. See "Language.Haskell.TH.Syntax#namelookup" for more details. lookupValueName :: String -> Q (Maybe Name) lookupValueName :: String -> Q (Maybe Name) lookupValueName s :: 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) {- Note [Name lookup] ~~~~~~~~~~~~~~~~~~ -} {- $namelookup #namelookup# The functions 'lookupTypeName' and 'lookupValueName' provide a way to query the current splice's context for what names are in scope. The function 'lookupTypeName' queries the type namespace, whereas 'lookupValueName' queries the value namespace, but the functions are otherwise identical. A call @lookupValueName s@ will check if there is a value with name @s@ in scope at the current splice's location. If there is, the @Name@ of this value is returned; if not, then @Nothing@ is returned. The returned name cannot be \"captured\". For example: > f = "global" > g = $( do > Just nm <- lookupValueName "f" > [| let f = "local" in $( varE nm ) |] In this case, @g = \"global\"@; the call to @lookupValueName@ returned the global @f@, and this name was /not/ captured by the local definition of @f@. The lookup is performed in the context of the /top-level/ splice being run. For example: > f = "global" > g = $( [| let f = "local" in > $(do > Just nm <- lookupValueName "f" > varE nm > ) |] ) Again in this example, @g = \"global\"@, because the call to @lookupValueName@ queries the context of the outer-most @$(...)@. Operators should be queried without any surrounding parentheses, like so: > lookupValueName "+" Qualified names are also supported, like so: > lookupValueName "Prelude.+" > lookupValueName "Prelude.map" -} {- | 'reify' looks up information about the 'Name'. It is sometimes useful to construct the argument name using 'lookupTypeName' or 'lookupValueName' to ensure that we are reifying from the right namespace. For instance, in this context: > data D = D which @D@ does @reify (mkName \"D\")@ return information about? (Answer: @D@-the-type, but don't rely on it.) To ensure we get information about @D@-the-value, use 'lookupValueName': > do > Just nm <- lookupValueName "D" > reify nm and to get information about @D@-the-type, use 'lookupTypeName'. -} reify :: Name -> Q Info reify :: Name -> Q Info reify v :: 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 nm@ attempts to find a fixity declaration for @nm@. For example, if the function @foo@ has the fixity declaration @infixr 7 foo@, then @reifyFixity 'foo@ would return @'Just' ('Fixity' 7 'InfixR')@. If the function @bar@ does not have a fixity declaration, then @reifyFixity 'bar@ returns 'Nothing', so you may assume @bar@ has 'defaultFixity'. -} reifyFixity :: Name -> Q (Maybe Fixity) reifyFixity :: Name -> Q (Maybe Fixity) reifyFixity nm :: 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) {- | @reifyInstances nm tys@ returns a list of visible instances of @nm tys@. That is, if @nm@ is the name of a type class, then all instances of this class at the types @tys@ are returned. Alternatively, if @nm@ is the name of a data family or type family, all instances of this family at the types @tys@ are returned. Note that this is a \"shallow\" test; the declarations returned merely have instance heads which unify with @nm tys@, they need not actually be satisfiable. - @reifyInstances ''Eq [ 'TupleT' 2 \``AppT`\` 'ConT' ''A \``AppT`\` 'ConT' ''B ]@ contains the @instance (Eq a, Eq b) => Eq (a, b)@ regardless of whether @A@ and @B@ themselves implement 'Eq' - @reifyInstances ''Show [ 'VarT' ('mkName' "a") ]@ produces every available instance of 'Eq' There is one edge case: @reifyInstances ''Typeable tys@ currently always produces an empty list (no matter what @tys@ are given). -} reifyInstances :: Name -> [Type] -> Q [InstanceDec] reifyInstances :: Name -> [Type] -> Q [Dec] reifyInstances cls :: Name cls tys :: [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 nm@ returns the list of roles associated with the parameters of the tycon @nm@. Fails if @nm@ cannot be found or is not a tycon. The returned list should never contain 'InferR'. -} reifyRoles :: Name -> Q [Role] reifyRoles :: Name -> Q [Role] reifyRoles nm :: 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 target@ returns the list of annotations -- associated with @target@. Only the annotations that are -- appropriately typed is returned. So if you have @Int@ and @String@ -- annotations for the same target, you have to call this function twice. reifyAnnotations :: Data a => AnnLookup -> Q [a] reifyAnnotations :: AnnLookup -> Q [a] reifyAnnotations an :: 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 mod@ looks up information about module @mod@. To -- look up the current module, call this function with the return -- value of 'Language.Haskell.TH.Lib.thisModule'. reifyModule :: Module -> Q ModuleInfo reifyModule :: Module -> Q ModuleInfo reifyModule m :: 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 nm@ looks up the strictness information for the fields -- of the constructor with the name @nm@. Note that the strictness information -- that 'reifyConStrictness' returns may not correspond to what is written in -- the source code. For example, in the following data declaration: -- -- @ -- data Pair a = Pair a a -- @ -- -- 'reifyConStrictness' would return @['DecidedLazy', DecidedLazy]@ under most -- circumstances, but it would return @['DecidedStrict', DecidedStrict]@ if the -- @-XStrictData@ language extension was enabled. reifyConStrictness :: Name -> Q [DecidedStrictness] reifyConStrictness :: Name -> Q [DecidedStrictness] reifyConStrictness n :: 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) -- | Is the list of instances returned by 'reifyInstances' nonempty? isInstance :: Name -> [Type] -> Q Bool isInstance :: Name -> [Type] -> Q Bool isInstance nm :: Name nm tys :: [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)) } -- | The location at which this computation is spliced. 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 -- |The 'runIO' function lets you run an I\/O computation in the 'Q' monad. -- Take care: you are guaranteed the ordering of calls to 'runIO' within -- a single 'Q' computation, but not about the order in which splices are run. -- -- Note: for various murky reasons, stdout and stderr handles are not -- necessarily flushed when the compiler finishes running, so you should -- flush them yourself. runIO :: IO a -> Q a runIO :: IO a -> Q a runIO m :: 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) -- | Record external files that runIO is using (dependent upon). -- The compiler can then recognize that it should re-compile the Haskell file -- when an external file changes. -- -- Expects an absolute file path. -- -- Notes: -- -- * ghc -M does not know about these dependencies - it does not execute TH. -- -- * The dependency is based on file content, not a modification time addDependentFile :: FilePath -> Q () addDependentFile :: String -> Q () addDependentFile fp :: 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) -- | Obtain a temporary file path with the given suffix. The compiler will -- delete this file after compilation. addTempFile :: String -> Q FilePath addTempFile :: String -> Q String addTempFile suffix :: 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) -- | Add additional top-level declarations. The added declarations will be type -- checked along with the current declaration group. addTopDecls :: [Dec] -> Q () addTopDecls :: [Dec] -> Q () addTopDecls ds :: [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" #-} -- deprecated in 8.6 -- | Emit a foreign file which will be compiled and linked to the object for -- the current module. Currently only languages that can be compiled with -- the C compiler are supported, and the flags passed as part of -optc will -- be also applied to the C compiler invocation that will compile them. -- -- Note that for non-C languages (for example C++) @extern "C"@ directives -- must be used to get symbols that we can access from Haskell. -- -- To get better errors, it is recommended to use #line pragmas when -- emitting C files, e.g. -- -- > {-# LANGUAGE CPP #-} -- > ... -- > addForeignSource LangC $ unlines -- > [ "#line " ++ show (__LINE__ + 1) ++ " " ++ show __FILE__ -- > , ... -- > ] addForeignSource :: ForeignSrcLang -> String -> Q () addForeignSource :: ForeignSrcLang -> String -> Q () addForeignSource lang :: ForeignSrcLang lang src :: String src = do let suffix :: String suffix = case ForeignSrcLang lang of LangC -> "c" LangCxx -> "cpp" LangObjc -> "m" LangObjcxx -> "mm" LangAsm -> "s" RawObject -> "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 -- | Same as 'addForeignSource', but expects to receive a path pointing to the -- foreign file instead of a 'String' of its contents. Consider using this in -- conjunction with 'addTempFile'. -- -- This is a good alternative to 'addForeignSource' when you are trying to -- directly link in an object file. addForeignFilePath :: ForeignSrcLang -> FilePath -> Q () addForeignFilePath :: ForeignSrcLang -> String -> Q () addForeignFilePath lang :: ForeignSrcLang lang fp :: 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) -- | Add a finalizer that will run in the Q monad after the current module has -- been type checked. This only makes sense when run within a top-level splice. -- -- The finalizer is given the local type environment at the splice point. Thus -- 'reify' is able to find the local definitions when executed inside the -- finalizer. addModFinalizer :: Q () -> Q () addModFinalizer :: Q () -> Q () addModFinalizer act :: 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)) -- | Adds a core plugin to the compilation pipeline. -- -- @addCorePlugin m@ has almost the same effect as passing @-fplugin=m@ to ghc -- in the command line. The major difference is that the plugin module @m@ -- must not belong to the current package. When TH executes, it is too late -- to tell the compiler that we needed to compile first a plugin module in the -- current package. addCorePlugin :: String -> Q () addCorePlugin :: String -> Q () addCorePlugin plugin :: 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) -- | Get state from the 'Q' monad. Note that the state is local to the -- Haskell module in which the Template Haskell expression is executed. 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 -- | Replace the state in the 'Q' monad. Note that the state is local to the -- Haskell module in which the Template Haskell expression is executed. putQ :: Typeable a => a -> Q () putQ :: a -> Q () putQ x :: 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) -- | Determine whether the given language extension is enabled in the 'Q' monad. isExtEnabled :: Extension -> Q Bool isExtEnabled :: Extension -> Q Bool isExtEnabled ext :: 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) -- | List all enabled language extensions. 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 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 ---------------------------------------------------- -- The following operations are used solely in DsMeta when desugaring brackets -- They are not necessary for the user, who can use ordinary return and (>>=) etc 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 ----------------------------------------------------- -- -- The Lift class -- ----------------------------------------------------- -- | A 'Lift' instance can have any of its values turned into a Template -- Haskell expression. This is needed when a value used within a Template -- Haskell quotation is bound outside the Oxford brackets (@[| ... |]@) but not -- at the top level. As an example: -- -- > add1 :: Int -> Q Exp -- > add1 x = [| x + 1 |] -- -- Template Haskell has no way of knowing what value @x@ will take on at -- splice-time, so it requires the type of @x@ to be an instance of 'Lift'. -- -- A 'Lift' instance must satisfy @$(lift x) ≡ x@ for all @x@, where @$(...)@ -- is a Template Haskell splice. -- -- 'Lift' instances can be derived automatically by use of the @-XDeriveLift@ -- GHC language extension: -- -- > {-# LANGUAGE DeriveLift #-} -- > module Foo where -- > -- > import Language.Haskell.TH.Syntax -- > -- > data Bar a = Bar1 a (Bar a) | Bar2 String -- > deriving Lift class Lift t where -- | Turn a value into a Template Haskell expression, suitable for use in -- a splice. lift :: t -> Q Exp default lift :: Data t => t -> Q Exp lift = t -> Q Exp forall a. Data a => a -> Q Exp liftData -- If you add any instances here, consider updating test th/TH_Lift instance Lift Integer where lift :: Integer -> Q Exp lift x :: Integer x = Exp -> Q Exp forall (m :: * -> *) a. Monad m => a -> m a return (Lit -> Exp LitE (Integer -> Lit IntegerL Integer x)) instance Lift Int where lift :: Int -> Q Exp lift x :: Int x = Exp -> Q Exp forall (m :: * -> *) a. Monad m => a -> m a return (Lit -> Exp LitE (Integer -> Lit IntegerL (Int -> Integer forall a b. (Integral a, Num b) => a -> b fromIntegral Int x))) instance Lift Int8 where lift :: Int8 -> Q Exp lift x :: Int8 x = Exp -> Q Exp forall (m :: * -> *) a. Monad m => a -> m a return (Lit -> Exp LitE (Integer -> Lit IntegerL (Int8 -> Integer forall a b. (Integral a, Num b) => a -> b fromIntegral Int8 x))) instance Lift Int16 where lift :: Int16 -> Q Exp lift x :: Int16 x = Exp -> Q Exp forall (m :: * -> *) a. Monad m => a -> m a return (Lit -> Exp LitE (Integer -> Lit IntegerL (Int16 -> Integer forall a b. (Integral a, Num b) => a -> b fromIntegral Int16 x))) instance Lift Int32 where lift :: Int32 -> Q Exp lift x :: Int32 x = Exp -> Q Exp forall (m :: * -> *) a. Monad m => a -> m a return (Lit -> Exp LitE (Integer -> Lit IntegerL (Int32 -> Integer forall a b. (Integral a, Num b) => a -> b fromIntegral Int32 x))) instance Lift Int64 where lift :: Int64 -> Q Exp lift x :: Int64 x = Exp -> Q Exp forall (m :: * -> *) a. Monad m => a -> m a return (Lit -> Exp LitE (Integer -> Lit IntegerL (Int64 -> Integer forall a b. (Integral a, Num b) => a -> b fromIntegral Int64 x))) instance Lift Word where lift :: Word -> Q Exp lift x :: Word x = Exp -> Q Exp forall (m :: * -> *) a. Monad m => a -> m a return (Lit -> Exp LitE (Integer -> Lit IntegerL (Word -> Integer forall a b. (Integral a, Num b) => a -> b fromIntegral Word x))) instance Lift Word8 where lift :: Word8 -> Q Exp lift x :: Word8 x = Exp -> Q Exp forall (m :: * -> *) a. Monad m => a -> m a return (Lit -> Exp LitE (Integer -> Lit IntegerL (Word8 -> Integer forall a b. (Integral a, Num b) => a -> b fromIntegral Word8 x))) instance Lift Word16 where lift :: Word16 -> Q Exp lift x :: Word16 x = Exp -> Q Exp forall (m :: * -> *) a. Monad m => a -> m a return (Lit -> Exp LitE (Integer -> Lit IntegerL (Word16 -> Integer forall a b. (Integral a, Num b) => a -> b fromIntegral Word16 x))) instance Lift Word32 where lift :: Word32 -> Q Exp lift x :: Word32 x = Exp -> Q Exp forall (m :: * -> *) a. Monad m => a -> m a return (Lit -> Exp LitE (Integer -> Lit IntegerL (Word32 -> Integer forall a b. (Integral a, Num b) => a -> b fromIntegral Word32 x))) instance Lift Word64 where lift :: Word64 -> Q Exp lift x :: Word64 x = Exp -> Q Exp forall (m :: * -> *) a. Monad m => a -> m a return (Lit -> Exp LitE (Integer -> Lit IntegerL (Word64 -> Integer forall a b. (Integral a, Num b) => a -> b fromIntegral Word64 x))) instance Lift Natural where lift :: Natural -> Q Exp lift x :: Natural x = Exp -> Q Exp forall (m :: * -> *) a. Monad m => a -> m a return (Lit -> Exp LitE (Integer -> Lit IntegerL (Natural -> Integer forall a b. (Integral a, Num b) => a -> b fromIntegral Natural x))) instance Integral a => Lift (Ratio a) where lift :: Ratio a -> Q Exp lift x :: 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 lift :: Float -> Q Exp lift x :: 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 Double where lift :: Double -> Q Exp lift x :: 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 Char where lift :: Char -> Q Exp lift x :: Char x = Exp -> Q Exp forall (m :: * -> *) a. Monad m => a -> m a return (Lit -> Exp LitE (Char -> Lit CharL Char x)) instance Lift Bool where lift :: Bool -> Q Exp lift True = Exp -> Q Exp forall (m :: * -> *) a. Monad m => a -> m a return (Name -> Exp ConE Name trueName) lift False = Exp -> Q Exp forall (m :: * -> *) a. Monad m => a -> m a return (Name -> Exp ConE Name falseName) instance Lift a => Lift (Maybe a) where lift :: Maybe a -> Q Exp lift Nothing = Exp -> Q Exp forall (m :: * -> *) a. Monad m => a -> m a return (Name -> Exp ConE Name nothingName) lift (Just x :: 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 lift :: Either a b -> Q Exp lift (Left x :: 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 y :: 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 lift :: [a] -> Q Exp lift xs :: [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 -- Used in TcExpr to short-circuit the lifting for strings liftString :: String -> Q Exp liftString s :: String s = Exp -> Q Exp forall (m :: * -> *) a. Monad m => a -> m a return (Lit -> Exp LitE (String -> Lit StringL String s)) -- | @since 2.15.0.0 instance Lift a => Lift (NonEmpty a) where lift :: NonEmpty a -> Q Exp lift (x :: a x :| xs :: [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')) -- | @since 2.15.0.0 instance Lift Void where 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 lift :: () -> Q Exp lift () = Exp -> Q Exp forall (m :: * -> *) a. Monad m => a -> m a return (Name -> Exp ConE (Int -> Name tupleDataName 0)) instance (Lift a, Lift b) => Lift (a, b) where lift :: (a, b) -> Q Exp lift (a :: a a, b :: b b) = ([Exp] -> Exp) -> Q [Exp] -> Q Exp forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r liftM [Exp] -> Exp TupE (Q [Exp] -> Q Exp) -> Q [Exp] -> Q Exp forall a b. (a -> b) -> a -> b $ [Q Exp] -> Q [Exp] forall (t :: * -> *) (m :: * -> *) a. (Traversable t, Monad m) => t (m a) -> m (t a) sequence [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 lift :: (a, b, c) -> Q Exp lift (a :: a a, b :: b b, c :: c c) = ([Exp] -> Exp) -> Q [Exp] -> Q Exp forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r liftM [Exp] -> Exp TupE (Q [Exp] -> Q Exp) -> Q [Exp] -> Q Exp forall a b. (a -> b) -> a -> b $ [Q Exp] -> Q [Exp] forall (t :: * -> *) (m :: * -> *) a. (Traversable t, Monad m) => t (m a) -> m (t a) sequence [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 lift :: (a, b, c, d) -> Q Exp lift (a :: a a, b :: b b, c :: c c, d :: d d) = ([Exp] -> Exp) -> Q [Exp] -> Q Exp forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r liftM [Exp] -> Exp TupE (Q [Exp] -> Q Exp) -> Q [Exp] -> Q Exp forall a b. (a -> b) -> a -> b $ [Q Exp] -> Q [Exp] forall (t :: * -> *) (m :: * -> *) a. (Traversable t, Monad m) => t (m a) -> m (t a) sequence [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 lift :: (a, b, c, d, e) -> Q Exp lift (a :: a a, b :: b b, c :: c c, d :: d d, e :: e e) = ([Exp] -> Exp) -> Q [Exp] -> Q Exp forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r liftM [Exp] -> Exp TupE (Q [Exp] -> Q Exp) -> Q [Exp] -> Q Exp forall a b. (a -> b) -> a -> b $ [Q Exp] -> Q [Exp] forall (t :: * -> *) (m :: * -> *) a. (Traversable t, Monad m) => t (m a) -> m (t a) sequence [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 lift :: (a, b, c, d, e, f) -> Q Exp lift (a :: a a, b :: b b, c :: c c, d :: d d, e :: e e, f :: f f) = ([Exp] -> Exp) -> Q [Exp] -> Q Exp forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r liftM [Exp] -> Exp TupE (Q [Exp] -> Q Exp) -> Q [Exp] -> Q Exp forall a b. (a -> b) -> a -> b $ [Q Exp] -> Q [Exp] forall (t :: * -> *) (m :: * -> *) a. (Traversable t, Monad m) => t (m a) -> m (t a) sequence [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 lift :: (a, b, c, d, e, f, g) -> Q Exp lift (a :: a a, b :: b b, c :: c c, d :: d d, e :: e e, f :: f f, g :: g g) = ([Exp] -> Exp) -> Q [Exp] -> Q Exp forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r liftM [Exp] -> Exp TupE (Q [Exp] -> Q Exp) -> Q [Exp] -> Q Exp forall a b. (a -> b) -> a -> b $ [Q Exp] -> Q [Exp] forall (t :: * -> *) (m :: * -> *) a. (Traversable t, Monad m) => t (m a) -> m (t a) sequence [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] -- TH has a special form for literal strings, -- which we should take advantage of. -- NB: the lhs of the rule has no args, so that -- the rule will apply to a 'lift' all on its own -- which happens to be the way the type checker -- creates it. {-# RULES "TH:liftString" lift = \s -> return (LitE (StringL s)) #-} trueName, falseName :: Name trueName :: Name trueName = NameSpace -> String -> String -> String -> Name mkNameG NameSpace DataName "ghc-prim" "GHC.Types" "True" falseName :: Name falseName = NameSpace -> String -> String -> String -> Name mkNameG NameSpace DataName "ghc-prim" "GHC.Types" "False" nothingName, justName :: Name nothingName :: Name nothingName = NameSpace -> String -> String -> String -> Name mkNameG NameSpace DataName "base" "GHC.Maybe" "Nothing" justName :: Name justName = NameSpace -> String -> String -> String -> Name mkNameG NameSpace DataName "base" "GHC.Maybe" "Just" leftName, rightName :: Name leftName :: Name leftName = NameSpace -> String -> String -> String -> Name mkNameG NameSpace DataName "base" "Data.Either" "Left" rightName :: Name rightName = NameSpace -> String -> String -> String -> Name mkNameG NameSpace DataName "base" "Data.Either" "Right" nonemptyName :: Name nonemptyName :: Name nonemptyName = NameSpace -> String -> String -> String -> Name mkNameG NameSpace DataName "base" "GHC.Base" ":|" ----------------------------------------------------- -- -- Generic Lift implementations -- ----------------------------------------------------- -- | 'dataToQa' is an internal utility function for constructing generic -- conversion functions from types with 'Data' instances to various -- quasi-quoting representations. See the source of 'dataToExpQ' and -- 'dataToPatQ' for two example usages: @mkCon@, @mkLit@ -- and @appQ@ are overloadable to account for different syntax for -- expressions and patterns; @antiQ@ allows you to override type-specific -- cases, a common usage is just @const Nothing@, which results in -- no overloading. 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 mkCon :: Name -> k mkCon mkLit :: Lit -> Q q mkLit appCon :: k -> [Q q] -> Q q appCon antiQ :: forall b. Data b => b -> Maybe (Q q) antiQ t :: a t = case a -> Maybe (Q q) forall b. Data b => b -> Maybe (Q q) antiQ a t of Nothing -> case Constr -> ConstrRep constrRep Constr constr of AlgConstr _ -> 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 "(:)" -> OccName -> NameFlavour -> Name Name (String -> OccName mkOccName ":") (NameSpace -> PkgName -> ModName -> NameFlavour NameG NameSpace DataName (String -> PkgName mkPkgName "ghc-prim") (String -> ModName mkModName "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 "ghc-prim") (String -> ModName mkModName "GHC.Types")) con :: String con@('(':_) -> OccName -> NameFlavour -> Name Name (String -> OccName mkOccName String con) (NameSpace -> PkgName -> ModName -> NameFlavour NameG NameSpace DataName (String -> PkgName mkPkgName "ghc-prim") (String -> ModName mkModName "GHC.Tuple")) -- Tricky case: see Note [Data for non-algebraic types] fun :: String fun@(x :: Char x:_) | 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 con :: 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 n :: Integer n -> Lit -> Q q mkLit (Lit -> Q q) -> Lit -> Q q forall a b. (a -> b) -> a -> b $ Integer -> Lit IntegerL Integer n FloatConstr n :: 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 c :: 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 y :: Q q y -> Q q y {- Note [Data for non-algebraic types] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Class Data was originally intended for algebraic data types. But it is possible to use it for abstract types too. For example, in package `text` we find instance Data Text where ... toConstr _ = packConstr packConstr :: Constr packConstr = mkConstr textDataType "pack" [] Prefix Here `packConstr` isn't a real data constructor, it's an ordinary function. Two complications * In such a case, we must take care to build the Name using mkNameG_v (for values), not mkNameG_d (for data constructors). See Trac #10796. * The pseudo-constructor is named only by its string, here "pack". But 'dataToQa' needs the TyCon of its defining module, and has to assume it's defined in the same module as the TyCon itself. But nothing enforces that; Trac #12596 shows what goes wrong if "pack" is defined in a different module than the data type "Text". -} -- | 'dataToExpQ' converts a value to a 'Q Exp' representation of the -- same value, in the SYB style. It is generalized to take a function -- override type-specific cases; see 'liftData' for a more commonly -- used variant. 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 -- Make sure that VarE is used if the Constr value relies on a -- function underneath the surface (instead of a constructor). -- See Trac #10796. varOrConE :: Name -> m Exp varOrConE s :: Name s = case Name -> Maybe NameSpace nameSpace Name s of Just VarName -> Exp -> m Exp forall (m :: * -> *) a. Monad m => a -> m a return (Name -> Exp VarE Name s) Just DataName -> Exp -> m Exp forall (m :: * -> *) a. Monad m => a -> m a return (Name -> Exp ConE Name s) _ -> 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 $ "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 x :: m Exp x y :: 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 c :: Lit c = Exp -> m Exp forall (m :: * -> *) a. Monad m => a -> m a return (Lit -> Exp LitE Lit c) -- | 'liftData' is a variant of 'lift' in the 'Lift' type class which -- works for any type with a 'Data' instance. 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' converts a value to a 'Q Pat' representation of the same -- value, in the SYB style. It takes a function to handle type-specific cases, -- alternatively, pass @const Nothing@ to get default behavior. 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 l :: 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 n :: Name n ps :: [m Pat] ps = case Name -> Maybe NameSpace nameSpace Name n of Just 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') _ -> 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 $ "Can't construct a pattern from name " String -> String -> String forall a. [a] -> [a] -> [a] ++ Name -> String showName Name n ----------------------------------------------------- -- Names and uniques ----------------------------------------------------- newtype ModName = ModName String -- Module name 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 -- package name 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) -- | Obtained from 'reifyModule' and 'Language.Haskell.TH.Lib.thisModule'. data Module = Module PkgName ModName -- package qualified module name 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 s :: String s = String -> ModName ModName String s modString :: ModName -> String modString :: ModName -> String modString (ModName m :: String m) = String m mkPkgName :: String -> PkgName mkPkgName :: String -> PkgName mkPkgName s :: String s = String -> PkgName PkgName String s pkgString :: PkgName -> String pkgString :: PkgName -> String pkgString (PkgName m :: String m) = String m ----------------------------------------------------- -- OccName ----------------------------------------------------- mkOccName :: String -> OccName mkOccName :: String -> OccName mkOccName s :: String s = String -> OccName OccName String s occString :: OccName -> String occString :: OccName -> String occString (OccName occ :: String occ) = String occ ----------------------------------------------------- -- Names ----------------------------------------------------- -- -- For "global" names ('NameG') we need a totally unique name, -- so we must include the name-space of the thing -- -- For unique-numbered things ('NameU'), we've got a unique reference -- anyway, so no need for name space -- -- For dynamically bound thing ('NameS') we probably want them to -- in a context-dependent way, so again we don't want the name -- space. For example: -- -- > let v = mkName "T" in [| data $v = $v |] -- -- Here we use the same Name for both type constructor and data constructor -- -- -- NameL and NameG are bound *outside* the TH syntax tree -- either globally (NameG) or locally (NameL). Ex: -- -- > f x = $(h [| (map, x) |]) -- -- The 'map' will be a NameG, and 'x' wil be a NameL -- -- These Names should never appear in a binding position in a TH syntax tree {- $namecapture #namecapture# Much of 'Name' API is concerned with the problem of /name capture/, which can be seen in the following example. > f expr = [| let x = 0 in $expr |] > ... > g x = $( f [| x |] ) > h y = $( f [| y |] ) A naive desugaring of this would yield: > g x = let x = 0 in x > h y = let x = 0 in y All of a sudden, @g@ and @h@ have different meanings! In this case, we say that the @x@ in the RHS of @g@ has been /captured/ by the binding of @x@ in @f@. What we actually want is for the @x@ in @f@ to be distinct from the @x@ in @g@, so we get the following desugaring: > g x = let x' = 0 in x > h y = let x' = 0 in y which avoids name capture as desired. In the general case, we say that a @Name@ can be captured if the thing it refers to can be changed by adding new declarations. -} {- | An abstract type representing names in the syntax tree. 'Name's can be constructed in several ways, which come with different name-capture guarantees (see "Language.Haskell.TH.Syntax#namecapture" for an explanation of name capture): * the built-in syntax @'f@ and @''T@ can be used to construct names, The expression @'f@ gives a @Name@ which refers to the value @f@ currently in scope, and @''T@ gives a @Name@ which refers to the type @T@ currently in scope. These names can never be captured. * 'lookupValueName' and 'lookupTypeName' are similar to @'f@ and @''T@ respectively, but the @Name@s are looked up at the point where the current splice is being run. These names can never be captured. * 'newName' monadically generates a new name, which can never be captured. * 'mkName' generates a capturable name. Names constructed using @newName@ and @mkName@ may be used in bindings (such as @let x = ...@ or @\x -> ...@), but names constructed using @lookupValueName@, @lookupTypeName@, @'f@, @''T@ may not. -} 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 -- check if unique is different before looking at strings (Name o1 :: OccName o1 f1 :: NameFlavour f1) compare :: Name -> Name -> Ordering `compare` (Name o2 :: OccName o2 f2 :: 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 -- ^ An unqualified name; dynamically bound | NameQ ModName -- ^ A qualified name; dynamically bound | NameU !Int -- ^ A unique local name | NameL !Int -- ^ Local name bound outside of the TH AST | NameG NameSpace PkgName ModName -- ^ Global name bound outside of the TH AST: -- An original name (occurrences only, not binders) -- Need the namespace too to be sure which -- thing we are naming 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 -- ^ Variables | DataName -- ^ Data constructors | TcClsName -- ^ Type constructors and classes; Haskell has them -- in the same name space for now. 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 = Int -- | The name without its module prefix. -- -- ==== __Examples__ -- -- >>> nameBase ''Data.Either.Either -- "Either" -- >>> nameBase (mkName "foo") -- "foo" -- >>> nameBase (mkName "Module.foo") -- "foo" nameBase :: Name -> String nameBase :: Name -> String nameBase (Name occ :: OccName occ _) = OccName -> String occString OccName occ -- | Module prefix of a name, if it exists. -- -- ==== __Examples__ -- -- >>> nameModule ''Data.Either.Either -- Just "Data.Either" -- >>> nameModule (mkName "foo") -- Nothing -- >>> nameModule (mkName "Module.foo") -- Just "Module" nameModule :: Name -> Maybe String nameModule :: Name -> Maybe String nameModule (Name _ (NameQ m :: ModName m)) = String -> Maybe String forall a. a -> Maybe a Just (ModName -> String modString ModName m) nameModule (Name _ (NameG _ _ m :: ModName m)) = String -> Maybe String forall a. a -> Maybe a Just (ModName -> String modString ModName m) nameModule _ = Maybe String forall a. Maybe a Nothing -- | A name's package, if it exists. -- -- ==== __Examples__ -- -- >>> namePackage ''Data.Either.Either -- Just "base" -- >>> namePackage (mkName "foo") -- Nothing -- >>> namePackage (mkName "Module.foo") -- Nothing namePackage :: Name -> Maybe String namePackage :: Name -> Maybe String namePackage (Name _ (NameG _ p :: PkgName p _)) = String -> Maybe String forall a. a -> Maybe a Just (PkgName -> String pkgString PkgName p) namePackage _ = Maybe String forall a. Maybe a Nothing -- | Returns whether a name represents an occurrence of a top-level variable -- ('VarName'), data constructor ('DataName'), type constructor, or type class -- ('TcClsName'). If we can't be sure, it returns 'Nothing'. -- -- ==== __Examples__ -- -- >>> nameSpace 'Prelude.id -- Just VarName -- >>> nameSpace (mkName "id") -- Nothing -- only works for top-level variable names -- >>> nameSpace 'Data.Maybe.Just -- Just DataName -- >>> nameSpace ''Data.Maybe.Maybe -- Just TcClsName -- >>> nameSpace ''Data.Ord.Ord -- Just TcClsName nameSpace :: Name -> Maybe NameSpace nameSpace :: Name -> Maybe NameSpace nameSpace (Name _ (NameG ns :: NameSpace ns _ _)) = NameSpace -> Maybe NameSpace forall a. a -> Maybe a Just NameSpace ns nameSpace _ = Maybe NameSpace forall a. Maybe a Nothing {- | Generate a capturable name. Occurrences of such names will be resolved according to the Haskell scoping rules at the occurrence site. For example: > f = [| pi + $(varE (mkName "pi")) |] > ... > g = let pi = 3 in $f In this case, @g@ is desugared to > g = Prelude.pi + 3 Note that @mkName@ may be used with qualified names: > mkName "Prelude.pi" See also 'Language.Haskell.TH.Lib.dyn' for a useful combinator. The above example could be rewritten using 'Language.Haskell.TH.Lib.dyn' as > f = [| pi + $(dyn "pi") |] -} mkName :: String -> Name -- The string can have a '.', thus "Foo.baz", -- giving a dynamically-bound qualified name, -- in which case we want to generate a NameQ -- -- Parse the string to see if it has a "." in it -- so we know whether to generate a qualified or unqualified name -- It's a bit tricky because we need to parse -- -- > Foo.Baz.x as Qual Foo.Baz x -- -- So we parse it from back to front mkName :: String -> Name mkName str :: String str = String -> String -> Name split [] (String -> String forall a. [a] -> [a] reverse String str) where split :: String -> String -> Name split occ :: String occ [] = OccName -> NameFlavour -> Name Name (String -> OccName mkOccName String occ) NameFlavour NameS split occ :: String occ ('.':rev :: 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))) -- The 'not (null occ)' guard ensures that -- mkName "&." = Name "&." NameS -- The 'is_rev_mod' guards ensure that -- mkName ".&" = Name ".&" NameS -- mkName "^.." = Name "^.." NameS -- Trac #8633 -- mkName "Data.Bits..&" = Name ".&" (NameQ "Data.Bits") -- This rather bizarre case actually happened; (.&.) is in Data.Bits split occ :: String occ (c :: Char c:rev :: String rev) = String -> String -> Name split (Char cChar -> String -> String forall a. a -> [a] -> [a] :String occ) String rev -- Recognises a reversed module name xA.yB.C, -- with at least one component, -- and each component looks like a module name -- (i.e. non-empty, starts with capital, all alpha) is_rev_mod_name :: String -> Bool is_rev_mod_name rev_mod_str :: String rev_mod_str | (compt :: String compt, rest :: 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 == '.') 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 (_dot :: Char _dot : rest' :: String rest') -> String -> Bool is_rev_mod_name String rest' | Bool otherwise = Bool False is_mod_char :: Char -> Bool is_mod_char c :: Char c = Char -> Bool isAlphaNum Char c Bool -> Bool -> Bool || Char c Char -> Char -> Bool forall a. Eq a => a -> a -> Bool == '_' Bool -> Bool -> Bool || Char c Char -> Char -> Bool forall a. Eq a => a -> a -> Bool == '\'' -- | Only used internally mkNameU :: String -> Uniq -> Name mkNameU :: String -> Int -> Name mkNameU s :: String s u :: Int u = OccName -> NameFlavour -> Name Name (String -> OccName mkOccName String s) (Int -> NameFlavour NameU Int u) -- | Only used internally mkNameL :: String -> Uniq -> Name mkNameL :: String -> Int -> Name mkNameL s :: String s u :: Int u = OccName -> NameFlavour -> Name Name (String -> OccName mkOccName String s) (Int -> NameFlavour NameL Int u) -- | Used for 'x etc, but not available to the programmer mkNameG :: NameSpace -> String -> String -> String -> Name mkNameG :: NameSpace -> String -> String -> String -> Name mkNameG ns :: NameSpace ns pkg :: String pkg modu :: String modu occ :: 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 n :: 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' ni :: NameIs ni nm :: Name nm = case NameIs ni of Alone -> String nms Applied | Bool pnam -> String nms | Bool otherwise -> "(" String -> String -> String forall a. [a] -> [a] -> [a] ++ String nms String -> String -> String forall a. [a] -> [a] -> [a] ++ ")" Infix | Bool pnam -> "`" String -> String -> String forall a. [a] -> [a] -> [a] ++ String nms String -> String -> String forall a. [a] -> [a] -> [a] ++ "`" | Bool otherwise -> String nms where -- For now, we make the NameQ and NameG print the same, even though -- NameQ is a qualified name (so what it means depends on what the -- current scope is), and NameG is an original name (so its meaning -- should be independent of what's in scope. -- We may well want to distinguish them in the end. -- Ditto NameU and NameL nms :: String nms = case Name nm of Name occ :: OccName occ NameS -> OccName -> String occString OccName occ Name occ :: OccName occ (NameQ m :: ModName m) -> ModName -> String modString ModName m String -> String -> String forall a. [a] -> [a] -> [a] ++ "." String -> String -> String forall a. [a] -> [a] -> [a] ++ OccName -> String occString OccName occ Name occ :: OccName occ (NameG _ _ m :: ModName m) -> ModName -> String modString ModName m String -> String -> String forall a. [a] -> [a] -> [a] ++ "." String -> String -> String forall a. [a] -> [a] -> [a] ++ OccName -> String occString OccName occ Name occ :: OccName occ (NameU u :: Int u) -> OccName -> String occString OccName occ String -> String -> String forall a. [a] -> [a] -> [a] ++ "_" String -> String -> String forall a. [a] -> [a] -> [a] ++ Int -> String forall a. Show a => a -> String show Int u Name occ :: OccName occ (NameL u :: Int u) -> OccName -> String occString OccName occ String -> String -> String forall a. [a] -> [a] -> [a] ++ "_" String -> String -> String forall a. [a] -> [a] -> [a] ++ Int -> String forall a. Show a => a -> String show Int u pnam :: Bool pnam = String -> Bool classify String nms -- True if we are function style, e.g. f, [], (,) -- False if we are operator style, e.g. +, :+ classify :: String -> Bool classify "" = Bool False -- shouldn't happen; . operator is handled below classify (x :: Char x:xs :: 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` "_[]()") = case (Char -> Bool) -> String -> String forall a. (a -> Bool) -> [a] -> [a] dropWhile (Char -> Char -> Bool forall a. Eq a => a -> a -> Bool /='.') String xs of (_:xs' :: String xs') -> String -> Bool classify String xs' [] -> Bool True | Bool otherwise = Bool False instance Show Name where show :: Name -> String show = Name -> String showName -- Tuple data and type constructors -- | Tuple data constructor tupleDataName :: Int -> Name -- | Tuple type constructor tupleTypeName :: Int -> Name tupleDataName :: Int -> Name tupleDataName 0 = Int -> NameSpace -> Name mk_tup_name 0 NameSpace DataName tupleDataName 1 = String -> Name forall a. HasCallStack => String -> a error "tupleDataName 1" tupleDataName n :: Int n = Int -> NameSpace -> Name mk_tup_name (Int nInt -> Int -> Int forall a. Num a => a -> a -> a -1) NameSpace DataName tupleTypeName :: Int -> Name tupleTypeName 0 = Int -> NameSpace -> Name mk_tup_name 0 NameSpace TcClsName tupleTypeName 1 = String -> Name forall a. HasCallStack => String -> a error "tupleTypeName 1" tupleTypeName n :: Int n = Int -> NameSpace -> Name mk_tup_name (Int nInt -> Int -> Int forall a. Num a => a -> a -> a -1) NameSpace TcClsName mk_tup_name :: Int -> NameSpace -> Name mk_tup_name :: Int -> NameSpace -> Name mk_tup_name n_commas :: Int n_commas space :: NameSpace space = OccName -> NameFlavour -> Name Name OccName occ (NameSpace -> PkgName -> ModName -> NameFlavour NameG NameSpace space (String -> PkgName mkPkgName "ghc-prim") ModName tup_mod) where occ :: OccName occ = String -> OccName mkOccName ('(' Char -> String -> String forall a. a -> [a] -> [a] : Int -> Char -> String forall a. Int -> a -> [a] replicate Int n_commas ',' String -> String -> String forall a. [a] -> [a] -> [a] ++ ")") tup_mod :: ModName tup_mod = String -> ModName mkModName "GHC.Tuple" -- Unboxed tuple data and type constructors -- | Unboxed tuple data constructor unboxedTupleDataName :: Int -> Name -- | Unboxed tuple type constructor unboxedTupleTypeName :: Int -> Name unboxedTupleDataName :: Int -> Name unboxedTupleDataName n :: Int n = Int -> NameSpace -> Name mk_unboxed_tup_name Int n NameSpace DataName unboxedTupleTypeName :: Int -> Name unboxedTupleTypeName n :: Int n = Int -> NameSpace -> Name mk_unboxed_tup_name Int n NameSpace TcClsName mk_unboxed_tup_name :: Int -> NameSpace -> Name mk_unboxed_tup_name :: Int -> NameSpace -> Name mk_unboxed_tup_name n :: Int n space :: NameSpace space = OccName -> NameFlavour -> Name Name (String -> OccName mkOccName String tup_occ) (NameSpace -> PkgName -> ModName -> NameFlavour NameG NameSpace space (String -> PkgName mkPkgName "ghc-prim") ModName tup_mod) where tup_occ :: String tup_occ | Int n Int -> Int -> Bool forall a. Eq a => a -> a -> Bool == 1 = "Unit#" -- See Note [One-tuples] in TysWiredIn | Bool otherwise = "(#" String -> String -> String forall a. [a] -> [a] -> [a] ++ Int -> Char -> String forall a. Int -> a -> [a] replicate Int n_commas ',' String -> String -> String forall a. [a] -> [a] -> [a] ++ "#)" n_commas :: Int n_commas = Int n Int -> Int -> Int forall a. Num a => a -> a -> a - 1 tup_mod :: ModName tup_mod = String -> ModName mkModName "GHC.Tuple" -- Unboxed sum data and type constructors -- | Unboxed sum data constructor unboxedSumDataName :: SumAlt -> SumArity -> Name -- | Unboxed sum type constructor unboxedSumTypeName :: SumArity -> Name unboxedSumDataName :: Int -> Int -> Name unboxedSumDataName alt :: Int alt arity :: 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] ++ "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 <= 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] ++ "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 < 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] ++ "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 "ghc-prim") (String -> ModName mkModName "GHC.Prim")) where prefix :: String prefix = "unboxedSumDataName: " debug_info :: String debug_info = " (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] ++ ", 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] ++ ")" -- Synced with the definition of mkSumDataConOcc in TysWiredIn sum_occ :: String sum_occ = '(' Char -> String -> String forall a. a -> [a] -> [a] : '#' Char -> String -> String forall a. a -> [a] -> [a] : Int -> String bars Int nbars_before String -> String -> String forall a. [a] -> [a] -> [a] ++ '_' Char -> String -> String forall a. a -> [a] -> [a] : Int -> String bars Int nbars_after String -> String -> String forall a. [a] -> [a] -> [a] ++ "#)" bars :: Int -> String bars i :: Int i = Int -> Char -> String forall a. Int -> a -> [a] replicate Int i '|' nbars_before :: Int nbars_before = Int alt Int -> Int -> Int forall a. Num a => a -> a -> a - 1 nbars_after :: Int nbars_after = Int arity Int -> Int -> Int forall a. Num a => a -> a -> a - Int alt unboxedSumTypeName :: Int -> Name unboxedSumTypeName arity :: Int arity | Int arity Int -> Int -> Bool forall a. Ord a => a -> a -> Bool < 2 = String -> Name forall a. HasCallStack => String -> a error (String -> Name) -> String -> Name forall a b. (a -> b) -> a -> b $ "unboxedSumTypeName: Arity must be >= 2." String -> String -> String forall a. [a] -> [a] -> [a] ++ " (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] ++ ")" | Bool otherwise = OccName -> NameFlavour -> Name Name (String -> OccName mkOccName String sum_occ) (NameSpace -> PkgName -> ModName -> NameFlavour NameG NameSpace TcClsName (String -> PkgName mkPkgName "ghc-prim") (String -> ModName mkModName "GHC.Prim")) where -- Synced with the definition of mkSumTyConOcc in TysWiredIn sum_occ :: String sum_occ = '(' Char -> String -> String forall a. a -> [a] -> [a] : '#' 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 - 1) '|' String -> String -> String forall a. [a] -> [a] -> [a] ++ "#)" ----------------------------------------------------- -- Locations ----------------------------------------------------- data Loc = Loc { Loc -> String loc_filename :: String , Loc -> String loc_package :: String , Loc -> String loc_module :: String , Loc -> (Int, Int) loc_start :: CharPos , Loc -> (Int, Int) 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) -- ^ Line and character position ----------------------------------------------------- -- -- The Info returned by reification -- ----------------------------------------------------- -- | Obtained from 'reify' in the 'Q' Monad. data Info = -- | A class, with a list of its visible instances ClassI Dec [InstanceDec] -- | A class method | ClassOpI Name Type ParentName -- | A \"plain\" type constructor. \"Fancier\" type constructors are returned -- using 'PrimTyConI' or 'FamilyI' as appropriate. At present, this reified -- declaration will never have derived instances attached to it (if you wish -- to check for an instance, see 'reifyInstances'). | TyConI Dec -- | A type or data family, with a list of its visible instances. A closed -- type family is returned with 0 instances. | FamilyI Dec [InstanceDec] -- | A \"primitive\" type constructor, which can't be expressed with a 'Dec'. -- Examples: @(->)@, @Int#@. | PrimTyConI Name Arity Unlifted -- | A data constructor | DataConI Name Type ParentName -- | A pattern synonym | PatSynI Name PatSynType {- | A \"value\" variable (as opposed to a type variable, see 'TyVarI'). The @Maybe Dec@ field contains @Just@ the declaration which defined the variable - including the RHS of the declaration - or else @Nothing@, in the case where the RHS is unavailable to the compiler. At present, this value is /always/ @Nothing@: returning the RHS has not yet been implemented because of lack of interest. -} | VarI Name Type (Maybe Dec) {- | A type variable. The @Type@ field contains the type which underlies the variable. At present, this is always @'VarT' theName@, but future changes may permit refinement of this. -} | TyVarI -- Scoped type variable Name Type -- What it is bound to 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 ) -- | Obtained from 'reifyModule' in the 'Q' Monad. data ModuleInfo = -- | Contains the import list of the module. 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 ) {- | In 'ClassOpI' and 'DataConI', name of the parent class or type -} type ParentName = Name -- | In 'UnboxedSumE' and 'UnboxedSumP', the number associated with a -- particular data constructor. 'SumAlt's are one-indexed and should never -- exceed the value of its corresponding 'SumArity'. For example: -- -- * @(\#_|\#)@ has 'SumAlt' 1 (out of a total 'SumArity' of 2) -- -- * @(\#|_\#)@ has 'SumAlt' 2 (out of a total 'SumArity' of 2) type SumAlt = Int -- | In 'UnboxedSumE', 'UnboxedSumT', and 'UnboxedSumP', the total number of -- 'SumAlt's. For example, @(\#|\#)@ has a 'SumArity' of 2. type SumArity = Int -- | In 'PrimTyConI', arity of the type constructor type Arity = Int -- | In 'PrimTyConI', is the type constructor unlifted? type Unlifted = Bool -- | 'InstanceDec' desribes a single instance of a class or type function. -- It is just a 'Dec', but guaranteed to be one of the following: -- -- * 'InstanceD' (with empty @['Dec']@) -- -- * 'DataInstD' or 'NewtypeInstD' (with empty derived @['Name']@) -- -- * 'TySynInstD' 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 ) -- | Highest allowed operator precedence for 'Fixity' constructor (answer: 9) maxPrecedence :: Int maxPrecedence :: Int maxPrecedence = (9::Int) -- | Default fixity: @infixl 9@ defaultFixity :: Fixity defaultFixity :: Fixity defaultFixity = Int -> FixityDirection -> Fixity Fixity Int maxPrecedence FixityDirection InfixL {- Note [Unresolved infix] ~~~~~~~~~~~~~~~~~~~~~~~ -} {- $infix #infix# When implementing antiquotation for quasiquoters, one often wants to parse strings into expressions: > parse :: String -> Maybe Exp But how should we parse @a + b * c@? If we don't know the fixities of @+@ and @*@, we don't know whether to parse it as @a + (b * c)@ or @(a + b) * c@. In cases like this, use 'UInfixE', 'UInfixP', or 'UInfixT', which stand for \"unresolved infix expression/pattern/type\", respectively. When the compiler is given a splice containing a tree of @UInfixE@ applications such as > UInfixE > (UInfixE e1 op1 e2) > op2 > (UInfixE e3 op3 e4) it will look up and the fixities of the relevant operators and reassociate the tree as necessary. * trees will not be reassociated across 'ParensE', 'ParensP', or 'ParensT', which are of use for parsing expressions like > (a + b * c) + d * e * 'InfixE', 'InfixP', and 'InfixT' expressions are never reassociated. * The 'UInfixE' constructor doesn't support sections. Sections such as @(a *)@ have no ambiguity, so 'InfixE' suffices. For longer sections such as @(a + b * c -)@, use an 'InfixE' constructor for the outer-most section, and use 'UInfixE' constructors for all other operators: > InfixE > Just (UInfixE ...a + b * c...) > op > Nothing Sections such as @(a + b +)@ and @((a + b) +)@ should be rendered into 'Exp's differently: > (+ a + b) ---> InfixE Nothing + (Just $ UInfixE a + b) > -- will result in a fixity error if (+) is left-infix > (+ (a + b)) ---> InfixE Nothing + (Just $ ParensE $ UInfixE a + b) > -- no fixity errors * Quoted expressions such as > [| a * b + c |] :: Q Exp > [p| a : b : c |] :: Q Pat > [t| T + T |] :: Q Type will never contain 'UInfixE', 'UInfixP', 'UInfixT', 'InfixT', 'ParensE', 'ParensP', or 'ParensT' constructors. -} ----------------------------------------------------- -- -- The main syntax data types -- ----------------------------------------------------- data Lit = CharL Char | StringL String | IntegerL Integer -- ^ Used for overloaded and non-overloaded -- literals. We don't have a good way to -- represent non-overloaded literals at -- the moment. Maybe that doesn't matter? | RationalL Rational -- Ditto | IntPrimL Integer | WordPrimL Integer | FloatPrimL Rational | DoublePrimL Rational | StringPrimL [Word8] -- ^ A primitive C-style string, type Addr# | 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 $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 ) -- We could add Int, Float, Double etc, as we do in HsLit, -- but that could complicate the -- supposedly-simple TH.Syntax literal type -- | Pattern in Haskell given in @{}@ data Pat = LitP Lit -- ^ @{ 5 or \'c\' }@ | VarP Name -- ^ @{ x }@ | TupP [Pat] -- ^ @{ (p1,p2) }@ | UnboxedTupP [Pat] -- ^ @{ (\# p1,p2 \#) }@ | UnboxedSumP Pat SumAlt SumArity -- ^ @{ (\#|p|\#) }@ | ConP Name [Pat] -- ^ @data T1 = C1 t1 t2; {C1 p1 p1} = e@ | InfixP Pat Name Pat -- ^ @foo ({x :+ y}) = e@ | UInfixP Pat Name Pat -- ^ @foo ({x :+ y}) = e@ -- -- See "Language.Haskell.TH.Syntax#infix" | ParensP Pat -- ^ @{(p)}@ -- -- See "Language.Haskell.TH.Syntax#infix" | TildeP Pat -- ^ @{ ~p }@ | BangP Pat -- ^ @{ !p }@ | AsP Name Pat -- ^ @{ x \@ p }@ | WildP -- ^ @{ _ }@ | RecP Name [FieldPat] -- ^ @f (Pt { pointx = x }) = g x@ | ListP [ Pat ] -- ^ @{ [1,2,3] }@ | SigP Pat Type -- ^ @{ p :: t }@ | ViewP Exp Pat -- ^ @{ e -> p }@ 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] -- ^ @case e of { pat -> body where decs }@ 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] -- ^ @f { p1 p2 = body where decs }@ 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 -- ^ @{ x }@ | ConE Name -- ^ @data T1 = C1 t1 t2; p = {C1} e1 e2 @ | LitE Lit -- ^ @{ 5 or \'c\'}@ | AppE Exp Exp -- ^ @{ f x }@ | AppTypeE Exp Type -- ^ @{ f \@Int }@ | InfixE (Maybe Exp) Exp (Maybe Exp) -- ^ @{x + y} or {(x+)} or {(+ x)} or {(+)}@ -- It's a bit gruesome to use an Exp as the -- operator, but how else can we distinguish -- constructors from non-constructors? -- Maybe there should be a var-or-con type? -- Or maybe we should leave it to the String itself? | UInfixE Exp Exp Exp -- ^ @{x + y}@ -- -- See "Language.Haskell.TH.Syntax#infix" | ParensE Exp -- ^ @{ (e) }@ -- -- See "Language.Haskell.TH.Syntax#infix" | LamE [Pat] Exp -- ^ @{ \\ p1 p2 -> e }@ | LamCaseE [Match] -- ^ @{ \\case m1; m2 }@ | TupE [Exp] -- ^ @{ (e1,e2) } @ | UnboxedTupE [Exp] -- ^ @{ (\# e1,e2 \#) } @ | UnboxedSumE Exp SumAlt SumArity -- ^ @{ (\#|e|\#) }@ | CondE Exp Exp Exp -- ^ @{ if e1 then e2 else e3 }@ | MultiIfE [(Guard, Exp)] -- ^ @{ if | g1 -> e1 | g2 -> e2 }@ | LetE [Dec] Exp -- ^ @{ let { x=e1; y=e2 } in e3 }@ | CaseE Exp [Match] -- ^ @{ case e of m1; m2 }@ | DoE [Stmt] -- ^ @{ do { p <- e1; e2 } }@ | MDoE [Stmt] -- ^ @{ mdo { x <- e1 y; y <- e2 x; } }@ | CompE [Stmt] -- ^ @{ [ (x,y) | x <- xs, y <- ys ] }@ -- -- The result expression of the comprehension is -- the /last/ of the @'Stmt'@s, and should be a 'NoBindS'. -- -- E.g. translation: -- -- > [ f x | x <- xs ] -- -- > CompE [BindS (VarP x) (VarE xs), NoBindS (AppE (VarE f) (VarE x))] | ArithSeqE Range -- ^ @{ [ 1 ,2 .. 10 ] }@ | ListE [ Exp ] -- ^ @{ [1,2,3] }@ | SigE Exp Type -- ^ @{ e :: t }@ | RecConE Name [FieldExp] -- ^ @{ T { x = y, z = w } }@ | RecUpdE Exp [FieldExp] -- ^ @{ (f x) { z = w } }@ | StaticE Exp -- ^ @{ static e }@ | UnboundVarE Name -- ^ @{ _x }@ -- -- This is used for holes or unresolved -- identifiers in AST quotes. Note that -- it could either have a variable name -- or constructor name. | LabelE String -- ^ @{ #x }@ ( Overloaded label ) | ImplicitParamVarE String -- ^ @{ ?x }@ ( Implicit parameter ) 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) -- Omitted: implicit parameters data Body = GuardedB [(Guard,Exp)] -- ^ @f p { | e1 = e2 -- | e3 = e4 } -- where ds@ | NormalB Exp -- ^ @f p { = e } where ds@ 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 -- ^ @f x { | odd x } = x@ | PatG [Stmt] -- ^ @f x { | Just y <- x, Just z <- y } = z@ 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 -- ^ @p <- e@ | LetS [ Dec ] -- ^ @{ let { x=e1; y=e2 } }@ | NoBindS Exp -- ^ @e@ | ParS [[Stmt]] -- ^ @x <- e1 | s2, s3 | s4@ (in 'CompE') | RecS [Stmt] -- ^ @rec { s1; s2 }@ 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] -- ^ @{ f p1 p2 = b where decs }@ | ValD Pat Body [Dec] -- ^ @{ p = b where decs }@ | DataD Cxt Name [TyVarBndr] (Maybe Kind) -- Kind signature (allowed only for GADTs) [Con] [DerivClause] -- ^ @{ data Cxt x => T x = A x | B (T x) -- deriving (Z,W) -- deriving stock Eq }@ | NewtypeD Cxt Name [TyVarBndr] (Maybe Kind) -- Kind signature Con [DerivClause] -- ^ @{ newtype Cxt x => T x = A (B x) -- deriving (Z,W Q) -- deriving stock Eq }@ | TySynD Name [TyVarBndr] Type -- ^ @{ type T x = (x,x) }@ | ClassD Cxt Name [TyVarBndr] [FunDep] [Dec] -- ^ @{ class Eq a => Ord a where ds }@ | InstanceD (Maybe Overlap) Cxt Type [Dec] -- ^ @{ instance {\-\# OVERLAPS \#-\} -- Show w => Show [w] where ds }@ | SigD Name Type -- ^ @{ length :: [a] -> Int }@ | ForeignD Foreign -- ^ @{ foreign import ... } --{ foreign export ... }@ | InfixD Fixity Name -- ^ @{ infix 3 foo }@ -- | pragmas | PragmaD Pragma -- ^ @{ {\-\# INLINE [1] foo \#-\} }@ -- | data families (may also appear in [Dec] of 'ClassD' and 'InstanceD') | DataFamilyD Name [TyVarBndr] (Maybe Kind) -- ^ @{ data family T a b c :: * }@ | DataInstD Cxt (Maybe [TyVarBndr]) Type (Maybe Kind) -- Kind signature [Con] [DerivClause] -- ^ @{ data instance Cxt x => T [x] -- = A x | B (T x) -- deriving (Z,W) -- deriving stock Eq }@ | NewtypeInstD Cxt (Maybe [TyVarBndr]) Type -- Quantified type vars (Maybe Kind) -- Kind signature Con [DerivClause] -- ^ @{ newtype instance Cxt x => T [x] -- = A (B x) -- deriving (Z,W) -- deriving stock Eq }@ | TySynInstD TySynEqn -- ^ @{ type instance ... }@ -- | open type families (may also appear in [Dec] of 'ClassD' and 'InstanceD') | OpenTypeFamilyD TypeFamilyHead -- ^ @{ type family T a b c = (r :: *) | r -> a b }@ | ClosedTypeFamilyD TypeFamilyHead [TySynEqn] -- ^ @{ type family F a b = (r :: *) | r -> a where ... }@ | RoleAnnotD Name [Role] -- ^ @{ type role T nominal representational }@ | StandaloneDerivD (Maybe DerivStrategy) Cxt Type -- ^ @{ deriving stock instance Ord a => Ord (Foo a) }@ | DefaultSigD Name Type -- ^ @{ default size :: Data a => a -> Int }@ -- | Pattern Synonyms | PatSynD Name PatSynArgs PatSynDir Pat -- ^ @{ pattern P v1 v2 .. vn <- p }@ unidirectional or -- @{ pattern P v1 v2 .. vn = p }@ implicit bidirectional or -- @{ pattern P v1 v2 .. vn <- p -- where P v1 v2 .. vn = e }@ explicit bidirectional -- -- also, besides prefix pattern synonyms, both infix and record -- pattern synonyms are supported. See 'PatSynArgs' for details | PatSynSigD Name PatSynType -- ^ A pattern synonym's type signature. | ImplicitParamBindD String Exp -- ^ @{ ?x = expr }@ -- -- Implicit parameter binding declaration. Can only be used in let -- and where clauses which consist entirely of implicit bindings. 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 $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 ) -- | Varieties of allowed instance overlap. data Overlap = Overlappable -- ^ May be overlapped by more specific instances | Overlapping -- ^ May overlap a more general instance | Overlaps -- ^ Both 'Overlapping' and 'Overlappable' | Incoherent -- ^ Both 'Overlappable' and 'Overlappable', and -- pick an arbitrary one if multiple choices are -- available. 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 ) -- | A single @deriving@ clause at the end of a datatype. data DerivClause = DerivClause (Maybe DerivStrategy) Cxt -- ^ @{ deriving stock (Eq, Ord) }@ 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 ) -- | What the user explicitly requests when deriving an instance. data DerivStrategy = StockStrategy -- ^ A \"standard\" derived instance | AnyclassStrategy -- ^ @-XDeriveAnyClass@ | NewtypeStrategy -- ^ @-XGeneralizedNewtypeDeriving@ | ViaStrategy Type -- ^ @-XDerivingVia@ 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 ) -- | A pattern synonym's type. Note that a pattern synonym's /fully/ -- specified type has a peculiar shape coming with two forall -- quantifiers and two constraint contexts. For example, consider the -- pattern synonym -- -- > pattern P x1 x2 ... xn = <some-pattern> -- -- P's complete type is of the following form -- -- > pattern P :: forall universals. required constraints -- > => forall existentials. provided constraints -- > => t1 -> t2 -> ... -> tn -> t -- -- consisting of four parts: -- -- 1. the (possibly empty lists of) universally quantified type -- variables and required constraints on them. -- 2. the (possibly empty lists of) existentially quantified -- type variables and the provided constraints on them. -- 3. the types @t1@, @t2@, .., @tn@ of @x1@, @x2@, .., @xn@, respectively -- 4. the type @t@ of @\<some-pattern\>@, mentioning only universals. -- -- Pattern synonym types interact with TH when (a) reifying a pattern -- synonym, (b) pretty printing, or (c) specifying a pattern synonym's -- type signature explicitly: -- -- * Reification always returns a pattern synonym's /fully/ specified -- type in abstract syntax. -- -- * Pretty printing via 'Language.Haskell.TH.Ppr.pprPatSynType' abbreviates -- a pattern synonym's type unambiguously in concrete syntax: The rule of -- thumb is to print initial empty universals and the required -- context as @() =>@, if existentials and a provided context -- follow. If only universals and their required context, but no -- existentials are specified, only the universals and their -- required context are printed. If both or none are specified, so -- both (or none) are printed. -- -- * When specifying a pattern synonym's type explicitly with -- 'PatSynSigD' either one of the universals, the existentials, or -- their contexts may be left empty. -- -- See the GHC user's guide for more information on pattern synonyms -- and their types: -- <https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/glasgow_exts.html#pattern-synonyms>. type PatSynType = Type -- | Common elements of 'OpenTypeFamilyD' and 'ClosedTypeFamilyD'. By -- analogy with "head" for type classes and type class instances as -- defined in /Type classes: an exploration of the design space/, the -- @TypeFamilyHead@ is defined to be the elements of the declaration -- between @type family@ and @where@. 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 ) -- | One equation of a type family instance or closed type family. The -- arguments are the left-hand-side type and the right-hand-side result. -- -- For instance, if you had the following type family: -- -- @ -- type family Foo (a :: k) :: k where -- forall k (a :: k). Foo \@k a = a -- @ -- -- The @Foo \@k a = a@ equation would be represented as follows: -- -- @ -- 'TySynEqn' ('Just' ['PlainTV' k, 'KindedTV' a ('VarT' k)]) -- ('AppT' ('AppKindT' ('ConT' ''Foo) ('VarT' k)) ('VarT' a)) -- ('VarT' a) -- @ 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 ) -- keep Callconv in sync with module ForeignCall in ghc/compiler/prelude/ForeignCall.hs 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) -- ^ @{ {\-\# COMPLETE C_1, ..., C_i [ :: T ] \#-} }@ 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