diff --git a/.gitignore b/.gitignore
index 9812cbc6c9b6093f8e29c45a2baeb9abbb980a6c..bfe7cade683ae72e6c7b34b30b9a5c8411905d53 100644
--- a/.gitignore
+++ b/.gitignore
@@ -183,7 +183,6 @@ _darcs/
/libraries/synopsis.png
/libraries/stamp/
/libraries/template-haskell/template-haskell.cabal
-/libraries/template-haskell-next/template-haskell-next.cabal
/linter.log
/mk/are-validating.mk
/mk/build.mk
diff --git a/compiler/GHC/Builtin/Names/TH.hs b/compiler/GHC/Builtin/Names/TH.hs
index 8929f3c1e8c8849ae8b3689d7b25f4712709acd0..acf2e018b699d5b2ad614b00dbaea7055809a5e4 100644
--- a/compiler/GHC/Builtin/Names/TH.hs
+++ b/compiler/GHC/Builtin/Names/TH.hs
@@ -179,21 +179,23 @@ templateHaskellNames = [
-- Quasiquoting
quoteDecName, quoteTypeName, quoteExpName, quotePatName]
-thSyn, thLib, qqLib :: Module
-thSyn = mkTHModule (fsLit "Language.Haskell.TH.Lib.Syntax")
-thLib = mkTHModule (fsLit "Language.Haskell.TH.Lib.Internal")
-qqLib = mkTHModule (fsLit "Language.Haskell.TH.Quote")
+thSyn, thLib, qqLib, liftLib :: Module
+thSyn = mkTHModule (fsLit "GHC.Internal.TH.Syntax")
+thLib = mkTHModule (fsLit "GHC.Internal.TH.Lib")
+qqLib = mkTHModule (fsLit "GHC.Internal.TH.Quote")
+liftLib = mkTHModule (fsLit "GHC.Internal.TH.Lift")
mkTHModule :: FastString -> Module
-mkTHModule m = mkModule thUnit (mkModuleNameFS m)
+mkTHModule m = mkModule ghcInternalUnit (mkModuleNameFS m)
-libFun, libTc, thFun, thTc, thCls, thCon :: FastString -> Unique -> Name
+libFun, libTc, thFun, thTc, thCls, thCon, liftFun :: FastString -> Unique -> Name
libFun = mk_known_key_name varName thLib
libTc = mk_known_key_name tcName thLib
thFun = mk_known_key_name varName thSyn
thTc = mk_known_key_name tcName thSyn
thCls = mk_known_key_name clsName thSyn
thCon = mk_known_key_name dataName thSyn
+liftFun = mk_known_key_name varName liftLib
thFld :: FastString -> FastString -> Unique -> Name
thFld con = mk_known_key_name (fieldName con) thSyn
@@ -203,7 +205,7 @@ qqFld = mk_known_key_name (fieldName (fsLit "QuasiQuoter")) qqLib
-------------------- TH.Syntax -----------------------
liftClassName :: Name
-liftClassName = thCls (fsLit "Lift") liftClassKey
+liftClassName = mk_known_key_name clsName liftLib (fsLit "Lift") liftClassKey
quoteClassName :: Name
quoteClassName = thCls (fsLit "Quote") quoteClassKey
@@ -239,8 +241,6 @@ returnQName = thFun (fsLit "returnQ") returnQIdKey
bindQName = thFun (fsLit "bindQ") bindQIdKey
sequenceQName = thFun (fsLit "sequenceQ") sequenceQIdKey
newNameName = thFun (fsLit "newName") newNameIdKey
-liftName = thFun (fsLit "lift") liftIdKey
-liftStringName = thFun (fsLit "liftString") liftStringIdKey
mkNameName = thFun (fsLit "mkName") mkNameIdKey
mkNameG_vName = thFun (fsLit "mkNameG_v") mkNameG_vIdKey
mkNameG_dName = thFun (fsLit "mkNameG_d") mkNameG_dIdKey
@@ -253,7 +253,9 @@ mkModNameName = thFun (fsLit "mkModName") mkModNameIdKey
unTypeName = thFld (fsLit "TExp") (fsLit "unType") unTypeIdKey
unTypeCodeName = thFun (fsLit "unTypeCode") unTypeCodeIdKey
unsafeCodeCoerceName = thFun (fsLit "unsafeCodeCoerce") unsafeCodeCoerceIdKey
-liftTypedName = thFun (fsLit "liftTyped") liftTypedIdKey
+liftName = liftFun (fsLit "lift") liftIdKey
+liftStringName = liftFun (fsLit "liftString") liftStringIdKey
+liftTypedName = liftFun (fsLit "liftTyped") liftTypedIdKey
-------------------- TH.Lib -----------------------
diff --git a/compiler/GHC/Hs/Expr.hs b/compiler/GHC/Hs/Expr.hs
index 1b07e8d7c7a09f565816090e80b1915efa164dc6..5c2ccc3716ed35a792e26ccfe78f3cc2346e1784 100644
--- a/compiler/GHC/Hs/Expr.hs
+++ b/compiler/GHC/Hs/Expr.hs
@@ -66,7 +66,7 @@ import GHC.Tc.Utils.TcType (TcType, TcTyVar)
import {-# SOURCE #-} GHC.Tc.Types.LclEnv (TcLclEnv)
import GHCi.RemoteTypes ( ForeignRef )
-import qualified Language.Haskell.TH as TH (Q)
+import qualified GHC.Internal.TH.Syntax as TH (Q)
-- libraries:
import Data.Data hiding (Fixity(..))
diff --git a/compiler/GHC/HsToCore/Quote.hs b/compiler/GHC/HsToCore/Quote.hs
index 0ba683482d16add8fc656c74e55bdfc116f75e9d..ae09974f2c7f4683e11bc235ce3ddf24c3be22ba 100644
--- a/compiler/GHC/HsToCore/Quote.hs
+++ b/compiler/GHC/HsToCore/Quote.hs
@@ -42,8 +42,7 @@ import GHC.HsToCore.Match.Literal
import GHC.HsToCore.Monad
import GHC.HsToCore.Binds
-import qualified Language.Haskell.TH as TH
-import qualified Language.Haskell.TH.Syntax as TH
+import qualified GHC.Internal.TH.Syntax as TH
import GHC.Hs
@@ -1008,7 +1007,7 @@ rep_sig d@(L _ (XSig {})) = pprPanic "rep_sig IdSig" (ppr d)
-- See Note [Scoped type variables in quotes]
-- and Note [Don't quantify implicit type variables in quotes]
rep_ty_sig_tvs :: [LHsTyVarBndr Specificity GhcRn]
- -> MetaM (Core [M TH.TyVarBndrSpec])
+ -> MetaM (Core [M (TH.TyVarBndr TH.Specificity)])
rep_ty_sig_tvs explicit_tvs
= repListM tyVarBndrSpecTyConName repTyVarBndr
explicit_tvs
@@ -1018,7 +1017,7 @@ rep_ty_sig_tvs explicit_tvs
-- See Note [Scoped type variables in quotes]
-- and Note [Don't quantify implicit type variables in quotes]
rep_ty_sig_outer_tvs :: HsOuterSigTyVarBndrs GhcRn
- -> MetaM (Core [M TH.TyVarBndrSpec])
+ -> MetaM (Core [M (TH.TyVarBndr TH.Specificity)])
rep_ty_sig_outer_tvs (HsOuterImplicit{}) =
coreListM tyVarBndrSpecTyConName []
rep_ty_sig_outer_tvs (HsOuterExplicit{hso_bndrs = explicit_tvs}) =
@@ -1208,7 +1207,7 @@ rep_bndr_vis (HsBndrInvisible _) = rep2_nw bndrInvisName []
addHsOuterFamEqnTyVarBinds ::
HsOuterFamEqnTyVarBndrs GhcRn
- -> (Core (Maybe [M TH.TyVarBndrUnit]) -> MetaM (Core (M a)))
+ -> (Core (Maybe [M (TH.TyVarBndr ())]) -> MetaM (Core (M a)))
-> MetaM (Core (M a))
addHsOuterFamEqnTyVarBinds outer_bndrs thing_inside = do
elt_ty <- wrapName tyVarBndrUnitTyConName
@@ -1222,7 +1221,7 @@ addHsOuterFamEqnTyVarBinds outer_bndrs thing_inside = do
addHsOuterSigTyVarBinds ::
HsOuterSigTyVarBndrs GhcRn
- -> (Core [M TH.TyVarBndrSpec] -> MetaM (Core (M a)))
+ -> (Core [M (TH.TyVarBndr TH.Specificity)] -> MetaM (Core (M a)))
-> MetaM (Core (M a))
addHsOuterSigTyVarBinds outer_bndrs thing_inside = case outer_bndrs of
HsOuterImplicit{hso_ximplicit = imp_tvs} ->
diff --git a/compiler/GHC/Iface/Recomp.hs b/compiler/GHC/Iface/Recomp.hs
index 60cba7bd5d733a53e6c9875b50da2e403a500a99..fdfb714e620ff285a9acbf142103cc55902dd368 100644
--- a/compiler/GHC/Iface/Recomp.hs
+++ b/compiler/GHC/Iface/Recomp.hs
@@ -596,7 +596,7 @@ checkDependencies hsc_env summary iface
liftIO $
check_mods (sort hs) prev_dep_mods
`recompThen`
- let allPkgDeps = sortBy (comparing snd) $ nubOrdOn snd (ps ++ implicit_deps)
+ let allPkgDeps = sortBy (comparing snd) $ nubOrdOn snd ps
in check_packages allPkgDeps prev_dep_pkgs
where
@@ -621,8 +621,6 @@ checkDependencies hsc_env summary iface
prev_dep_pkgs = Set.toAscList (Set.union (dep_direct_pkgs (mi_deps iface))
(dep_plugin_pkgs (mi_deps iface)))
- implicit_deps = map (fsLit "Implicit",) (implicitPackageDeps dflags)
-
-- GHC.Prim is very special and doesn't appear in ms_textual_imps but
-- ghc-prim will appear in the package dependencies still. In order to not confuse
-- the recompilation logic we need to not forget we imported GHC.Prim.
diff --git a/compiler/GHC/Plugins.hs b/compiler/GHC/Plugins.hs
index 862de7ac4d7c257cd7495b90ab23db70a21c20d6..784a9b7f11fb0c7933ab779788212f6d028c2ecb 100644
--- a/compiler/GHC/Plugins.hs
+++ b/compiler/GHC/Plugins.hs
@@ -156,7 +156,7 @@ import GHC.Parser.Errors.Types ( PsWarning, PsError )
import GHC.Types.Error ( Messages )
import GHC.Hs ( HsParsedModule )
-import qualified Language.Haskell.TH as TH
+import qualified GHC.Internal.TH.Syntax as TH
{- This instance is defined outside GHC.Core.Opt.Monad so that
GHC.Core.Opt.Monad does not depend on GHC.Tc.Utils.Env -}
diff --git a/compiler/GHC/Rename/Names.hs b/compiler/GHC/Rename/Names.hs
index 6e74ab9debbfd94b0747a42b3289313fd81a7131..1041f6f3c8cd5980899228d9c0c0f001f0d38b6c 100644
--- a/compiler/GHC/Rename/Names.hs
+++ b/compiler/GHC/Rename/Names.hs
@@ -215,11 +215,7 @@ rnImports imports = do
let (decls, imp_user_spec, rdr_env, imp_avails, hpc_usage) = combine (stuff1 ++ stuff2)
-- Update imp_boot_mods if imp_direct_mods mentions any of them
let merged_import_avail = clobberSourceImports imp_avails
- dflags <- getDynFlags
- let final_import_avail =
- merged_import_avail { imp_dep_direct_pkgs = S.fromList (implicitPackageDeps dflags)
- `S.union` imp_dep_direct_pkgs merged_import_avail}
- return (decls, imp_user_spec, rdr_env, final_import_avail, hpc_usage)
+ return (decls, imp_user_spec, rdr_env, merged_import_avail, hpc_usage)
where
clobberSourceImports imp_avails =
diff --git a/compiler/GHC/Rename/Splice.hs b/compiler/GHC/Rename/Splice.hs
index 2352b1f353ee395059b9f828a28e313a4e2be34d..a9767ef9dde3bcf32b5b9f649216914d2a4563e0 100644
--- a/compiler/GHC/Rename/Splice.hs
+++ b/compiler/GHC/Rename/Splice.hs
@@ -67,7 +67,7 @@ import {-# SOURCE #-} GHC.Tc.Gen.Splice
import GHC.Tc.Zonk.Type
import GHCi.RemoteTypes ( ForeignRef )
-import qualified Language.Haskell.TH as TH (Q)
+import qualified GHC.Internal.TH.Syntax as TH (Q)
import qualified GHC.LanguageExtensions as LangExt
diff --git a/compiler/GHC/Runtime/Interpreter/JS.hs b/compiler/GHC/Runtime/Interpreter/JS.hs
index f68a61bb8bb1dd7cd766d442a1bbde60071552b0..276d9419be2288766f9682446be38e99baafe651 100644
--- a/compiler/GHC/Runtime/Interpreter/JS.hs
+++ b/compiler/GHC/Runtime/Interpreter/JS.hs
@@ -303,7 +303,6 @@ jsLinkObjects logger tmpfs tmp_dir cfg unit_env inst objs is_root = do
}
let units = preloadUnits (ue_units unit_env)
- ++ [thUnitId] -- don't forget TH which is an implicit dep
-- compute dependencies
let link_spec = LinkSpec
diff --git a/compiler/GHC/Tc/Errors/Ppr.hs b/compiler/GHC/Tc/Errors/Ppr.hs
index a7703c8b6c640e1c812d53fb4346ca7702625ec9..9a14a02010d11b7c13636567dbe55587f8f03957 100644
--- a/compiler/GHC/Tc/Errors/Ppr.hs
+++ b/compiler/GHC/Tc/Errors/Ppr.hs
@@ -35,7 +35,12 @@ module GHC.Tc.Errors.Ppr
import GHC.Prelude
-import qualified Language.Haskell.TH as TH
+import qualified GHC.Internal.TH.Syntax as TH
+-- In stage1: import "ghc-boot-th-next" qualified GHC.Internal.TH.Syntax as TH
+-- In stage2: import "ghc-boot-th" qualified GHC.Internal.TH.Syntax as TH
+-- which resolves to
+-- import "ghc-internal" qualified GHC.Internal.TH.Syntax as TH
+import qualified GHC.Internal.TH.Ppr as TH
import GHC.Builtin.Names
import GHC.Builtin.Types ( boxedRepDataConTyCon, tYPETyCon, filterCTuple, pretendNameIsInScope )
diff --git a/compiler/GHC/Tc/Errors/Types.hs b/compiler/GHC/Tc/Errors/Types.hs
index 35599c9788b7d0c78c9d15fbdb2b9044f5d5e8aa..7df78d9d8272f0b0078cbdd2b7fc5d60ae684401 100644
--- a/compiler/GHC/Tc/Errors/Types.hs
+++ b/compiler/GHC/Tc/Errors/Types.hs
@@ -218,7 +218,7 @@ import Language.Haskell.Syntax.Basic (FieldLabelString(..))
import qualified Data.List.NonEmpty as NE
import Data.Typeable (Typeable)
import GHC.Unit.Module.Warnings (WarningCategory, WarningTxt)
-import qualified Language.Haskell.TH.Syntax as TH
+import qualified GHC.Internal.TH.Syntax as TH
import GHC.Generics ( Generic )
import GHC.Types.Name.Env (NameEnv)
diff --git a/compiler/GHC/Tc/Gen/Splice.hs b/compiler/GHC/Tc/Gen/Splice.hs
index 83720b1b00338fdb38c681ed7401d05ceb72ac07..a792203b56564a5b9287cbd92201eb38cbba6820 100644
--- a/compiler/GHC/Tc/Gen/Splice.hs
+++ b/compiler/GHC/Tc/Gen/Splice.hs
@@ -131,9 +131,9 @@ import GHC.Data.FastString
import GHC.Data.Maybe( MaybeErr(..) )
import qualified GHC.Data.EnumSet as EnumSet
-import qualified Language.Haskell.TH as TH
-- THSyntax gives access to internal functions and data types
-import qualified Language.Haskell.TH.Syntax as TH
+import qualified GHC.Internal.TH.Syntax as TH
+import qualified GHC.Internal.TH.Ppr as TH
#if defined(HAVE_INTERNAL_INTERPRETER)
-- Because GHC.Desugar might not be in the base library of the bootstrapping compiler
@@ -2921,7 +2921,9 @@ tcGetInterp = do
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-- Staged Metaprogramming as implemented in Template Haskell introduces a whole
-- new dimension of staging to the already staged bootstrapping process.
--- The `template-haskell` library plays a crucial role in this process.
+-- While users depend on the user-facing `template-haskell` library, the TH
+-- interface (all wired-in identifiers) is defined in `ghc-internal` and for
+-- bootstrapping purposes, re-exported from `ghc-boot-th`.
--
-- Nomenclature:
--
@@ -2929,29 +2931,28 @@ tcGetInterp = do
-- stage(N+1) compiler: The result of compiling GHC from source with stage(N)
-- Recall that any code compiled by the stage1 compiler should be binary
-- identical to the same code compiled by later stages.
--- boot TH: the `template-haskell` that comes with (and is linked to) the
+-- boot `ghc-boot-th`: the `ghc-boot-th` that comes with (and is linked to) the
-- boot/stage0 compiler
--- in-tree TH: the `template-haskell` library that lives in GHC's repository.
--- Recall that building in-tree TH with the stage1 compiler yields a binary
--- that is identical to the in-tree TH compiled by stage2.
--- boot library: A library such as bytestring or containers that GHC depends on.
--- CONFUSINGLY, we build these libraries with the boot compiler as well as
--- the stage1 compiler; thus the "boot" in boot library does not refer to a
--- stage.
+-- in-tree `ghc-boot-th`: the `ghc-boot-th` library that lives in GHC's repository.
--
--- Here is how we bootstrap `template-haskell` in tandem with GHC:
+-- Here is how we bootstrap TH in tandem with GHC:
--
--- 1. Link the stage1 compiler against the boot TH library.
--- 2. When building the stage1 compiler, build a CPP'd version of the in-tree
--- TH using the boot compiler under a different package-id,
--- `template-haskell-next`, and build stage1 GHC against that.
--- 3. Build the in-tree TH with the stage1 compiler.
--- 4. Build and link the stage2 compiler against the in-tree TH.
+-- 1. Build the stage1 compiler with the boot compiler.
+-- The latter comes with its own boot `ghc-boot-th` library, but we do not import it.
+-- 2. Instead, the stage1 compiler depends on the in-tree `ghc-boot-th`.
+-- * To avoid clashes with the boot `ghc-boot-th`, we change its
+-- package-id `ghc-boot-th-next`.
+-- * There is a bit of CPP to vendor the stage1 TH AST defined in
+-- `ghc-internal`, which we cannot build with the boot compiler.
+-- 3. Build `ghc-internal` and in-tree `ghc-boot-th` with the stage1 compiler.
+-- From here on `ghc-boot-th` re-exposes the TH modules from `ghc-internal`.
+-- 4. Build and link the stage2 compiler against the in-tree `ghc-boot-th`.
+-- NB: No dependency on `ghc-boot-th-next`.
--
-- Observations:
--
-- A. The vendoring in (2) means that the fully qualified name of the in-tree TH
--- AST will be, e.g., `template-haskell-next:...VarE`, not `template-haskell:...VarE`.
+-- AST will be, e.g., `ghc-boot-th-next:...VarE`, not `ghc-internal:...VarE`.
-- That is OK, because we need it just for the `Binary` instance and to
-- convert TH ASTs returned by splices into the Hs AST, both of which do not
-- depend on the fully qualified name of the type to serialise! Importantly,
@@ -2959,7 +2960,10 @@ tcGetInterp = do
-- unaffected, because the desugaring refers to names in the in-tree TH
-- library, which is built in the next stage, stage1, and later.
--
--- (Rejected) alternative designs:
+-- When we decided in favour of the current design, `template-haskell`
+-- still contained the wired-in Ids that meanwhile were moved to
+-- `ghc-internal`.
+-- These were the (rejected) alternative designs back then:
--
-- 1b. Build the in-tree TH with the stage0 compiler and link the stage1 compiler
-- against it. This is what we did until Apr 24 and it is problematic (#23536):
@@ -2994,7 +2998,7 @@ tcGetInterp = do
-- thus rejected.)
-- * We have thus made it impossible to refactor in-tree TH.
-- This problem was discussed in #23536.
--- 1c. Do not build the stage1 compiler against any template-haskell library.
+-- 1c. Do not build the stage1 compiler against any library exposing the in-tree TH AST.
-- This is viable because no splices need to be run as part of the
-- bootstrapping process, so we could CPP away all the code in the stage1
-- compiler that refers to template-haskell types. However,
@@ -3018,7 +3022,7 @@ tcGetInterp = do
-- Note [Hard-wiring in-tree template-haskell for desugaring quotes]
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-- To desugar Template Haskell quotes, GHC needs to wire in a bunch of Names in the
--- `template-haskell` library as Note [Known-key names], in GHC.Builtin.Names.TH.
+-- `ghc-internal` library as Note [Known-key names], in GHC.Builtin.Names.TH.
-- Consider
-- > foo :: Q Exp
-- > foo = [| unwords ["hello", "world"] |]
@@ -3026,6 +3030,6 @@ tcGetInterp = do
-- > varE (mkNameS "unwords") `appE` listE [litE (stringE "hello"), litE (stringE "world")]
-- And all these smart constructors are known-key.
-- NB: Since the constructors are known-key, it is impossible to link this program
--- against another template-haskell library in which, e.g., `varE` was moved into a
+-- against another `ghc-internal` library in which, e.g., `varE` was moved into a
-- different module. So effectively, GHC is hard-wired against the in-tree
--- template-haskell library.
+-- `ghc-internal` library.
diff --git a/compiler/GHC/Tc/Gen/Splice.hs-boot b/compiler/GHC/Tc/Gen/Splice.hs-boot
index ffa59c6132198b816fe58aabf6cfa7bd55d7b73c..2ae3756498c177c3473c3eacf380611fb81f41e9 100644
--- a/compiler/GHC/Tc/Gen/Splice.hs-boot
+++ b/compiler/GHC/Tc/Gen/Splice.hs-boot
@@ -11,7 +11,7 @@ import GHC.Types.Annotations ( Annotation, CoreAnnTarget )
import GHC.Hs.Extension ( GhcRn, GhcPs, GhcTc )
import GHC.Hs ( HsQuote, HsExpr, LHsExpr, LHsType, LPat, LHsDecl, ThModFinalizers, HsUntypedSpliceResult )
-import qualified Language.Haskell.TH as TH
+import qualified GHC.Internal.TH.Syntax as TH
tcTypedSplice :: Name
-> LHsExpr GhcRn
diff --git a/compiler/GHC/Tc/Types/TH.hs b/compiler/GHC/Tc/Types/TH.hs
index ed66c448c8dbb9e2893186227f320cbe66f6953a..ad2c62c020ff7bce28422121ec48fe87ac80491f 100644
--- a/compiler/GHC/Tc/Types/TH.hs
+++ b/compiler/GHC/Tc/Types/TH.hs
@@ -13,7 +13,7 @@ module GHC.Tc.Types.TH (
) where
import GHCi.RemoteTypes
-import qualified Language.Haskell.TH as TH
+import qualified GHC.Internal.TH.Syntax as TH
import GHC.Tc.Types.Evidence
import GHC.Utils.Outputable
import GHC.Prelude
diff --git a/compiler/GHC/ThToHs.hs b/compiler/GHC/ThToHs.hs
index 96be958fb9b752439c8439e395f74d7e092af449..99329e8eb16d0a5c9b0fadb407bf3c2697b9ec5a 100644
--- a/compiler/GHC/ThToHs.hs
+++ b/compiler/GHC/ThToHs.hs
@@ -59,8 +59,7 @@ import Data.List.NonEmpty( NonEmpty (..), nonEmpty )
import qualified Data.List.NonEmpty as NE
import Data.Maybe( catMaybes, isNothing )
import Data.Word (Word64)
-import Language.Haskell.TH as TH hiding (sigP)
-import Language.Haskell.TH.Syntax as TH
+import GHC.Internal.TH.Syntax as TH
import Foreign.ForeignPtr
import Foreign.Ptr
import System.IO.Unsafe
@@ -1775,7 +1774,7 @@ cvtTypeKind typeOrKind ty
-> mk_apps (HsExplicitListTy noAnn IsPromoted []) tys'
PromotedConsT -- See Note [Representing concrete syntax in types]
- -- in Language.Haskell.TH.Syntax
+ -- in GHC.Internal.TH.Syntax
| Just normals <- m_normals
, [ty1, L _ (HsExplicitListTy _ ip tys2)] <- normals
-> returnLA (HsExplicitListTy noAnn ip (ty1:tys2))
diff --git a/compiler/GHC/Unit/State.hs b/compiler/GHC/Unit/State.hs
index fde3c734d0fc370af2af80397f8fb4e92269bb75..be6374cca334d417353844d662930273e4a89f89 100644
--- a/compiler/GHC/Unit/State.hs
+++ b/compiler/GHC/Unit/State.hs
@@ -68,8 +68,7 @@ module GHC.Unit.State (
pprWithUnitState,
-- * Utils
- unwireUnit,
- implicitPackageDeps)
+ unwireUnit)
where
import GHC.Prelude
@@ -116,7 +115,6 @@ import Data.Set (Set)
import Data.Monoid (First(..))
import qualified Data.Semigroup as Semigroup
import qualified Data.Set as Set
-import GHC.LanguageExtensions
import Control.Applicative
-- ---------------------------------------------------------------------------
@@ -2268,11 +2266,3 @@ pprWithUnitState :: UnitState -> SDoc -> SDoc
pprWithUnitState state = updSDocContext (\ctx -> ctx
{ sdocUnitIdForUser = \fs -> pprUnitIdForUser state (UnitId fs)
})
-
--- | Add package dependencies on the wired-in packages we use
-implicitPackageDeps :: DynFlags -> [UnitId]
-implicitPackageDeps dflags
- = [thUnitId | xopt TemplateHaskellQuotes dflags]
- -- TODO: Should also include `base` and `ghc-prim` if we use those implicitly, but
- -- it is possible to not depend on base (for example, see `ghc-prim`)
-
diff --git a/compiler/GHC/Unit/Types.hs b/compiler/GHC/Unit/Types.hs
index 061c29e71a508d242dcaecb2bb153e8d5072718e..acb6908db1a11c7e4f9197c483fbb9d60d6ac759 100644
--- a/compiler/GHC/Unit/Types.hs
+++ b/compiler/GHC/Unit/Types.hs
@@ -65,7 +65,6 @@ module GHC.Unit.Types
, ghcInternalUnitId
, baseUnitId
, rtsUnitId
- , thUnitId
, mainUnitId
, thisGhcUnitId
, interactiveUnitId
@@ -75,7 +74,6 @@ module GHC.Unit.Types
, ghcInternalUnit
, baseUnit
, rtsUnit
- , thUnit
, mainUnit
, thisGhcUnit
, interactiveUnit
@@ -596,11 +594,11 @@ Make sure you change 'GHC.Unit.State.findWiredInUnits' if you add an entry here.
-}
bignumUnitId, primUnitId, ghcInternalUnitId, baseUnitId, rtsUnitId,
- thUnitId, mainUnitId, thisGhcUnitId, interactiveUnitId,
+ mainUnitId, thisGhcUnitId, interactiveUnitId,
experimentalUnitId :: UnitId
bignumUnit, primUnit, ghcInternalUnit, baseUnit, rtsUnit,
- thUnit, mainUnit, thisGhcUnit, interactiveUnit, experimentalUnit :: Unit
+ mainUnit, thisGhcUnit, interactiveUnit, experimentalUnit :: Unit
primUnitId = UnitId (fsLit "ghc-prim")
bignumUnitId = UnitId (fsLit "ghc-bignum")
@@ -609,10 +607,8 @@ baseUnitId = UnitId (fsLit "base")
rtsUnitId = UnitId (fsLit "rts")
thisGhcUnitId = UnitId (fsLit cProjectUnitId) -- See Note [GHC's Unit Id]
interactiveUnitId = UnitId (fsLit "interactive")
-thUnitId = UnitId (fsLit "template-haskell")
experimentalUnitId = UnitId (fsLit "ghc-experimental")
-thUnit = RealUnit (Definite thUnitId)
primUnit = RealUnit (Definite primUnitId)
bignumUnit = RealUnit (Definite bignumUnitId)
ghcInternalUnit = RealUnit (Definite ghcInternalUnitId)
@@ -638,7 +634,6 @@ wiredInUnitIds =
, ghcInternalUnitId
, baseUnitId
, rtsUnitId
- , thUnitId
, experimentalUnitId
]
-- NB: ghc is no longer part of the wired-in units since its unit-id, given
diff --git a/compiler/ghc.cabal.in b/compiler/ghc.cabal.in
index 5d2dbb8084f5a074df4d3939264f54792d1a24b7..f59b69ff7d3310573e1af55bc2e0c71ef886c6a5 100644
--- a/compiler/ghc.cabal.in
+++ b/compiler/ghc.cabal.in
@@ -85,8 +85,8 @@ Flag hadrian-stage0
Flag bootstrap
Description:
Enabled when building the stage1 compiler in order to vendor the in-tree
- `template-haskell` library (including its dependency `ghc-boot-th`), while
- allowing dependencies to depend on the boot `template-haskell` library.
+ `ghc-boot-th` library, and through that the in-tree TH AST defintions from
+ `ghc-internal`.
See Note [Bootstrapping Template Haskell]
Default: False
Manual: True
@@ -135,10 +135,10 @@ Library
if flag(bootstrap)
Build-Depends:
- template-haskell-next
+ ghc-boot-th-next == @ProjectVersionMunged@
else
Build-Depends:
- template-haskell == 2.22.*
+ ghc-boot-th == @ProjectVersionMunged@
if os(windows)
Build-Depends: Win32 >= 2.3 && < 2.15
diff --git a/hadrian/src/Packages.hs b/hadrian/src/Packages.hs
index bf181065880728003fecc01f5c5c3de608c21d46..f0e8c1afa75918ab37f58e4de18a2ae2ffebac22 100644
--- a/hadrian/src/Packages.hs
+++ b/hadrian/src/Packages.hs
@@ -9,7 +9,7 @@ module Packages (
ghcToolchain, ghcToolchainBin, haddock, haskeline,
hsc2hs, hp2ps, hpc, hpcBin, integerGmp, integerSimple, iserv, iservProxy,
libffi, mtl, osString, parsec, pretty, primitive, process, remoteIserv, rts,
- runGhc, semaphoreCompat, stm, templateHaskell, templateHaskellNext, terminfo, text, time, timeout,
+ runGhc, semaphoreCompat, stm, templateHaskell, terminfo, text, time, timeout,
transformers, unlit, unix, win32, xhtml,
lintersCommon, lintNotes, lintCodes, lintCommitMsg, lintSubmoduleRefs, lintWhitespace,
ghcPackages, isGhcPackage,
@@ -41,7 +41,7 @@ ghcPackages =
, ghcCompact, ghcConfig, ghcExperimental, ghcHeap, ghcInternal, ghci, ghciWrapper, ghcPkg, ghcPrim
, ghcToolchain, ghcToolchainBin, haddock, haskeline, hsc2hs
, hp2ps, hpc, hpcBin, integerGmp, integerSimple, iserv, libffi, mtl, osString
- , parsec, pretty, process, rts, runGhc, stm, semaphoreCompat, templateHaskell, templateHaskellNext
+ , parsec, pretty, process, rts, runGhc, stm, semaphoreCompat, templateHaskell
, terminfo, text, time, transformers, unlit, unix, win32, xhtml
, timeout
, lintersCommon
@@ -124,7 +124,6 @@ runGhc = util "runghc"
semaphoreCompat = lib "semaphore-compat"
stm = lib "stm"
templateHaskell = lib "template-haskell"
-templateHaskellNext = lib "template-haskell-next"
terminfo = lib "terminfo"
text = lib "text"
time = lib "time"
diff --git a/hadrian/src/Rules/Generate.hs b/hadrian/src/Rules/Generate.hs
index 6e1312e12f58bc4f1249cd86922a9f8de19776f6..32ca2f054279d30bb2211710ec88f5295054eebe 100644
--- a/hadrian/src/Rules/Generate.hs
+++ b/hadrian/src/Rules/Generate.hs
@@ -344,14 +344,6 @@ templateRules = do
templateRule "utils/ghc-pkg/ghc-pkg.cabal" $ projectVersion
templateRule "libraries/template-haskell/template-haskell.cabal" $ mconcat
[ projectVersion
- , interpolateVar "Suffix" $ pure ""
- , interpolateVar "SourceRoot" $ pure "."
- ]
- templateRuleFrom "libraries/template-haskell/template-haskell.cabal.in"
- "libraries/template-haskell-next/template-haskell-next.cabal" $ mconcat
- [ projectVersion
- , interpolateVar "Suffix" $ pure "-next"
- , interpolateVar "SourceRoot" $ pure "../template-haskell"
]
templateRule "libraries/prologue.txt" $ packageVersions
templateRule "rts/include/ghcversion.h" $ mconcat
diff --git a/hadrian/src/Rules/ToolArgs.hs b/hadrian/src/Rules/ToolArgs.hs
index 7bbab5382897f71b5feb978adafd07bac844c2b7..3e8543ef026cb57c71bbe0fac162932abc1018b9 100644
--- a/hadrian/src/Rules/ToolArgs.hs
+++ b/hadrian/src/Rules/ToolArgs.hs
@@ -154,7 +154,6 @@ toolTargets = [ cabalSyntax
, hpc
, hpcBin -- # executable
, time
- , templateHaskellNext
, semaphoreCompat
, unlit -- # executable
] ++ if windowsHost then [ win32 ] else [ unix ]
diff --git a/hadrian/src/Settings/Default.hs b/hadrian/src/Settings/Default.hs
index 41f744e7b4ab3a2a7d7b3a4eb824720b1c8d4f9d..be5540af166ed730745337419d1299067b732050 100644
--- a/hadrian/src/Settings/Default.hs
+++ b/hadrian/src/Settings/Default.hs
@@ -102,7 +102,6 @@ stage0Packages = do
, process -- depends on filepath
, runGhc
, semaphoreCompat -- depends on
- , templateHaskellNext
, time -- depends on win32
, unlit
, if windowsHost then win32 else unix
@@ -127,7 +126,6 @@ stage1Packages = do
| p == unix = False
-- These packages are only needed for bootstrapping.
-- See Note [Bootstrapping Template Haskell]
- | p == templateHaskellNext = False
| p == ghcBootThNext = False
| otherwise = True
diff --git a/hadrian/src/Settings/Packages.hs b/hadrian/src/Settings/Packages.hs
index d6430ada71773d989087dd20bb87eae89dc6c7c0..35c9badeaca76950d5e1c74f15da4ac2591fb4d5 100644
--- a/hadrian/src/Settings/Packages.hs
+++ b/hadrian/src/Settings/Packages.hs
@@ -186,8 +186,8 @@ packageArgs = do
, package haddock ?
builder (Cabal Flags) ? arg "in-ghc-tree"
- ---------------------------- template-haskell --------------------------
- , package templateHaskellNext ?
+ ---------------------------- ghc-boot-th-next --------------------------
+ , package ghcBootThNext ?
builder (Cabal Flags) ? stage0 `cabalFlag` "bootstrap"
---------------------------------- text --------------------------------
diff --git a/libraries/base/src/Control/Monad/IO/Class.hs b/libraries/base/src/Control/Monad/IO/Class.hs
index c277cec56fd5657da8c395f08eee71d645cb73a4..5619cefc873be2e4aa6186d4c529828ebeccb0c0 100644
--- a/libraries/base/src/Control/Monad/IO/Class.hs
+++ b/libraries/base/src/Control/Monad/IO/Class.hs
@@ -14,61 +14,8 @@
-- Class of monads based on @IO@.
-----------------------------------------------------------------------------
-module Control.Monad.IO.Class (
- MonadIO(..)
- ) where
-
-import GHC.Internal.Base
-
--- | Monads in which 'IO' computations may be embedded.
--- Any monad built by applying a sequence of monad transformers to the
--- 'IO' monad will be an instance of this class.
---
--- Instances should satisfy the following laws, which state that 'liftIO'
--- is a transformer of monads:
---
--- * @'liftIO' . 'return' = 'return'@
---
--- * @'liftIO' (m >>= f) = 'liftIO' m >>= ('liftIO' . f)@
-
-class (Monad m) => MonadIO m where
- -- | Lift a computation from the 'IO' monad.
- -- This allows us to run IO computations in any monadic stack, so long as it supports these kinds of operations
- -- (i.e. 'IO' is the base monad for the stack).
- --
- -- === __Example__
- --
- --
- -- > import Control.Monad.Trans.State -- from the "transformers" library
- -- >
- -- > printState :: Show s => StateT s IO ()
- -- > printState = do
- -- > state <- get
- -- > liftIO $ print state
- --
- --
- -- Had we omitted @'liftIO'@, we would have ended up with this error:
- --
- -- > • Couldn't match type ‘IO’ with ‘StateT s IO’
- -- > Expected type: StateT s IO ()
- -- > Actual type: IO ()
- --
- -- The important part here is the mismatch between @StateT s IO ()@ and @'IO' ()@.
- --
- -- Luckily, we know of a function that takes an @'IO' a@ and returns an @(m a)@: @'liftIO'@,
- -- enabling us to run the program and see the expected results:
- --
- -- @
- -- > evalStateT printState "hello"
- -- "hello"
- --
- -- > evalStateT printState 3
- -- 3
- -- @
- --
- liftIO :: IO a -> m a
-
--- | @since 4.9.0.0
-instance MonadIO IO where
- liftIO = id
+module Control.Monad.IO.Class
+ ( MonadIO(..) )
+ where
+import GHC.Internal.Control.Monad.IO.Class
diff --git a/libraries/base/src/Data/Array/Byte.hs b/libraries/base/src/Data/Array/Byte.hs
index f954c627e7f173eee131d611a4c2e0a68522bf34..72bd13dea324f93a621348ca8e18d96e9d4aad69 100644
--- a/libraries/base/src/Data/Array/Byte.hs
+++ b/libraries/base/src/Data/Array/Byte.hs
@@ -13,6 +13,7 @@
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE Trustworthy #-}
{-# LANGUAGE UnboxedTuples #-}
+{-# LANGUAGE TemplateHaskellQuotes #-}
module Data.Array.Byte (
ByteArray(..),
@@ -30,6 +31,9 @@ import GHC.Num.Integer (Integer(..))
import GHC.Internal.Show (intToDigit)
import GHC.Internal.ST (ST(..), runST)
import GHC.Internal.Word (Word8(..))
+import GHC.Internal.TH.Syntax
+import GHC.Internal.TH.Lift
+import GHC.Internal.ForeignPtr
import Prelude
-- | Lifted wrapper for 'ByteArray#'.
@@ -196,6 +200,35 @@ instance Show ByteArray where
comma | i == 0 = id
| otherwise = showString ", "
+instance Lift ByteArray where
+ liftTyped x = unsafeCodeCoerce (lift x)
+ lift (ByteArray b) = return
+ (AppE (AppE (VarE addrToByteArrayName) (LitE (IntegerL (fromIntegral len))))
+ (LitE (BytesPrimL (Bytes ptr 0 (fromIntegral len)))))
+ where
+ len# = sizeofByteArray# b
+ len = I# len#
+ pb :: ByteArray#
+ !(ByteArray pb)
+ | isTrue# (isByteArrayPinned# b) = ByteArray b
+ | otherwise = runST $ ST $
+ \s -> case newPinnedByteArray# len# s of
+ (# s', mb #) -> case copyByteArray# b 0# mb 0# len# s' of
+ s'' -> case unsafeFreezeByteArray# mb s'' of
+ (# s''', ret #) -> (# s''', ByteArray ret #)
+ ptr :: ForeignPtr Word8
+ ptr = ForeignPtr (byteArrayContents# pb) (PlainPtr (unsafeCoerce# pb))
+
+addrToByteArrayName :: Name
+addrToByteArrayName = 'addrToByteArray
+
+addrToByteArray :: Int -> Addr# -> ByteArray
+addrToByteArray (I# len) addr = runST $ ST $
+ \s -> case newByteArray# len s of
+ (# s', mb #) -> case copyAddrToByteArray# addr mb 0# len s' of
+ s'' -> case unsafeFreezeByteArray# mb s'' of
+ (# s''', ret #) -> (# s''', ByteArray ret #)
+
-- | Compare prefixes of given length.
compareByteArraysFromBeginning :: ByteArray -> ByteArray -> Int -> Ordering
{-# INLINE compareByteArraysFromBeginning #-}
diff --git a/libraries/base/src/Data/Fixed.hs b/libraries/base/src/Data/Fixed.hs
index dfbbcfaeedb6bdf5b930724344f25561454fbd40..7f48a6632443aa5c24038c16d2571357b403d839 100644
--- a/libraries/base/src/Data/Fixed.hs
+++ b/libraries/base/src/Data/Fixed.hs
@@ -2,6 +2,7 @@
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE PolyKinds #-}
{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE TemplateHaskellQuotes #-}
-----------------------------------------------------------------------------
-- |
@@ -90,6 +91,8 @@ import GHC.Internal.TypeLits (KnownNat, natVal)
import GHC.Internal.Read
import GHC.Internal.Text.ParserCombinators.ReadPrec
import GHC.Internal.Text.Read.Lex
+import qualified GHC.Internal.TH.Syntax as TH
+import qualified GHC.Internal.TH.Lift as TH
import Data.Typeable
import Prelude
@@ -140,6 +143,13 @@ instance (Typeable k,Typeable a) => Data (Fixed (a :: k)) where
dataTypeOf _ = tyFixed
toConstr _ = conMkFixed
+-- |
+-- @since template-haskell-2.19.0.0
+-- @since base-4.21.0.0
+instance TH.Lift (Fixed a) where
+ liftTyped x = TH.unsafeCodeCoerce (TH.lift x)
+ lift (MkFixed x) = [| MkFixed x |]
+
-- | Types which can be used as a resolution argument to the 'Fixed' type constructor must implement the 'HasResolution' typeclass.
class HasResolution (a :: k) where
-- | Provide the resolution for a fixed-point fractional number.
diff --git a/libraries/ghc-boot-th/GHC/ForeignSrcLang/Type.hs b/libraries/ghc-boot-th/GHC/ForeignSrcLang/Type.hs
index 19b223f56dbef6509517a90177653252f5241c8a..723296b79b712e7a99b95f1ad6de8aba41df6fa6 100644
--- a/libraries/ghc-boot-th/GHC/ForeignSrcLang/Type.hs
+++ b/libraries/ghc-boot-th/GHC/ForeignSrcLang/Type.hs
@@ -1,18 +1,5 @@
-{-# LANGUAGE DeriveGeneric #-}
module GHC.ForeignSrcLang.Type
( ForeignSrcLang(..)
) where
-import Prelude -- See note [Why do we import Prelude here?]
-import GHC.Generics (Generic)
-
--- | Foreign formats supported by GHC via TH
-data ForeignSrcLang
- = LangC -- ^ C
- | LangCxx -- ^ C++
- | LangObjc -- ^ Objective C
- | LangObjcxx -- ^ Objective C++
- | LangAsm -- ^ Assembly language (.s)
- | LangJs -- ^ JavaScript
- | RawObject -- ^ Object (.o)
- deriving (Eq, Show, Generic)
+import GHC.Internal.ForeignSrcLang
diff --git a/libraries/template-haskell/Language/Haskell/TH/Lib/Map.hs b/libraries/ghc-boot-th/GHC/Internal/TH/Lib/Map.hs
similarity index 98%
rename from libraries/template-haskell/Language/Haskell/TH/Lib/Map.hs
rename to libraries/ghc-boot-th/GHC/Internal/TH/Lib/Map.hs
index 27794dd735d9a1935466f2199f2f27f6d09a49ff..7d3f80be3cae6e48f9bc2616d3ccbeac51120ada 100644
--- a/libraries/template-haskell/Language/Haskell/TH/Lib/Map.hs
+++ b/libraries/ghc-boot-th/GHC/Internal/TH/Lib/Map.hs
@@ -10,11 +10,11 @@
--
-- The original code is BSD-licensed and copyrighted by Daan Leijen, Andriy Palamarchuk, et al.
-module Language.Haskell.TH.Lib.Map
+module GHC.Internal.TH.Lib.Map
( Map
, empty
, insert
- , Language.Haskell.TH.Lib.Map.lookup
+ , GHC.Internal.TH.Lib.Map.lookup
) where
import Prelude
diff --git a/libraries/ghc-boot-th/GHC/Internal/TH/Ppr.hs b/libraries/ghc-boot-th/GHC/Internal/TH/Ppr.hs
new file mode 100644
index 0000000000000000000000000000000000000000..fb35c98b448458794f913511fa7871eb574ead80
--- /dev/null
+++ b/libraries/ghc-boot-th/GHC/Internal/TH/Ppr.hs
@@ -0,0 +1,1075 @@
+{-# LANGUAGE Trustworthy #-}
+{-# LANGUAGE LambdaCase #-}
+-- | contains a prettyprinter for the
+-- Template Haskell datatypes
+
+module GHC.Internal.TH.Ppr where
+ -- All of the exports from this module should
+ -- be "public" functions. The main module TH
+ -- re-exports them all.
+
+import Text.PrettyPrint (render)
+import GHC.Internal.TH.PprLib
+import GHC.Internal.TH.Syntax
+import Data.Word ( Word8 )
+import Data.Char ( toLower, chr)
+import GHC.Show ( showMultiLineString )
+import GHC.Lexeme( isVarSymChar )
+import Data.Ratio ( numerator, denominator )
+import Data.Foldable ( toList )
+import Prelude hiding ((<>))
+
+nestDepth :: Int
+nestDepth = 4
+
+type Precedence = Int
+appPrec, opPrec, unopPrec, funPrec, qualPrec, sigPrec, noPrec :: Precedence
+appPrec = 6 -- Argument of a function or type application
+opPrec = 5 -- Argument of an infix operator
+unopPrec = 4 -- Argument of an unresolved infix operator
+funPrec = 3 -- Argument of a function arrow
+qualPrec = 2 -- Forall-qualified type or result of a function arrow
+sigPrec = 1 -- Argument of an explicit type signature
+noPrec = 0 -- Others
+
+parensIf :: Bool -> Doc -> Doc
+parensIf True d = parens d
+parensIf False d = d
+
+------------------------------
+
+pprint :: Ppr a => a -> String
+pprint x = render $ to_HPJ_Doc $ ppr x
+
+class Ppr a where
+ ppr :: a -> Doc
+ ppr_list :: [a] -> Doc
+ ppr_list = vcat . map ppr
+
+instance Ppr a => Ppr [a] where
+ ppr x = ppr_list x
+
+------------------------------
+instance Ppr Name where
+ ppr v = pprName v
+
+------------------------------
+instance Ppr Info where
+ ppr (TyConI d) = ppr d
+ ppr (ClassI d is) = ppr d $$ vcat (map ppr is)
+ ppr (FamilyI d is) = ppr d $$ vcat (map ppr is)
+ ppr (PrimTyConI name arity is_unlifted)
+ = text "Primitive"
+ <+> (if is_unlifted then text "unlifted" else empty)
+ <+> text "type constructor" <+> quotes (ppr name)
+ <+> parens (text "arity" <+> int arity)
+ ppr (ClassOpI v ty cls)
+ = text "Class op from" <+> ppr cls <> colon <+> ppr_sig v ty
+ ppr (DataConI v ty tc)
+ = text "Constructor from" <+> ppr tc <> colon <+> ppr_sig v ty
+ ppr (PatSynI nm ty) = pprPatSynSig nm ty
+ ppr (TyVarI v ty)
+ = text "Type variable" <+> ppr v <+> equals <+> ppr ty
+ ppr (VarI v ty mb_d)
+ = vcat [ppr_sig v ty,
+ case mb_d of { Nothing -> empty; Just d -> ppr d }]
+
+ppr_sig :: Name -> Type -> Doc
+ppr_sig v ty = pprName' Applied v <+> dcolon <+> ppr ty
+
+pprFixity :: Name -> Fixity -> NamespaceSpecifier -> Doc
+pprFixity _ f _ | f == defaultFixity = empty
+pprFixity v (Fixity i d) ns_spec
+ = ppr_fix d <+> int i <+> pprNamespaceSpecifier ns_spec <+> pprName' Infix v
+ where ppr_fix InfixR = text "infixr"
+ ppr_fix InfixL = text "infixl"
+ ppr_fix InfixN = text "infix"
+
+pprNamespaceSpecifier :: NamespaceSpecifier -> Doc
+pprNamespaceSpecifier NoNamespaceSpecifier = empty
+pprNamespaceSpecifier TypeNamespaceSpecifier = text "type"
+pprNamespaceSpecifier DataNamespaceSpecifier = text "data"
+
+-- | Pretty prints a pattern synonym type signature
+pprPatSynSig :: Name -> PatSynType -> Doc
+pprPatSynSig nm ty
+ = text "pattern" <+> pprPrefixOcc nm <+> dcolon <+> pprPatSynType ty
+
+-- | Pretty prints a pattern synonym's type; follows the usual
+-- conventions to print a pattern synonym type compactly, yet
+-- unambiguously. See the note on 'PatSynType' and the section on
+-- pattern synonyms in the GHC user's guide for more information.
+pprPatSynType :: PatSynType -> Doc
+pprPatSynType ty@(ForallT uniTys reqs ty'@(ForallT exTys provs ty''))
+ | null exTys, null provs = ppr (ForallT uniTys reqs ty'')
+ | null uniTys, null reqs = noreqs <+> ppr ty'
+ | null reqs = pprForallBndrs uniTys <+> noreqs <+> ppr ty'
+ | otherwise = ppr ty
+ where noreqs = text "() =>"
+ pprForallBndrs tvs = text "forall" <+> hsep (map ppr tvs) <+> text "."
+pprPatSynType ty = ppr ty
+
+------------------------------
+instance Ppr Module where
+ ppr (Module pkg m) = text (pkgString pkg) <+> text (modString m)
+
+instance Ppr ModuleInfo where
+ ppr (ModuleInfo imps) = text "Module" <+> vcat (map ppr imps)
+
+------------------------------
+instance Ppr Exp where
+ ppr = pprExp noPrec
+
+pprPrefixOcc :: Name -> Doc
+-- Print operators with parens around them
+pprPrefixOcc n = parensIf (isSymOcc n) (ppr n)
+
+isSymOcc :: Name -> Bool
+isSymOcc n
+ = case nameBase n of
+ [] -> True -- Empty name; weird
+ (c:_) -> isVarSymChar c
+ -- c.f. isVarSymChar in GHC itself
+
+pprInfixExp :: Exp -> Doc
+pprInfixExp (VarE v) = pprName' Infix v
+pprInfixExp (ConE v) = pprName' Infix v
+pprInfixExp (UnboundVarE v) = pprName' Infix v
+-- This case will only ever be reached in exceptional circumstances.
+-- For example, when printing an error message in case of a malformed expression.
+pprInfixExp e = text "`" <> ppr e <> text "`"
+
+pprExp :: Precedence -> Exp -> Doc
+pprExp _ (VarE v) = pprName' Applied v
+pprExp _ (ConE c) = pprName' Applied c
+pprExp i (LitE l) = pprLit i l
+pprExp i (AppE e1 e2) = parensIf (i >= appPrec) $ pprExp opPrec e1
+ <+> pprExp appPrec e2
+pprExp i (AppTypeE e t)
+ = parensIf (i >= appPrec) $ pprExp opPrec e <+> char '@' <> pprParendType t
+pprExp _ (ParensE e) = parens (pprExp noPrec e)
+pprExp i (UInfixE e1 op e2)
+ = parensIf (i > unopPrec) $ pprExp unopPrec e1
+ <+> pprInfixExp op
+ <+> pprExp unopPrec e2
+pprExp i (InfixE (Just e1) op (Just e2))
+ = parensIf (i >= opPrec) $ pprExp opPrec e1
+ <+> pprInfixExp op
+ <+> pprExp opPrec e2
+pprExp _ (InfixE me1 op me2) = parens $ pprMaybeExp noPrec me1
+ <+> pprInfixExp op
+ <+> pprMaybeExp noPrec me2
+pprExp i (LamE [] e) = pprExp i e -- #13856
+pprExp i (LamE ps e) = parensIf (i > noPrec) $ char '\\' <> hsep (map (pprPat appPrec) ps)
+ <+> text "->" <+> ppr e
+pprExp i (LamCaseE ms)
+ = parensIf (i > noPrec) $ text "\\case" $$ braces (semiSep ms)
+pprExp i (LamCasesE ms)
+ = parensIf (i > noPrec) $ text "\\cases" $$ braces (semi_sep ms)
+ where semi_sep = sep . punctuate semi . map (pprClause False)
+pprExp i (TupE es)
+ | [Just e] <- es
+ = pprExp i (ConE (tupleDataName 1) `AppE` e)
+ | otherwise
+ = parens (commaSepWith (pprMaybeExp noPrec) es)
+pprExp _ (UnboxedTupE es) = hashParens (commaSepWith (pprMaybeExp noPrec) es)
+pprExp _ (UnboxedSumE e alt arity) = unboxedSumBars (ppr e) alt arity
+-- Nesting in Cond is to avoid potential problems in do statements
+pprExp i (CondE guard true false)
+ = parensIf (i > noPrec) $ sep [text "if" <+> ppr guard,
+ nest 1 $ text "then" <+> ppr true,
+ nest 1 $ text "else" <+> ppr false]
+pprExp i (MultiIfE alts)
+ = parensIf (i > noPrec) $ vcat $
+ case alts of
+ [] -> [text "if {}"]
+ (alt : alts') -> text "if" <+> pprGuarded arrow alt
+ : map (nest 3 . pprGuarded arrow) alts'
+pprExp i (LetE ds_ e) = parensIf (i > noPrec) $ text "let" <+> pprDecs ds_
+ $$ text " in" <+> ppr e
+ where
+ pprDecs [] = empty
+ pprDecs [d] = ppr d
+ pprDecs ds = braces (semiSep ds)
+
+pprExp i (CaseE e ms)
+ = parensIf (i > noPrec) $ text "case" <+> ppr e <+> text "of"
+ $$ braces (semiSep ms)
+pprExp i (DoE m ss_) = parensIf (i > noPrec) $
+ pprQualifier m <> text "do" <+> pprStms ss_
+ where
+ pprQualifier Nothing = empty
+ pprQualifier (Just modName) = text (modString modName) <> char '.'
+ pprStms [] = empty
+ pprStms [s] = ppr s
+ pprStms ss = braces (semiSep ss)
+pprExp i (MDoE m ss_) = parensIf (i > noPrec) $
+ pprQualifier m <> text "mdo" <+> pprStms ss_
+ where
+ pprQualifier Nothing = empty
+ pprQualifier (Just modName) = text (modString modName) <> char '.'
+ pprStms [] = empty
+ pprStms [s] = ppr s
+ pprStms ss = braces (semiSep ss)
+
+pprExp _ (CompE []) = text "<<Empty CompExp>>"
+-- This will probably break with fixity declarations - would need a ';'
+pprExp _ (CompE ss) =
+ if null ss'
+ -- If there are no statements in a list comprehension besides the last
+ -- one, we simply treat it like a normal list.
+ then text "[" <> ppr s <> text "]"
+ else text "[" <> ppr s
+ <+> bar
+ <+> commaSep ss'
+ <> text "]"
+ where s = last ss
+ ss' = init ss
+pprExp _ (ArithSeqE d) = ppr d
+pprExp _ (ListE es) = brackets (commaSep es)
+pprExp i (SigE e t) = parensIf (i > noPrec) $ pprExp sigPrec e
+ <+> dcolon <+> pprType sigPrec t
+pprExp _ (RecConE nm fs) = pprName' Applied nm <> braces (pprFields fs)
+pprExp _ (RecUpdE e fs) = pprExp appPrec e <> braces (pprFields fs)
+pprExp i (StaticE e) = parensIf (i >= appPrec) $
+ text "static"<+> pprExp appPrec e
+pprExp _ (UnboundVarE v) = pprName' Applied v
+pprExp _ (LabelE s) = text "#" <> text s
+pprExp _ (ImplicitParamVarE n) = text ('?' : n)
+pprExp _ (GetFieldE e f) = pprExp appPrec e <> text ('.': f)
+pprExp _ (ProjectionE xs) = parens $ hcat $ map ((char '.'<>) . text) $ toList xs
+pprExp _ (TypedBracketE e) = text "[||" <> ppr e <> text "||]"
+pprExp _ (TypedSpliceE e) = text "$$" <> pprExp appPrec e
+pprExp i (TypeE t) = parensIf (i > noPrec) $ text "type" <+> ppr t
+
+pprFields :: [(Name,Exp)] -> Doc
+pprFields = sep . punctuate comma . map (\(s,e) -> pprName' Applied s <+> equals <+> ppr e)
+
+pprMaybeExp :: Precedence -> Maybe Exp -> Doc
+pprMaybeExp _ Nothing = empty
+pprMaybeExp i (Just e) = pprExp i e
+
+------------------------------
+instance Ppr Stmt where
+ ppr (BindS p e) = ppr p <+> text "<-" <+> ppr e
+ ppr (LetS ds) = text "let" <+> (braces (semiSep ds))
+ ppr (NoBindS e) = ppr e
+ ppr (ParS sss) = sep $ punctuate bar
+ $ map commaSep sss
+ ppr (RecS ss) = text "rec" <+> (braces (semiSep ss))
+
+------------------------------
+instance Ppr Match where
+ ppr (Match p rhs ds) = pprMatchPat p <+> pprBody False rhs
+ $$ where_clause ds
+
+pprMatchPat :: Pat -> Doc
+-- Everything except pattern signatures bind more tightly than (->)
+pprMatchPat p@(SigP {}) = parens (ppr p)
+pprMatchPat p = ppr p
+
+------------------------------
+pprGuarded :: Doc -> (Guard, Exp) -> Doc
+pprGuarded eqDoc (guard, expr) = case guard of
+ NormalG guardExpr -> bar <+> ppr guardExpr <+> eqDoc <+> ppr expr
+ PatG stmts -> bar <+> vcat (punctuate comma $ map ppr stmts) $$
+ nest nestDepth (eqDoc <+> ppr expr)
+
+------------------------------
+pprBody :: Bool -> Body -> Doc
+pprBody eq body = case body of
+ GuardedB xs -> nest nestDepth $ vcat $ map (pprGuarded eqDoc) xs
+ NormalB e -> eqDoc <+> ppr e
+ where eqDoc | eq = equals
+ | otherwise = arrow
+
+------------------------------
+pprClause :: Bool -> Clause -> Doc
+pprClause eqDoc (Clause ps rhs ds)
+ = hsep (map (pprPat appPrec) ps) <+> pprBody eqDoc rhs
+ $$ where_clause ds
+
+------------------------------
+instance Ppr Lit where
+ ppr = pprLit noPrec
+
+pprLit :: Precedence -> Lit -> Doc
+pprLit i (IntPrimL x) = parensIf (i > noPrec && x < 0)
+ (integer x <> char '#')
+pprLit _ (WordPrimL x) = integer x <> text "##"
+pprLit i (FloatPrimL x) = parensIf (i > noPrec && x < 0)
+ (float (fromRational x) <> char '#')
+pprLit i (DoublePrimL x) = parensIf (i > noPrec && x < 0)
+ (double (fromRational x) <> text "##")
+pprLit i (IntegerL x) = parensIf (i > noPrec && x < 0) (integer x)
+pprLit _ (CharL c) = text (show c)
+pprLit _ (CharPrimL c) = text (show c) <> char '#'
+pprLit _ (StringL s) = pprString s
+pprLit _ (StringPrimL s) = pprString (bytesToString s) <> char '#'
+pprLit _ (BytesPrimL {}) = pprString "<binary data>"
+pprLit i (RationalL rat)
+ | withoutFactor 2 (withoutFactor 5 $ denominator rat) /= 1
+ -- if the denominator has prime factors other than 2 and 5
+ -- or can't be represented as Double, show as fraction
+ = parensIf (i > noPrec) $
+ integer (numerator rat) <+> char '/' <+> integer (denominator rat)
+ | rat /= 0 && (zeroes < -2 || zeroes > 6),
+ let (n, d) = properFraction (rat / magnitude)
+ -- if < 0.01 or >= 100_000_000, use scientific notation
+ = parensIf (i > noPrec && rat < 0)
+ (integer n
+ <> (if d == 0 then empty else char '.' <> decimals (abs d))
+ <> char 'e' <> integer zeroes)
+ | let (n, d) = properFraction rat
+ = parensIf (i > noPrec && rat < 0)
+ (integer n <> char '.'
+ <> if d == 0 then char '0' else decimals (abs d))
+ where zeroes :: Integer
+ zeroes = log10 (abs rat)
+ log10 :: Rational -> Integer
+ log10 x
+ | x >= 10 = 1 + log10 (x / 10)
+ | x < 1 = -1 + log10 (x * 10)
+ | otherwise = 0
+ magnitude :: Rational
+ magnitude = 10 ^^ zeroes
+ withoutFactor :: Integer -> Integer -> Integer
+ withoutFactor _ 0 = 0
+ withoutFactor p n
+ | (n', 0) <- divMod n p = withoutFactor p n'
+ | otherwise = n
+ -- | Expects the argument 0 <= x < 1
+ decimals :: Rational -> Doc
+ decimals x
+ | x == 0 = empty
+ | otherwise = integer n <> decimals d
+ where (n, d) = properFraction (x * 10)
+
+bytesToString :: [Word8] -> String
+bytesToString = map (chr . fromIntegral)
+
+pprString :: String -> Doc
+-- Print newlines as newlines with Haskell string escape notation,
+-- not as '\n'. For other non-printables use regular escape notation.
+pprString s = vcat (map text (showMultiLineString s))
+
+------------------------------
+instance Ppr Pat where
+ ppr = pprPat noPrec
+
+pprPat :: Precedence -> Pat -> Doc
+pprPat i (LitP l) = pprLit i l
+pprPat _ (VarP v) = pprName' Applied v
+pprPat i (TupP ps)
+ | [_] <- ps
+ = pprPat i (ConP (tupleDataName 1) [] ps)
+ | otherwise
+ = parens (commaSep ps)
+pprPat _ (UnboxedTupP ps) = hashParens (commaSep ps)
+pprPat _ (UnboxedSumP p alt arity) = unboxedSumBars (ppr p) alt arity
+pprPat i (ConP s ts ps) = parensIf (i >= appPrec) $
+ pprName' Applied s
+ <+> sep (map (\t -> char '@' <> pprParendType t) ts)
+ <+> sep (map (pprPat appPrec) ps)
+pprPat _ (ParensP p) = parens $ pprPat noPrec p
+pprPat i (UInfixP p1 n p2)
+ = parensIf (i > unopPrec) (pprPat unopPrec p1 <+>
+ pprName' Infix n <+>
+ pprPat unopPrec p2)
+pprPat i (InfixP p1 n p2)
+ = parensIf (i >= opPrec) (pprPat opPrec p1 <+>
+ pprName' Infix n <+>
+ pprPat opPrec p2)
+pprPat i (TildeP p) = parensIf (i > noPrec) $ char '~' <> pprPat appPrec p
+pprPat i (BangP p) = parensIf (i > noPrec) $ char '!' <> pprPat appPrec p
+pprPat i (AsP v p) = parensIf (i > noPrec) $ ppr v <> text "@"
+ <> pprPat appPrec p
+pprPat _ WildP = text "_"
+pprPat _ (RecP nm fs)
+ = parens $ pprName' Applied nm
+ <+> braces (sep $ punctuate comma $
+ map (\(s,p) -> pprName' Applied s <+> equals <+> ppr p) fs)
+pprPat _ (ListP ps) = brackets (commaSep ps)
+pprPat i (SigP p t) = parensIf (i > noPrec) $ ppr p <+> dcolon <+> ppr t
+pprPat _ (ViewP e p) = parens $ pprExp noPrec e <+> text "->" <+> pprPat noPrec p
+pprPat _ (TypeP t) = parens $ text "type" <+> ppr t
+pprPat _ (InvisP t) = parens $ text "@" <+> ppr t
+
+------------------------------
+instance Ppr Dec where
+ ppr = ppr_dec True
+
+ppr_dec :: Bool -- ^ declaration on the toplevel?
+ -> Dec
+ -> Doc
+ppr_dec isTop (FunD f cs) = layout $ map (\c -> pprPrefixOcc f <+> ppr c) cs
+ where
+ layout :: [Doc] -> Doc
+ layout = if isTop then vcat else semiSepWith id
+ppr_dec _ (ValD p r ds) = ppr p <+> pprBody True r
+ $$ where_clause ds
+ppr_dec _ (TySynD t xs rhs)
+ = ppr_tySyn empty (Just t) (hsep (map ppr xs)) rhs
+ppr_dec isTop (DataD ctxt t xs ksig cs decs)
+ = ppr_data isTop empty ctxt (Just t) (hsep (map ppr xs)) ksig cs decs
+ppr_dec isTop (NewtypeD ctxt t xs ksig c decs)
+ = ppr_newtype isTop empty ctxt (Just t) (sep (map ppr xs)) ksig c decs
+ppr_dec isTop (TypeDataD t xs ksig cs)
+ = ppr_type_data isTop empty [] (Just t) (hsep (map ppr xs)) ksig cs []
+ppr_dec _ (ClassD ctxt c xs fds ds)
+ = text "class" <+> pprCxt ctxt <+> pprName' Applied c <+> hsep (map ppr xs) <+> ppr fds
+ $$ where_clause ds
+ppr_dec _ (InstanceD o ctxt i ds) =
+ text "instance" <+> maybe empty ppr_overlap o <+> pprCxt ctxt <+> ppr i
+ $$ where_clause ds
+ppr_dec _ (SigD f t) = pprPrefixOcc f <+> dcolon <+> ppr t
+ppr_dec _ (KiSigD f k) = text "type" <+> pprPrefixOcc f <+> dcolon <+> ppr k
+ppr_dec _ (ForeignD f) = ppr f
+ppr_dec _ (InfixD fx ns_spec n) = pprFixity n fx ns_spec
+ppr_dec _ (DefaultD tys) =
+ text "default" <+> parens (sep $ punctuate comma $ map ppr tys)
+ppr_dec _ (PragmaD p) = ppr p
+ppr_dec isTop (DataFamilyD tc tvs kind)
+ = text "data" <+> maybeFamily <+> pprName' Applied tc <+> hsep (map ppr tvs) <+> maybeKind
+ where
+ maybeFamily | isTop = text "family"
+ | otherwise = empty
+ maybeKind | (Just k') <- kind = dcolon <+> ppr k'
+ | otherwise = empty
+ppr_dec isTop (DataInstD ctxt bndrs ty ksig cs decs)
+ = ppr_data isTop (maybeInst <+> ppr_bndrs bndrs)
+ ctxt Nothing (ppr ty) ksig cs decs
+ where
+ maybeInst | isTop = text "instance"
+ | otherwise = empty
+ppr_dec isTop (NewtypeInstD ctxt bndrs ty ksig c decs)
+ = ppr_newtype isTop (maybeInst <+> ppr_bndrs bndrs)
+ ctxt Nothing (ppr ty) ksig c decs
+ where
+ maybeInst | isTop = text "instance"
+ | otherwise = empty
+ppr_dec isTop (TySynInstD (TySynEqn mb_bndrs ty rhs))
+ = ppr_tySyn (maybeInst <+> ppr_bndrs mb_bndrs)
+ Nothing (ppr ty) rhs
+ where
+ maybeInst | isTop = text "instance"
+ | otherwise = empty
+ppr_dec isTop (OpenTypeFamilyD tfhead)
+ = text "type" <+> maybeFamily <+> ppr_tf_head tfhead
+ where
+ maybeFamily | isTop = text "family"
+ | otherwise = empty
+ppr_dec _ (ClosedTypeFamilyD tfhead eqns)
+ = hang (text "type family" <+> ppr_tf_head tfhead <+> text "where")
+ nestDepth (vcat (map ppr_eqn eqns))
+ where
+ ppr_eqn (TySynEqn mb_bndrs lhs rhs)
+ = ppr_bndrs mb_bndrs <+> ppr lhs <+> text "=" <+> ppr rhs
+ppr_dec _ (RoleAnnotD name roles)
+ = hsep [ text "type role", pprName' Applied name ] <+> hsep (map ppr roles)
+ppr_dec _ (StandaloneDerivD ds cxt ty)
+ = hsep [ text "deriving"
+ , maybe empty ppr_deriv_strategy ds
+ , text "instance"
+ , pprCxt cxt
+ , ppr ty ]
+ppr_dec _ (DefaultSigD n ty)
+ = hsep [ text "default", pprPrefixOcc n, dcolon, ppr ty ]
+ppr_dec _ (PatSynD name args dir pat)
+ = text "pattern" <+> pprNameArgs <+> ppr dir <+> pprPatRHS
+ where
+ pprNameArgs | InfixPatSyn a1 a2 <- args = ppr a1 <+> pprName' Infix name <+> ppr a2
+ | otherwise = pprName' Applied name <+> ppr args
+ pprPatRHS | ExplBidir cls <- dir = hang (ppr pat <+> text "where")
+ nestDepth
+ (vcat $ (pprName' Applied name <+>) . ppr <$> cls)
+ | otherwise = ppr pat
+ppr_dec _ (PatSynSigD name ty)
+ = pprPatSynSig name ty
+ppr_dec _ (ImplicitParamBindD n e)
+ = hsep [text ('?' : n), text "=", ppr e]
+
+ppr_deriv_strategy :: DerivStrategy -> Doc
+ppr_deriv_strategy ds =
+ case ds of
+ StockStrategy -> text "stock"
+ AnyclassStrategy -> text "anyclass"
+ NewtypeStrategy -> text "newtype"
+ ViaStrategy ty -> text "via" <+> pprParendType ty
+
+ppr_overlap :: Overlap -> Doc
+ppr_overlap o = text $
+ case o of
+ Overlaps -> "{-# OVERLAPS #-}"
+ Overlappable -> "{-# OVERLAPPABLE #-}"
+ Overlapping -> "{-# OVERLAPPING #-}"
+ Incoherent -> "{-# INCOHERENT #-}"
+
+ppr_data :: Bool -- ^ declaration on the toplevel?
+ -> Doc -> Cxt -> Maybe Name -> Doc -> Maybe Kind -> [Con] -> [DerivClause]
+ -> Doc
+ppr_data = ppr_typedef "data"
+
+ppr_newtype :: Bool -- ^ declaration on the toplevel?
+ -> Doc -> Cxt -> Maybe Name -> Doc -> Maybe Kind -> Con -> [DerivClause]
+ -> Doc
+ppr_newtype isTop maybeInst ctxt t argsDoc ksig c decs
+ = ppr_typedef "newtype" isTop maybeInst ctxt t argsDoc ksig [c] decs
+
+ppr_type_data :: Bool -- ^ declaration on the toplevel?
+ -> Doc -> Cxt -> Maybe Name -> Doc -> Maybe Kind -> [Con] -> [DerivClause]
+ -> Doc
+ppr_type_data = ppr_typedef "type data"
+
+ppr_typedef :: String -> Bool -> Doc -> Cxt -> Maybe Name -> Doc -> Maybe Kind -> [Con] -> [DerivClause] -> Doc
+ppr_typedef data_or_newtype isTop maybeInst ctxt t argsDoc ksig cs decs
+ = sep [text data_or_newtype <+> maybeInst
+ <+> pprCxt ctxt
+ <+> case t of
+ Just n -> pprName' Applied n <+> argsDoc
+ Nothing -> argsDoc
+ <+> ksigDoc <+> maybeWhere,
+ nest nestDepth (layout (pref $ map ppr cs)),
+ if null decs
+ then empty
+ else nest nestDepth
+ $ vcat $ map ppr_deriv_clause decs]
+ where
+ pref :: [Doc] -> [Doc]
+ pref xs | isGadtDecl = xs
+ pref [] = [] -- No constructors; can't happen in H98
+ pref (d:ds) = (char '=' <+> d):map (bar <+>) ds
+
+ layout :: [Doc] -> Doc
+ layout | isGadtDecl && not isTop = braces . semiSepWith id
+ | otherwise = vcat
+
+ maybeWhere :: Doc
+ maybeWhere | isGadtDecl = text "where"
+ | otherwise = empty
+
+ isGadtDecl :: Bool
+ isGadtDecl = not (null cs) && all isGadtCon cs
+ where isGadtCon (GadtC _ _ _ ) = True
+ isGadtCon (RecGadtC _ _ _) = True
+ isGadtCon (ForallC _ _ x ) = isGadtCon x
+ isGadtCon _ = False
+
+ ksigDoc = case ksig of
+ Nothing -> empty
+ Just k -> dcolon <+> ppr k
+
+
+ppr_deriv_clause :: DerivClause -> Doc
+ppr_deriv_clause (DerivClause ds ctxt)
+ = text "deriving" <+> pp_strat_before
+ <+> ppr_cxt_preds appPrec ctxt
+ <+> pp_strat_after
+ where
+ -- @via@ is unique in that in comes /after/ the class being derived,
+ -- so we must special-case it.
+ (pp_strat_before, pp_strat_after) =
+ case ds of
+ Just (via@ViaStrategy{}) -> (empty, ppr_deriv_strategy via)
+ _ -> (maybe empty ppr_deriv_strategy ds, empty)
+
+ppr_tySyn :: Doc -> Maybe Name -> Doc -> Type -> Doc
+ppr_tySyn maybeInst t argsDoc rhs
+ = text "type" <+> maybeInst
+ <+> case t of
+ Just n -> pprName' Applied n <+> argsDoc
+ Nothing -> argsDoc
+ <+> text "=" <+> ppr rhs
+
+ppr_tf_head :: TypeFamilyHead -> Doc
+ppr_tf_head (TypeFamilyHead tc tvs res inj)
+ = pprName' Applied tc <+> hsep (map ppr tvs) <+> ppr res <+> maybeInj
+ where
+ maybeInj | (Just inj') <- inj = ppr inj'
+ | otherwise = empty
+
+ppr_bndrs :: PprFlag flag => Maybe [TyVarBndr flag] -> Doc
+ppr_bndrs (Just bndrs) = text "forall" <+> sep (map ppr bndrs) <> text "."
+ppr_bndrs Nothing = empty
+
+------------------------------
+instance Ppr FunDep where
+ ppr (FunDep xs ys) = hsep (map ppr xs) <+> text "->" <+> hsep (map ppr ys)
+ ppr_list [] = empty
+ ppr_list xs = bar <+> commaSep xs
+
+------------------------------
+instance Ppr FamilyResultSig where
+ ppr NoSig = empty
+ ppr (KindSig k) = dcolon <+> ppr k
+ ppr (TyVarSig bndr) = text "=" <+> ppr bndr
+
+------------------------------
+instance Ppr InjectivityAnn where
+ ppr (InjectivityAnn lhs rhs) =
+ bar <+> ppr lhs <+> text "->" <+> hsep (map ppr rhs)
+
+------------------------------
+instance Ppr Foreign where
+ ppr (ImportF callconv safety impent as typ)
+ = text "foreign import"
+ <+> showtextl callconv
+ <+> showtextl safety
+ <+> text (show impent)
+ <+> pprName' Applied as
+ <+> dcolon <+> ppr typ
+ ppr (ExportF callconv expent as typ)
+ = text "foreign export"
+ <+> showtextl callconv
+ <+> text (show expent)
+ <+> pprName' Applied as
+ <+> dcolon <+> ppr typ
+
+------------------------------
+instance Ppr Pragma where
+ ppr (InlineP n inline rm phases)
+ = text "{-#"
+ <+> ppr inline
+ <+> ppr rm
+ <+> ppr phases
+ <+> pprName' Applied n
+ <+> text "#-}"
+ ppr (OpaqueP n)
+ = text "{-# OPAQUE" <+> pprName' Applied n <+> text "#-}"
+ ppr (SpecialiseP n ty inline phases)
+ = text "{-# SPECIALISE"
+ <+> maybe empty ppr inline
+ <+> ppr phases
+ <+> sep [ pprName' Applied n <+> dcolon
+ , nest 2 $ ppr ty ]
+ <+> text "#-}"
+ ppr (SpecialiseInstP inst)
+ = text "{-# SPECIALISE instance" <+> ppr inst <+> text "#-}"
+ ppr (RuleP n ty_bndrs tm_bndrs lhs rhs phases)
+ = sep [ text "{-# RULES" <+> pprString n <+> ppr phases
+ , nest 4 $ ppr_ty_forall ty_bndrs <+> ppr_tm_forall ty_bndrs
+ <+> ppr lhs
+ , nest 4 $ char '=' <+> ppr rhs <+> text "#-}" ]
+ where ppr_ty_forall Nothing = empty
+ ppr_ty_forall (Just bndrs) = text "forall"
+ <+> fsep (map ppr bndrs)
+ <+> char '.'
+ ppr_tm_forall Nothing | null tm_bndrs = empty
+ ppr_tm_forall _ = text "forall"
+ <+> fsep (map ppr tm_bndrs)
+ <+> char '.'
+ ppr (AnnP tgt expr)
+ = text "{-# ANN" <+> target1 tgt <+> ppr expr <+> text "#-}"
+ where target1 ModuleAnnotation = text "module"
+ target1 (TypeAnnotation t) = text "type" <+> pprName' Applied t
+ target1 (ValueAnnotation v) = pprName' Applied v
+ ppr (LineP line file)
+ = text "{-# LINE" <+> int line <+> text (show file) <+> text "#-}"
+ ppr (CompleteP cls mty)
+ = text "{-# COMPLETE" <+> (fsep $ punctuate comma $ map (pprName' Applied) cls)
+ <+> maybe empty (\ty -> dcolon <+> pprName' Applied ty) mty <+> text "#-}"
+ ppr (SCCP nm str)
+ = text "{-# SCC" <+> pprName' Applied nm <+> maybe empty pprString str <+> text "#-}"
+
+------------------------------
+instance Ppr Inline where
+ ppr NoInline = text "NOINLINE"
+ ppr Inline = text "INLINE"
+ ppr Inlinable = text "INLINABLE"
+
+------------------------------
+instance Ppr RuleMatch where
+ ppr ConLike = text "CONLIKE"
+ ppr FunLike = empty
+
+------------------------------
+instance Ppr Phases where
+ ppr AllPhases = empty
+ ppr (FromPhase i) = brackets $ int i
+ ppr (BeforePhase i) = brackets $ char '~' <> int i
+
+------------------------------
+instance Ppr RuleBndr where
+ ppr (RuleVar n) = ppr n
+ ppr (TypedRuleVar n ty) = parens $ ppr n <+> dcolon <+> ppr ty
+
+------------------------------
+instance Ppr Clause where
+ ppr = pprClause True
+
+------------------------------
+instance Ppr Con where
+ ppr (NormalC c sts) = pprName' Applied c <+> sep (map pprBangType sts)
+
+ ppr (RecC c vsts)
+ = pprName' Applied c <+> braces (sep (punctuate comma $ map pprVarBangType vsts))
+
+ ppr (InfixC st1 c st2) = pprBangType st1
+ <+> pprName' Infix c
+ <+> pprBangType st2
+
+ ppr (ForallC ns ctxt (GadtC cs sts ty))
+ = commaSepApplied cs <+> dcolon <+> pprForall ns ctxt
+ <+> pprGadtRHS sts ty
+
+ ppr (ForallC ns ctxt (RecGadtC cs vsts ty))
+ = commaSepApplied cs <+> dcolon <+> pprForall ns ctxt
+ <+> pprRecFields vsts ty
+
+ ppr (ForallC ns ctxt con)
+ = pprForall ns ctxt <+> ppr con
+
+ ppr (GadtC cs sts ty)
+ = commaSepApplied cs <+> dcolon <+> pprGadtRHS sts ty
+
+ ppr (RecGadtC cs vsts ty)
+ = commaSepApplied cs <+> dcolon <+> pprRecFields vsts ty
+
+instance Ppr PatSynDir where
+ ppr Unidir = text "<-"
+ ppr ImplBidir = text "="
+ ppr (ExplBidir _) = text "<-"
+ -- the ExplBidir's clauses are pretty printed together with the
+ -- entire pattern synonym; so only print the direction here.
+
+instance Ppr PatSynArgs where
+ ppr (PrefixPatSyn args) = sep $ map ppr args
+ ppr (InfixPatSyn a1 a2) = ppr a1 <+> ppr a2
+ ppr (RecordPatSyn sels) = braces $ sep (punctuate comma (map (pprName' Applied) sels))
+
+commaSepApplied :: [Name] -> Doc
+commaSepApplied = commaSepWith (pprName' Applied)
+
+pprForall :: [TyVarBndr Specificity] -> Cxt -> Doc
+pprForall = pprForall' ForallInvis
+
+pprForallVis :: [TyVarBndr ()] -> Cxt -> Doc
+pprForallVis = pprForall' ForallVis
+
+pprForall' :: PprFlag flag => ForallVisFlag -> [TyVarBndr flag] -> Cxt -> Doc
+pprForall' fvf tvs cxt
+ -- even in the case without any tvs, there could be a non-empty
+ -- context cxt (e.g., in the case of pattern synonyms, where there
+ -- are multiple forall binders and contexts).
+ | [] <- tvs = pprCxt cxt
+ | otherwise = text "forall" <+> hsep (map ppr tvs)
+ <+> separator <+> pprCxt cxt
+ where
+ separator = case fvf of
+ ForallVis -> text "->"
+ ForallInvis -> char '.'
+
+pprRecFields :: [(Name, Strict, Type)] -> Type -> Doc
+pprRecFields vsts ty
+ = braces (sep (punctuate comma $ map pprVarBangType vsts))
+ <+> arrow <+> ppr ty
+
+pprGadtRHS :: [(Strict, Type)] -> Type -> Doc
+pprGadtRHS [] ty
+ = ppr ty
+pprGadtRHS sts ty
+ = sep (punctuate (space <> arrow) (map pprBangType sts))
+ <+> arrow <+> ppr ty
+
+------------------------------
+pprVarBangType :: VarBangType -> Doc
+-- Slight infelicity: with print non-atomic type with parens
+pprVarBangType (v, bang, t) = pprName' Applied v <+> dcolon <+> pprBangType (bang, t)
+
+------------------------------
+pprBangType :: BangType -> Doc
+-- Make sure we print
+--
+-- Con {-# UNPACK #-} a
+--
+-- rather than
+--
+-- Con {-# UNPACK #-}a
+--
+-- when there's no strictness annotation. If there is a strictness annotation,
+-- it's okay to not put a space between it and the type.
+pprBangType (bt@(Bang _ NoSourceStrictness), t) = ppr bt <+> pprParendType t
+pprBangType (bt, t) = ppr bt <> pprParendType t
+
+------------------------------
+instance Ppr Bang where
+ ppr (Bang su ss) = ppr su <+> ppr ss
+
+------------------------------
+instance Ppr SourceUnpackedness where
+ ppr NoSourceUnpackedness = empty
+ ppr SourceNoUnpack = text "{-# NOUNPACK #-}"
+ ppr SourceUnpack = text "{-# UNPACK #-}"
+
+------------------------------
+instance Ppr SourceStrictness where
+ ppr NoSourceStrictness = empty
+ ppr SourceLazy = char '~'
+ ppr SourceStrict = char '!'
+
+------------------------------
+instance Ppr DecidedStrictness where
+ ppr DecidedLazy = empty
+ ppr DecidedStrict = char '!'
+ ppr DecidedUnpack = text "{-# UNPACK #-} !"
+
+------------------------------
+{-# DEPRECATED pprVarStrictType
+ "As of @template-haskell-2.11.0.0@, 'VarStrictType' has been replaced by 'VarBangType'. Please use 'pprVarBangType' instead." #-}
+pprVarStrictType :: (Name, Strict, Type) -> Doc
+pprVarStrictType = pprVarBangType
+
+------------------------------
+{-# DEPRECATED pprStrictType
+ "As of @template-haskell-2.11.0.0@, 'StrictType' has been replaced by 'BangType'. Please use 'pprBangType' instead." #-}
+pprStrictType :: (Strict, Type) -> Doc
+pprStrictType = pprBangType
+
+------------------------------
+pprType :: Precedence -> Type -> Doc
+pprType _ (VarT v) = pprName' Applied v
+-- `Applied` is used here instead of `ppr` because of infix names (#13887)
+pprType _ (ConT c) = pprName' Applied c
+pprType _ (TupleT 0) = text "()"
+pprType p (TupleT 1) = pprType p (ConT (tupleTypeName 1))
+pprType _ (TupleT n) = parens (hcat (replicate (n-1) comma))
+pprType _ (UnboxedTupleT n) = hashParens $ hcat $ replicate (n-1) comma
+pprType _ (UnboxedSumT arity) = hashParens $ hcat $ replicate (arity-1) bar
+pprType _ ArrowT = parens (text "->")
+pprType _ MulArrowT = text "FUN"
+pprType _ ListT = text "[]"
+pprType _ (LitT l) = pprTyLit l
+pprType _ (PromotedT c) = text "'" <> pprName' Applied c
+pprType _ (PromotedTupleT 0) = text "'()"
+pprType p (PromotedTupleT 1) = pprType p (PromotedT (tupleDataName 1))
+pprType _ (PromotedTupleT n) = quoteParens (hcat (replicate (n-1) comma))
+pprType _ PromotedNilT = text "'[]"
+pprType _ PromotedConsT = text "'(:)"
+pprType _ StarT = char '*'
+pprType _ ConstraintT = text "Constraint"
+pprType _ (SigT ty k) = parens (ppr ty <+> text "::" <+> ppr k)
+pprType _ WildCardT = char '_'
+pprType p t@(InfixT {}) = pprInfixT p t
+pprType p t@(UInfixT {}) = pprInfixT p t
+pprType p t@(PromotedInfixT {}) = pprInfixT p t
+pprType p t@(PromotedUInfixT {}) = pprInfixT p t
+pprType _ (ParensT t) = parens (pprType noPrec t)
+pprType p (ImplicitParamT n ty) =
+ parensIf (p >= sigPrec) $ text ('?':n) <+> text "::" <+> pprType sigPrec ty
+pprType _ EqualityT = text "(~)"
+pprType p (ForallT tvars ctxt ty) =
+ parensIf (p >= funPrec) $ sep [pprForall tvars ctxt, pprType qualPrec ty]
+pprType p (ForallVisT tvars ty) =
+ parensIf (p >= funPrec) $ sep [pprForallVis tvars [], pprType qualPrec ty]
+pprType p t@AppT{} = pprTyApp p (split t)
+pprType p t@AppKindT{} = pprTyApp p (split t)
+
+------------------------------
+pprParendType :: Type -> Doc
+pprParendType = pprType appPrec
+
+pprInfixT :: Precedence -> Type -> Doc
+pprInfixT p = \case
+ InfixT x n y -> with x n y "" opPrec
+ UInfixT x n y -> with x n y "" unopPrec
+ PromotedInfixT x n y -> with x n y "'" opPrec
+ PromotedUInfixT x n y -> with x n y "'" unopPrec
+ t -> pprParendType t
+ where
+ with x n y prefix p' =
+ parensIf
+ (p >= p')
+ (pprType opPrec x <+> text prefix <> pprName' Infix n <+> pprType opPrec y)
+
+instance Ppr Type where
+ ppr = pprType noPrec
+instance Ppr TypeArg where
+ ppr (TANormal ty) = ppr ty
+ ppr (TyArg ki) = char '@' <> parensIf (isStarT ki) (ppr ki)
+
+pprParendTypeArg :: TypeArg -> Doc
+pprParendTypeArg (TANormal ty) = pprParendType ty
+pprParendTypeArg (TyArg ki) = char '@' <> parensIf (isStarT ki) (pprParendType ki)
+
+isStarT :: Type -> Bool
+isStarT StarT = True
+isStarT _ = False
+
+{- Note [Pretty-printing kind signatures]
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+GHC's parser only recognises a kind signature in a type when there are
+parens around it. E.g. the parens are required here:
+ f :: (Int :: *)
+ type instance F Int = (Bool :: *)
+So we always print a SigT with parens (see #10050). -}
+
+pprTyApp :: Precedence -> (Type, [TypeArg]) -> Doc
+pprTyApp p app@(MulArrowT, [TANormal (PromotedT c), TANormal arg1, TANormal arg2])
+ | p >= funPrec = parens (pprTyApp noPrec app)
+ | c == oneName = sep [pprFunArgType arg1 <+> text "%1 ->", pprType qualPrec arg2]
+ | c == manyName = sep [pprFunArgType arg1 <+> text "->", pprType qualPrec arg2]
+pprTyApp p (MulArrowT, [TANormal argm, TANormal arg1, TANormal arg2]) =
+ parensIf (p >= funPrec) $
+ sep [pprFunArgType arg1 <+> text "%" <> pprType appPrec argm <+> text "->",
+ pprType qualPrec arg2]
+pprTyApp p (ArrowT, [TANormal arg1, TANormal arg2]) =
+ parensIf (p >= funPrec) $
+ sep [pprFunArgType arg1 <+> text "->", pprType qualPrec arg2]
+pprTyApp p (EqualityT, [TANormal arg1, TANormal arg2]) =
+ parensIf (p >= opPrec) $
+ sep [pprType opPrec arg1 <+> text "~", pprType opPrec arg2]
+pprTyApp _ (ListT, [TANormal arg]) = brackets (pprType noPrec arg)
+pprTyApp p (TupleT 1, args) = pprTyApp p (ConT (tupleTypeName 1), args)
+pprTyApp _ (TupleT n, args)
+ | length args == n, Just args' <- traverse fromTANormal args
+ = parens (commaSep args')
+pprTyApp p (PromotedTupleT 1, args) = pprTyApp p (PromotedT (tupleDataName 1), args)
+pprTyApp _ (PromotedTupleT n, args)
+ | length args == n, Just args' <- traverse fromTANormal args
+ = quoteParens (commaSep args')
+pprTyApp p (fun, args) =
+ parensIf (p >= appPrec) $ pprParendType fun <+> sep (map pprParendTypeArg args)
+
+fromTANormal :: TypeArg -> Maybe Type
+fromTANormal (TANormal arg) = Just arg
+fromTANormal (TyArg _) = Nothing
+
+-- Print the type to the left of @->@. Everything except forall and (->) binds more tightly than (->).
+pprFunArgType :: Type -> Doc
+pprFunArgType = pprType funPrec
+
+data ForallVisFlag = ForallVis -- forall a -> {...}
+ | ForallInvis -- forall a. {...}
+ deriving Show
+
+data TypeArg = TANormal Type
+ | TyArg Kind
+
+split :: Type -> (Type, [TypeArg]) -- Split into function and args
+split t = go t []
+ where go (AppT t1 t2) args = go t1 (TANormal t2:args)
+ go (AppKindT ty ki) args = go ty (TyArg ki:args)
+ go ty args = (ty, args)
+
+pprTyLit :: TyLit -> Doc
+pprTyLit (NumTyLit n) = integer n
+pprTyLit (StrTyLit s) = text (show s)
+pprTyLit (CharTyLit c) = text (show c)
+
+instance Ppr TyLit where
+ ppr = pprTyLit
+
+------------------------------
+class PprFlag flag where
+ pprTyVarBndr :: (TyVarBndr flag) -> Doc
+
+instance PprFlag () where
+ pprTyVarBndr (PlainTV nm ()) = ppr nm
+ pprTyVarBndr (KindedTV nm () k) = parens (ppr nm <+> dcolon <+> ppr k)
+
+instance PprFlag Specificity where
+ pprTyVarBndr (PlainTV nm SpecifiedSpec) = ppr nm
+ pprTyVarBndr (PlainTV nm InferredSpec) = braces (ppr nm)
+ pprTyVarBndr (KindedTV nm SpecifiedSpec k) = parens (ppr nm <+> dcolon <+> ppr k)
+ pprTyVarBndr (KindedTV nm InferredSpec k) = braces (ppr nm <+> dcolon <+> ppr k)
+
+instance PprFlag BndrVis where
+ pprTyVarBndr (PlainTV nm vis) = pprBndrVis vis (ppr nm)
+ pprTyVarBndr (KindedTV nm vis k) = pprBndrVis vis (parens (ppr nm <+> dcolon <+> ppr k))
+
+pprBndrVis :: BndrVis -> Doc -> Doc
+pprBndrVis BndrReq d = d
+pprBndrVis BndrInvis d = char '@' <> d
+
+instance PprFlag flag => Ppr (TyVarBndr flag) where
+ ppr bndr = pprTyVarBndr bndr
+
+instance Ppr Role where
+ ppr NominalR = text "nominal"
+ ppr RepresentationalR = text "representational"
+ ppr PhantomR = text "phantom"
+ ppr InferR = text "_"
+
+------------------------------
+pprCxt :: Cxt -> Doc
+pprCxt [] = empty
+pprCxt ts = ppr_cxt_preds funPrec ts <+> text "=>"
+
+ppr_cxt_preds :: Precedence -> Cxt -> Doc
+ppr_cxt_preds _ [] = text "()"
+ppr_cxt_preds p [t] = pprType p t
+ppr_cxt_preds _ ts = parens (commaSep ts)
+
+------------------------------
+instance Ppr Range where
+ ppr = brackets . pprRange
+ where pprRange :: Range -> Doc
+ pprRange (FromR e) = ppr e <+> text ".."
+ pprRange (FromThenR e1 e2) = ppr e1 <> text ","
+ <+> ppr e2 <+> text ".."
+ pprRange (FromToR e1 e2) = ppr e1 <+> text ".." <+> ppr e2
+ pprRange (FromThenToR e1 e2 e3) = ppr e1 <> text ","
+ <+> ppr e2 <+> text ".."
+ <+> ppr e3
+
+------------------------------
+where_clause :: [Dec] -> Doc
+where_clause [] = empty
+where_clause ds = nest nestDepth $ text "where" <+> braces (semiSepWith (ppr_dec False) ds)
+
+showtextl :: Show a => a -> Doc
+showtextl = text . map toLower . show
+
+hashParens :: Doc -> Doc
+hashParens d = text "(# " <> d <> text " #)"
+
+quoteParens :: Doc -> Doc
+quoteParens d = text "'(" <> d <> text ")"
+
+-----------------------------
+instance Ppr Loc where
+ ppr (Loc { loc_module = md
+ , loc_package = pkg
+ , loc_start = (start_ln, start_col)
+ , loc_end = (end_ln, end_col) })
+ = hcat [ text pkg, colon, text md, colon
+ , parens $ int start_ln <> comma <> int start_col
+ , text "-"
+ , parens $ int end_ln <> comma <> int end_col ]
+
+-- Takes a separator and a pretty-printing function and prints a list of things
+-- separated by the separator followed by space.
+sepWith :: Doc -> (a -> Doc) -> [a] -> Doc
+sepWith sepDoc pprFun = sep . punctuate sepDoc . map pprFun
+
+-- Takes a list of printable things and prints them separated by commas followed
+-- by space.
+commaSep :: Ppr a => [a] -> Doc
+commaSep = commaSepWith ppr
+
+-- Takes a list of things and prints them with the given pretty-printing
+-- function, separated by commas followed by space.
+commaSepWith :: (a -> Doc) -> [a] -> Doc
+commaSepWith pprFun = sepWith comma pprFun
+
+-- Takes a list of printable things and prints them separated by semicolons
+-- followed by space.
+semiSep :: Ppr a => [a] -> Doc
+semiSep = sep . punctuate semi . map ppr
+
+-- Takes a list of things and prints them with the given pretty-printing
+-- function, separated by semicolons followed by space.
+semiSepWith :: (a -> Doc) -> [a] -> Doc
+semiSepWith pprFun = sepWith semi pprFun
+
+-- Prints out the series of vertical bars that wraps an expression or pattern
+-- used in an unboxed sum.
+unboxedSumBars :: Doc -> SumAlt -> SumArity -> Doc
+unboxedSumBars d alt arity = hashParens $
+ bars (alt-1) <> d <> bars (arity - alt)
+ where
+ bars i = hsep (replicate i bar)
+
+-- Text containing the vertical bar character.
+bar :: Doc
+bar = char '|'
diff --git a/libraries/ghc-boot-th/GHC/Internal/TH/PprLib.hs b/libraries/ghc-boot-th/GHC/Internal/TH/PprLib.hs
new file mode 100644
index 0000000000000000000000000000000000000000..9754735df09200bfc18a166d70acc151be1205ef
--- /dev/null
+++ b/libraries/ghc-boot-th/GHC/Internal/TH/PprLib.hs
@@ -0,0 +1,226 @@
+{-# LANGUAGE FlexibleInstances, Safe #-}
+
+-- | Monadic front-end to Text.PrettyPrint
+
+module GHC.Internal.TH.PprLib (
+
+ -- * The document type
+ Doc, -- Abstract, instance of Show
+ PprM,
+
+ -- * Primitive Documents
+ empty,
+ semi, comma, colon, dcolon, space, equals, arrow,
+ lparen, rparen, lbrack, rbrack, lbrace, rbrace,
+
+ -- * Converting values into documents
+ text, char, ptext,
+ int, integer, float, double, rational,
+
+ -- * Wrapping documents in delimiters
+ parens, brackets, braces, quotes, doubleQuotes,
+
+ -- * Combining documents
+ (<>), (<+>), hcat, hsep,
+ ($$), ($+$), vcat,
+ sep, cat,
+ fsep, fcat,
+ nest,
+ hang, punctuate,
+
+ -- * Predicates on documents
+ isEmpty,
+
+ to_HPJ_Doc, pprName, pprName'
+ ) where
+
+
+import GHC.Internal.TH.Syntax
+ (Uniq, Name(..), showName', NameFlavour(..), NameIs(..))
+import qualified Text.PrettyPrint as HPJ
+import Control.Monad (liftM, liftM2, ap)
+import GHC.Internal.TH.Lib.Map ( Map )
+import qualified GHC.Internal.TH.Lib.Map as Map ( lookup, insert, empty )
+import Prelude hiding ((<>))
+
+infixl 6 <>
+infixl 6 <+>
+infixl 5 $$, $+$
+
+-- ---------------------------------------------------------------------------
+-- The interface
+
+-- The primitive Doc values
+
+instance Show Doc where
+ show d = HPJ.render (to_HPJ_Doc d)
+
+isEmpty :: Doc -> PprM Bool; -- ^ Returns 'True' if the document is empty
+
+empty :: Doc; -- ^ An empty document
+semi :: Doc; -- ^ A ';' character
+comma :: Doc; -- ^ A ',' character
+colon :: Doc; -- ^ A ':' character
+dcolon :: Doc; -- ^ A "::" string
+space :: Doc; -- ^ A space character
+equals :: Doc; -- ^ A '=' character
+arrow :: Doc; -- ^ A "->" string
+lparen :: Doc; -- ^ A '(' character
+rparen :: Doc; -- ^ A ')' character
+lbrack :: Doc; -- ^ A '[' character
+rbrack :: Doc; -- ^ A ']' character
+lbrace :: Doc; -- ^ A '{' character
+rbrace :: Doc; -- ^ A '}' character
+
+text :: String -> Doc
+ptext :: String -> Doc
+char :: Char -> Doc
+int :: Int -> Doc
+integer :: Integer -> Doc
+float :: Float -> Doc
+double :: Double -> Doc
+rational :: Rational -> Doc
+
+
+parens :: Doc -> Doc; -- ^ Wrap document in @(...)@
+brackets :: Doc -> Doc; -- ^ Wrap document in @[...]@
+braces :: Doc -> Doc; -- ^ Wrap document in @{...}@
+quotes :: Doc -> Doc; -- ^ Wrap document in @\'...\'@
+doubleQuotes :: Doc -> Doc; -- ^ Wrap document in @\"...\"@
+
+-- Combining @Doc@ values
+
+(<>) :: Doc -> Doc -> Doc; -- ^Beside
+hcat :: [Doc] -> Doc; -- ^List version of '<>'
+(<+>) :: Doc -> Doc -> Doc; -- ^Beside, separated by space
+hsep :: [Doc] -> Doc; -- ^List version of '<+>'
+
+($$) :: Doc -> Doc -> Doc; -- ^Above; if there is no
+ -- overlap it \"dovetails\" the two
+($+$) :: Doc -> Doc -> Doc; -- ^Above, without dovetailing.
+vcat :: [Doc] -> Doc; -- ^List version of '$$'
+
+cat :: [Doc] -> Doc; -- ^ Either hcat or vcat
+sep :: [Doc] -> Doc; -- ^ Either hsep or vcat
+fcat :: [Doc] -> Doc; -- ^ \"Paragraph fill\" version of cat
+fsep :: [Doc] -> Doc; -- ^ \"Paragraph fill\" version of sep
+
+nest :: Int -> Doc -> Doc; -- ^ Nested
+
+
+-- GHC-specific ones.
+
+hang :: Doc -> Int -> Doc -> Doc; -- ^ @hang d1 n d2 = sep [d1, nest n d2]@
+punctuate :: Doc -> [Doc] -> [Doc]
+ -- ^ @punctuate p [d1, ... dn] = [d1 \<> p, d2 \<> p, ... dn-1 \<> p, dn]@
+
+-- ---------------------------------------------------------------------------
+-- The "implementation"
+
+type State = (Map Name Name, Uniq)
+data PprM a = PprM { runPprM :: State -> (a, State) }
+
+pprName :: Name -> Doc
+pprName = pprName' Alone
+
+pprName' :: NameIs -> Name -> Doc
+pprName' ni n@(Name o (NameU _))
+ = PprM $ \s@(fm, i)
+ -> let (n', s') = case Map.lookup n fm of
+ Just d -> (d, s)
+ Nothing -> let n'' = Name o (NameU i)
+ in (n'', (Map.insert n n'' fm, i + 1))
+ in (HPJ.text $ showName' ni n', s')
+pprName' ni n = text $ showName' ni n
+
+{-
+instance Show Name where
+ show (Name occ (NameU u)) = occString occ ++ "_" ++ show (I# u)
+ show (Name occ NameS) = occString occ
+ show (Name occ (NameG ns m)) = modString m ++ "." ++ occString occ
+
+data Name = Name OccName NameFlavour
+
+data NameFlavour
+ | NameU Int# -- A unique local name
+-}
+
+to_HPJ_Doc :: Doc -> HPJ.Doc
+to_HPJ_Doc d = fst $ runPprM d (Map.empty, 0)
+
+instance Functor PprM where
+ fmap = liftM
+
+instance Applicative PprM where
+ pure x = PprM $ \s -> (x, s)
+ (<*>) = ap
+
+instance Monad PprM where
+ m >>= k = PprM $ \s -> let (x, s') = runPprM m s
+ in runPprM (k x) s'
+
+type Doc = PprM HPJ.Doc
+
+-- The primitive Doc values
+
+isEmpty = liftM HPJ.isEmpty
+
+empty = return HPJ.empty
+semi = return HPJ.semi
+comma = return HPJ.comma
+colon = return HPJ.colon
+dcolon = return $ HPJ.text "::"
+space = return HPJ.space
+equals = return HPJ.equals
+arrow = return $ HPJ.text "->"
+lparen = return HPJ.lparen
+rparen = return HPJ.rparen
+lbrack = return HPJ.lbrack
+rbrack = return HPJ.rbrack
+lbrace = return HPJ.lbrace
+rbrace = return HPJ.rbrace
+
+text = return . HPJ.text
+ptext = return . HPJ.ptext
+char = return . HPJ.char
+int = return . HPJ.int
+integer = return . HPJ.integer
+float = return . HPJ.float
+double = return . HPJ.double
+rational = return . HPJ.rational
+
+
+parens = liftM HPJ.parens
+brackets = liftM HPJ.brackets
+braces = liftM HPJ.braces
+quotes = liftM HPJ.quotes
+doubleQuotes = liftM HPJ.doubleQuotes
+
+-- Combining @Doc@ values
+
+(<>) = liftM2 (HPJ.<>)
+hcat = liftM HPJ.hcat . sequence
+(<+>) = liftM2 (HPJ.<+>)
+hsep = liftM HPJ.hsep . sequence
+
+($$) = liftM2 (HPJ.$$)
+($+$) = liftM2 (HPJ.$+$)
+vcat = liftM HPJ.vcat . sequence
+
+cat = liftM HPJ.cat . sequence
+sep = liftM HPJ.sep . sequence
+fcat = liftM HPJ.fcat . sequence
+fsep = liftM HPJ.fsep . sequence
+
+nest n = liftM (HPJ.nest n)
+
+hang d1 n d2 = do d1' <- d1
+ d2' <- d2
+ return (HPJ.hang d1' n d2')
+
+-- punctuate uses the same definition as Text.PrettyPrint
+punctuate _ [] = []
+punctuate p (d:ds) = go d ds
+ where
+ go d' [] = [d']
+ go d' (e:es) = (d' <> p) : go e es
diff --git a/libraries/ghc-boot-th/GHC/LanguageExtensions/Type.hs b/libraries/ghc-boot-th/GHC/LanguageExtensions/Type.hs
index a74427c920e1c834b62e739446654fc77b0e1d4e..c605adb9fed4d2ba17ac4245d1650e64714130a2 100644
--- a/libraries/ghc-boot-th/GHC/LanguageExtensions/Type.hs
+++ b/libraries/ghc-boot-th/GHC/LanguageExtensions/Type.hs
@@ -8,155 +8,7 @@
--
-- A data type defining the language extensions supported by GHC.
--
-{-# LANGUAGE DeriveGeneric, Safe #-}
+{-# LANGUAGE Safe #-}
module GHC.LanguageExtensions.Type ( Extension(..) ) where
-import Prelude -- See note [Why do we import Prelude here?]
-import GHC.Generics
-
--- | The language extensions known to GHC.
---
--- Note that there is an orphan 'Binary' instance for this type supplied by
--- the "GHC.LanguageExtensions" module provided by @ghc-boot@. We can't provide
--- here as this would require adding transitive dependencies to the
--- @template-haskell@ package, which must have a minimal dependency set.
-data Extension
--- See Note [Updating flag description in the User's Guide] in
--- GHC.Driver.Session
- = Cpp
- | OverlappingInstances
- | UndecidableInstances
- | IncoherentInstances
- | UndecidableSuperClasses
- | MonomorphismRestriction
- | MonoLocalBinds
- | DeepSubsumption
- | RelaxedPolyRec -- Deprecated
- | ExtendedDefaultRules -- Use GHC's extended rules for defaulting
- | ForeignFunctionInterface
- | UnliftedFFITypes
- | InterruptibleFFI
- | CApiFFI
- | GHCForeignImportPrim
- | JavaScriptFFI
- | ParallelArrays -- Syntactic support for parallel arrays
- | Arrows -- Arrow-notation syntax
- | TemplateHaskell
- | TemplateHaskellQuotes -- subset of TH supported by stage1, no splice
- | QualifiedDo
- | QuasiQuotes
- | ImplicitParams
- | ImplicitPrelude
- | ScopedTypeVariables
- | AllowAmbiguousTypes
- | UnboxedTuples
- | UnboxedSums
- | UnliftedNewtypes
- | UnliftedDatatypes
- | BangPatterns
- | TypeFamilies
- | TypeFamilyDependencies
- | TypeInType -- Deprecated
- | OverloadedStrings
- | OverloadedLists
- | NumDecimals
- | DisambiguateRecordFields
- | RecordWildCards
- | NamedFieldPuns
- | ViewPatterns
- | GADTs
- | GADTSyntax
- | NPlusKPatterns
- | DoAndIfThenElse
- | BlockArguments
- | RebindableSyntax
- | ConstraintKinds
- | PolyKinds -- Kind polymorphism
- | DataKinds -- Datatype promotion
- | TypeData -- allow @type data@ definitions
- | InstanceSigs
- | ApplicativeDo
- | LinearTypes
- | RequiredTypeArguments -- Visible forall (VDQ) in types of terms
-
- | StandaloneDeriving
- | DeriveDataTypeable
- | AutoDeriveTypeable -- Automatic derivation of Typeable
- | DeriveFunctor
- | DeriveTraversable
- | DeriveFoldable
- | DeriveGeneric -- Allow deriving Generic/1
- | DefaultSignatures -- Allow extra signatures for defmeths
- | DeriveAnyClass -- Allow deriving any class
- | DeriveLift -- Allow deriving Lift
- | DerivingStrategies
- | DerivingVia -- Derive through equal representation
-
- | TypeSynonymInstances
- | FlexibleContexts
- | FlexibleInstances
- | ConstrainedClassMethods
- | MultiParamTypeClasses
- | NullaryTypeClasses
- | FunctionalDependencies
- | UnicodeSyntax
- | ExistentialQuantification
- | MagicHash
- | EmptyDataDecls
- | KindSignatures
- | RoleAnnotations
- | ParallelListComp
- | TransformListComp
- | MonadComprehensions
- | GeneralizedNewtypeDeriving
- | RecursiveDo
- | PostfixOperators
- | TupleSections
- | PatternGuards
- | LiberalTypeSynonyms
- | RankNTypes
- | ImpredicativeTypes
- | TypeOperators
- | ExplicitNamespaces
- | PackageImports
- | ExplicitForAll
- | AlternativeLayoutRule
- | AlternativeLayoutRuleTransitional
- | DatatypeContexts
- | NondecreasingIndentation
- | RelaxedLayout
- | TraditionalRecordSyntax
- | LambdaCase
- | MultiWayIf
- | BinaryLiterals
- | NegativeLiterals
- | HexFloatLiterals
- | DuplicateRecordFields
- | OverloadedLabels
- | EmptyCase
- | PatternSynonyms
- | PartialTypeSignatures
- | NamedWildCards
- | StaticPointers
- | TypeApplications
- | Strict
- | StrictData
- | EmptyDataDeriving
- | NumericUnderscores
- | QuantifiedConstraints
- | StarIsType
- | ImportQualifiedPost
- | CUSKs
- | StandaloneKindSignatures
- | LexicalNegation
- | FieldSelectors
- | OverloadedRecordDot
- | OverloadedRecordUpdate
- | TypeAbstractions
- | ExtendedLiterals
- | ListTuplePuns
- deriving (Eq, Enum, Show, Generic, Bounded)
--- 'Ord' and 'Bounded' are provided for GHC API users (see discussions
--- in https://gitlab.haskell.org/ghc/ghc/merge_requests/2707 and
--- https://gitlab.haskell.org/ghc/ghc/merge_requests/826).
-instance Ord Extension where compare a b = compare (fromEnum a) (fromEnum b)
+import GHC.Internal.LanguageExtensions
diff --git a/libraries/ghc-boot-th/GHC/Lexeme.hs b/libraries/ghc-boot-th/GHC/Lexeme.hs
index 09d83917d354db087d9c65db8c60500953d75d8d..1b896e1ab92a993da6af4f684b4e35e8bb60696c 100644
--- a/libraries/ghc-boot-th/GHC/Lexeme.hs
+++ b/libraries/ghc-boot-th/GHC/Lexeme.hs
@@ -1,3 +1,4 @@
+{-# LANGUAGE CPP #-}
-----------------------------------------------------------------------------
-- |
-- Module : GHC.Lexeme
@@ -14,37 +15,4 @@ module GHC.Lexeme (
startsVarSymASCII, isVarSymChar, okSymChar
) where
-import Prelude -- See note [Why do we import Prelude here?]
-import Data.Char
-
--- | Is this character acceptable in a symbol (after the first char)?
--- See alexGetByte in GHC.Parser.Lexer
-okSymChar :: Char -> Bool
-okSymChar c
- | c `elem` "(),;[]`{}_\"'"
- = False
- | otherwise
- = case generalCategory c of
- ConnectorPunctuation -> True
- DashPunctuation -> True
- OtherPunctuation -> True
- MathSymbol -> True
- CurrencySymbol -> True
- ModifierSymbol -> True
- OtherSymbol -> True
- _ -> False
-
-startsVarSym, startsVarId, startsConSym, startsConId :: Char -> Bool
-startsVarSym c = okSymChar c && c /= ':' -- Infix Ids
-startsConSym c = c == ':' -- Infix data constructors
-startsVarId c = c == '_' || case generalCategory c of -- Ordinary Ids
- LowercaseLetter -> True
- OtherLetter -> True -- See #1103
- _ -> False
-startsConId c = isUpper c || c == '(' -- Ordinary type constructors and data constructors
-
-startsVarSymASCII :: Char -> Bool
-startsVarSymASCII c = c `elem` "!#$%&*+./<=>?@\\^|~-"
-
-isVarSymChar :: Char -> Bool
-isVarSymChar c = c == ':' || startsVarSym c
+import GHC.Internal.Lexeme
diff --git a/libraries/ghc-boot-th/ghc-boot-th.cabal.in b/libraries/ghc-boot-th/ghc-boot-th.cabal.in
index d61f773310e1f92c0d11123026b69fc2923893f7..a47ef4816cfa31567ffdcae78bd62b6c10df2536 100644
--- a/libraries/ghc-boot-th/ghc-boot-th.cabal.in
+++ b/libraries/ghc-boot-th/ghc-boot-th.cabal.in
@@ -26,15 +26,49 @@ source-repository head
location: https://gitlab.haskell.org/ghc/ghc.git
subdir: libraries/ghc-boot-th
+Flag bootstrap
+ Description:
+ Enabled when building the stage1 compiler in order to vendor the in-tree
+ `ghc-boot-th` library, and through that the in-tree TH AST defintions from
+ `ghc-internal`.
+ See Note [Bootstrapping Template Haskell]
+ Default: False
+ Manual: True
+
Library
- hs-source-dirs: @SourceRoot@
default-language: Haskell2010
other-extensions: DeriveGeneric
default-extensions: NoImplicitPrelude
exposed-modules:
- GHC.LanguageExtensions.Type
GHC.ForeignSrcLang.Type
+ GHC.Internal.TH.Lib.Map
+ GHC.Internal.TH.Ppr
+ GHC.Internal.TH.PprLib
+ GHC.LanguageExtensions.Type
GHC.Lexeme
- build-depends: base >= 4.7 && < 4.21
+ build-depends:
+ base >= 4.7 && < 4.21,
+ ghc-prim,
+ pretty == 1.1.*
+
+ if flag(bootstrap)
+ cpp-options: -DBOOTSTRAP_TH
+ hs-source-dirs: @SourceRoot@ ../ghc-internal/src
+ exposed-modules:
+ GHC.Internal.TH.Lib
+ GHC.Internal.TH.Syntax
+ other-modules:
+ GHC.Internal.ForeignSrcLang
+ GHC.Internal.LanguageExtensions
+ GHC.Internal.Lexeme
+ else
+ hs-source-dirs: @SourceRoot@
+ build-depends:
+ ghc-internal
+ reexported-modules:
+ GHC.Internal.TH.Lib,
+ GHC.Internal.TH.Lift,
+ GHC.Internal.TH.Quote,
+ GHC.Internal.TH.Syntax
diff --git a/libraries/ghc-internal/ghc-internal.cabal b/libraries/ghc-internal/ghc-internal.cabal
index 290fd62975976aaf934ad6c318c57291b8c1cbf7..c971f098b6b902815035bf003e9ad99e41ec9960 100644
--- a/libraries/ghc-internal/ghc-internal.cabal
+++ b/libraries/ghc-internal/ghc-internal.cabal
@@ -100,6 +100,7 @@ Library
GHC.Internal.Control.Monad
GHC.Internal.Control.Monad.Fail
GHC.Internal.Control.Monad.Fix
+ GHC.Internal.Control.Monad.IO.Class
GHC.Internal.Control.Monad.ST
GHC.Internal.Control.Monad.ST.Lazy
GHC.Internal.Control.Monad.ST.Imp
@@ -160,6 +161,7 @@ Library
GHC.Internal.Foreign.Ptr
GHC.Internal.Foreign.StablePtr
GHC.Internal.Foreign.Storable
+ GHC.Internal.ForeignSrcLang
GHC.Internal.Arr
GHC.Internal.ArrayArray
GHC.Internal.Base
@@ -229,6 +231,8 @@ Library
GHC.Internal.Integer.Logarithms
GHC.Internal.IsList
GHC.Internal.Ix
+ GHC.Internal.LanguageExtensions
+ GHC.Internal.Lexeme
GHC.Internal.List
GHC.Internal.Maybe
GHC.Internal.MVar
@@ -255,6 +259,10 @@ Library
GHC.Internal.Stack.Types
GHC.Internal.Stats
GHC.Internal.Storable
+ GHC.Internal.TH.Syntax
+ GHC.Internal.TH.Lib
+ GHC.Internal.TH.Lift
+ GHC.Internal.TH.Quote
GHC.Internal.TopHandler
GHC.Internal.TypeError
GHC.Internal.TypeLits
diff --git a/libraries/ghc-internal/src/GHC/Internal/Base.hs b/libraries/ghc-internal/src/GHC/Internal/Base.hs
index 41cb422c6f8530d85316f1a59fb1ac4318c7195b..24071599e7980db30bfa505746e031d77e6a0efb 100644
--- a/libraries/ghc-internal/src/GHC/Internal/Base.hs
+++ b/libraries/ghc-internal/src/GHC/Internal/Base.hs
@@ -416,12 +416,15 @@ W3:
* Do-notation introduces references to GHC.Internal.Base for Monad stuff.
* Likewise arrow-notation to GHC.Internal.Control.Arrow
* Likewise RecursiveDo stuff to GHC.Internal.Control.Monad.Fix
- * (Does TemplateHaskellQuotes fall into this category as well?)
+ * TemplateHaskell quotes introduce references to GHC.Internal.TH.Lib.
- These are not problematic in practice. For example, a program
- that uses arrow-notation but does not otherwise import the Arrow
- type class will almost certainly fail to type-check anyway.
- (The "Arrow m" constraint will be very hard to solve!)
+ These are not problematic in practice, because we do not make use of
+ overloaded notation during bootstrap of GHC. Yet! If in the future we
+ we decide to use TemplateHaskell in GHC or `ghc-internal`, we need to
+ add explicit imports. To demonstrate that these errors can occur, consider
+ e n = [| True |]
+ which compiles with -XTemplateHaskell *without* requiring the user to
+ import GHC.Internal.TH.Lib.
W4:
Stock derived instances introduce references to various things.
@@ -430,15 +433,12 @@ W4:
as long as the module which defines Eq imports GHC.Magic this cannot
cause trouble.
- Things are a bit more complex for the Lift class (see #22229).
- * Derived Lift instances refer to machinery in
- Language.Haskell.TH.Lib.Internal, which is not imported by the module
- Language.Haskell.TH.Lib.Syntax that defines the Lift class.
- * Language.Haskell.TH.Lib.Internal imports Language.Haskell.TH.Lib.Syntax, so
- we can't add the reverse dependency without using a .hs-boot file
- * What we do instead is that we expose a module Language.Haskell.TH.Syntax
- importing both Language.Haskell.TH.Lib.{Syntax,Internal). Users are expected
- to import this module.
+ A similar solution concerns the deriving of Lift instances with
+ -XTemplateHaskell: A derived Lift instance must (transitively)
+ import GHC.Internal.TH.Lift, where the Lift class is defined.
+ The derived Lift instance references various identifiers in
+ GHC.Internal.TH.Lib, so it is an import of GHC.Internal.TH.Lift.
+
W5:
If no explicit "default" declaration is present, the assumed
diff --git a/libraries/ghc-internal/src/GHC/Internal/Control/Monad/IO/Class.hs b/libraries/ghc-internal/src/GHC/Internal/Control/Monad/IO/Class.hs
new file mode 100644
index 0000000000000000000000000000000000000000..3863ef9fea8afe54f485d3b60af1ef28f7f54d64
--- /dev/null
+++ b/libraries/ghc-internal/src/GHC/Internal/Control/Monad/IO/Class.hs
@@ -0,0 +1,74 @@
+{-# LANGUAGE Trustworthy #-}
+
+-----------------------------------------------------------------------------
+-- |
+-- Module : GHC.Internal.Control.Monad.IO.Class
+-- Copyright : (c) Andy Gill 2001,
+-- (c) Oregon Graduate Institute of Science and Technology, 2001
+-- License : BSD-style (see the file LICENSE)
+--
+-- Maintainer : R.Paterson@city.ac.uk
+-- Stability : stable
+-- Portability : portable
+--
+-- Class of monads based on @IO@.
+-----------------------------------------------------------------------------
+
+module GHC.Internal.Control.Monad.IO.Class (
+ MonadIO(..)
+ ) where
+
+import GHC.Internal.Base
+
+-- | Monads in which 'IO' computations may be embedded.
+-- Any monad built by applying a sequence of monad transformers to the
+-- 'IO' monad will be an instance of this class.
+--
+-- Instances should satisfy the following laws, which state that 'liftIO'
+-- is a transformer of monads:
+--
+-- * @'liftIO' . 'return' = 'return'@
+--
+-- * @'liftIO' (m >>= f) = 'liftIO' m >>= ('liftIO' . f)@
+
+class (Monad m) => MonadIO m where
+ -- | Lift a computation from the 'IO' monad.
+ -- This allows us to run IO computations in any monadic stack, so long as it supports these kinds of operations
+ -- (i.e. 'IO' is the base monad for the stack).
+ --
+ -- === __Example__
+ --
+ --
+ -- > import Control.Monad.Trans.State -- from the "transformers" library
+ -- >
+ -- > printState :: Show s => StateT s IO ()
+ -- > printState = do
+ -- > state <- get
+ -- > liftIO $ print state
+ --
+ --
+ -- Had we omitted @'liftIO'@, we would have ended up with this error:
+ --
+ -- > • Couldn't match type ‘IO’ with ‘StateT s IO’
+ -- > Expected type: StateT s IO ()
+ -- > Actual type: IO ()
+ --
+ -- The important part here is the mismatch between @StateT s IO ()@ and @'IO' ()@.
+ --
+ -- Luckily, we know of a function that takes an @'IO' a@ and returns an @(m a)@: @'liftIO'@,
+ -- enabling us to run the program and see the expected results:
+ --
+ -- @
+ -- > evalStateT printState "hello"
+ -- "hello"
+ --
+ -- > evalStateT printState 3
+ -- 3
+ -- @
+ --
+ liftIO :: IO a -> m a
+
+-- | @since base-4.9.0.0
+instance MonadIO IO where
+ liftIO = id
+
diff --git a/libraries/ghc-internal/src/GHC/Internal/ForeignSrcLang.hs b/libraries/ghc-internal/src/GHC/Internal/ForeignSrcLang.hs
new file mode 100644
index 0000000000000000000000000000000000000000..578acca17d0022a894bac889298eec6a2d7c7c88
--- /dev/null
+++ b/libraries/ghc-internal/src/GHC/Internal/ForeignSrcLang.hs
@@ -0,0 +1,25 @@
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE DeriveGeneric #-}
+module GHC.Internal.ForeignSrcLang
+ ( ForeignSrcLang(..)
+ ) where
+
+#ifdef BOOTSTRAP_TH
+import Prelude -- See note [Why do we import Prelude here?]
+import GHC.Generics (Generic)
+#else
+import GHC.Internal.Base
+import GHC.Internal.Show
+import GHC.Internal.Generics
+#endif
+
+-- | Foreign formats supported by GHC via TH
+data ForeignSrcLang
+ = LangC -- ^ C
+ | LangCxx -- ^ C++
+ | LangObjc -- ^ Objective C
+ | LangObjcxx -- ^ Objective C++
+ | LangAsm -- ^ Assembly language (.s)
+ | LangJs -- ^ JavaScript
+ | RawObject -- ^ Object (.o)
+ deriving (Eq, Show, Generic)
diff --git a/libraries/ghc-internal/src/GHC/Internal/LanguageExtensions.hs b/libraries/ghc-internal/src/GHC/Internal/LanguageExtensions.hs
new file mode 100644
index 0000000000000000000000000000000000000000..d2fc5d903697e1142fe592f7da78c53934827244
--- /dev/null
+++ b/libraries/ghc-internal/src/GHC/Internal/LanguageExtensions.hs
@@ -0,0 +1,169 @@
+-----------------------------------------------------------------------------
+-- |
+-- Module : GHC.Internal.LanguageExtensions
+-- Copyright : (c) The GHC Team
+--
+-- Maintainer : ghc-devs@haskell.org
+-- Portability : portable
+--
+-- A data type defining the language extensions supported by GHC.
+--
+{-# LANGUAGE DeriveGeneric, CPP, Trustworthy #-}
+module GHC.Internal.LanguageExtensions ( Extension(..) ) where
+
+#ifdef BOOTSTRAP_TH
+import Prelude -- See note [Why do we import Prelude here?]
+import GHC.Generics (Generic)
+#else
+import GHC.Internal.Base
+import GHC.Internal.Show
+import GHC.Internal.Generics
+import GHC.Internal.Data.Enum
+#endif
+
+-- | The language extensions known to GHC.
+--
+-- Note that there is an orphan 'Binary' instance for this type supplied by
+-- the "GHC.LanguageExtensions" module provided by @ghc-boot@. We can't provide
+-- here as this would require adding transitive dependencies to the
+-- @template-haskell@ package, which must have a minimal dependency set.
+data Extension
+-- See Note [Updating flag description in the User's Guide] in
+-- GHC.Driver.Session
+ = Cpp
+ | OverlappingInstances
+ | UndecidableInstances
+ | IncoherentInstances
+ | UndecidableSuperClasses
+ | MonomorphismRestriction
+ | MonoLocalBinds
+ | DeepSubsumption
+ | RelaxedPolyRec -- Deprecated
+ | ExtendedDefaultRules -- Use GHC's extended rules for defaulting
+ | ForeignFunctionInterface
+ | UnliftedFFITypes
+ | InterruptibleFFI
+ | CApiFFI
+ | GHCForeignImportPrim
+ | JavaScriptFFI
+ | ParallelArrays -- Syntactic support for parallel arrays
+ | Arrows -- Arrow-notation syntax
+ | TemplateHaskell
+ | TemplateHaskellQuotes -- subset of TH supported by stage1, no splice
+ | QualifiedDo
+ | QuasiQuotes
+ | ImplicitParams
+ | ImplicitPrelude
+ | ScopedTypeVariables
+ | AllowAmbiguousTypes
+ | UnboxedTuples
+ | UnboxedSums
+ | UnliftedNewtypes
+ | UnliftedDatatypes
+ | BangPatterns
+ | TypeFamilies
+ | TypeFamilyDependencies
+ | TypeInType -- Deprecated
+ | OverloadedStrings
+ | OverloadedLists
+ | NumDecimals
+ | DisambiguateRecordFields
+ | RecordWildCards
+ | NamedFieldPuns
+ | ViewPatterns
+ | GADTs
+ | GADTSyntax
+ | NPlusKPatterns
+ | DoAndIfThenElse
+ | BlockArguments
+ | RebindableSyntax
+ | ConstraintKinds
+ | PolyKinds -- Kind polymorphism
+ | DataKinds -- Datatype promotion
+ | TypeData -- allow @type data@ definitions
+ | InstanceSigs
+ | ApplicativeDo
+ | LinearTypes
+ | RequiredTypeArguments -- Visible forall (VDQ) in types of terms
+
+ | StandaloneDeriving
+ | DeriveDataTypeable
+ | AutoDeriveTypeable -- Automatic derivation of Typeable
+ | DeriveFunctor
+ | DeriveTraversable
+ | DeriveFoldable
+ | DeriveGeneric -- Allow deriving Generic/1
+ | DefaultSignatures -- Allow extra signatures for defmeths
+ | DeriveAnyClass -- Allow deriving any class
+ | DeriveLift -- Allow deriving Lift
+ | DerivingStrategies
+ | DerivingVia -- Derive through equal representation
+
+ | TypeSynonymInstances
+ | FlexibleContexts
+ | FlexibleInstances
+ | ConstrainedClassMethods
+ | MultiParamTypeClasses
+ | NullaryTypeClasses
+ | FunctionalDependencies
+ | UnicodeSyntax
+ | ExistentialQuantification
+ | MagicHash
+ | EmptyDataDecls
+ | KindSignatures
+ | RoleAnnotations
+ | ParallelListComp
+ | TransformListComp
+ | MonadComprehensions
+ | GeneralizedNewtypeDeriving
+ | RecursiveDo
+ | PostfixOperators
+ | TupleSections
+ | PatternGuards
+ | LiberalTypeSynonyms
+ | RankNTypes
+ | ImpredicativeTypes
+ | TypeOperators
+ | ExplicitNamespaces
+ | PackageImports
+ | ExplicitForAll
+ | AlternativeLayoutRule
+ | AlternativeLayoutRuleTransitional
+ | DatatypeContexts
+ | NondecreasingIndentation
+ | RelaxedLayout
+ | TraditionalRecordSyntax
+ | LambdaCase
+ | MultiWayIf
+ | BinaryLiterals
+ | NegativeLiterals
+ | HexFloatLiterals
+ | DuplicateRecordFields
+ | OverloadedLabels
+ | EmptyCase
+ | PatternSynonyms
+ | PartialTypeSignatures
+ | NamedWildCards
+ | StaticPointers
+ | TypeApplications
+ | Strict
+ | StrictData
+ | EmptyDataDeriving
+ | NumericUnderscores
+ | QuantifiedConstraints
+ | StarIsType
+ | ImportQualifiedPost
+ | CUSKs
+ | StandaloneKindSignatures
+ | LexicalNegation
+ | FieldSelectors
+ | OverloadedRecordDot
+ | OverloadedRecordUpdate
+ | TypeAbstractions
+ | ExtendedLiterals
+ | ListTuplePuns
+ deriving (Eq, Enum, Show, Generic, Bounded)
+-- 'Ord' and 'Bounded' are provided for GHC API users (see discussions
+-- in https://gitlab.haskell.org/ghc/ghc/merge_requests/2707 and
+-- https://gitlab.haskell.org/ghc/ghc/merge_requests/826).
+instance Ord Extension where compare a b = compare (fromEnum a) (fromEnum b)
diff --git a/libraries/ghc-internal/src/GHC/Internal/Lexeme.hs b/libraries/ghc-internal/src/GHC/Internal/Lexeme.hs
new file mode 100644
index 0000000000000000000000000000000000000000..0d9c967c8274bcd8614793c1f13572be7e4af5b3
--- /dev/null
+++ b/libraries/ghc-internal/src/GHC/Internal/Lexeme.hs
@@ -0,0 +1,57 @@
+{-# LANGUAGE CPP #-}
+-----------------------------------------------------------------------------
+-- |
+-- Module : GHC.Internal.Lexeme
+-- Copyright : (c) The GHC Team
+--
+-- Maintainer : ghc-devs@haskell.org
+-- Portability : portable
+--
+-- Functions to evaluate whether or not a string is a valid identifier.
+--
+module GHC.Internal.Lexeme (
+ -- * Lexical characteristics of Haskell names
+ startsVarSym, startsVarId, startsConSym, startsConId,
+ startsVarSymASCII, isVarSymChar, okSymChar
+ ) where
+
+#ifdef BOOTSTRAP_TH
+import Prelude -- See note [Why do we import Prelude here?]
+import Data.Char
+#else
+import GHC.Internal.Base
+import GHC.Internal.Unicode
+import GHC.Internal.List (elem)
+#endif
+
+-- | Is this character acceptable in a symbol (after the first char)?
+-- See alexGetByte in GHC.Parser.Lexer
+okSymChar :: Char -> Bool
+okSymChar c
+ | c `elem` "(),;[]`{}_\"'"
+ = False
+ | otherwise
+ = case generalCategory c of
+ ConnectorPunctuation -> True
+ DashPunctuation -> True
+ OtherPunctuation -> True
+ MathSymbol -> True
+ CurrencySymbol -> True
+ ModifierSymbol -> True
+ OtherSymbol -> True
+ _ -> False
+
+startsVarSym, startsVarId, startsConSym, startsConId :: Char -> Bool
+startsVarSym c = okSymChar c && c /= ':' -- Infix Ids
+startsConSym c = c == ':' -- Infix data constructors
+startsVarId c = c == '_' || case generalCategory c of -- Ordinary Ids
+ LowercaseLetter -> True
+ OtherLetter -> True -- See #1103
+ _ -> False
+startsConId c = isUpper c || c == '(' -- Ordinary type constructors and data constructors
+
+startsVarSymASCII :: Char -> Bool
+startsVarSymASCII c = c `elem` "!#$%&*+./<=>?@\\^|~-"
+
+isVarSymChar :: Char -> Bool
+isVarSymChar c = c == ':' || startsVarSym c
diff --git a/libraries/ghc-internal/src/GHC/Internal/TH/Lib.hs b/libraries/ghc-internal/src/GHC/Internal/TH/Lib.hs
new file mode 100644
index 0000000000000000000000000000000000000000..28e6c8040b0d9b6dee9272e417f11512728e580c
--- /dev/null
+++ b/libraries/ghc-internal/src/GHC/Internal/TH/Lib.hs
@@ -0,0 +1,1251 @@
+{-# OPTIONS_HADDOCK not-home #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE StandaloneKindSignatures #-}
+{-# LANGUAGE Trustworthy #-}
+
+-- |
+-- GHC.Internal.TH.Lib exposes some additional functionality that
+-- is used internally in GHC's integration with Template Haskell. This is not a
+-- part of the public API, and as such, there are no API guarantees for this
+-- module from version to version.
+
+-- Why do we have both GHC.Internal.TH.Lib and
+-- Language.Haskell.TH.Lib? Ultimately, it's because the functions in the
+-- former (which are tailored for GHC's use) need different type signatures
+-- than the ones in the latter. Syncing up the Internal type signatures would
+-- involve a massive amount of breaking changes, so for the time being, we
+-- relegate as many changes as we can to just the Internal module, where it
+-- is safe to break things.
+
+module GHC.Internal.TH.Lib where
+
+import GHC.Internal.TH.Syntax hiding (Role, InjectivityAnn)
+import qualified GHC.Internal.TH.Syntax as TH
+#ifdef BOOTSTRAP_TH
+import Control.Applicative(liftA, Applicative(..))
+import qualified Data.Kind as Kind (Type)
+import Data.Word( Word8 )
+import Data.List.NonEmpty ( NonEmpty(..) )
+import GHC.Exts (TYPE)
+import Prelude hiding (Applicative(..))
+#else
+import GHC.Internal.Base hiding (Type, Module, inline)
+import GHC.Internal.Data.Foldable
+import GHC.Internal.Data.Functor
+import GHC.Internal.Data.Maybe
+import GHC.Internal.Data.Traversable (traverse, sequenceA)
+import GHC.Internal.Integer
+import GHC.Internal.List (zip)
+import GHC.Internal.Real
+import GHC.Internal.Show
+import GHC.Internal.Word
+import qualified GHC.Types as Kind (Type)
+#endif
+
+----------------------------------------------------------
+-- * Type synonyms
+----------------------------------------------------------
+
+-- | Representation-polymorphic since /template-haskell-2.17.0.0/.
+type TExpQ :: TYPE r -> Kind.Type
+type TExpQ a = Q (TExp a)
+
+type CodeQ :: TYPE r -> Kind.Type
+type CodeQ = Code Q
+
+type InfoQ = Q Info
+type PatQ = Q Pat
+type FieldPatQ = Q FieldPat
+type ExpQ = Q Exp
+type DecQ = Q Dec
+type DecsQ = Q [Dec]
+type Decs = [Dec] -- Defined as it is more convenient to wire-in
+type ConQ = Q Con
+type TypeQ = Q Type
+type KindQ = Q Kind
+type TyLitQ = Q TyLit
+type CxtQ = Q Cxt
+type PredQ = Q Pred
+type DerivClauseQ = Q DerivClause
+type MatchQ = Q Match
+type ClauseQ = Q Clause
+type BodyQ = Q Body
+type GuardQ = Q Guard
+type StmtQ = Q Stmt
+type RangeQ = Q Range
+type SourceStrictnessQ = Q SourceStrictness
+type SourceUnpackednessQ = Q SourceUnpackedness
+type BangQ = Q Bang
+type BangTypeQ = Q BangType
+type VarBangTypeQ = Q VarBangType
+type StrictTypeQ = Q StrictType
+type VarStrictTypeQ = Q VarStrictType
+type FieldExpQ = Q FieldExp
+type RuleBndrQ = Q RuleBndr
+type TySynEqnQ = Q TySynEqn
+type PatSynDirQ = Q PatSynDir
+type PatSynArgsQ = Q PatSynArgs
+type FamilyResultSigQ = Q FamilyResultSig
+type DerivStrategyQ = Q DerivStrategy
+
+-- must be defined here for DsMeta to find it
+type Role = TH.Role
+type InjectivityAnn = TH.InjectivityAnn
+
+type TyVarBndrUnit = TyVarBndr ()
+type TyVarBndrSpec = TyVarBndr Specificity
+type TyVarBndrVis = TyVarBndr BndrVis
+
+----------------------------------------------------------
+-- * Lowercase pattern syntax functions
+----------------------------------------------------------
+
+intPrimL :: Integer -> Lit
+intPrimL = IntPrimL
+wordPrimL :: Integer -> Lit
+wordPrimL = WordPrimL
+floatPrimL :: Rational -> Lit
+floatPrimL = FloatPrimL
+doublePrimL :: Rational -> Lit
+doublePrimL = DoublePrimL
+integerL :: Integer -> Lit
+integerL = IntegerL
+charL :: Char -> Lit
+charL = CharL
+charPrimL :: Char -> Lit
+charPrimL = CharPrimL
+stringL :: String -> Lit
+stringL = StringL
+stringPrimL :: [Word8] -> Lit
+stringPrimL = StringPrimL
+bytesPrimL :: Bytes -> Lit
+bytesPrimL = BytesPrimL
+rationalL :: Rational -> Lit
+rationalL = RationalL
+
+litP :: Quote m => Lit -> m Pat
+litP l = pure (LitP l)
+
+varP :: Quote m => Name -> m Pat
+varP v = pure (VarP v)
+
+tupP :: Quote m => [m Pat] -> m Pat
+tupP ps = do { ps1 <- sequenceA ps; pure (TupP ps1)}
+
+unboxedTupP :: Quote m => [m Pat] -> m Pat
+unboxedTupP ps = do { ps1 <- sequenceA ps; pure (UnboxedTupP ps1)}
+
+unboxedSumP :: Quote m => m Pat -> SumAlt -> SumArity -> m Pat
+unboxedSumP p alt arity = do { p1 <- p; pure (UnboxedSumP p1 alt arity) }
+
+conP :: Quote m => Name -> [m Type] -> [m Pat] -> m Pat
+conP n ts ps = do ps' <- sequenceA ps
+ ts' <- sequenceA ts
+ pure (ConP n ts' ps')
+infixP :: Quote m => m Pat -> Name -> m Pat -> m Pat
+infixP p1 n p2 = do p1' <- p1
+ p2' <- p2
+ pure (InfixP p1' n p2')
+uInfixP :: Quote m => m Pat -> Name -> m Pat -> m Pat
+uInfixP p1 n p2 = do p1' <- p1
+ p2' <- p2
+ pure (UInfixP p1' n p2')
+parensP :: Quote m => m Pat -> m Pat
+parensP p = do p' <- p
+ pure (ParensP p')
+
+tildeP :: Quote m => m Pat -> m Pat
+tildeP p = do p' <- p
+ pure (TildeP p')
+bangP :: Quote m => m Pat -> m Pat
+bangP p = do p' <- p
+ pure (BangP p')
+asP :: Quote m => Name -> m Pat -> m Pat
+asP n p = do p' <- p
+ pure (AsP n p')
+wildP :: Quote m => m Pat
+wildP = pure WildP
+recP :: Quote m => Name -> [m FieldPat] -> m Pat
+recP n fps = do fps' <- sequenceA fps
+ pure (RecP n fps')
+listP :: Quote m => [m Pat] -> m Pat
+listP ps = do ps' <- sequenceA ps
+ pure (ListP ps')
+sigP :: Quote m => m Pat -> m Type -> m Pat
+sigP p t = do p' <- p
+ t' <- t
+ pure (SigP p' t')
+typeP :: Quote m => m Type -> m Pat
+typeP t = do t' <- t
+ pure (TypeP t')
+invisP :: Quote m => m Type -> m Pat
+invisP t = do t' <- t
+ pure (InvisP t')
+viewP :: Quote m => m Exp -> m Pat -> m Pat
+viewP e p = do e' <- e
+ p' <- p
+ pure (ViewP e' p')
+
+
+fieldPat :: Quote m => Name -> m Pat -> m FieldPat
+fieldPat n p = do p' <- p
+ pure (n, p')
+
+
+-------------------------------------------------------------------------------
+-- * Stmt
+
+bindS :: Quote m => m Pat -> m Exp -> m Stmt
+bindS p e = liftA2 BindS p e
+
+letS :: Quote m => [m Dec] -> m Stmt
+letS ds = do { ds1 <- sequenceA ds; pure (LetS ds1) }
+
+noBindS :: Quote m => m Exp -> m Stmt
+noBindS e = do { e1 <- e; pure (NoBindS e1) }
+
+parS :: Quote m => [[m Stmt]] -> m Stmt
+parS sss = do { sss1 <- traverse sequenceA sss; pure (ParS sss1) }
+
+recS :: Quote m => [m Stmt] -> m Stmt
+recS ss = do { ss1 <- sequenceA ss; pure (RecS ss1) }
+
+-------------------------------------------------------------------------------
+-- * Range
+
+fromR :: Quote m => m Exp -> m Range
+fromR x = do { a <- x; pure (FromR a) }
+
+fromThenR :: Quote m => m Exp -> m Exp -> m Range
+fromThenR x y = do { a <- x; b <- y; pure (FromThenR a b) }
+
+fromToR :: Quote m => m Exp -> m Exp -> m Range
+fromToR x y = do { a <- x; b <- y; pure (FromToR a b) }
+
+fromThenToR :: Quote m => m Exp -> m Exp -> m Exp -> m Range
+fromThenToR x y z = do { a <- x; b <- y; c <- z;
+ pure (FromThenToR a b c) }
+-------------------------------------------------------------------------------
+-- * Body
+
+normalB :: Quote m => m Exp -> m Body
+normalB e = do { e1 <- e; pure (NormalB e1) }
+
+guardedB :: Quote m => [m (Guard,Exp)] -> m Body
+guardedB ges = do { ges' <- sequenceA ges; pure (GuardedB ges') }
+
+-------------------------------------------------------------------------------
+-- * Guard
+
+normalG :: Quote m => m Exp -> m Guard
+normalG e = do { e1 <- e; pure (NormalG e1) }
+
+normalGE :: Quote m => m Exp -> m Exp -> m (Guard, Exp)
+normalGE g e = do { g1 <- g; e1 <- e; pure (NormalG g1, e1) }
+
+patG :: Quote m => [m Stmt] -> m Guard
+patG ss = do { ss' <- sequenceA ss; pure (PatG ss') }
+
+patGE :: Quote m => [m Stmt] -> m Exp -> m (Guard, Exp)
+patGE ss e = do { ss' <- sequenceA ss;
+ e' <- e;
+ pure (PatG ss', e') }
+
+-------------------------------------------------------------------------------
+-- * Match and Clause
+
+-- | Use with 'caseE'
+match :: Quote m => m Pat -> m Body -> [m Dec] -> m Match
+match p rhs ds = do { p' <- p;
+ r' <- rhs;
+ ds' <- sequenceA ds;
+ pure (Match p' r' ds') }
+
+-- | Use with 'funD'
+clause :: Quote m => [m Pat] -> m Body -> [m Dec] -> m Clause
+clause ps r ds = do { ps' <- sequenceA ps;
+ r' <- r;
+ ds' <- sequenceA ds;
+ pure (Clause ps' r' ds') }
+
+---------------------------------------------------------------------------
+-- * Exp
+
+-- | Dynamically binding a variable (unhygienic)
+dyn :: Quote m => String -> m Exp
+dyn s = pure (VarE (mkName s))
+
+varE :: Quote m => Name -> m Exp
+varE s = pure (VarE s)
+
+conE :: Quote m => Name -> m Exp
+conE s = pure (ConE s)
+
+litE :: Quote m => Lit -> m Exp
+litE c = pure (LitE c)
+
+appE :: Quote m => m Exp -> m Exp -> m Exp
+appE x y = do { a <- x; b <- y; pure (AppE a b)}
+
+appTypeE :: Quote m => m Exp -> m Type -> m Exp
+appTypeE x t = do { a <- x; s <- t; pure (AppTypeE a s) }
+
+parensE :: Quote m => m Exp -> m Exp
+parensE x = do { x' <- x; pure (ParensE x') }
+
+uInfixE :: Quote m => m Exp -> m Exp -> m Exp -> m Exp
+uInfixE x s y = do { x' <- x; s' <- s; y' <- y;
+ pure (UInfixE x' s' y') }
+
+infixE :: Quote m => Maybe (m Exp) -> m Exp -> Maybe (m Exp) -> m Exp
+infixE (Just x) s (Just y) = do { a <- x; s' <- s; b <- y;
+ pure (InfixE (Just a) s' (Just b))}
+infixE Nothing s (Just y) = do { s' <- s; b <- y;
+ pure (InfixE Nothing s' (Just b))}
+infixE (Just x) s Nothing = do { a <- x; s' <- s;
+ pure (InfixE (Just a) s' Nothing)}
+infixE Nothing s Nothing = do { s' <- s; pure (InfixE Nothing s' Nothing) }
+
+infixApp :: Quote m => m Exp -> m Exp -> m Exp -> m Exp
+infixApp x y z = infixE (Just x) y (Just z)
+sectionL :: Quote m => m Exp -> m Exp -> m Exp
+sectionL x y = infixE (Just x) y Nothing
+sectionR :: Quote m => m Exp -> m Exp -> m Exp
+sectionR x y = infixE Nothing x (Just y)
+
+lamE :: Quote m => [m Pat] -> m Exp -> m Exp
+lamE ps e = do ps' <- sequenceA ps
+ e' <- e
+ pure (LamE ps' e')
+
+-- | Single-arg lambda
+lam1E :: Quote m => m Pat -> m Exp -> m Exp
+lam1E p e = lamE [p] e
+
+-- | Lambda-case (@\case@)
+lamCaseE :: Quote m => [m Match] -> m Exp
+lamCaseE ms = LamCaseE <$> sequenceA ms
+
+-- | Lambda-cases (@\cases@)
+lamCasesE :: Quote m => [m Clause] -> m Exp
+lamCasesE ms = LamCasesE <$> sequenceA ms
+
+tupE :: Quote m => [Maybe (m Exp)] -> m Exp
+tupE es = do { es1 <- traverse sequenceA es; pure (TupE es1)}
+
+unboxedTupE :: Quote m => [Maybe (m Exp)] -> m Exp
+unboxedTupE es = do { es1 <- traverse sequenceA es; pure (UnboxedTupE es1)}
+
+unboxedSumE :: Quote m => m Exp -> SumAlt -> SumArity -> m Exp
+unboxedSumE e alt arity = do { e1 <- e; pure (UnboxedSumE e1 alt arity) }
+
+condE :: Quote m => m Exp -> m Exp -> m Exp -> m Exp
+condE x y z = do { a <- x; b <- y; c <- z; pure (CondE a b c)}
+
+multiIfE :: Quote m => [m (Guard, Exp)] -> m Exp
+multiIfE alts = MultiIfE <$> sequenceA alts
+
+letE :: Quote m => [m Dec] -> m Exp -> m Exp
+letE ds e = do { ds2 <- sequenceA ds; e2 <- e; pure (LetE ds2 e2) }
+
+caseE :: Quote m => m Exp -> [m Match] -> m Exp
+caseE e ms = do { e1 <- e; ms1 <- sequenceA ms; pure (CaseE e1 ms1) }
+
+doE :: Quote m => Maybe ModName -> [m Stmt] -> m Exp
+doE m ss = do { ss1 <- sequenceA ss; pure (DoE m ss1) }
+
+mdoE :: Quote m => Maybe ModName -> [m Stmt] -> m Exp
+mdoE m ss = do { ss1 <- sequenceA ss; pure (MDoE m ss1) }
+
+compE :: Quote m => [m Stmt] -> m Exp
+compE ss = do { ss1 <- sequenceA ss; pure (CompE ss1) }
+
+arithSeqE :: Quote m => m Range -> m Exp
+arithSeqE r = do { r' <- r; pure (ArithSeqE r') }
+
+listE :: Quote m => [m Exp] -> m Exp
+listE es = do { es1 <- sequenceA es; pure (ListE es1) }
+
+sigE :: Quote m => m Exp -> m Type -> m Exp
+sigE e t = do { e1 <- e; t1 <- t; pure (SigE e1 t1) }
+
+recConE :: Quote m => Name -> [m (Name,Exp)] -> m Exp
+recConE c fs = do { flds <- sequenceA fs; pure (RecConE c flds) }
+
+recUpdE :: Quote m => m Exp -> [m (Name,Exp)] -> m Exp
+recUpdE e fs = do { e1 <- e; flds <- sequenceA fs; pure (RecUpdE e1 flds) }
+
+stringE :: Quote m => String -> m Exp
+stringE = litE . stringL
+
+fieldExp :: Quote m => Name -> m Exp -> m (Name, Exp)
+fieldExp s e = do { e' <- e; pure (s,e') }
+
+-- | @staticE x = [| static x |]@
+staticE :: Quote m => m Exp -> m Exp
+staticE = fmap StaticE
+
+unboundVarE :: Quote m => Name -> m Exp
+unboundVarE s = pure (UnboundVarE s)
+
+labelE :: Quote m => String -> m Exp
+labelE s = pure (LabelE s)
+
+implicitParamVarE :: Quote m => String -> m Exp
+implicitParamVarE n = pure (ImplicitParamVarE n)
+
+getFieldE :: Quote m => m Exp -> String -> m Exp
+getFieldE e f = do
+ e' <- e
+ pure (GetFieldE e' f)
+
+projectionE :: Quote m => NonEmpty String -> m Exp
+projectionE xs = pure (ProjectionE xs)
+
+typedSpliceE :: Quote m => m Exp -> m Exp
+typedSpliceE = fmap TypedSpliceE
+
+typedBracketE :: Quote m => m Exp -> m Exp
+typedBracketE = fmap TypedBracketE
+
+-- ** 'arithSeqE' Shortcuts
+fromE :: Quote m => m Exp -> m Exp
+fromE x = do { a <- x; pure (ArithSeqE (FromR a)) }
+
+fromThenE :: Quote m => m Exp -> m Exp -> m Exp
+fromThenE x y = do { a <- x; b <- y; pure (ArithSeqE (FromThenR a b)) }
+
+fromToE :: Quote m => m Exp -> m Exp -> m Exp
+fromToE x y = do { a <- x; b <- y; pure (ArithSeqE (FromToR a b)) }
+
+fromThenToE :: Quote m => m Exp -> m Exp -> m Exp -> m Exp
+fromThenToE x y z = do { a <- x; b <- y; c <- z;
+ pure (ArithSeqE (FromThenToR a b c)) }
+
+typeE :: Quote m => m Type -> m Exp
+typeE = fmap TypeE
+
+-------------------------------------------------------------------------------
+-- * Dec
+
+valD :: Quote m => m Pat -> m Body -> [m Dec] -> m Dec
+valD p b ds =
+ do { p' <- p
+ ; ds' <- sequenceA ds
+ ; b' <- b
+ ; pure (ValD p' b' ds')
+ }
+
+funD :: Quote m => Name -> [m Clause] -> m Dec
+funD nm cs =
+ do { cs1 <- sequenceA cs
+ ; pure (FunD nm cs1)
+ }
+
+tySynD :: Quote m => Name -> [m (TyVarBndr BndrVis)] -> m Type -> m Dec
+tySynD tc tvs rhs =
+ do { tvs1 <- sequenceA tvs
+ ; rhs1 <- rhs
+ ; pure (TySynD tc tvs1 rhs1)
+ }
+
+dataD :: Quote m => m Cxt -> Name -> [m (TyVarBndr BndrVis)] -> Maybe (m Kind) -> [m Con]
+ -> [m DerivClause] -> m Dec
+dataD ctxt tc tvs ksig cons derivs =
+ do
+ ctxt1 <- ctxt
+ tvs1 <- sequenceA tvs
+ ksig1 <- sequenceA ksig
+ cons1 <- sequenceA cons
+ derivs1 <- sequenceA derivs
+ pure (DataD ctxt1 tc tvs1 ksig1 cons1 derivs1)
+
+newtypeD :: Quote m => m Cxt -> Name -> [m (TyVarBndr BndrVis)] -> Maybe (m Kind) -> m Con
+ -> [m DerivClause] -> m Dec
+newtypeD ctxt tc tvs ksig con derivs =
+ do
+ ctxt1 <- ctxt
+ tvs1 <- sequenceA tvs
+ ksig1 <- sequenceA ksig
+ con1 <- con
+ derivs1 <- sequenceA derivs
+ pure (NewtypeD ctxt1 tc tvs1 ksig1 con1 derivs1)
+
+typeDataD :: Quote m => Name -> [m (TyVarBndr BndrVis)] -> Maybe (m Kind) -> [m Con]
+ -> m Dec
+typeDataD tc tvs ksig cons =
+ do
+ tvs1 <- sequenceA tvs
+ ksig1 <- sequenceA ksig
+ cons1 <- sequenceA cons
+ pure (TypeDataD tc tvs1 ksig1 cons1)
+
+classD :: Quote m => m Cxt -> Name -> [m (TyVarBndr BndrVis)] -> [FunDep] -> [m Dec] -> m Dec
+classD ctxt cls tvs fds decs =
+ do
+ tvs1 <- sequenceA tvs
+ decs1 <- sequenceA decs
+ ctxt1 <- ctxt
+ pure $ ClassD ctxt1 cls tvs1 fds decs1
+
+instanceD :: Quote m => m Cxt -> m Type -> [m Dec] -> m Dec
+instanceD = instanceWithOverlapD Nothing
+
+instanceWithOverlapD :: Quote m => Maybe Overlap -> m Cxt -> m Type -> [m Dec] -> m Dec
+instanceWithOverlapD o ctxt ty decs =
+ do
+ ctxt1 <- ctxt
+ decs1 <- sequenceA decs
+ ty1 <- ty
+ pure $ InstanceD o ctxt1 ty1 decs1
+
+
+
+sigD :: Quote m => Name -> m Type -> m Dec
+sigD fun ty = liftA (SigD fun) $ ty
+
+kiSigD :: Quote m => Name -> m Kind -> m Dec
+kiSigD fun ki = liftA (KiSigD fun) $ ki
+
+forImpD :: Quote m => Callconv -> Safety -> String -> Name -> m Type -> m Dec
+forImpD cc s str n ty
+ = do ty' <- ty
+ pure $ ForeignD (ImportF cc s str n ty')
+
+infixLD :: Quote m => Int -> Name -> m Dec
+infixLD prec = infixLWithSpecD prec NoNamespaceSpecifier
+
+infixRD :: Quote m => Int -> Name -> m Dec
+infixRD prec = infixRWithSpecD prec NoNamespaceSpecifier
+
+infixND :: Quote m => Int -> Name -> m Dec
+infixND prec = infixNWithSpecD prec NoNamespaceSpecifier
+
+infixLWithSpecD :: Quote m => Int -> NamespaceSpecifier -> Name -> m Dec
+infixLWithSpecD prec ns_spec nm = pure (InfixD (Fixity prec InfixL) ns_spec nm)
+
+infixRWithSpecD :: Quote m => Int -> NamespaceSpecifier -> Name -> m Dec
+infixRWithSpecD prec ns_spec nm = pure (InfixD (Fixity prec InfixR) ns_spec nm)
+
+infixNWithSpecD :: Quote m => Int -> NamespaceSpecifier -> Name -> m Dec
+infixNWithSpecD prec ns_spec nm = pure (InfixD (Fixity prec InfixN) ns_spec nm)
+
+defaultD :: Quote m => [m Type] -> m Dec
+defaultD tys = DefaultD <$> sequenceA tys
+
+pragInlD :: Quote m => Name -> Inline -> RuleMatch -> Phases -> m Dec
+pragInlD name inline rm phases
+ = pure $ PragmaD $ InlineP name inline rm phases
+
+pragOpaqueD :: Quote m => Name -> m Dec
+pragOpaqueD name = pure $ PragmaD $ OpaqueP name
+
+pragSpecD :: Quote m => Name -> m Type -> Phases -> m Dec
+pragSpecD n ty phases
+ = do
+ ty1 <- ty
+ pure $ PragmaD $ SpecialiseP n ty1 Nothing phases
+
+pragSpecInlD :: Quote m => Name -> m Type -> Inline -> Phases -> m Dec
+pragSpecInlD n ty inline phases
+ = do
+ ty1 <- ty
+ pure $ PragmaD $ SpecialiseP n ty1 (Just inline) phases
+
+pragSpecInstD :: Quote m => m Type -> m Dec
+pragSpecInstD ty
+ = do
+ ty1 <- ty
+ pure $ PragmaD $ SpecialiseInstP ty1
+
+pragRuleD :: Quote m => String -> Maybe [m (TyVarBndr ())] -> [m RuleBndr] -> m Exp -> m Exp
+ -> Phases -> m Dec
+pragRuleD n ty_bndrs tm_bndrs lhs rhs phases
+ = do
+ ty_bndrs1 <- traverse sequenceA ty_bndrs
+ tm_bndrs1 <- sequenceA tm_bndrs
+ lhs1 <- lhs
+ rhs1 <- rhs
+ pure $ PragmaD $ RuleP n ty_bndrs1 tm_bndrs1 lhs1 rhs1 phases
+
+pragAnnD :: Quote m => AnnTarget -> m Exp -> m Dec
+pragAnnD target expr
+ = do
+ exp1 <- expr
+ pure $ PragmaD $ AnnP target exp1
+
+pragLineD :: Quote m => Int -> String -> m Dec
+pragLineD line file = pure $ PragmaD $ LineP line file
+
+pragCompleteD :: Quote m => [Name] -> Maybe Name -> m Dec
+pragCompleteD cls mty = pure $ PragmaD $ CompleteP cls mty
+
+pragSCCFunD :: Quote m => Name -> m Dec
+pragSCCFunD nm = pure $ PragmaD $ SCCP nm Nothing
+
+pragSCCFunNamedD :: Quote m => Name -> String -> m Dec
+pragSCCFunNamedD nm str = pure $ PragmaD $ SCCP nm (Just str)
+
+dataInstD :: Quote m => m Cxt -> (Maybe [m (TyVarBndr ())]) -> m Type -> Maybe (m Kind) -> [m Con]
+ -> [m DerivClause] -> m Dec
+dataInstD ctxt mb_bndrs ty ksig cons derivs =
+ do
+ ctxt1 <- ctxt
+ mb_bndrs1 <- traverse sequenceA mb_bndrs
+ ty1 <- ty
+ ksig1 <- sequenceA ksig
+ cons1 <- sequenceA cons
+ derivs1 <- sequenceA derivs
+ pure (DataInstD ctxt1 mb_bndrs1 ty1 ksig1 cons1 derivs1)
+
+newtypeInstD :: Quote m => m Cxt -> (Maybe [m (TyVarBndr ())]) -> m Type -> Maybe (m Kind) -> m Con
+ -> [m DerivClause] -> m Dec
+newtypeInstD ctxt mb_bndrs ty ksig con derivs =
+ do
+ ctxt1 <- ctxt
+ mb_bndrs1 <- traverse sequenceA mb_bndrs
+ ty1 <- ty
+ ksig1 <- sequenceA ksig
+ con1 <- con
+ derivs1 <- sequenceA derivs
+ pure (NewtypeInstD ctxt1 mb_bndrs1 ty1 ksig1 con1 derivs1)
+
+tySynInstD :: Quote m => m TySynEqn -> m Dec
+tySynInstD eqn =
+ do
+ eqn1 <- eqn
+ pure (TySynInstD eqn1)
+
+dataFamilyD :: Quote m => Name -> [m (TyVarBndr BndrVis)] -> Maybe (m Kind) -> m Dec
+dataFamilyD tc tvs kind =
+ do tvs' <- sequenceA tvs
+ kind' <- sequenceA kind
+ pure $ DataFamilyD tc tvs' kind'
+
+openTypeFamilyD :: Quote m => Name -> [m (TyVarBndr BndrVis)] -> m FamilyResultSig
+ -> Maybe InjectivityAnn -> m Dec
+openTypeFamilyD tc tvs res inj =
+ do tvs' <- sequenceA tvs
+ res' <- res
+ pure $ OpenTypeFamilyD (TypeFamilyHead tc tvs' res' inj)
+
+closedTypeFamilyD :: Quote m => Name -> [m (TyVarBndr BndrVis)] -> m FamilyResultSig
+ -> Maybe InjectivityAnn -> [m TySynEqn] -> m Dec
+closedTypeFamilyD tc tvs result injectivity eqns =
+ do tvs1 <- sequenceA tvs
+ result1 <- result
+ eqns1 <- sequenceA eqns
+ pure (ClosedTypeFamilyD (TypeFamilyHead tc tvs1 result1 injectivity) eqns1)
+
+roleAnnotD :: Quote m => Name -> [Role] -> m Dec
+roleAnnotD name roles = pure $ RoleAnnotD name roles
+
+standaloneDerivD :: Quote m => m Cxt -> m Type -> m Dec
+standaloneDerivD = standaloneDerivWithStrategyD Nothing
+
+standaloneDerivWithStrategyD :: Quote m => Maybe (m DerivStrategy) -> m Cxt -> m Type -> m Dec
+standaloneDerivWithStrategyD mdsq ctxtq tyq =
+ do
+ mds <- sequenceA mdsq
+ ctxt <- ctxtq
+ ty <- tyq
+ pure $ StandaloneDerivD mds ctxt ty
+
+defaultSigD :: Quote m => Name -> m Type -> m Dec
+defaultSigD n tyq =
+ do
+ ty <- tyq
+ pure $ DefaultSigD n ty
+
+-- | Pattern synonym declaration
+patSynD :: Quote m => Name -> m PatSynArgs -> m PatSynDir -> m Pat -> m Dec
+patSynD name args dir pat = do
+ args' <- args
+ dir' <- dir
+ pat' <- pat
+ pure (PatSynD name args' dir' pat')
+
+-- | Pattern synonym type signature
+patSynSigD :: Quote m => Name -> m Type -> m Dec
+patSynSigD nm ty =
+ do ty' <- ty
+ pure $ PatSynSigD nm ty'
+
+-- | Implicit parameter binding declaration. Can only be used in let
+-- and where clauses which consist entirely of implicit bindings.
+implicitParamBindD :: Quote m => String -> m Exp -> m Dec
+implicitParamBindD n e =
+ do
+ e' <- e
+ pure $ ImplicitParamBindD n e'
+
+tySynEqn :: Quote m => (Maybe [m (TyVarBndr ())]) -> m Type -> m Type -> m TySynEqn
+tySynEqn mb_bndrs lhs rhs =
+ do
+ mb_bndrs1 <- traverse sequenceA mb_bndrs
+ lhs1 <- lhs
+ rhs1 <- rhs
+ pure (TySynEqn mb_bndrs1 lhs1 rhs1)
+
+cxt :: Quote m => [m Pred] -> m Cxt
+cxt = sequenceA
+
+derivClause :: Quote m => Maybe (m DerivStrategy) -> [m Pred] -> m DerivClause
+derivClause mds p = do mds' <- sequenceA mds
+ p' <- cxt p
+ pure $ DerivClause mds' p'
+
+stockStrategy :: Quote m => m DerivStrategy
+stockStrategy = pure StockStrategy
+
+anyclassStrategy :: Quote m => m DerivStrategy
+anyclassStrategy = pure AnyclassStrategy
+
+newtypeStrategy :: Quote m => m DerivStrategy
+newtypeStrategy = pure NewtypeStrategy
+
+viaStrategy :: Quote m => m Type -> m DerivStrategy
+viaStrategy = fmap ViaStrategy
+
+normalC :: Quote m => Name -> [m BangType] -> m Con
+normalC con strtys = liftA (NormalC con) $ sequenceA strtys
+
+recC :: Quote m => Name -> [m VarBangType] -> m Con
+recC con varstrtys = liftA (RecC con) $ sequenceA varstrtys
+
+infixC :: Quote m => m (Bang, Type) -> Name -> m (Bang, Type) -> m Con
+infixC st1 con st2 = do st1' <- st1
+ st2' <- st2
+ pure $ InfixC st1' con st2'
+
+forallC :: Quote m => [m (TyVarBndr Specificity)] -> m Cxt -> m Con -> m Con
+forallC ns ctxt con = do
+ ns' <- sequenceA ns
+ ctxt' <- ctxt
+ con' <- con
+ pure $ ForallC ns' ctxt' con'
+
+gadtC :: Quote m => [Name] -> [m StrictType] -> m Type -> m Con
+gadtC cons strtys ty = liftA2 (GadtC cons) (sequenceA strtys) ty
+
+recGadtC :: Quote m => [Name] -> [m VarStrictType] -> m Type -> m Con
+recGadtC cons varstrtys ty = liftA2 (RecGadtC cons) (sequenceA varstrtys) ty
+
+-------------------------------------------------------------------------------
+-- * Type
+
+forallT :: Quote m => [m (TyVarBndr Specificity)] -> m Cxt -> m Type -> m Type
+forallT tvars ctxt ty = do
+ tvars1 <- sequenceA tvars
+ ctxt1 <- ctxt
+ ty1 <- ty
+ pure $ ForallT tvars1 ctxt1 ty1
+
+forallVisT :: Quote m => [m (TyVarBndr ())] -> m Type -> m Type
+forallVisT tvars ty = ForallVisT <$> sequenceA tvars <*> ty
+
+varT :: Quote m => Name -> m Type
+varT = pure . VarT
+
+conT :: Quote m => Name -> m Type
+conT = pure . ConT
+
+infixT :: Quote m => m Type -> Name -> m Type -> m Type
+infixT t1 n t2 = do t1' <- t1
+ t2' <- t2
+ pure (InfixT t1' n t2')
+
+uInfixT :: Quote m => m Type -> Name -> m Type -> m Type
+uInfixT t1 n t2 = do t1' <- t1
+ t2' <- t2
+ pure (UInfixT t1' n t2')
+
+promotedInfixT :: Quote m => m Type -> Name -> m Type -> m Type
+promotedInfixT t1 n t2 = do t1' <- t1
+ t2' <- t2
+ pure (PromotedInfixT t1' n t2')
+
+promotedUInfixT :: Quote m => m Type -> Name -> m Type -> m Type
+promotedUInfixT t1 n t2 = do t1' <- t1
+ t2' <- t2
+ pure (PromotedUInfixT t1' n t2')
+
+parensT :: Quote m => m Type -> m Type
+parensT t = do t' <- t
+ pure (ParensT t')
+
+appT :: Quote m => m Type -> m Type -> m Type
+appT t1 t2 = do
+ t1' <- t1
+ t2' <- t2
+ pure $ AppT t1' t2'
+
+appKindT :: Quote m => m Type -> m Kind -> m Type
+appKindT ty ki = do
+ ty' <- ty
+ ki' <- ki
+ pure $ AppKindT ty' ki'
+
+arrowT :: Quote m => m Type
+arrowT = pure ArrowT
+
+mulArrowT :: Quote m => m Type
+mulArrowT = pure MulArrowT
+
+listT :: Quote m => m Type
+listT = pure ListT
+
+litT :: Quote m => m TyLit -> m Type
+litT l = fmap LitT l
+
+tupleT :: Quote m => Int -> m Type
+tupleT i = pure (TupleT i)
+
+unboxedTupleT :: Quote m => Int -> m Type
+unboxedTupleT i = pure (UnboxedTupleT i)
+
+unboxedSumT :: Quote m => SumArity -> m Type
+unboxedSumT arity = pure (UnboxedSumT arity)
+
+sigT :: Quote m => m Type -> m Kind -> m Type
+sigT t k
+ = do
+ t' <- t
+ k' <- k
+ pure $ SigT t' k'
+
+equalityT :: Quote m => m Type
+equalityT = pure EqualityT
+
+wildCardT :: Quote m => m Type
+wildCardT = pure WildCardT
+
+implicitParamT :: Quote m => String -> m Type -> m Type
+implicitParamT n t
+ = do
+ t' <- t
+ pure $ ImplicitParamT n t'
+
+{-# DEPRECATED classP "As of template-haskell-2.10, constraint predicates (Pred) are just types (Type), in keeping with ConstraintKinds. Please use 'conT' and 'appT'." #-}
+classP :: Quote m => Name -> [m Type] -> m Pred
+classP cla tys
+ = do
+ tysl <- sequenceA tys
+ pure (foldl AppT (ConT cla) tysl)
+
+{-# DEPRECATED equalP "As of template-haskell-2.10, constraint predicates (Pred) are just types (Type), in keeping with ConstraintKinds. Please see 'equalityT'." #-}
+equalP :: Quote m => m Type -> m Type -> m Pred
+equalP tleft tright
+ = do
+ tleft1 <- tleft
+ tright1 <- tright
+ eqT <- equalityT
+ pure (foldl AppT eqT [tleft1, tright1])
+
+promotedT :: Quote m => Name -> m Type
+promotedT = pure . PromotedT
+
+promotedTupleT :: Quote m => Int -> m Type
+promotedTupleT i = pure (PromotedTupleT i)
+
+promotedNilT :: Quote m => m Type
+promotedNilT = pure PromotedNilT
+
+promotedConsT :: Quote m => m Type
+promotedConsT = pure PromotedConsT
+
+noSourceUnpackedness, sourceNoUnpack, sourceUnpack :: Quote m => m SourceUnpackedness
+noSourceUnpackedness = pure NoSourceUnpackedness
+sourceNoUnpack = pure SourceNoUnpack
+sourceUnpack = pure SourceUnpack
+
+noSourceStrictness, sourceLazy, sourceStrict :: Quote m => m SourceStrictness
+noSourceStrictness = pure NoSourceStrictness
+sourceLazy = pure SourceLazy
+sourceStrict = pure SourceStrict
+
+{-# DEPRECATED isStrict
+ ["Use 'bang'. See https://gitlab.haskell.org/ghc/ghc/wikis/migration/8.0. ",
+ "Example usage: 'bang noSourceUnpackedness sourceStrict'"] #-}
+{-# DEPRECATED notStrict
+ ["Use 'bang'. See https://gitlab.haskell.org/ghc/ghc/wikis/migration/8.0. ",
+ "Example usage: 'bang noSourceUnpackedness noSourceStrictness'"] #-}
+{-# DEPRECATED unpacked
+ ["Use 'bang'. See https://gitlab.haskell.org/ghc/ghc/wikis/migration/8.0. ",
+ "Example usage: 'bang sourceUnpack sourceStrict'"] #-}
+isStrict, notStrict, unpacked :: Quote m => m Strict
+isStrict = bang noSourceUnpackedness sourceStrict
+notStrict = bang noSourceUnpackedness noSourceStrictness
+unpacked = bang sourceUnpack sourceStrict
+
+bang :: Quote m => m SourceUnpackedness -> m SourceStrictness -> m Bang
+bang u s = do u' <- u
+ s' <- s
+ pure (Bang u' s')
+
+bangType :: Quote m => m Bang -> m Type -> m BangType
+bangType = liftA2 (,)
+
+varBangType :: Quote m => Name -> m BangType -> m VarBangType
+varBangType v bt = (\(b, t) -> (v, b, t)) <$> bt
+
+{-# DEPRECATED strictType
+ "As of @template-haskell-2.11.0.0@, 'StrictType' has been replaced by 'BangType'. Please use 'bangType' instead." #-}
+strictType :: Quote m => m Strict -> m Type -> m StrictType
+strictType = bangType
+
+{-# DEPRECATED varStrictType
+ "As of @template-haskell-2.11.0.0@, 'VarStrictType' has been replaced by 'VarBangType'. Please use 'varBangType' instead." #-}
+varStrictType :: Quote m => Name -> m StrictType -> m VarStrictType
+varStrictType = varBangType
+
+-- * Type Literals
+
+-- MonadFail here complicates things (a lot) because it would mean we would
+-- have to emit a MonadFail constraint during typechecking if there was any
+-- chance the desugaring would use numTyLit, which in general is hard to
+-- predict.
+numTyLit :: Quote m => Integer -> m TyLit
+numTyLit n = if n >= 0 then pure (NumTyLit n)
+ else error ("Negative type-level number: " ++ show n)
+
+strTyLit :: Quote m => String -> m TyLit
+strTyLit s = pure (StrTyLit s)
+
+charTyLit :: Quote m => Char -> m TyLit
+charTyLit c = pure (CharTyLit c)
+
+-------------------------------------------------------------------------------
+-- * Kind
+
+plainTV :: Quote m => Name -> m (TyVarBndr ())
+plainTV n = pure $ PlainTV n ()
+
+plainInvisTV :: Quote m => Name -> Specificity -> m (TyVarBndr Specificity)
+plainInvisTV n s = pure $ PlainTV n s
+
+plainBndrTV :: Quote m => Name -> BndrVis -> m (TyVarBndr BndrVis)
+plainBndrTV n v = pure $ PlainTV n v
+
+kindedTV :: Quote m => Name -> m Kind -> m (TyVarBndr ())
+kindedTV n = fmap (KindedTV n ())
+
+kindedInvisTV :: Quote m => Name -> Specificity -> m Kind -> m (TyVarBndr Specificity)
+kindedInvisTV n s = fmap (KindedTV n s)
+
+kindedBndrTV :: Quote m => Name -> BndrVis -> m Kind -> m (TyVarBndr BndrVis)
+kindedBndrTV n v = fmap (KindedTV n v)
+
+specifiedSpec :: Specificity
+specifiedSpec = SpecifiedSpec
+
+inferredSpec :: Specificity
+inferredSpec = InferredSpec
+
+bndrReq :: BndrVis
+bndrReq = BndrReq
+
+bndrInvis :: BndrVis
+bndrInvis = BndrInvis
+
+varK :: Name -> Kind
+varK = VarT
+
+conK :: Name -> Kind
+conK = ConT
+
+tupleK :: Int -> Kind
+tupleK = TupleT
+
+arrowK :: Kind
+arrowK = ArrowT
+
+listK :: Kind
+listK = ListT
+
+appK :: Kind -> Kind -> Kind
+appK = AppT
+
+starK :: Quote m => m Kind
+starK = pure StarT
+
+constraintK :: Quote m => m Kind
+constraintK = pure ConstraintT
+
+-------------------------------------------------------------------------------
+-- * Type family result
+
+noSig :: Quote m => m FamilyResultSig
+noSig = pure NoSig
+
+kindSig :: Quote m => m Kind -> m FamilyResultSig
+kindSig = fmap KindSig
+
+tyVarSig :: Quote m => m (TyVarBndr ()) -> m FamilyResultSig
+tyVarSig = fmap TyVarSig
+
+-------------------------------------------------------------------------------
+-- * Injectivity annotation
+
+injectivityAnn :: Name -> [Name] -> InjectivityAnn
+injectivityAnn = TH.InjectivityAnn
+
+-------------------------------------------------------------------------------
+-- * Role
+
+nominalR, representationalR, phantomR, inferR :: Role
+nominalR = NominalR
+representationalR = RepresentationalR
+phantomR = PhantomR
+inferR = InferR
+
+-------------------------------------------------------------------------------
+-- * Callconv
+
+cCall, stdCall, cApi, prim, javaScript :: Callconv
+cCall = CCall
+stdCall = StdCall
+cApi = CApi
+prim = Prim
+javaScript = JavaScript
+
+-------------------------------------------------------------------------------
+-- * Safety
+
+unsafe, safe, interruptible :: Safety
+unsafe = Unsafe
+safe = Safe
+interruptible = Interruptible
+
+-------------------------------------------------------------------------------
+-- * FunDep
+
+funDep :: [Name] -> [Name] -> FunDep
+funDep = FunDep
+
+-------------------------------------------------------------------------------
+-- * RuleBndr
+ruleVar :: Quote m => Name -> m RuleBndr
+ruleVar = pure . RuleVar
+
+typedRuleVar :: Quote m => Name -> m Type -> m RuleBndr
+typedRuleVar n ty = TypedRuleVar n <$> ty
+
+-------------------------------------------------------------------------------
+-- * AnnTarget
+valueAnnotation :: Name -> AnnTarget
+valueAnnotation = ValueAnnotation
+
+typeAnnotation :: Name -> AnnTarget
+typeAnnotation = TypeAnnotation
+
+moduleAnnotation :: AnnTarget
+moduleAnnotation = ModuleAnnotation
+
+-------------------------------------------------------------------------------
+-- * Pattern Synonyms (sub constructs)
+
+unidir, implBidir :: Quote m => m PatSynDir
+unidir = pure Unidir
+implBidir = pure ImplBidir
+
+explBidir :: Quote m => [m Clause] -> m PatSynDir
+explBidir cls = do
+ cls' <- sequenceA cls
+ pure (ExplBidir cls')
+
+prefixPatSyn :: Quote m => [Name] -> m PatSynArgs
+prefixPatSyn args = pure $ PrefixPatSyn args
+
+recordPatSyn :: Quote m => [Name] -> m PatSynArgs
+recordPatSyn sels = pure $ RecordPatSyn sels
+
+infixPatSyn :: Quote m => Name -> Name -> m PatSynArgs
+infixPatSyn arg1 arg2 = pure $ InfixPatSyn arg1 arg2
+
+--------------------------------------------------------------
+-- * Useful helper function
+
+appsE :: Quote m => [m Exp] -> m Exp
+appsE [] = error "appsE []"
+appsE [x] = x
+appsE (x:y:zs) = appsE ( (appE x y) : zs )
+
+-- | pure the Module at the place of splicing. Can be used as an
+-- input for 'reifyModule'.
+thisModule :: Q Module
+thisModule = do
+ loc <- location
+ pure $ Module (mkPkgName $ loc_package loc) (mkModName $ loc_module loc)
+
+--------------------------------------------------------------
+-- * Documentation combinators
+
+-- | Attaches Haddock documentation to the declaration provided. Unlike
+-- 'putDoc', the names do not need to be in scope when calling this function so
+-- it can be used for quoted declarations and anything else currently being
+-- spliced.
+-- Not all declarations can have documentation attached to them. For those that
+-- can't, 'withDecDoc' will return it unchanged without any side effects.
+withDecDoc :: String -> Q Dec -> Q Dec
+withDecDoc doc dec = do
+ dec' <- dec
+ case doc_loc dec' of
+ Just loc -> qAddModFinalizer $ qPutDoc loc doc
+ Nothing -> pure ()
+ pure dec'
+ where
+ doc_loc (FunD n _) = Just $ DeclDoc n
+ doc_loc (ValD (VarP n) _ _) = Just $ DeclDoc n
+ doc_loc (DataD _ n _ _ _ _) = Just $ DeclDoc n
+ doc_loc (NewtypeD _ n _ _ _ _) = Just $ DeclDoc n
+ doc_loc (TypeDataD n _ _ _) = Just $ DeclDoc n
+ doc_loc (TySynD n _ _) = Just $ DeclDoc n
+ doc_loc (ClassD _ n _ _ _) = Just $ DeclDoc n
+ doc_loc (SigD n _) = Just $ DeclDoc n
+ doc_loc (ForeignD (ImportF _ _ _ n _)) = Just $ DeclDoc n
+ doc_loc (ForeignD (ExportF _ _ n _)) = Just $ DeclDoc n
+ doc_loc (InfixD _ _ n) = Just $ DeclDoc n
+ doc_loc (DataFamilyD n _ _) = Just $ DeclDoc n
+ doc_loc (OpenTypeFamilyD (TypeFamilyHead n _ _ _)) = Just $ DeclDoc n
+ doc_loc (ClosedTypeFamilyD (TypeFamilyHead n _ _ _) _) = Just $ DeclDoc n
+ doc_loc (PatSynD n _ _ _) = Just $ DeclDoc n
+ doc_loc (PatSynSigD n _) = Just $ DeclDoc n
+
+ -- For instances we just pass along the full type
+ doc_loc (InstanceD _ _ t _) = Just $ InstDoc t
+ doc_loc (DataInstD _ _ t _ _ _) = Just $ InstDoc t
+ doc_loc (NewtypeInstD _ _ t _ _ _) = Just $ InstDoc t
+ doc_loc (TySynInstD (TySynEqn _ t _)) = Just $ InstDoc t
+
+ -- Declarations that can't have documentation attached to
+ -- ValDs that aren't a simple variable pattern
+ doc_loc (ValD _ _ _) = Nothing
+ doc_loc (KiSigD _ _) = Nothing
+ doc_loc (PragmaD _) = Nothing
+ doc_loc (RoleAnnotD _ _) = Nothing
+ doc_loc (StandaloneDerivD _ _ _) = Nothing
+ doc_loc (DefaultSigD _ _) = Nothing
+ doc_loc (ImplicitParamBindD _ _) = Nothing
+ doc_loc (DefaultD _) = Nothing
+
+-- | Variant of 'withDecDoc' that applies the same documentation to
+-- multiple declarations. Useful for documenting quoted declarations.
+withDecsDoc :: String -> Q [Dec] -> Q [Dec]
+withDecsDoc doc decs = decs >>= mapM (withDecDoc doc . pure)
+
+-- | Variant of 'funD' that attaches Haddock documentation.
+funD_doc :: Name -> [Q Clause]
+ -> Maybe String -- ^ Documentation to attach to function
+ -> [Maybe String] -- ^ Documentation to attach to arguments
+ -> Q Dec
+funD_doc nm cs mfun_doc arg_docs = do
+ qAddModFinalizer $ sequence_
+ [putDoc (ArgDoc nm i) s | (i, Just s) <- zip [0..] arg_docs]
+ let dec = funD nm cs
+ case mfun_doc of
+ Just fun_doc -> withDecDoc fun_doc dec
+ Nothing -> funD nm cs
+
+-- | Variant of 'dataD' that attaches Haddock documentation.
+dataD_doc :: Q Cxt -> Name -> [Q (TyVarBndr BndrVis)] -> Maybe (Q Kind)
+ -> [(Q Con, Maybe String, [Maybe String])]
+ -- ^ List of constructors, documentation for the constructor, and
+ -- documentation for the arguments
+ -> [Q DerivClause]
+ -> Maybe String
+ -- ^ Documentation to attach to the data declaration
+ -> Q Dec
+dataD_doc ctxt tc tvs ksig cons_with_docs derivs mdoc = do
+ qAddModFinalizer $ mapM_ docCons cons_with_docs
+ let dec = dataD ctxt tc tvs ksig (map (\(con, _, _) -> con) cons_with_docs) derivs
+ maybe dec (flip withDecDoc dec) mdoc
+
+-- | Variant of 'newtypeD' that attaches Haddock documentation.
+newtypeD_doc :: Q Cxt -> Name -> [Q (TyVarBndr BndrVis)] -> Maybe (Q Kind)
+ -> (Q Con, Maybe String, [Maybe String])
+ -- ^ The constructor, documentation for the constructor, and
+ -- documentation for the arguments
+ -> [Q DerivClause]
+ -> Maybe String
+ -- ^ Documentation to attach to the newtype declaration
+ -> Q Dec
+newtypeD_doc ctxt tc tvs ksig con_with_docs@(con, _, _) derivs mdoc = do
+ qAddModFinalizer $ docCons con_with_docs
+ let dec = newtypeD ctxt tc tvs ksig con derivs
+ maybe dec (flip withDecDoc dec) mdoc
+
+-- | Variant of 'typeDataD' that attaches Haddock documentation.
+typeDataD_doc :: Name -> [Q (TyVarBndr BndrVis)] -> Maybe (Q Kind)
+ -> [(Q Con, Maybe String, [Maybe String])]
+ -- ^ List of constructors, documentation for the constructor, and
+ -- documentation for the arguments
+ -> Maybe String
+ -- ^ Documentation to attach to the data declaration
+ -> Q Dec
+typeDataD_doc tc tvs ksig cons_with_docs mdoc = do
+ qAddModFinalizer $ mapM_ docCons cons_with_docs
+ let dec = typeDataD tc tvs ksig (map (\(con, _, _) -> con) cons_with_docs)
+ maybe dec (flip withDecDoc dec) mdoc
+
+-- | Variant of 'dataInstD' that attaches Haddock documentation.
+dataInstD_doc :: Q Cxt -> (Maybe [Q (TyVarBndr ())]) -> Q Type -> Maybe (Q Kind)
+ -> [(Q Con, Maybe String, [Maybe String])]
+ -- ^ List of constructors, documentation for the constructor, and
+ -- documentation for the arguments
+ -> [Q DerivClause]
+ -> Maybe String
+ -- ^ Documentation to attach to the instance declaration
+ -> Q Dec
+dataInstD_doc ctxt mb_bndrs ty ksig cons_with_docs derivs mdoc = do
+ qAddModFinalizer $ mapM_ docCons cons_with_docs
+ let dec = dataInstD ctxt mb_bndrs ty ksig (map (\(con, _, _) -> con) cons_with_docs)
+ derivs
+ maybe dec (flip withDecDoc dec) mdoc
+
+-- | Variant of 'newtypeInstD' that attaches Haddock documentation.
+newtypeInstD_doc :: Q Cxt -> (Maybe [Q (TyVarBndr ())]) -> Q Type
+ -> Maybe (Q Kind)
+ -> (Q Con, Maybe String, [Maybe String])
+ -- ^ The constructor, documentation for the constructor, and
+ -- documentation for the arguments
+ -> [Q DerivClause]
+ -> Maybe String
+ -- ^ Documentation to attach to the instance declaration
+ -> Q Dec
+newtypeInstD_doc ctxt mb_bndrs ty ksig con_with_docs@(con, _, _) derivs mdoc = do
+ qAddModFinalizer $ docCons con_with_docs
+ let dec = newtypeInstD ctxt mb_bndrs ty ksig con derivs
+ maybe dec (flip withDecDoc dec) mdoc
+
+-- | Variant of 'patSynD' that attaches Haddock documentation.
+patSynD_doc :: Name -> Q PatSynArgs -> Q PatSynDir -> Q Pat
+ -> Maybe String -- ^ Documentation to attach to the pattern synonym
+ -> [Maybe String] -- ^ Documentation to attach to the pattern arguments
+ -> Q Dec
+patSynD_doc name args dir pat mdoc arg_docs = do
+ qAddModFinalizer $ sequence_
+ [putDoc (ArgDoc name i) s | (i, Just s) <- zip [0..] arg_docs]
+ let dec = patSynD name args dir pat
+ maybe dec (flip withDecDoc dec) mdoc
+
+-- | Document a data/newtype constructor with its arguments.
+docCons :: (Q Con, Maybe String, [Maybe String]) -> Q ()
+docCons (c, md, arg_docs) = do
+ c' <- c
+ -- Attach docs to the constructors
+ sequence_ [ putDoc (DeclDoc nm) d | Just d <- [md], nm <- get_cons_names c' ]
+ -- Attach docs to the arguments
+ case c' of
+ -- Record selector documentation isn't stored in the argument map,
+ -- but in the declaration map instead
+ RecC _ var_bang_types ->
+ sequence_ [ putDoc (DeclDoc nm) arg_doc
+ | (Just arg_doc, (nm, _, _)) <- zip arg_docs var_bang_types
+ ]
+ _ ->
+ sequence_ [ putDoc (ArgDoc nm i) arg_doc
+ | nm <- get_cons_names c'
+ , (i, Just arg_doc) <- zip [0..] arg_docs
+ ]
diff --git a/libraries/ghc-internal/src/GHC/Internal/TH/Lift.hs b/libraries/ghc-internal/src/GHC/Internal/TH/Lift.hs
new file mode 100644
index 0000000000000000000000000000000000000000..55b015ac414884bd30d479ee7548534b24c29b8f
--- /dev/null
+++ b/libraries/ghc-internal/src/GHC/Internal/TH/Lift.hs
@@ -0,0 +1,569 @@
+{-# OPTIONS_HADDOCK not-home #-} -- we want users to import Language.Haskell.TH.Syntax instead
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE BangPatterns #-}
+{-# LANGUAGE DefaultSignatures #-}
+{-# LANGUAGE KindSignatures #-}
+{-# LANGUAGE MagicHash #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE RankNTypes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE TemplateHaskellQuotes #-}
+{-# LANGUAGE Trustworthy #-}
+{-# LANGUAGE TypeOperators #-}
+{-# LANGUAGE UnboxedSums #-}
+{-# LANGUAGE UnboxedTuples #-}
+{-# OPTIONS_GHC -fno-warn-inline-rule-shadowing #-}
+
+-- | This module gives the definition of the 'Lift' class.
+--
+-- This is an internal module.
+-- Please import "Language.Haskell.TH" or "Language.Haskell.TH.Syntax" instead!
+
+module GHC.Internal.TH.Lift
+ ( Lift(..)
+ -- * Generic Lift implementations
+ , dataToQa
+ , dataToExpQ
+ , liftData
+ , dataToPatQ
+ -- * Wired-in names
+ , liftString
+ , trueName
+ , falseName
+ , nothingName
+ , justName
+ , leftName
+ , rightName
+ , nonemptyName
+ )
+ where
+
+import GHC.Internal.TH.Syntax
+import GHC.Internal.TH.Lib () -- See wrinkle (W4) of Note [Tracking dependencies on primitives]
+import GHC.Internal.Lexeme ( startsVarSym, startsVarId )
+
+import GHC.Internal.Data.Either
+import GHC.Internal.Type.Reflection
+import GHC.Internal.Data.Bool
+import GHC.Internal.Base hiding (Type, Module, inline)
+import GHC.Internal.Data.Foldable
+import GHC.Internal.Data.Functor
+import GHC.Internal.Integer
+import GHC.Internal.Real
+import GHC.Internal.Word
+import GHC.Internal.Int
+import GHC.Internal.Data.Data
+import GHC.Internal.Natural
+
+-- | 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 (@[| ... |]@ or
+-- @[|| ... ||]@) but not at the top level. As an example:
+--
+-- > add1 :: Int -> Code Q Int
+-- > 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@ and @$$(liftTyped x) ≡ x@
+-- for all @x@, where @$(...)@ and @$$(...)@ are Template Haskell splices.
+-- It is additionally expected that @'lift' x ≡ 'unTypeCode' ('liftTyped' x)@.
+--
+-- '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
+--
+-- Representation-polymorphic since /template-haskell-2.16.0.0/.
+class Lift (t :: TYPE r) where
+ -- | Turn a value into a Template Haskell expression, suitable for use in
+ -- a splice.
+ lift :: Quote m => t -> m Exp
+ default lift :: (r ~ ('BoxedRep 'Lifted), Quote m) => t -> m Exp
+ lift = unTypeCode . liftTyped
+
+ -- | Turn a value into a Template Haskell typed expression, suitable for use
+ -- in a typed splice.
+ --
+ -- @since template-haskell-2.16.0.0
+ liftTyped :: Quote m => t -> Code m t
+
+
+-- If you add any instances here, consider updating test th/TH_Lift
+instance Lift Integer where
+ liftTyped x = unsafeCodeCoerce (lift x)
+ lift x = return (LitE (IntegerL x))
+
+instance Lift Int where
+ liftTyped x = unsafeCodeCoerce (lift x)
+ lift x = return (LitE (IntegerL (fromIntegral x)))
+
+-- | @since template-haskell-2.16.0.0
+instance Lift Int# where
+ liftTyped x = unsafeCodeCoerce (lift x)
+ lift x = return (LitE (IntPrimL (fromIntegral (I# x))))
+
+instance Lift Int8 where
+ liftTyped x = unsafeCodeCoerce (lift x)
+ lift x = return (LitE (IntegerL (fromIntegral x)))
+
+instance Lift Int16 where
+ liftTyped x = unsafeCodeCoerce (lift x)
+ lift x = return (LitE (IntegerL (fromIntegral x)))
+
+instance Lift Int32 where
+ liftTyped x = unsafeCodeCoerce (lift x)
+ lift x = return (LitE (IntegerL (fromIntegral x)))
+
+instance Lift Int64 where
+ liftTyped x = unsafeCodeCoerce (lift x)
+ lift x = return (LitE (IntegerL (fromIntegral x)))
+
+-- | @since template-haskell-2.16.0.0
+instance Lift Word# where
+ liftTyped x = unsafeCodeCoerce (lift x)
+ lift x = return (LitE (WordPrimL (fromIntegral (W# x))))
+
+instance Lift Word where
+ liftTyped x = unsafeCodeCoerce (lift x)
+ lift x = return (LitE (IntegerL (fromIntegral x)))
+
+instance Lift Word8 where
+ liftTyped x = unsafeCodeCoerce (lift x)
+ lift x = return (LitE (IntegerL (fromIntegral x)))
+
+instance Lift Word16 where
+ liftTyped x = unsafeCodeCoerce (lift x)
+ lift x = return (LitE (IntegerL (fromIntegral x)))
+
+instance Lift Word32 where
+ liftTyped x = unsafeCodeCoerce (lift x)
+ lift x = return (LitE (IntegerL (fromIntegral x)))
+
+instance Lift Word64 where
+ liftTyped x = unsafeCodeCoerce (lift x)
+ lift x = return (LitE (IntegerL (fromIntegral x)))
+
+instance Lift Natural where
+ liftTyped x = unsafeCodeCoerce (lift x)
+ lift x = return (LitE (IntegerL (fromIntegral x)))
+
+instance Integral a => Lift (Ratio a) where
+ liftTyped x = unsafeCodeCoerce (lift x)
+ lift x = return (LitE (RationalL (toRational x)))
+
+instance Lift Float where
+ liftTyped x = unsafeCodeCoerce (lift x)
+ lift x = return (LitE (RationalL (toRational x)))
+
+-- | @since template-haskell-2.16.0.0
+instance Lift Float# where
+ liftTyped x = unsafeCodeCoerce (lift x)
+ lift x = return (LitE (FloatPrimL (toRational (F# x))))
+
+instance Lift Double where
+ liftTyped x = unsafeCodeCoerce (lift x)
+ lift x = return (LitE (RationalL (toRational x)))
+
+-- | @since template-haskell-2.16.0.0
+instance Lift Double# where
+ liftTyped x = unsafeCodeCoerce (lift x)
+ lift x = return (LitE (DoublePrimL (toRational (D# x))))
+
+instance Lift Char where
+ liftTyped x = unsafeCodeCoerce (lift x)
+ lift x = return (LitE (CharL x))
+
+-- | @since template-haskell-2.16.0.0
+instance Lift Char# where
+ liftTyped x = unsafeCodeCoerce (lift x)
+ lift x = return (LitE (CharPrimL (C# x)))
+
+instance Lift Bool where
+ liftTyped x = unsafeCodeCoerce (lift x)
+
+ lift True = return (ConE trueName)
+ lift False = return (ConE falseName)
+
+-- | Produces an 'Addr#' literal from the NUL-terminated C-string starting at
+-- the given memory address.
+--
+-- @since template-haskell-2.16.0.0
+instance Lift Addr# where
+ liftTyped x = unsafeCodeCoerce (lift x)
+ lift x
+ = return (LitE (StringPrimL (map (fromIntegral . ord) (unpackCString# x))))
+
+instance Lift a => Lift (Maybe a) where
+ liftTyped x = unsafeCodeCoerce (lift x)
+
+ lift Nothing = return (ConE nothingName)
+ lift (Just x) = liftM (ConE justName `AppE`) (lift x)
+
+instance (Lift a, Lift b) => Lift (Either a b) where
+ liftTyped x = unsafeCodeCoerce (lift x)
+
+ lift (Left x) = liftM (ConE leftName `AppE`) (lift x)
+ lift (Right y) = liftM (ConE rightName `AppE`) (lift y)
+
+instance Lift a => Lift [a] where
+ liftTyped x = unsafeCodeCoerce (lift x)
+ lift xs = do { xs' <- mapM lift xs; return (ListE xs') }
+
+liftString :: Quote m => String -> m Exp
+-- Used in GHC.Tc.Gen.Expr to short-circuit the lifting for strings
+liftString s = return (LitE (StringL s))
+
+-- | @since template-haskell-2.15.0.0
+instance Lift a => Lift (NonEmpty a) where
+ liftTyped x = unsafeCodeCoerce (lift x)
+
+ lift (x :| xs) = do
+ x' <- lift x
+ xs' <- lift xs
+ return (InfixE (Just x') (ConE nonemptyName) (Just xs'))
+
+-- | @since template-haskell-2.15.0.0
+instance Lift Void where
+ liftTyped = liftCode . absurd
+ lift = pure . absurd
+
+instance Lift () where
+ liftTyped x = unsafeCodeCoerce (lift x)
+ lift () = return (ConE (tupleDataName 0))
+
+instance (Lift a, Lift b) => Lift (a, b) where
+ liftTyped x = unsafeCodeCoerce (lift x)
+ lift (a, b)
+ = liftM TupE $ sequence $ map (fmap Just) [lift a, lift b]
+
+instance (Lift a, Lift b, Lift c) => Lift (a, b, c) where
+ liftTyped x = unsafeCodeCoerce (lift x)
+ lift (a, b, c)
+ = liftM TupE $ sequence $ map (fmap Just) [lift a, lift b, lift c]
+
+instance (Lift a, Lift b, Lift c, Lift d) => Lift (a, b, c, d) where
+ liftTyped x = unsafeCodeCoerce (lift x)
+ lift (a, b, c, d)
+ = liftM TupE $ sequence $ map (fmap Just) [lift a, lift b, lift c, lift d]
+
+instance (Lift a, Lift b, Lift c, Lift d, Lift e)
+ => Lift (a, b, c, d, e) where
+ liftTyped x = unsafeCodeCoerce (lift x)
+ lift (a, b, c, d, e)
+ = liftM TupE $ sequence $ map (fmap Just) [ lift a, lift b
+ , lift c, lift d, lift e ]
+
+instance (Lift a, Lift b, Lift c, Lift d, Lift e, Lift f)
+ => Lift (a, b, c, d, e, f) where
+ liftTyped x = unsafeCodeCoerce (lift x)
+ lift (a, b, c, d, e, f)
+ = liftM TupE $ sequence $ map (fmap Just) [ lift a, lift b, lift c
+ , lift d, lift e, lift f ]
+
+instance (Lift a, Lift b, Lift c, Lift d, Lift e, Lift f, Lift g)
+ => Lift (a, b, c, d, e, f, g) where
+ liftTyped x = unsafeCodeCoerce (lift x)
+ lift (a, b, c, d, e, f, g)
+ = liftM TupE $ sequence $ map (fmap Just) [ lift a, lift b, lift c
+ , lift d, lift e, lift f, lift g ]
+
+-- | @since template-haskell-2.16.0.0
+instance Lift (# #) where
+ liftTyped x = unsafeCodeCoerce (lift x)
+ lift (# #) = return (ConE (unboxedTupleTypeName 0))
+
+-- | @since template-haskell-2.16.0.0
+instance (Lift a) => Lift (# a #) where
+ liftTyped x = unsafeCodeCoerce (lift x)
+ lift (# a #)
+ = liftM UnboxedTupE $ sequence $ map (fmap Just) [lift a]
+
+-- | @since template-haskell-2.16.0.0
+instance (Lift a, Lift b) => Lift (# a, b #) where
+ liftTyped x = unsafeCodeCoerce (lift x)
+ lift (# a, b #)
+ = liftM UnboxedTupE $ sequence $ map (fmap Just) [lift a, lift b]
+
+-- | @since template-haskell-2.16.0.0
+instance (Lift a, Lift b, Lift c)
+ => Lift (# a, b, c #) where
+ liftTyped x = unsafeCodeCoerce (lift x)
+ lift (# a, b, c #)
+ = liftM UnboxedTupE $ sequence $ map (fmap Just) [lift a, lift b, lift c]
+
+-- | @since template-haskell-2.16.0.0
+instance (Lift a, Lift b, Lift c, Lift d)
+ => Lift (# a, b, c, d #) where
+ liftTyped x = unsafeCodeCoerce (lift x)
+ lift (# a, b, c, d #)
+ = liftM UnboxedTupE $ sequence $ map (fmap Just) [ lift a, lift b
+ , lift c, lift d ]
+
+-- | @since template-haskell-2.16.0.0
+instance (Lift a, Lift b, Lift c, Lift d, Lift e)
+ => Lift (# a, b, c, d, e #) where
+ liftTyped x = unsafeCodeCoerce (lift x)
+ lift (# a, b, c, d, e #)
+ = liftM UnboxedTupE $ sequence $ map (fmap Just) [ lift a, lift b
+ , lift c, lift d, lift e ]
+
+-- | @since template-haskell-2.16.0.0
+instance (Lift a, Lift b, Lift c, Lift d, Lift e, Lift f)
+ => Lift (# a, b, c, d, e, f #) where
+ liftTyped x = unsafeCodeCoerce (lift x)
+ lift (# a, b, c, d, e, f #)
+ = liftM UnboxedTupE $ sequence $ map (fmap Just) [ lift a, lift b, lift c
+ , lift d, lift e, lift f ]
+
+-- | @since template-haskell-2.16.0.0
+instance (Lift a, Lift b, Lift c, Lift d, Lift e, Lift f, Lift g)
+ => Lift (# a, b, c, d, e, f, g #) where
+ liftTyped x = unsafeCodeCoerce (lift x)
+ lift (# a, b, c, d, e, f, g #)
+ = liftM UnboxedTupE $ sequence $ map (fmap Just) [ lift a, lift b, lift c
+ , lift d, lift e, lift f
+ , lift g ]
+
+-- | @since template-haskell-2.16.0.0
+instance (Lift a, Lift b) => Lift (# a | b #) where
+ liftTyped x = unsafeCodeCoerce (lift x)
+ lift x
+ = case x of
+ (# y | #) -> UnboxedSumE <$> lift y <*> pure 1 <*> pure 2
+ (# | y #) -> UnboxedSumE <$> lift y <*> pure 2 <*> pure 2
+
+-- | @since template-haskell-2.16.0.0
+instance (Lift a, Lift b, Lift c)
+ => Lift (# a | b | c #) where
+ liftTyped x = unsafeCodeCoerce (lift x)
+ lift x
+ = case x of
+ (# y | | #) -> UnboxedSumE <$> lift y <*> pure 1 <*> pure 3
+ (# | y | #) -> UnboxedSumE <$> lift y <*> pure 2 <*> pure 3
+ (# | | y #) -> UnboxedSumE <$> lift y <*> pure 3 <*> pure 3
+
+-- | @since template-haskell-2.16.0.0
+instance (Lift a, Lift b, Lift c, Lift d)
+ => Lift (# a | b | c | d #) where
+ liftTyped x = unsafeCodeCoerce (lift x)
+ lift x
+ = case x of
+ (# y | | | #) -> UnboxedSumE <$> lift y <*> pure 1 <*> pure 4
+ (# | y | | #) -> UnboxedSumE <$> lift y <*> pure 2 <*> pure 4
+ (# | | y | #) -> UnboxedSumE <$> lift y <*> pure 3 <*> pure 4
+ (# | | | y #) -> UnboxedSumE <$> lift y <*> pure 4 <*> pure 4
+
+-- | @since template-haskell-2.16.0.0
+instance (Lift a, Lift b, Lift c, Lift d, Lift e)
+ => Lift (# a | b | c | d | e #) where
+ liftTyped x = unsafeCodeCoerce (lift x)
+ lift x
+ = case x of
+ (# y | | | | #) -> UnboxedSumE <$> lift y <*> pure 1 <*> pure 5
+ (# | y | | | #) -> UnboxedSumE <$> lift y <*> pure 2 <*> pure 5
+ (# | | y | | #) -> UnboxedSumE <$> lift y <*> pure 3 <*> pure 5
+ (# | | | y | #) -> UnboxedSumE <$> lift y <*> pure 4 <*> pure 5
+ (# | | | | y #) -> UnboxedSumE <$> lift y <*> pure 5 <*> pure 5
+
+-- | @since template-haskell-2.16.0.0
+instance (Lift a, Lift b, Lift c, Lift d, Lift e, Lift f)
+ => Lift (# a | b | c | d | e | f #) where
+ liftTyped x = unsafeCodeCoerce (lift x)
+ lift x
+ = case x of
+ (# y | | | | | #) -> UnboxedSumE <$> lift y <*> pure 1 <*> pure 6
+ (# | y | | | | #) -> UnboxedSumE <$> lift y <*> pure 2 <*> pure 6
+ (# | | y | | | #) -> UnboxedSumE <$> lift y <*> pure 3 <*> pure 6
+ (# | | | y | | #) -> UnboxedSumE <$> lift y <*> pure 4 <*> pure 6
+ (# | | | | y | #) -> UnboxedSumE <$> lift y <*> pure 5 <*> pure 6
+ (# | | | | | y #) -> UnboxedSumE <$> lift y <*> pure 6 <*> pure 6
+
+-- | @since template-haskell-2.16.0.0
+instance (Lift a, Lift b, Lift c, Lift d, Lift e, Lift f, Lift g)
+ => Lift (# a | b | c | d | e | f | g #) where
+ liftTyped x = unsafeCodeCoerce (lift x)
+ lift x
+ = case x of
+ (# y | | | | | | #) -> UnboxedSumE <$> lift y <*> pure 1 <*> pure 7
+ (# | y | | | | | #) -> UnboxedSumE <$> lift y <*> pure 2 <*> pure 7
+ (# | | y | | | | #) -> UnboxedSumE <$> lift y <*> pure 3 <*> pure 7
+ (# | | | y | | | #) -> UnboxedSumE <$> lift y <*> pure 4 <*> pure 7
+ (# | | | | y | | #) -> UnboxedSumE <$> lift y <*> pure 5 <*> pure 7
+ (# | | | | | y | #) -> UnboxedSumE <$> lift y <*> pure 6 <*> pure 7
+ (# | | | | | | y #) -> UnboxedSumE <$> lift y <*> pure 7 <*> pure 7
+
+-- 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 = 'True
+falseName = 'False
+
+nothingName, justName :: Name
+nothingName = 'Nothing
+justName = 'Just
+
+leftName, rightName :: Name
+leftName = 'Left
+rightName = 'Right
+
+nonemptyName :: Name
+nonemptyName = '(:|)
+
+-----------------------------------------------------
+--
+-- 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 m a k q. (Quote m, Data a)
+ => (Name -> k)
+ -> (Lit -> m q)
+ -> (k -> [m q] -> m q)
+ -> (forall b . Data b => b -> Maybe (m q))
+ -> a
+ -> m q
+dataToQa mkCon mkLit appCon antiQ t =
+ case antiQ t of
+ Nothing ->
+ case constrRep constr of
+ AlgConstr _ ->
+ appCon (mkCon funOrConName) conArgs
+ where
+ funOrConName :: Name
+ funOrConName =
+ case showConstr constr of
+ "(:)" -> Name (mkOccName ":")
+ (NameG DataName
+ (mkPkgName "ghc-prim")
+ (mkModName "GHC.Types"))
+ con@"[]" -> Name (mkOccName con)
+ (NameG DataName
+ (mkPkgName "ghc-prim")
+ (mkModName "GHC.Types"))
+ con@('(':_) -> Name (mkOccName con)
+ (NameG DataName
+ (mkPkgName "ghc-prim")
+ (mkModName "GHC.Tuple"))
+
+ -- Tricky case: see Note [Data for non-algebraic types]
+ fun@(x:_) | startsVarSym x || startsVarId x
+ -> mkNameG_v tyconPkg tyconMod fun
+ con -> mkNameG_d tyconPkg tyconMod con
+
+ where
+ tycon :: TyCon
+ tycon = (typeRepTyCon . typeOf) t
+
+ tyconPkg, tyconMod :: String
+ tyconPkg = tyConPackage tycon
+ tyconMod = tyConModule tycon
+
+ conArgs :: [m q]
+ conArgs = gmapQ (dataToQa mkCon mkLit appCon antiQ) t
+ IntConstr n ->
+ mkLit $ IntegerL n
+ FloatConstr n ->
+ mkLit $ RationalL n
+ CharConstr c ->
+ mkLit $ CharL c
+ where
+ constr :: Constr
+ constr = toConstr t
+
+ Just y -> 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 #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; #12596 shows what goes wrong if
+ "pack" is defined in a different module than the data type "Text".
+ -}
+
+-- | 'dataToExpQ' converts a value to a '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 :: (Quote m, Data a)
+ => (forall b . Data b => b -> Maybe (m Exp))
+ -> a
+ -> m Exp
+dataToExpQ = dataToQa varOrConE litE (foldl appE)
+ where
+ -- Make sure that VarE is used if the Constr value relies on a
+ -- function underneath the surface (instead of a constructor).
+ -- See #10796.
+ varOrConE s =
+ case nameSpace s of
+ Just VarName -> return (VarE s)
+ Just (FldName {}) -> return (VarE s)
+ Just DataName -> return (ConE s)
+ _ -> error $ "Can't construct an expression from name "
+ ++ showName s
+ appE x y = do { a <- x; b <- y; return (AppE a b)}
+ litE c = return (LitE c)
+
+-- | 'liftData' is a variant of 'lift' in the 'Lift' type class which
+-- works for any type with a 'Data' instance.
+liftData :: (Quote m, Data a) => a -> m Exp
+liftData = dataToExpQ (const Nothing)
+
+-- | 'dataToPatQ' converts a value to a '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 :: (Quote m, Data a)
+ => (forall b . Data b => b -> Maybe (m Pat))
+ -> a
+ -> m Pat
+dataToPatQ = dataToQa id litP conP
+ where litP l = return (LitP l)
+ conP n ps =
+ case nameSpace n of
+ Just DataName -> do
+ ps' <- sequence ps
+ return (ConP n [] ps')
+ _ -> error $ "Can't construct a pattern from name "
+ ++ showName n
diff --git a/libraries/ghc-internal/src/GHC/Internal/TH/Quote.hs b/libraries/ghc-internal/src/GHC/Internal/TH/Quote.hs
new file mode 100644
index 0000000000000000000000000000000000000000..45d4f34938cefe44d87fdd2442e7fba45a076911
--- /dev/null
+++ b/libraries/ghc-internal/src/GHC/Internal/TH/Quote.hs
@@ -0,0 +1,42 @@
+{-# LANGUAGE CPP, RankNTypes, ScopedTypeVariables, Trustworthy #-}
+{- |
+Module : GHC.Internal.TH.Quote
+Description : Quasi-quoting support for Template Haskell
+
+Template Haskell supports quasiquoting, which permits users to construct
+program fragments by directly writing concrete syntax. A quasiquoter is
+essentially a function with takes a string to a Template Haskell AST.
+This module defines the 'QuasiQuoter' datatype, which specifies a
+quasiquoter @q@ which can be invoked using the syntax
+@[q| ... string to parse ... |]@ when the @QuasiQuotes@ language
+extension is enabled, and some utility functions for manipulating
+quasiquoters. Nota bene: this package does not define any parsers,
+that is up to you.
+
+This is an internal module. Please import 'Language.Haskell.TH.Quote' instead.
+-}
+module GHC.Internal.TH.Quote(
+ QuasiQuoter(..),
+ ) where
+
+import GHC.Internal.TH.Syntax
+import GHC.Internal.Base hiding (Type)
+
+
+-- | The 'QuasiQuoter' type, a value @q@ of this type can be used
+-- in the syntax @[q| ... string to parse ...|]@. In fact, for
+-- convenience, a 'QuasiQuoter' actually defines multiple quasiquoters
+-- to be used in different splice contexts; if you are only interested
+-- in defining a quasiquoter to be used for expressions, you would
+-- define a 'QuasiQuoter' with only 'quoteExp', and leave the other
+-- fields stubbed out with errors.
+data QuasiQuoter = QuasiQuoter {
+ -- | Quasi-quoter for expressions, invoked by quotes like @lhs = $[q|...]@
+ quoteExp :: String -> Q Exp,
+ -- | Quasi-quoter for patterns, invoked by quotes like @f $[q|...] = rhs@
+ quotePat :: String -> Q Pat,
+ -- | Quasi-quoter for types, invoked by quotes like @f :: $[q|...]@
+ quoteType :: String -> Q Type,
+ -- | Quasi-quoter for declarations, invoked by top-level quotes
+ quoteDec :: String -> Q [Dec]
+ }
diff --git a/libraries/template-haskell/Language/Haskell/TH/Lib/Syntax.hs b/libraries/ghc-internal/src/GHC/Internal/TH/Syntax.hs
similarity index 80%
rename from libraries/template-haskell/Language/Haskell/TH/Lib/Syntax.hs
rename to libraries/ghc-internal/src/GHC/Internal/TH/Syntax.hs
index 8d080fef9bb56867ffa346013ed47cf2b9761f4b..1f2c76a38d7af5d07dc176c3f1f43bdc3cac2b95 100644
--- a/libraries/template-haskell/Language/Haskell/TH/Lib/Syntax.hs
+++ b/libraries/ghc-internal/src/GHC/Internal/TH/Syntax.hs
@@ -7,7 +7,6 @@
Trustworthy, DeriveFunctor, DeriveTraversable,
BangPatterns, RecordWildCards, ImplicitParams #-}
-{-# OPTIONS_GHC -fno-warn-inline-rule-shadowing #-}
{-# LANGUAGE TemplateHaskellQuotes #-}
{-# LANGUAGE StandaloneKindSignatures #-}
@@ -18,21 +17,21 @@
-- guarantees for this module from version to version.
--
-- Import "Language.Haskell.TH" or "Language.Haskell.TH.Syntax" instead!
-module Language.Haskell.TH.Lib.Syntax
- ( module Language.Haskell.TH.Lib.Syntax
+module GHC.Internal.TH.Syntax
+ ( module GHC.Internal.TH.Syntax
-- * Language extensions
- , module Language.Haskell.TH.LanguageExtensions
+ , module GHC.Internal.LanguageExtensions
, ForeignSrcLang(..)
-- * Notes
-- ** Unresolved Infix
-- $infix
) where
+#ifdef BOOTSTRAP_TH
import Prelude
import Data.Data hiding (Fixity(..))
import Data.IORef
import System.IO.Unsafe ( unsafePerformIO )
-import System.FilePath
import GHC.IO.Unsafe ( unsafeDupableInterleaveIO )
import Control.Monad.IO.Class (MonadIO (..))
import Control.Monad.Fix (MonadFix (..))
@@ -46,34 +45,41 @@ import Data.Word
import GHC.Generics ( Generic )
import qualified Data.Kind as Kind (Type)
import GHC.Ptr ( Ptr, plusPtr )
-import GHC.Lexeme ( startsVarSym, startsVarId )
-import GHC.ForeignSrcLang.Type
-import Language.Haskell.TH.LanguageExtensions
-import Prelude hiding (Applicative(..))
import Foreign.ForeignPtr
import Foreign.C.String
import Foreign.C.Types
-import GHC.Types (TYPE, RuntimeRep(..), Levity(..))
-
-#ifndef BOOTSTRAP_TH
-import Control.Monad (liftM)
-import Data.Array.Byte (ByteArray(..))
-import Data.Char (ord)
-import Data.Int
-import Data.Ratio
-import Data.Void ( Void, absurd )
-import GHC.CString ( unpackCString# )
-import GHC.Exts
- ( ByteArray#, unsafeFreezeByteArray#, copyAddrToByteArray#, newByteArray#
- , isByteArrayPinned#, isTrue#, sizeofByteArray#, unsafeCoerce#, byteArrayContents#
- , copyByteArray#, newPinnedByteArray#)
-import GHC.ForeignPtr (ForeignPtr(..), ForeignPtrContents(..))
-import GHC.Prim ( Int#, Word#, Char#, Double#, Float#, Addr# )
-import GHC.ST (ST(..), runST)
-import GHC.Types ( Int(..), Word(..), Char(..), Double(..), Float(..))
-import Numeric.Natural
-import qualified Data.Fixed as Fixed
+import GHC.Types (TYPE, RuntimeRep(..))
+#else
+import GHC.Internal.Base hiding (Type, Module, sequence)
+import GHC.Internal.Data.Data hiding (Fixity(..))
+import GHC.Internal.Data.Traversable
+import GHC.Internal.Word
+import GHC.Internal.Generics (Generic)
+import GHC.Internal.IORef
+import GHC.Internal.System.IO
+import GHC.Internal.Show
+import GHC.Internal.Integer
+import GHC.Internal.Real
+import GHC.Internal.Data.Foldable
+import GHC.Internal.Foreign.Ptr
+import GHC.Internal.ForeignPtr
+import GHC.Internal.Data.Typeable
+import GHC.Internal.Control.Monad.IO.Class
+import GHC.Internal.Foreign.C.Types
+import GHC.Internal.Foreign.C.String
+import GHC.Internal.Control.Monad.Fail
+import GHC.Internal.Control.Monad.Fix
+import GHC.Internal.Control.Exception
+import GHC.Internal.Num
+import GHC.Internal.IO.Unsafe
+import GHC.Internal.List (dropWhile, break, replicate, reverse, last)
+import GHC.Internal.MVar
+import GHC.Internal.IO.Exception
+import GHC.Internal.Unicode
+import qualified GHC.Types as Kind (Type)
#endif
+import GHC.Internal.ForeignSrcLang
+import GHC.Internal.LanguageExtensions
-----------------------------------------------------
--
@@ -784,13 +790,6 @@ runIO m = Q (qRunIO m)
getPackageRoot :: Q FilePath
getPackageRoot = Q qGetPackageRoot
--- | The input is a filepath, which if relative is offset by the package root.
-makeRelativeToProject :: FilePath -> Q FilePath
-makeRelativeToProject fp | isRelative fp = do
- root <- getPackageRoot
- return (root </> fp)
-makeRelativeToProject fp = return fp
-
-- | Record external files that runIO is using (dependent upon).
@@ -968,570 +967,11 @@ sequenceQ :: forall m . Monad m => forall a . [m a] -> m [a]
sequenceQ = 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 (@[| ... |]@ or
--- @[|| ... ||]@) but not at the top level. As an example:
---
--- > add1 :: Int -> Code Q Int
--- > 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@ and @$$(liftTyped x) ≡ x@
--- for all @x@, where @$(...)@ and @$$(...)@ are Template Haskell splices.
--- It is additionally expected that @'lift' x ≡ 'unTypeCode' ('liftTyped' x)@.
---
--- '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
---
--- Representation-polymorphic since /template-haskell-2.16.0.0/.
-class Lift (t :: TYPE r) where
- -- | Turn a value into a Template Haskell expression, suitable for use in
- -- a splice.
- lift :: Quote m => t -> m Exp
- default lift :: (r ~ ('BoxedRep 'Lifted), Quote m) => t -> m Exp
- lift = unTypeCode . liftTyped
-
- -- | Turn a value into a Template Haskell typed expression, suitable for use
- -- in a typed splice.
- --
- -- @since 2.16.0.0
- liftTyped :: Quote m => t -> Code m t
-
-
--- See Note [Bootstrapping Template Haskell]
-#ifndef BOOTSTRAP_TH
--- If you add any instances here, consider updating test th/TH_Lift
-instance Lift Integer where
- liftTyped x = unsafeCodeCoerce (lift x)
- lift x = return (LitE (IntegerL x))
-
-instance Lift Int where
- liftTyped x = unsafeCodeCoerce (lift x)
- lift x = return (LitE (IntegerL (fromIntegral x)))
-
--- | @since 2.16.0.0
-instance Lift Int# where
- liftTyped x = unsafeCodeCoerce (lift x)
- lift x = return (LitE (IntPrimL (fromIntegral (I# x))))
-
-instance Lift Int8 where
- liftTyped x = unsafeCodeCoerce (lift x)
- lift x = return (LitE (IntegerL (fromIntegral x)))
-
-instance Lift Int16 where
- liftTyped x = unsafeCodeCoerce (lift x)
- lift x = return (LitE (IntegerL (fromIntegral x)))
-
-instance Lift Int32 where
- liftTyped x = unsafeCodeCoerce (lift x)
- lift x = return (LitE (IntegerL (fromIntegral x)))
-
-instance Lift Int64 where
- liftTyped x = unsafeCodeCoerce (lift x)
- lift x = return (LitE (IntegerL (fromIntegral x)))
-
--- | @since 2.16.0.0
-instance Lift Word# where
- liftTyped x = unsafeCodeCoerce (lift x)
- lift x = return (LitE (WordPrimL (fromIntegral (W# x))))
-
-instance Lift Word where
- liftTyped x = unsafeCodeCoerce (lift x)
- lift x = return (LitE (IntegerL (fromIntegral x)))
-
-instance Lift Word8 where
- liftTyped x = unsafeCodeCoerce (lift x)
- lift x = return (LitE (IntegerL (fromIntegral x)))
-
-instance Lift Word16 where
- liftTyped x = unsafeCodeCoerce (lift x)
- lift x = return (LitE (IntegerL (fromIntegral x)))
-
-instance Lift Word32 where
- liftTyped x = unsafeCodeCoerce (lift x)
- lift x = return (LitE (IntegerL (fromIntegral x)))
-
-instance Lift Word64 where
- liftTyped x = unsafeCodeCoerce (lift x)
- lift x = return (LitE (IntegerL (fromIntegral x)))
-
-instance Lift Natural where
- liftTyped x = unsafeCodeCoerce (lift x)
- lift x = return (LitE (IntegerL (fromIntegral x)))
-
-instance Lift (Fixed.Fixed a) where
- liftTyped x = unsafeCodeCoerce (lift x)
- lift (Fixed.MkFixed x) = do
- ex <- lift x
- return (ConE mkFixedName `AppE` ex)
- where
- mkFixedName = 'Fixed.MkFixed
-
-instance Integral a => Lift (Ratio a) where
- liftTyped x = unsafeCodeCoerce (lift x)
- lift x = return (LitE (RationalL (toRational x)))
-
-instance Lift Float where
- liftTyped x = unsafeCodeCoerce (lift x)
- lift x = return (LitE (RationalL (toRational x)))
-
--- | @since 2.16.0.0
-instance Lift Float# where
- liftTyped x = unsafeCodeCoerce (lift x)
- lift x = return (LitE (FloatPrimL (toRational (F# x))))
-
-instance Lift Double where
- liftTyped x = unsafeCodeCoerce (lift x)
- lift x = return (LitE (RationalL (toRational x)))
-
--- | @since 2.16.0.0
-instance Lift Double# where
- liftTyped x = unsafeCodeCoerce (lift x)
- lift x = return (LitE (DoublePrimL (toRational (D# x))))
-
-instance Lift Char where
- liftTyped x = unsafeCodeCoerce (lift x)
- lift x = return (LitE (CharL x))
-
--- | @since 2.16.0.0
-instance Lift Char# where
- liftTyped x = unsafeCodeCoerce (lift x)
- lift x = return (LitE (CharPrimL (C# x)))
-
-instance Lift Bool where
- liftTyped x = unsafeCodeCoerce (lift x)
-
- lift True = return (ConE trueName)
- lift False = return (ConE falseName)
-
--- | Produces an 'Addr#' literal from the NUL-terminated C-string starting at
--- the given memory address.
---
--- @since 2.16.0.0
-instance Lift Addr# where
- liftTyped x = unsafeCodeCoerce (lift x)
- lift x
- = return (LitE (StringPrimL (map (fromIntegral . ord) (unpackCString# x))))
-
--- |
--- @since 2.19.0.0
-instance Lift ByteArray where
- liftTyped x = unsafeCodeCoerce (lift x)
- lift (ByteArray b) = return
- (AppE (AppE (VarE addrToByteArrayName) (LitE (IntegerL (fromIntegral len))))
- (LitE (BytesPrimL (Bytes ptr 0 (fromIntegral len)))))
- where
- len# = sizeofByteArray# b
- len = I# len#
- pb :: ByteArray#
- !(ByteArray pb)
- | isTrue# (isByteArrayPinned# b) = ByteArray b
- | otherwise = runST $ ST $
- \s -> case newPinnedByteArray# len# s of
- (# s', mb #) -> case copyByteArray# b 0# mb 0# len# s' of
- s'' -> case unsafeFreezeByteArray# mb s'' of
- (# s''', ret #) -> (# s''', ByteArray ret #)
- ptr :: ForeignPtr Word8
- ptr = ForeignPtr (byteArrayContents# pb) (PlainPtr (unsafeCoerce# pb))
-
-addrToByteArrayName :: Name
-addrToByteArrayName = 'addrToByteArray
-
-addrToByteArray :: Int -> Addr# -> ByteArray
-addrToByteArray (I# len) addr = runST $ ST $
- \s -> case newByteArray# len s of
- (# s', mb #) -> case copyAddrToByteArray# addr mb 0# len s' of
- s'' -> case unsafeFreezeByteArray# mb s'' of
- (# s''', ret #) -> (# s''', ByteArray ret #)
-
-instance Lift a => Lift (Maybe a) where
- liftTyped x = unsafeCodeCoerce (lift x)
-
- lift Nothing = return (ConE nothingName)
- lift (Just x) = liftM (ConE justName `AppE`) (lift x)
-
-instance (Lift a, Lift b) => Lift (Either a b) where
- liftTyped x = unsafeCodeCoerce (lift x)
-
- lift (Left x) = liftM (ConE leftName `AppE`) (lift x)
- lift (Right y) = liftM (ConE rightName `AppE`) (lift y)
-
-instance Lift a => Lift [a] where
- liftTyped x = unsafeCodeCoerce (lift x)
- lift xs = do { xs' <- mapM lift xs; return (ListE xs') }
-
-liftString :: Quote m => String -> m Exp
--- Used in GHC.Tc.Gen.Expr to short-circuit the lifting for strings
-liftString s = return (LitE (StringL s))
-
--- | @since 2.15.0.0
-instance Lift a => Lift (NonEmpty a) where
- liftTyped x = unsafeCodeCoerce (lift x)
-
- lift (x :| xs) = do
- x' <- lift x
- xs' <- lift xs
- return (InfixE (Just x') (ConE nonemptyName) (Just xs'))
-
--- | @since 2.15.0.0
-instance Lift Void where
- liftTyped = liftCode . absurd
- lift = pure . absurd
-
-instance Lift () where
- liftTyped x = unsafeCodeCoerce (lift x)
- lift () = return (ConE (tupleDataName 0))
-
-instance (Lift a, Lift b) => Lift (a, b) where
- liftTyped x = unsafeCodeCoerce (lift x)
- lift (a, b)
- = liftM TupE $ sequence $ map (fmap Just) [lift a, lift b]
-
-instance (Lift a, Lift b, Lift c) => Lift (a, b, c) where
- liftTyped x = unsafeCodeCoerce (lift x)
- lift (a, b, c)
- = liftM TupE $ sequence $ map (fmap Just) [lift a, lift b, lift c]
-
-instance (Lift a, Lift b, Lift c, Lift d) => Lift (a, b, c, d) where
- liftTyped x = unsafeCodeCoerce (lift x)
- lift (a, b, c, d)
- = liftM TupE $ sequence $ map (fmap Just) [lift a, lift b, lift c, lift d]
-
-instance (Lift a, Lift b, Lift c, Lift d, Lift e)
- => Lift (a, b, c, d, e) where
- liftTyped x = unsafeCodeCoerce (lift x)
- lift (a, b, c, d, e)
- = liftM TupE $ sequence $ map (fmap Just) [ lift a, lift b
- , lift c, lift d, lift e ]
-
-instance (Lift a, Lift b, Lift c, Lift d, Lift e, Lift f)
- => Lift (a, b, c, d, e, f) where
- liftTyped x = unsafeCodeCoerce (lift x)
- lift (a, b, c, d, e, f)
- = liftM TupE $ sequence $ map (fmap Just) [ lift a, lift b, lift c
- , lift d, lift e, lift f ]
-
-instance (Lift a, Lift b, Lift c, Lift d, Lift e, Lift f, Lift g)
- => Lift (a, b, c, d, e, f, g) where
- liftTyped x = unsafeCodeCoerce (lift x)
- lift (a, b, c, d, e, f, g)
- = liftM TupE $ sequence $ map (fmap Just) [ lift a, lift b, lift c
- , lift d, lift e, lift f, lift g ]
-
--- | @since 2.16.0.0
-instance Lift (# #) where
- liftTyped x = unsafeCodeCoerce (lift x)
- lift (# #) = return (ConE (unboxedTupleTypeName 0))
-
--- | @since 2.16.0.0
-instance (Lift a) => Lift (# a #) where
- liftTyped x = unsafeCodeCoerce (lift x)
- lift (# a #)
- = liftM UnboxedTupE $ sequence $ map (fmap Just) [lift a]
-
--- | @since 2.16.0.0
-instance (Lift a, Lift b) => Lift (# a, b #) where
- liftTyped x = unsafeCodeCoerce (lift x)
- lift (# a, b #)
- = liftM UnboxedTupE $ sequence $ map (fmap Just) [lift a, lift b]
-
--- | @since 2.16.0.0
-instance (Lift a, Lift b, Lift c)
- => Lift (# a, b, c #) where
- liftTyped x = unsafeCodeCoerce (lift x)
- lift (# a, b, c #)
- = liftM UnboxedTupE $ sequence $ map (fmap Just) [lift a, lift b, lift c]
-
--- | @since 2.16.0.0
-instance (Lift a, Lift b, Lift c, Lift d)
- => Lift (# a, b, c, d #) where
- liftTyped x = unsafeCodeCoerce (lift x)
- lift (# a, b, c, d #)
- = liftM UnboxedTupE $ sequence $ map (fmap Just) [ lift a, lift b
- , lift c, lift d ]
-
--- | @since 2.16.0.0
-instance (Lift a, Lift b, Lift c, Lift d, Lift e)
- => Lift (# a, b, c, d, e #) where
- liftTyped x = unsafeCodeCoerce (lift x)
- lift (# a, b, c, d, e #)
- = liftM UnboxedTupE $ sequence $ map (fmap Just) [ lift a, lift b
- , lift c, lift d, lift e ]
-
--- | @since 2.16.0.0
-instance (Lift a, Lift b, Lift c, Lift d, Lift e, Lift f)
- => Lift (# a, b, c, d, e, f #) where
- liftTyped x = unsafeCodeCoerce (lift x)
- lift (# a, b, c, d, e, f #)
- = liftM UnboxedTupE $ sequence $ map (fmap Just) [ lift a, lift b, lift c
- , lift d, lift e, lift f ]
-
--- | @since 2.16.0.0
-instance (Lift a, Lift b, Lift c, Lift d, Lift e, Lift f, Lift g)
- => Lift (# a, b, c, d, e, f, g #) where
- liftTyped x = unsafeCodeCoerce (lift x)
- lift (# a, b, c, d, e, f, g #)
- = liftM UnboxedTupE $ sequence $ map (fmap Just) [ lift a, lift b, lift c
- , lift d, lift e, lift f
- , lift g ]
-
--- | @since 2.16.0.0
-instance (Lift a, Lift b) => Lift (# a | b #) where
- liftTyped x = unsafeCodeCoerce (lift x)
- lift x
- = case x of
- (# y | #) -> UnboxedSumE <$> lift y <*> pure 1 <*> pure 2
- (# | y #) -> UnboxedSumE <$> lift y <*> pure 2 <*> pure 2
-
--- | @since 2.16.0.0
-instance (Lift a, Lift b, Lift c)
- => Lift (# a | b | c #) where
- liftTyped x = unsafeCodeCoerce (lift x)
- lift x
- = case x of
- (# y | | #) -> UnboxedSumE <$> lift y <*> pure 1 <*> pure 3
- (# | y | #) -> UnboxedSumE <$> lift y <*> pure 2 <*> pure 3
- (# | | y #) -> UnboxedSumE <$> lift y <*> pure 3 <*> pure 3
-
--- | @since 2.16.0.0
-instance (Lift a, Lift b, Lift c, Lift d)
- => Lift (# a | b | c | d #) where
- liftTyped x = unsafeCodeCoerce (lift x)
- lift x
- = case x of
- (# y | | | #) -> UnboxedSumE <$> lift y <*> pure 1 <*> pure 4
- (# | y | | #) -> UnboxedSumE <$> lift y <*> pure 2 <*> pure 4
- (# | | y | #) -> UnboxedSumE <$> lift y <*> pure 3 <*> pure 4
- (# | | | y #) -> UnboxedSumE <$> lift y <*> pure 4 <*> pure 4
-
--- | @since 2.16.0.0
-instance (Lift a, Lift b, Lift c, Lift d, Lift e)
- => Lift (# a | b | c | d | e #) where
- liftTyped x = unsafeCodeCoerce (lift x)
- lift x
- = case x of
- (# y | | | | #) -> UnboxedSumE <$> lift y <*> pure 1 <*> pure 5
- (# | y | | | #) -> UnboxedSumE <$> lift y <*> pure 2 <*> pure 5
- (# | | y | | #) -> UnboxedSumE <$> lift y <*> pure 3 <*> pure 5
- (# | | | y | #) -> UnboxedSumE <$> lift y <*> pure 4 <*> pure 5
- (# | | | | y #) -> UnboxedSumE <$> lift y <*> pure 5 <*> pure 5
-
--- | @since 2.16.0.0
-instance (Lift a, Lift b, Lift c, Lift d, Lift e, Lift f)
- => Lift (# a | b | c | d | e | f #) where
- liftTyped x = unsafeCodeCoerce (lift x)
- lift x
- = case x of
- (# y | | | | | #) -> UnboxedSumE <$> lift y <*> pure 1 <*> pure 6
- (# | y | | | | #) -> UnboxedSumE <$> lift y <*> pure 2 <*> pure 6
- (# | | y | | | #) -> UnboxedSumE <$> lift y <*> pure 3 <*> pure 6
- (# | | | y | | #) -> UnboxedSumE <$> lift y <*> pure 4 <*> pure 6
- (# | | | | y | #) -> UnboxedSumE <$> lift y <*> pure 5 <*> pure 6
- (# | | | | | y #) -> UnboxedSumE <$> lift y <*> pure 6 <*> pure 6
-
--- | @since 2.16.0.0
-instance (Lift a, Lift b, Lift c, Lift d, Lift e, Lift f, Lift g)
- => Lift (# a | b | c | d | e | f | g #) where
- liftTyped x = unsafeCodeCoerce (lift x)
- lift x
- = case x of
- (# y | | | | | | #) -> UnboxedSumE <$> lift y <*> pure 1 <*> pure 7
- (# | y | | | | | #) -> UnboxedSumE <$> lift y <*> pure 2 <*> pure 7
- (# | | y | | | | #) -> UnboxedSumE <$> lift y <*> pure 3 <*> pure 7
- (# | | | y | | | #) -> UnboxedSumE <$> lift y <*> pure 4 <*> pure 7
- (# | | | | y | | #) -> UnboxedSumE <$> lift y <*> pure 5 <*> pure 7
- (# | | | | | y | #) -> UnboxedSumE <$> lift y <*> pure 6 <*> pure 7
- (# | | | | | | y #) -> UnboxedSumE <$> lift y <*> pure 7 <*> pure 7
-
--- 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 = 'True
-falseName = 'False
-
-nothingName, justName :: Name
-nothingName = 'Nothing
-justName = 'Just
-
-leftName, rightName :: Name
-leftName = 'Left
-rightName = 'Right
-
-nonemptyName :: Name
-nonemptyName = '(:|)
-#endif
oneName, manyName :: Name
oneName = mkNameG DataName "ghc-prim" "GHC.Types" "One"
manyName = mkNameG DataName "ghc-prim" "GHC.Types" "Many"
------------------------------------------------------
---
--- 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 m a k q. (Quote m, Data a)
- => (Name -> k)
- -> (Lit -> m q)
- -> (k -> [m q] -> m q)
- -> (forall b . Data b => b -> Maybe (m q))
- -> a
- -> m q
-dataToQa mkCon mkLit appCon antiQ t =
- case antiQ t of
- Nothing ->
- case constrRep constr of
- AlgConstr _ ->
- appCon (mkCon funOrConName) conArgs
- where
- funOrConName :: Name
- funOrConName =
- case showConstr constr of
- "(:)" -> Name (mkOccName ":")
- (NameG DataName
- (mkPkgName "ghc-prim")
- (mkModName "GHC.Types"))
- con@"[]" -> Name (mkOccName con)
- (NameG DataName
- (mkPkgName "ghc-prim")
- (mkModName "GHC.Types"))
- con@('(':_) -> Name (mkOccName con)
- (NameG DataName
- (mkPkgName "ghc-prim")
- (mkModName "GHC.Tuple"))
-
- -- Tricky case: see Note [Data for non-algebraic types]
- fun@(x:_) | startsVarSym x || startsVarId x
- -> mkNameG_v tyconPkg tyconMod fun
- con -> mkNameG_d tyconPkg tyconMod con
-
- where
- tycon :: TyCon
- tycon = (typeRepTyCon . typeOf) t
-
- tyconPkg, tyconMod :: String
- tyconPkg = tyConPackage tycon
- tyconMod = tyConModule tycon
-
- conArgs :: [m q]
- conArgs = gmapQ (dataToQa mkCon mkLit appCon antiQ) t
- IntConstr n ->
- mkLit $ IntegerL n
- FloatConstr n ->
- mkLit $ RationalL n
- CharConstr c ->
- mkLit $ CharL c
- where
- constr :: Constr
- constr = toConstr t
-
- Just y -> 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 #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; #12596 shows what goes wrong if
- "pack" is defined in a different module than the data type "Text".
- -}
-
--- | 'dataToExpQ' converts a value to a '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 :: (Quote m, Data a)
- => (forall b . Data b => b -> Maybe (m Exp))
- -> a
- -> m Exp
-dataToExpQ = dataToQa varOrConE litE (foldl appE)
- where
- -- Make sure that VarE is used if the Constr value relies on a
- -- function underneath the surface (instead of a constructor).
- -- See #10796.
- varOrConE s =
- case nameSpace s of
- Just VarName -> return (VarE s)
- Just (FldName {}) -> return (VarE s)
- Just DataName -> return (ConE s)
- _ -> error $ "Can't construct an expression from name "
- ++ showName s
- appE x y = do { a <- x; b <- y; return (AppE a b)}
- litE c = return (LitE c)
-
--- | 'liftData' is a variant of 'lift' in the 'Lift' type class which
--- works for any type with a 'Data' instance.
-liftData :: (Quote m, Data a) => a -> m Exp
-liftData = dataToExpQ (const Nothing)
-
--- | 'dataToPatQ' converts a value to a '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 :: (Quote m, Data a)
- => (forall b . Data b => b -> Maybe (m Pat))
- -> a
- -> m Pat
-dataToPatQ = dataToQa id litP conP
- where litP l = return (LitP l)
- conP n ps =
- case nameSpace n of
- Just DataName -> do
- ps' <- sequence ps
- return (ConP n [] ps')
- _ -> error $ "Can't construct a pattern from name "
- ++ showName n
-----------------------------------------------------
-- Names and uniques
diff --git a/libraries/ghci/GHCi/Message.hs b/libraries/ghci/GHCi/Message.hs
index 2660285660f42eae860858776271b6ecca30c750..09efb86cdbffee910c5f5db752f3ef42c599a4bf 100644
--- a/libraries/ghci/GHCi/Message.hs
+++ b/libraries/ghci/GHCi/Message.hs
@@ -53,8 +53,7 @@ import Data.Map (Map)
import Foreign
import GHC.Generics
import GHC.Stack.CCS
-import qualified Language.Haskell.TH as TH
-import qualified Language.Haskell.TH.Syntax as TH
+import qualified GHC.Internal.TH.Syntax as TH
import System.Exit
import System.IO
import System.IO.Error
diff --git a/libraries/ghci/GHCi/TH.hs b/libraries/ghci/GHCi/TH.hs
index a99cd5892b9ce69c3974f7514bec81d4e6c9b016..b4dfa4022a15c9f478e0f8fc1d648078e9398ad6 100644
--- a/libraries/ghci/GHCi/TH.hs
+++ b/libraries/ghci/GHCi/TH.hs
@@ -110,8 +110,7 @@ import Data.Map (Map)
import qualified Data.Map as M
import Data.Maybe
import GHC.Desugar
-import qualified Language.Haskell.TH as TH
-import qualified Language.Haskell.TH.Syntax as TH
+import qualified GHC.Internal.TH.Syntax as TH
import Unsafe.Coerce
-- | Create a new instance of 'QState'
diff --git a/libraries/ghci/GHCi/TH/Binary.hs b/libraries/ghci/GHCi/TH/Binary.hs
index 7d6b6bcd2d499ec1ccd8e3fd05bb73baf897b9c3..61205e06849c3569ce38cc06c7499892b3f761c1 100644
--- a/libraries/ghci/GHCi/TH/Binary.hs
+++ b/libraries/ghci/GHCi/TH/Binary.hs
@@ -12,8 +12,7 @@ import Data.Binary
import qualified Data.ByteString as B
import qualified Data.ByteString.Internal as B
import GHC.Serialized
-import qualified Language.Haskell.TH as TH
-import qualified Language.Haskell.TH.Syntax as TH
+import qualified GHC.Internal.TH.Syntax as TH
-- Put these in a separate module because they take ages to compile
instance Binary TH.Loc
diff --git a/libraries/ghci/ghci.cabal.in b/libraries/ghci/ghci.cabal.in
index c18d7850ce10d666854c7848902f3e54b24ac1ba..172cf9f888be29d9eb4f32e83fa8544c508d493b 100644
--- a/libraries/ghci/ghci.cabal.in
+++ b/libraries/ghci/ghci.cabal.in
@@ -25,8 +25,8 @@ Flag internal-interpreter
Flag bootstrap
Description:
Enabled when building the stage1 compiler in order to vendor the in-tree
- `template-haskell` library (including its dependency `ghc-boot-th`), while
- allowing dependencies to depend on the boot `template-haskell` library.
+ `ghc-boot-th` library, and through that the in-tree TH AST defintions from
+ `ghc-internal`.
See Note [Bootstrapping Template Haskell]
Default: False
Manual: True
@@ -97,10 +97,10 @@ library
if flag(bootstrap)
build-depends:
- template-haskell-next == 2.22.*
+ ghc-boot-th-next == @ProjectVersionMunged@
else
build-depends:
- template-haskell == 2.22.*
+ ghc-boot-th == @ProjectVersionMunged@
if !os(windows)
Build-Depends: unix >= 2.7 && < 2.9
diff --git a/libraries/template-haskell/Language/Haskell/TH/Lib.hs b/libraries/template-haskell/Language/Haskell/TH/Lib.hs
index 27169d6342a5badf3a7a39cdad5f9c38bdd23132..afe108fbb5a70feabc3d4c17cedcf76b2b72b2d5 100644
--- a/libraries/template-haskell/Language/Haskell/TH/Lib.hs
+++ b/libraries/template-haskell/Language/Haskell/TH/Lib.hs
@@ -139,7 +139,7 @@ module Language.Haskell.TH.Lib (
) where
-import Language.Haskell.TH.Lib.Internal hiding
+import GHC.Internal.TH.Lib hiding
( tySynD
, dataD
, newtypeD
@@ -179,7 +179,7 @@ import Language.Haskell.TH.Lib.Internal hiding
, Role
, InjectivityAnn
)
-import qualified Language.Haskell.TH.Lib.Internal as Internal
+import qualified GHC.Internal.TH.Lib as Internal
import Language.Haskell.TH.Syntax
import Control.Applicative (Applicative(..))
diff --git a/libraries/template-haskell/Language/Haskell/TH/Lib/Internal.hs b/libraries/template-haskell/Language/Haskell/TH/Lib/Internal.hs
index 532cef954d2202db0453bef4a8daaa9a247d6521..90bb7de919a688c5c73766f3d93b79c9eb8c36db 100644
--- a/libraries/template-haskell/Language/Haskell/TH/Lib/Internal.hs
+++ b/libraries/template-haskell/Language/Haskell/TH/Lib/Internal.hs
@@ -1,15 +1,11 @@
-{-# OPTIONS_HADDOCK not-home #-}
-{-# LANGUAGE PolyKinds #-}
-{-# LANGUAGE StandaloneKindSignatures #-}
-{-# LANGUAGE Trustworthy #-}
-
+{-# LANGUAGE Safe #-}
-- |
-- Language.Haskell.TH.Lib.Internal exposes some additional functionality that
-- is used internally in GHC's integration with Template Haskell. This is not a
-- part of the public API, and as such, there are no API guarantees for this
-- module from version to version.
--- Why do we have both Language.Haskell.TH.Lib.Internal and
+-- Why do we have both GHC.Internal.TH.Lib and
-- Language.Haskell.TH.Lib? Ultimately, it's because the functions in the
-- former (which are tailored for GHC's use) need different type signatures
-- than the ones in the latter. Syncing up the Internal type signatures would
@@ -17,1220 +13,8 @@
-- relegate as many changes as we can to just the Internal module, where it
-- is safe to break things.
-module Language.Haskell.TH.Lib.Internal where
-
-import Language.Haskell.TH.Lib.Syntax hiding (Role, InjectivityAnn)
-import qualified Language.Haskell.TH.Lib.Syntax as TH
-import Control.Applicative(liftA, Applicative(..))
-import qualified Data.Kind as Kind (Type)
-import Data.Word( Word8 )
-import Data.List.NonEmpty ( NonEmpty(..) )
-import GHC.Exts (TYPE)
-import Prelude hiding (Applicative(..))
-
-----------------------------------------------------------
--- * Type synonyms
-----------------------------------------------------------
-
--- | Representation-polymorphic since /template-haskell-2.17.0.0/.
-type TExpQ :: TYPE r -> Kind.Type
-type TExpQ a = Q (TExp a)
-
-type CodeQ :: TYPE r -> Kind.Type
-type CodeQ = Code Q
-
-type InfoQ = Q Info
-type PatQ = Q Pat
-type FieldPatQ = Q FieldPat
-type ExpQ = Q Exp
-type DecQ = Q Dec
-type DecsQ = Q [Dec]
-type Decs = [Dec] -- Defined as it is more convenient to wire-in
-type ConQ = Q Con
-type TypeQ = Q Type
-type KindQ = Q Kind
-type TyLitQ = Q TyLit
-type CxtQ = Q Cxt
-type PredQ = Q Pred
-type DerivClauseQ = Q DerivClause
-type MatchQ = Q Match
-type ClauseQ = Q Clause
-type BodyQ = Q Body
-type GuardQ = Q Guard
-type StmtQ = Q Stmt
-type RangeQ = Q Range
-type SourceStrictnessQ = Q SourceStrictness
-type SourceUnpackednessQ = Q SourceUnpackedness
-type BangQ = Q Bang
-type BangTypeQ = Q BangType
-type VarBangTypeQ = Q VarBangType
-type StrictTypeQ = Q StrictType
-type VarStrictTypeQ = Q VarStrictType
-type FieldExpQ = Q FieldExp
-type RuleBndrQ = Q RuleBndr
-type TySynEqnQ = Q TySynEqn
-type PatSynDirQ = Q PatSynDir
-type PatSynArgsQ = Q PatSynArgs
-type FamilyResultSigQ = Q FamilyResultSig
-type DerivStrategyQ = Q DerivStrategy
-
--- must be defined here for DsMeta to find it
-type Role = TH.Role
-type InjectivityAnn = TH.InjectivityAnn
-
-type TyVarBndrUnit = TyVarBndr ()
-type TyVarBndrSpec = TyVarBndr Specificity
-type TyVarBndrVis = TyVarBndr BndrVis
-
-----------------------------------------------------------
--- * Lowercase pattern syntax functions
-----------------------------------------------------------
-
-intPrimL :: Integer -> Lit
-intPrimL = IntPrimL
-wordPrimL :: Integer -> Lit
-wordPrimL = WordPrimL
-floatPrimL :: Rational -> Lit
-floatPrimL = FloatPrimL
-doublePrimL :: Rational -> Lit
-doublePrimL = DoublePrimL
-integerL :: Integer -> Lit
-integerL = IntegerL
-charL :: Char -> Lit
-charL = CharL
-charPrimL :: Char -> Lit
-charPrimL = CharPrimL
-stringL :: String -> Lit
-stringL = StringL
-stringPrimL :: [Word8] -> Lit
-stringPrimL = StringPrimL
-bytesPrimL :: Bytes -> Lit
-bytesPrimL = BytesPrimL
-rationalL :: Rational -> Lit
-rationalL = RationalL
-
-litP :: Quote m => Lit -> m Pat
-litP l = pure (LitP l)
-
-varP :: Quote m => Name -> m Pat
-varP v = pure (VarP v)
-
-tupP :: Quote m => [m Pat] -> m Pat
-tupP ps = do { ps1 <- sequenceA ps; pure (TupP ps1)}
-
-unboxedTupP :: Quote m => [m Pat] -> m Pat
-unboxedTupP ps = do { ps1 <- sequenceA ps; pure (UnboxedTupP ps1)}
-
-unboxedSumP :: Quote m => m Pat -> SumAlt -> SumArity -> m Pat
-unboxedSumP p alt arity = do { p1 <- p; pure (UnboxedSumP p1 alt arity) }
-
-conP :: Quote m => Name -> [m Type] -> [m Pat] -> m Pat
-conP n ts ps = do ps' <- sequenceA ps
- ts' <- sequenceA ts
- pure (ConP n ts' ps')
-infixP :: Quote m => m Pat -> Name -> m Pat -> m Pat
-infixP p1 n p2 = do p1' <- p1
- p2' <- p2
- pure (InfixP p1' n p2')
-uInfixP :: Quote m => m Pat -> Name -> m Pat -> m Pat
-uInfixP p1 n p2 = do p1' <- p1
- p2' <- p2
- pure (UInfixP p1' n p2')
-parensP :: Quote m => m Pat -> m Pat
-parensP p = do p' <- p
- pure (ParensP p')
-
-tildeP :: Quote m => m Pat -> m Pat
-tildeP p = do p' <- p
- pure (TildeP p')
-bangP :: Quote m => m Pat -> m Pat
-bangP p = do p' <- p
- pure (BangP p')
-asP :: Quote m => Name -> m Pat -> m Pat
-asP n p = do p' <- p
- pure (AsP n p')
-wildP :: Quote m => m Pat
-wildP = pure WildP
-recP :: Quote m => Name -> [m FieldPat] -> m Pat
-recP n fps = do fps' <- sequenceA fps
- pure (RecP n fps')
-listP :: Quote m => [m Pat] -> m Pat
-listP ps = do ps' <- sequenceA ps
- pure (ListP ps')
-sigP :: Quote m => m Pat -> m Type -> m Pat
-sigP p t = do p' <- p
- t' <- t
- pure (SigP p' t')
-typeP :: Quote m => m Type -> m Pat
-typeP t = do t' <- t
- pure (TypeP t')
-invisP :: Quote m => m Type -> m Pat
-invisP t = do t' <- t
- pure (InvisP t')
-viewP :: Quote m => m Exp -> m Pat -> m Pat
-viewP e p = do e' <- e
- p' <- p
- pure (ViewP e' p')
-
-
-fieldPat :: Quote m => Name -> m Pat -> m FieldPat
-fieldPat n p = do p' <- p
- pure (n, p')
-
-
--------------------------------------------------------------------------------
--- * Stmt
-
-bindS :: Quote m => m Pat -> m Exp -> m Stmt
-bindS p e = liftA2 BindS p e
-
-letS :: Quote m => [m Dec] -> m Stmt
-letS ds = do { ds1 <- sequenceA ds; pure (LetS ds1) }
-
-noBindS :: Quote m => m Exp -> m Stmt
-noBindS e = do { e1 <- e; pure (NoBindS e1) }
-
-parS :: Quote m => [[m Stmt]] -> m Stmt
-parS sss = do { sss1 <- traverse sequenceA sss; pure (ParS sss1) }
-
-recS :: Quote m => [m Stmt] -> m Stmt
-recS ss = do { ss1 <- sequenceA ss; pure (RecS ss1) }
-
--------------------------------------------------------------------------------
--- * Range
-
-fromR :: Quote m => m Exp -> m Range
-fromR x = do { a <- x; pure (FromR a) }
-
-fromThenR :: Quote m => m Exp -> m Exp -> m Range
-fromThenR x y = do { a <- x; b <- y; pure (FromThenR a b) }
-
-fromToR :: Quote m => m Exp -> m Exp -> m Range
-fromToR x y = do { a <- x; b <- y; pure (FromToR a b) }
-
-fromThenToR :: Quote m => m Exp -> m Exp -> m Exp -> m Range
-fromThenToR x y z = do { a <- x; b <- y; c <- z;
- pure (FromThenToR a b c) }
--------------------------------------------------------------------------------
--- * Body
-
-normalB :: Quote m => m Exp -> m Body
-normalB e = do { e1 <- e; pure (NormalB e1) }
-
-guardedB :: Quote m => [m (Guard,Exp)] -> m Body
-guardedB ges = do { ges' <- sequenceA ges; pure (GuardedB ges') }
-
--------------------------------------------------------------------------------
--- * Guard
-
-normalG :: Quote m => m Exp -> m Guard
-normalG e = do { e1 <- e; pure (NormalG e1) }
-
-normalGE :: Quote m => m Exp -> m Exp -> m (Guard, Exp)
-normalGE g e = do { g1 <- g; e1 <- e; pure (NormalG g1, e1) }
-
-patG :: Quote m => [m Stmt] -> m Guard
-patG ss = do { ss' <- sequenceA ss; pure (PatG ss') }
-
-patGE :: Quote m => [m Stmt] -> m Exp -> m (Guard, Exp)
-patGE ss e = do { ss' <- sequenceA ss;
- e' <- e;
- pure (PatG ss', e') }
-
--------------------------------------------------------------------------------
--- * Match and Clause
-
--- | Use with 'caseE'
-match :: Quote m => m Pat -> m Body -> [m Dec] -> m Match
-match p rhs ds = do { p' <- p;
- r' <- rhs;
- ds' <- sequenceA ds;
- pure (Match p' r' ds') }
-
--- | Use with 'funD'
-clause :: Quote m => [m Pat] -> m Body -> [m Dec] -> m Clause
-clause ps r ds = do { ps' <- sequenceA ps;
- r' <- r;
- ds' <- sequenceA ds;
- pure (Clause ps' r' ds') }
-
----------------------------------------------------------------------------
--- * Exp
-
--- | Dynamically binding a variable (unhygienic)
-dyn :: Quote m => String -> m Exp
-dyn s = pure (VarE (mkName s))
-
-varE :: Quote m => Name -> m Exp
-varE s = pure (VarE s)
-
-conE :: Quote m => Name -> m Exp
-conE s = pure (ConE s)
-
-litE :: Quote m => Lit -> m Exp
-litE c = pure (LitE c)
-
-appE :: Quote m => m Exp -> m Exp -> m Exp
-appE x y = do { a <- x; b <- y; pure (AppE a b)}
-
-appTypeE :: Quote m => m Exp -> m Type -> m Exp
-appTypeE x t = do { a <- x; s <- t; pure (AppTypeE a s) }
-
-parensE :: Quote m => m Exp -> m Exp
-parensE x = do { x' <- x; pure (ParensE x') }
-
-uInfixE :: Quote m => m Exp -> m Exp -> m Exp -> m Exp
-uInfixE x s y = do { x' <- x; s' <- s; y' <- y;
- pure (UInfixE x' s' y') }
-
-infixE :: Quote m => Maybe (m Exp) -> m Exp -> Maybe (m Exp) -> m Exp
-infixE (Just x) s (Just y) = do { a <- x; s' <- s; b <- y;
- pure (InfixE (Just a) s' (Just b))}
-infixE Nothing s (Just y) = do { s' <- s; b <- y;
- pure (InfixE Nothing s' (Just b))}
-infixE (Just x) s Nothing = do { a <- x; s' <- s;
- pure (InfixE (Just a) s' Nothing)}
-infixE Nothing s Nothing = do { s' <- s; pure (InfixE Nothing s' Nothing) }
-
-infixApp :: Quote m => m Exp -> m Exp -> m Exp -> m Exp
-infixApp x y z = infixE (Just x) y (Just z)
-sectionL :: Quote m => m Exp -> m Exp -> m Exp
-sectionL x y = infixE (Just x) y Nothing
-sectionR :: Quote m => m Exp -> m Exp -> m Exp
-sectionR x y = infixE Nothing x (Just y)
-
-lamE :: Quote m => [m Pat] -> m Exp -> m Exp
-lamE ps e = do ps' <- sequenceA ps
- e' <- e
- pure (LamE ps' e')
-
--- | Single-arg lambda
-lam1E :: Quote m => m Pat -> m Exp -> m Exp
-lam1E p e = lamE [p] e
-
--- | Lambda-case (@\case@)
-lamCaseE :: Quote m => [m Match] -> m Exp
-lamCaseE ms = LamCaseE <$> sequenceA ms
-
--- | Lambda-cases (@\cases@)
-lamCasesE :: Quote m => [m Clause] -> m Exp
-lamCasesE ms = LamCasesE <$> sequenceA ms
-
-tupE :: Quote m => [Maybe (m Exp)] -> m Exp
-tupE es = do { es1 <- traverse sequenceA es; pure (TupE es1)}
-
-unboxedTupE :: Quote m => [Maybe (m Exp)] -> m Exp
-unboxedTupE es = do { es1 <- traverse sequenceA es; pure (UnboxedTupE es1)}
-
-unboxedSumE :: Quote m => m Exp -> SumAlt -> SumArity -> m Exp
-unboxedSumE e alt arity = do { e1 <- e; pure (UnboxedSumE e1 alt arity) }
-
-condE :: Quote m => m Exp -> m Exp -> m Exp -> m Exp
-condE x y z = do { a <- x; b <- y; c <- z; pure (CondE a b c)}
-
-multiIfE :: Quote m => [m (Guard, Exp)] -> m Exp
-multiIfE alts = MultiIfE <$> sequenceA alts
-
-letE :: Quote m => [m Dec] -> m Exp -> m Exp
-letE ds e = do { ds2 <- sequenceA ds; e2 <- e; pure (LetE ds2 e2) }
-
-caseE :: Quote m => m Exp -> [m Match] -> m Exp
-caseE e ms = do { e1 <- e; ms1 <- sequenceA ms; pure (CaseE e1 ms1) }
-
-doE :: Quote m => Maybe ModName -> [m Stmt] -> m Exp
-doE m ss = do { ss1 <- sequenceA ss; pure (DoE m ss1) }
-
-mdoE :: Quote m => Maybe ModName -> [m Stmt] -> m Exp
-mdoE m ss = do { ss1 <- sequenceA ss; pure (MDoE m ss1) }
-
-compE :: Quote m => [m Stmt] -> m Exp
-compE ss = do { ss1 <- sequenceA ss; pure (CompE ss1) }
-
-arithSeqE :: Quote m => m Range -> m Exp
-arithSeqE r = do { r' <- r; pure (ArithSeqE r') }
-
-listE :: Quote m => [m Exp] -> m Exp
-listE es = do { es1 <- sequenceA es; pure (ListE es1) }
-
-sigE :: Quote m => m Exp -> m Type -> m Exp
-sigE e t = do { e1 <- e; t1 <- t; pure (SigE e1 t1) }
-
-recConE :: Quote m => Name -> [m (Name,Exp)] -> m Exp
-recConE c fs = do { flds <- sequenceA fs; pure (RecConE c flds) }
-
-recUpdE :: Quote m => m Exp -> [m (Name,Exp)] -> m Exp
-recUpdE e fs = do { e1 <- e; flds <- sequenceA fs; pure (RecUpdE e1 flds) }
-
-stringE :: Quote m => String -> m Exp
-stringE = litE . stringL
-
-fieldExp :: Quote m => Name -> m Exp -> m (Name, Exp)
-fieldExp s e = do { e' <- e; pure (s,e') }
-
--- | @staticE x = [| static x |]@
-staticE :: Quote m => m Exp -> m Exp
-staticE = fmap StaticE
-
-unboundVarE :: Quote m => Name -> m Exp
-unboundVarE s = pure (UnboundVarE s)
-
-labelE :: Quote m => String -> m Exp
-labelE s = pure (LabelE s)
-
-implicitParamVarE :: Quote m => String -> m Exp
-implicitParamVarE n = pure (ImplicitParamVarE n)
-
-getFieldE :: Quote m => m Exp -> String -> m Exp
-getFieldE e f = do
- e' <- e
- pure (GetFieldE e' f)
-
-projectionE :: Quote m => NonEmpty String -> m Exp
-projectionE xs = pure (ProjectionE xs)
-
-typedSpliceE :: Quote m => m Exp -> m Exp
-typedSpliceE = fmap TypedSpliceE
-
-typedBracketE :: Quote m => m Exp -> m Exp
-typedBracketE = fmap TypedBracketE
-
--- ** 'arithSeqE' Shortcuts
-fromE :: Quote m => m Exp -> m Exp
-fromE x = do { a <- x; pure (ArithSeqE (FromR a)) }
-
-fromThenE :: Quote m => m Exp -> m Exp -> m Exp
-fromThenE x y = do { a <- x; b <- y; pure (ArithSeqE (FromThenR a b)) }
-
-fromToE :: Quote m => m Exp -> m Exp -> m Exp
-fromToE x y = do { a <- x; b <- y; pure (ArithSeqE (FromToR a b)) }
-
-fromThenToE :: Quote m => m Exp -> m Exp -> m Exp -> m Exp
-fromThenToE x y z = do { a <- x; b <- y; c <- z;
- pure (ArithSeqE (FromThenToR a b c)) }
-
-typeE :: Quote m => m Type -> m Exp
-typeE = fmap TypeE
-
--------------------------------------------------------------------------------
--- * Dec
-
-valD :: Quote m => m Pat -> m Body -> [m Dec] -> m Dec
-valD p b ds =
- do { p' <- p
- ; ds' <- sequenceA ds
- ; b' <- b
- ; pure (ValD p' b' ds')
- }
-
-funD :: Quote m => Name -> [m Clause] -> m Dec
-funD nm cs =
- do { cs1 <- sequenceA cs
- ; pure (FunD nm cs1)
- }
-
-tySynD :: Quote m => Name -> [m (TyVarBndr BndrVis)] -> m Type -> m Dec
-tySynD tc tvs rhs =
- do { tvs1 <- sequenceA tvs
- ; rhs1 <- rhs
- ; pure (TySynD tc tvs1 rhs1)
- }
-
-dataD :: Quote m => m Cxt -> Name -> [m (TyVarBndr BndrVis)] -> Maybe (m Kind) -> [m Con]
- -> [m DerivClause] -> m Dec
-dataD ctxt tc tvs ksig cons derivs =
- do
- ctxt1 <- ctxt
- tvs1 <- sequenceA tvs
- ksig1 <- sequenceA ksig
- cons1 <- sequenceA cons
- derivs1 <- sequenceA derivs
- pure (DataD ctxt1 tc tvs1 ksig1 cons1 derivs1)
-
-newtypeD :: Quote m => m Cxt -> Name -> [m (TyVarBndr BndrVis)] -> Maybe (m Kind) -> m Con
- -> [m DerivClause] -> m Dec
-newtypeD ctxt tc tvs ksig con derivs =
- do
- ctxt1 <- ctxt
- tvs1 <- sequenceA tvs
- ksig1 <- sequenceA ksig
- con1 <- con
- derivs1 <- sequenceA derivs
- pure (NewtypeD ctxt1 tc tvs1 ksig1 con1 derivs1)
-
-typeDataD :: Quote m => Name -> [m (TyVarBndr BndrVis)] -> Maybe (m Kind) -> [m Con]
- -> m Dec
-typeDataD tc tvs ksig cons =
- do
- tvs1 <- sequenceA tvs
- ksig1 <- sequenceA ksig
- cons1 <- sequenceA cons
- pure (TypeDataD tc tvs1 ksig1 cons1)
-
-classD :: Quote m => m Cxt -> Name -> [m (TyVarBndr BndrVis)] -> [FunDep] -> [m Dec] -> m Dec
-classD ctxt cls tvs fds decs =
- do
- tvs1 <- sequenceA tvs
- decs1 <- sequenceA decs
- ctxt1 <- ctxt
- pure $ ClassD ctxt1 cls tvs1 fds decs1
-
-instanceD :: Quote m => m Cxt -> m Type -> [m Dec] -> m Dec
-instanceD = instanceWithOverlapD Nothing
-
-instanceWithOverlapD :: Quote m => Maybe Overlap -> m Cxt -> m Type -> [m Dec] -> m Dec
-instanceWithOverlapD o ctxt ty decs =
- do
- ctxt1 <- ctxt
- decs1 <- sequenceA decs
- ty1 <- ty
- pure $ InstanceD o ctxt1 ty1 decs1
-
-
-
-sigD :: Quote m => Name -> m Type -> m Dec
-sigD fun ty = liftA (SigD fun) $ ty
-
-kiSigD :: Quote m => Name -> m Kind -> m Dec
-kiSigD fun ki = liftA (KiSigD fun) $ ki
-
-forImpD :: Quote m => Callconv -> Safety -> String -> Name -> m Type -> m Dec
-forImpD cc s str n ty
- = do ty' <- ty
- pure $ ForeignD (ImportF cc s str n ty')
-
-infixLD :: Quote m => Int -> Name -> m Dec
-infixLD prec = infixLWithSpecD prec NoNamespaceSpecifier
-
-infixRD :: Quote m => Int -> Name -> m Dec
-infixRD prec = infixRWithSpecD prec NoNamespaceSpecifier
-
-infixND :: Quote m => Int -> Name -> m Dec
-infixND prec = infixNWithSpecD prec NoNamespaceSpecifier
-
-infixLWithSpecD :: Quote m => Int -> NamespaceSpecifier -> Name -> m Dec
-infixLWithSpecD prec ns_spec nm = pure (InfixD (Fixity prec InfixL) ns_spec nm)
-
-infixRWithSpecD :: Quote m => Int -> NamespaceSpecifier -> Name -> m Dec
-infixRWithSpecD prec ns_spec nm = pure (InfixD (Fixity prec InfixR) ns_spec nm)
-
-infixNWithSpecD :: Quote m => Int -> NamespaceSpecifier -> Name -> m Dec
-infixNWithSpecD prec ns_spec nm = pure (InfixD (Fixity prec InfixN) ns_spec nm)
-
-defaultD :: Quote m => [m Type] -> m Dec
-defaultD tys = DefaultD <$> sequenceA tys
-
-pragInlD :: Quote m => Name -> Inline -> RuleMatch -> Phases -> m Dec
-pragInlD name inline rm phases
- = pure $ PragmaD $ InlineP name inline rm phases
-
-pragOpaqueD :: Quote m => Name -> m Dec
-pragOpaqueD name = pure $ PragmaD $ OpaqueP name
-
-pragSpecD :: Quote m => Name -> m Type -> Phases -> m Dec
-pragSpecD n ty phases
- = do
- ty1 <- ty
- pure $ PragmaD $ SpecialiseP n ty1 Nothing phases
-
-pragSpecInlD :: Quote m => Name -> m Type -> Inline -> Phases -> m Dec
-pragSpecInlD n ty inline phases
- = do
- ty1 <- ty
- pure $ PragmaD $ SpecialiseP n ty1 (Just inline) phases
-
-pragSpecInstD :: Quote m => m Type -> m Dec
-pragSpecInstD ty
- = do
- ty1 <- ty
- pure $ PragmaD $ SpecialiseInstP ty1
-
-pragRuleD :: Quote m => String -> Maybe [m (TyVarBndr ())] -> [m RuleBndr] -> m Exp -> m Exp
- -> Phases -> m Dec
-pragRuleD n ty_bndrs tm_bndrs lhs rhs phases
- = do
- ty_bndrs1 <- traverse sequenceA ty_bndrs
- tm_bndrs1 <- sequenceA tm_bndrs
- lhs1 <- lhs
- rhs1 <- rhs
- pure $ PragmaD $ RuleP n ty_bndrs1 tm_bndrs1 lhs1 rhs1 phases
-
-pragAnnD :: Quote m => AnnTarget -> m Exp -> m Dec
-pragAnnD target expr
- = do
- exp1 <- expr
- pure $ PragmaD $ AnnP target exp1
-
-pragLineD :: Quote m => Int -> String -> m Dec
-pragLineD line file = pure $ PragmaD $ LineP line file
-
-pragCompleteD :: Quote m => [Name] -> Maybe Name -> m Dec
-pragCompleteD cls mty = pure $ PragmaD $ CompleteP cls mty
-
-pragSCCFunD :: Quote m => Name -> m Dec
-pragSCCFunD nm = pure $ PragmaD $ SCCP nm Nothing
-
-pragSCCFunNamedD :: Quote m => Name -> String -> m Dec
-pragSCCFunNamedD nm str = pure $ PragmaD $ SCCP nm (Just str)
-
-dataInstD :: Quote m => m Cxt -> (Maybe [m (TyVarBndr ())]) -> m Type -> Maybe (m Kind) -> [m Con]
- -> [m DerivClause] -> m Dec
-dataInstD ctxt mb_bndrs ty ksig cons derivs =
- do
- ctxt1 <- ctxt
- mb_bndrs1 <- traverse sequenceA mb_bndrs
- ty1 <- ty
- ksig1 <- sequenceA ksig
- cons1 <- sequenceA cons
- derivs1 <- sequenceA derivs
- pure (DataInstD ctxt1 mb_bndrs1 ty1 ksig1 cons1 derivs1)
-
-newtypeInstD :: Quote m => m Cxt -> (Maybe [m (TyVarBndr ())]) -> m Type -> Maybe (m Kind) -> m Con
- -> [m DerivClause] -> m Dec
-newtypeInstD ctxt mb_bndrs ty ksig con derivs =
- do
- ctxt1 <- ctxt
- mb_bndrs1 <- traverse sequenceA mb_bndrs
- ty1 <- ty
- ksig1 <- sequenceA ksig
- con1 <- con
- derivs1 <- sequenceA derivs
- pure (NewtypeInstD ctxt1 mb_bndrs1 ty1 ksig1 con1 derivs1)
-
-tySynInstD :: Quote m => m TySynEqn -> m Dec
-tySynInstD eqn =
- do
- eqn1 <- eqn
- pure (TySynInstD eqn1)
-
-dataFamilyD :: Quote m => Name -> [m (TyVarBndr BndrVis)] -> Maybe (m Kind) -> m Dec
-dataFamilyD tc tvs kind =
- do tvs' <- sequenceA tvs
- kind' <- sequenceA kind
- pure $ DataFamilyD tc tvs' kind'
-
-openTypeFamilyD :: Quote m => Name -> [m (TyVarBndr BndrVis)] -> m FamilyResultSig
- -> Maybe InjectivityAnn -> m Dec
-openTypeFamilyD tc tvs res inj =
- do tvs' <- sequenceA tvs
- res' <- res
- pure $ OpenTypeFamilyD (TypeFamilyHead tc tvs' res' inj)
-
-closedTypeFamilyD :: Quote m => Name -> [m (TyVarBndr BndrVis)] -> m FamilyResultSig
- -> Maybe InjectivityAnn -> [m TySynEqn] -> m Dec
-closedTypeFamilyD tc tvs result injectivity eqns =
- do tvs1 <- sequenceA tvs
- result1 <- result
- eqns1 <- sequenceA eqns
- pure (ClosedTypeFamilyD (TypeFamilyHead tc tvs1 result1 injectivity) eqns1)
-
-roleAnnotD :: Quote m => Name -> [Role] -> m Dec
-roleAnnotD name roles = pure $ RoleAnnotD name roles
-
-standaloneDerivD :: Quote m => m Cxt -> m Type -> m Dec
-standaloneDerivD = standaloneDerivWithStrategyD Nothing
-
-standaloneDerivWithStrategyD :: Quote m => Maybe (m DerivStrategy) -> m Cxt -> m Type -> m Dec
-standaloneDerivWithStrategyD mdsq ctxtq tyq =
- do
- mds <- sequenceA mdsq
- ctxt <- ctxtq
- ty <- tyq
- pure $ StandaloneDerivD mds ctxt ty
-
-defaultSigD :: Quote m => Name -> m Type -> m Dec
-defaultSigD n tyq =
- do
- ty <- tyq
- pure $ DefaultSigD n ty
-
--- | Pattern synonym declaration
-patSynD :: Quote m => Name -> m PatSynArgs -> m PatSynDir -> m Pat -> m Dec
-patSynD name args dir pat = do
- args' <- args
- dir' <- dir
- pat' <- pat
- pure (PatSynD name args' dir' pat')
-
--- | Pattern synonym type signature
-patSynSigD :: Quote m => Name -> m Type -> m Dec
-patSynSigD nm ty =
- do ty' <- ty
- pure $ PatSynSigD nm ty'
-
--- | Implicit parameter binding declaration. Can only be used in let
--- and where clauses which consist entirely of implicit bindings.
-implicitParamBindD :: Quote m => String -> m Exp -> m Dec
-implicitParamBindD n e =
- do
- e' <- e
- pure $ ImplicitParamBindD n e'
-
-tySynEqn :: Quote m => (Maybe [m (TyVarBndr ())]) -> m Type -> m Type -> m TySynEqn
-tySynEqn mb_bndrs lhs rhs =
- do
- mb_bndrs1 <- traverse sequenceA mb_bndrs
- lhs1 <- lhs
- rhs1 <- rhs
- pure (TySynEqn mb_bndrs1 lhs1 rhs1)
-
-cxt :: Quote m => [m Pred] -> m Cxt
-cxt = sequenceA
-
-derivClause :: Quote m => Maybe (m DerivStrategy) -> [m Pred] -> m DerivClause
-derivClause mds p = do mds' <- sequenceA mds
- p' <- cxt p
- pure $ DerivClause mds' p'
-
-stockStrategy :: Quote m => m DerivStrategy
-stockStrategy = pure StockStrategy
-
-anyclassStrategy :: Quote m => m DerivStrategy
-anyclassStrategy = pure AnyclassStrategy
-
-newtypeStrategy :: Quote m => m DerivStrategy
-newtypeStrategy = pure NewtypeStrategy
-
-viaStrategy :: Quote m => m Type -> m DerivStrategy
-viaStrategy = fmap ViaStrategy
-
-normalC :: Quote m => Name -> [m BangType] -> m Con
-normalC con strtys = liftA (NormalC con) $ sequenceA strtys
-
-recC :: Quote m => Name -> [m VarBangType] -> m Con
-recC con varstrtys = liftA (RecC con) $ sequenceA varstrtys
-
-infixC :: Quote m => m (Bang, Type) -> Name -> m (Bang, Type) -> m Con
-infixC st1 con st2 = do st1' <- st1
- st2' <- st2
- pure $ InfixC st1' con st2'
-
-forallC :: Quote m => [m (TyVarBndr Specificity)] -> m Cxt -> m Con -> m Con
-forallC ns ctxt con = do
- ns' <- sequenceA ns
- ctxt' <- ctxt
- con' <- con
- pure $ ForallC ns' ctxt' con'
-
-gadtC :: Quote m => [Name] -> [m StrictType] -> m Type -> m Con
-gadtC cons strtys ty = liftA2 (GadtC cons) (sequenceA strtys) ty
-
-recGadtC :: Quote m => [Name] -> [m VarStrictType] -> m Type -> m Con
-recGadtC cons varstrtys ty = liftA2 (RecGadtC cons) (sequenceA varstrtys) ty
-
--------------------------------------------------------------------------------
--- * Type
-
-forallT :: Quote m => [m (TyVarBndr Specificity)] -> m Cxt -> m Type -> m Type
-forallT tvars ctxt ty = do
- tvars1 <- sequenceA tvars
- ctxt1 <- ctxt
- ty1 <- ty
- pure $ ForallT tvars1 ctxt1 ty1
-
-forallVisT :: Quote m => [m (TyVarBndr ())] -> m Type -> m Type
-forallVisT tvars ty = ForallVisT <$> sequenceA tvars <*> ty
-
-varT :: Quote m => Name -> m Type
-varT = pure . VarT
-
-conT :: Quote m => Name -> m Type
-conT = pure . ConT
-
-infixT :: Quote m => m Type -> Name -> m Type -> m Type
-infixT t1 n t2 = do t1' <- t1
- t2' <- t2
- pure (InfixT t1' n t2')
-
-uInfixT :: Quote m => m Type -> Name -> m Type -> m Type
-uInfixT t1 n t2 = do t1' <- t1
- t2' <- t2
- pure (UInfixT t1' n t2')
-
-promotedInfixT :: Quote m => m Type -> Name -> m Type -> m Type
-promotedInfixT t1 n t2 = do t1' <- t1
- t2' <- t2
- pure (PromotedInfixT t1' n t2')
-
-promotedUInfixT :: Quote m => m Type -> Name -> m Type -> m Type
-promotedUInfixT t1 n t2 = do t1' <- t1
- t2' <- t2
- pure (PromotedUInfixT t1' n t2')
-
-parensT :: Quote m => m Type -> m Type
-parensT t = do t' <- t
- pure (ParensT t')
-
-appT :: Quote m => m Type -> m Type -> m Type
-appT t1 t2 = do
- t1' <- t1
- t2' <- t2
- pure $ AppT t1' t2'
-
-appKindT :: Quote m => m Type -> m Kind -> m Type
-appKindT ty ki = do
- ty' <- ty
- ki' <- ki
- pure $ AppKindT ty' ki'
-
-arrowT :: Quote m => m Type
-arrowT = pure ArrowT
-
-mulArrowT :: Quote m => m Type
-mulArrowT = pure MulArrowT
-
-listT :: Quote m => m Type
-listT = pure ListT
-
-litT :: Quote m => m TyLit -> m Type
-litT l = fmap LitT l
-
-tupleT :: Quote m => Int -> m Type
-tupleT i = pure (TupleT i)
-
-unboxedTupleT :: Quote m => Int -> m Type
-unboxedTupleT i = pure (UnboxedTupleT i)
-
-unboxedSumT :: Quote m => SumArity -> m Type
-unboxedSumT arity = pure (UnboxedSumT arity)
-
-sigT :: Quote m => m Type -> m Kind -> m Type
-sigT t k
- = do
- t' <- t
- k' <- k
- pure $ SigT t' k'
-
-equalityT :: Quote m => m Type
-equalityT = pure EqualityT
-
-wildCardT :: Quote m => m Type
-wildCardT = pure WildCardT
-
-implicitParamT :: Quote m => String -> m Type -> m Type
-implicitParamT n t
- = do
- t' <- t
- pure $ ImplicitParamT n t'
-
-{-# DEPRECATED classP "As of template-haskell-2.10, constraint predicates (Pred) are just types (Type), in keeping with ConstraintKinds. Please use 'conT' and 'appT'." #-}
-classP :: Quote m => Name -> [m Type] -> m Pred
-classP cla tys
- = do
- tysl <- sequenceA tys
- pure (foldl AppT (ConT cla) tysl)
-
-{-# DEPRECATED equalP "As of template-haskell-2.10, constraint predicates (Pred) are just types (Type), in keeping with ConstraintKinds. Please see 'equalityT'." #-}
-equalP :: Quote m => m Type -> m Type -> m Pred
-equalP tleft tright
- = do
- tleft1 <- tleft
- tright1 <- tright
- eqT <- equalityT
- pure (foldl AppT eqT [tleft1, tright1])
-
-promotedT :: Quote m => Name -> m Type
-promotedT = pure . PromotedT
-
-promotedTupleT :: Quote m => Int -> m Type
-promotedTupleT i = pure (PromotedTupleT i)
-
-promotedNilT :: Quote m => m Type
-promotedNilT = pure PromotedNilT
-
-promotedConsT :: Quote m => m Type
-promotedConsT = pure PromotedConsT
-
-noSourceUnpackedness, sourceNoUnpack, sourceUnpack :: Quote m => m SourceUnpackedness
-noSourceUnpackedness = pure NoSourceUnpackedness
-sourceNoUnpack = pure SourceNoUnpack
-sourceUnpack = pure SourceUnpack
-
-noSourceStrictness, sourceLazy, sourceStrict :: Quote m => m SourceStrictness
-noSourceStrictness = pure NoSourceStrictness
-sourceLazy = pure SourceLazy
-sourceStrict = pure SourceStrict
-
-{-# DEPRECATED isStrict
- ["Use 'bang'. See https://gitlab.haskell.org/ghc/ghc/wikis/migration/8.0. ",
- "Example usage: 'bang noSourceUnpackedness sourceStrict'"] #-}
-{-# DEPRECATED notStrict
- ["Use 'bang'. See https://gitlab.haskell.org/ghc/ghc/wikis/migration/8.0. ",
- "Example usage: 'bang noSourceUnpackedness noSourceStrictness'"] #-}
-{-# DEPRECATED unpacked
- ["Use 'bang'. See https://gitlab.haskell.org/ghc/ghc/wikis/migration/8.0. ",
- "Example usage: 'bang sourceUnpack sourceStrict'"] #-}
-isStrict, notStrict, unpacked :: Quote m => m Strict
-isStrict = bang noSourceUnpackedness sourceStrict
-notStrict = bang noSourceUnpackedness noSourceStrictness
-unpacked = bang sourceUnpack sourceStrict
-
-bang :: Quote m => m SourceUnpackedness -> m SourceStrictness -> m Bang
-bang u s = do u' <- u
- s' <- s
- pure (Bang u' s')
-
-bangType :: Quote m => m Bang -> m Type -> m BangType
-bangType = liftA2 (,)
-
-varBangType :: Quote m => Name -> m BangType -> m VarBangType
-varBangType v bt = (\(b, t) -> (v, b, t)) <$> bt
-
-{-# DEPRECATED strictType
- "As of @template-haskell-2.11.0.0@, 'StrictType' has been replaced by 'BangType'. Please use 'bangType' instead." #-}
-strictType :: Quote m => m Strict -> m Type -> m StrictType
-strictType = bangType
-
-{-# DEPRECATED varStrictType
- "As of @template-haskell-2.11.0.0@, 'VarStrictType' has been replaced by 'VarBangType'. Please use 'varBangType' instead." #-}
-varStrictType :: Quote m => Name -> m StrictType -> m VarStrictType
-varStrictType = varBangType
-
--- * Type Literals
-
--- MonadFail here complicates things (a lot) because it would mean we would
--- have to emit a MonadFail constraint during typechecking if there was any
--- chance the desugaring would use numTyLit, which in general is hard to
--- predict.
-numTyLit :: Quote m => Integer -> m TyLit
-numTyLit n = if n >= 0 then pure (NumTyLit n)
- else error ("Negative type-level number: " ++ show n)
-
-strTyLit :: Quote m => String -> m TyLit
-strTyLit s = pure (StrTyLit s)
-
-charTyLit :: Quote m => Char -> m TyLit
-charTyLit c = pure (CharTyLit c)
-
--------------------------------------------------------------------------------
--- * Kind
-
-plainTV :: Quote m => Name -> m (TyVarBndr ())
-plainTV n = pure $ PlainTV n ()
-
-plainInvisTV :: Quote m => Name -> Specificity -> m (TyVarBndr Specificity)
-plainInvisTV n s = pure $ PlainTV n s
-
-plainBndrTV :: Quote m => Name -> BndrVis -> m (TyVarBndr BndrVis)
-plainBndrTV n v = pure $ PlainTV n v
-
-kindedTV :: Quote m => Name -> m Kind -> m (TyVarBndr ())
-kindedTV n = fmap (KindedTV n ())
-
-kindedInvisTV :: Quote m => Name -> Specificity -> m Kind -> m (TyVarBndr Specificity)
-kindedInvisTV n s = fmap (KindedTV n s)
-
-kindedBndrTV :: Quote m => Name -> BndrVis -> m Kind -> m (TyVarBndr BndrVis)
-kindedBndrTV n v = fmap (KindedTV n v)
-
-specifiedSpec :: Specificity
-specifiedSpec = SpecifiedSpec
-
-inferredSpec :: Specificity
-inferredSpec = InferredSpec
-
-bndrReq :: BndrVis
-bndrReq = BndrReq
-
-bndrInvis :: BndrVis
-bndrInvis = BndrInvis
-
-varK :: Name -> Kind
-varK = VarT
-
-conK :: Name -> Kind
-conK = ConT
-
-tupleK :: Int -> Kind
-tupleK = TupleT
-
-arrowK :: Kind
-arrowK = ArrowT
-
-listK :: Kind
-listK = ListT
-
-appK :: Kind -> Kind -> Kind
-appK = AppT
-
-starK :: Quote m => m Kind
-starK = pure StarT
-
-constraintK :: Quote m => m Kind
-constraintK = pure ConstraintT
-
--------------------------------------------------------------------------------
--- * Type family result
-
-noSig :: Quote m => m FamilyResultSig
-noSig = pure NoSig
-
-kindSig :: Quote m => m Kind -> m FamilyResultSig
-kindSig = fmap KindSig
-
-tyVarSig :: Quote m => m (TyVarBndr ()) -> m FamilyResultSig
-tyVarSig = fmap TyVarSig
-
--------------------------------------------------------------------------------
--- * Injectivity annotation
-
-injectivityAnn :: Name -> [Name] -> InjectivityAnn
-injectivityAnn = TH.InjectivityAnn
-
--------------------------------------------------------------------------------
--- * Role
-
-nominalR, representationalR, phantomR, inferR :: Role
-nominalR = NominalR
-representationalR = RepresentationalR
-phantomR = PhantomR
-inferR = InferR
-
--------------------------------------------------------------------------------
--- * Callconv
-
-cCall, stdCall, cApi, prim, javaScript :: Callconv
-cCall = CCall
-stdCall = StdCall
-cApi = CApi
-prim = Prim
-javaScript = JavaScript
-
--------------------------------------------------------------------------------
--- * Safety
-
-unsafe, safe, interruptible :: Safety
-unsafe = Unsafe
-safe = Safe
-interruptible = Interruptible
-
--------------------------------------------------------------------------------
--- * FunDep
-
-funDep :: [Name] -> [Name] -> FunDep
-funDep = FunDep
-
--------------------------------------------------------------------------------
--- * RuleBndr
-ruleVar :: Quote m => Name -> m RuleBndr
-ruleVar = pure . RuleVar
-
-typedRuleVar :: Quote m => Name -> m Type -> m RuleBndr
-typedRuleVar n ty = TypedRuleVar n <$> ty
-
--------------------------------------------------------------------------------
--- * AnnTarget
-valueAnnotation :: Name -> AnnTarget
-valueAnnotation = ValueAnnotation
-
-typeAnnotation :: Name -> AnnTarget
-typeAnnotation = TypeAnnotation
-
-moduleAnnotation :: AnnTarget
-moduleAnnotation = ModuleAnnotation
-
--------------------------------------------------------------------------------
--- * Pattern Synonyms (sub constructs)
-
-unidir, implBidir :: Quote m => m PatSynDir
-unidir = pure Unidir
-implBidir = pure ImplBidir
-
-explBidir :: Quote m => [m Clause] -> m PatSynDir
-explBidir cls = do
- cls' <- sequenceA cls
- pure (ExplBidir cls')
-
-prefixPatSyn :: Quote m => [Name] -> m PatSynArgs
-prefixPatSyn args = pure $ PrefixPatSyn args
-
-recordPatSyn :: Quote m => [Name] -> m PatSynArgs
-recordPatSyn sels = pure $ RecordPatSyn sels
-
-infixPatSyn :: Quote m => Name -> Name -> m PatSynArgs
-infixPatSyn arg1 arg2 = pure $ InfixPatSyn arg1 arg2
-
---------------------------------------------------------------
--- * Useful helper function
-
-appsE :: Quote m => [m Exp] -> m Exp
-appsE [] = error "appsE []"
-appsE [x] = x
-appsE (x:y:zs) = appsE ( (appE x y) : zs )
-
--- | pure the Module at the place of splicing. Can be used as an
--- input for 'reifyModule'.
-thisModule :: Q Module
-thisModule = do
- loc <- location
- pure $ Module (mkPkgName $ loc_package loc) (mkModName $ loc_module loc)
-
---------------------------------------------------------------
--- * Documentation combinators
-
--- | Attaches Haddock documentation to the declaration provided. Unlike
--- 'putDoc', the names do not need to be in scope when calling this function so
--- it can be used for quoted declarations and anything else currently being
--- spliced.
--- Not all declarations can have documentation attached to them. For those that
--- can't, 'withDecDoc' will return it unchanged without any side effects.
-withDecDoc :: String -> Q Dec -> Q Dec
-withDecDoc doc dec = do
- dec' <- dec
- case doc_loc dec' of
- Just loc -> qAddModFinalizer $ qPutDoc loc doc
- Nothing -> pure ()
- pure dec'
+module Language.Haskell.TH.Lib.Internal
+ ( module GHC.Internal.TH.Lib )
where
- doc_loc (FunD n _) = Just $ DeclDoc n
- doc_loc (ValD (VarP n) _ _) = Just $ DeclDoc n
- doc_loc (DataD _ n _ _ _ _) = Just $ DeclDoc n
- doc_loc (NewtypeD _ n _ _ _ _) = Just $ DeclDoc n
- doc_loc (TypeDataD n _ _ _) = Just $ DeclDoc n
- doc_loc (TySynD n _ _) = Just $ DeclDoc n
- doc_loc (ClassD _ n _ _ _) = Just $ DeclDoc n
- doc_loc (SigD n _) = Just $ DeclDoc n
- doc_loc (ForeignD (ImportF _ _ _ n _)) = Just $ DeclDoc n
- doc_loc (ForeignD (ExportF _ _ n _)) = Just $ DeclDoc n
- doc_loc (InfixD _ _ n) = Just $ DeclDoc n
- doc_loc (DataFamilyD n _ _) = Just $ DeclDoc n
- doc_loc (OpenTypeFamilyD (TypeFamilyHead n _ _ _)) = Just $ DeclDoc n
- doc_loc (ClosedTypeFamilyD (TypeFamilyHead n _ _ _) _) = Just $ DeclDoc n
- doc_loc (PatSynD n _ _ _) = Just $ DeclDoc n
- doc_loc (PatSynSigD n _) = Just $ DeclDoc n
-
- -- For instances we just pass along the full type
- doc_loc (InstanceD _ _ t _) = Just $ InstDoc t
- doc_loc (DataInstD _ _ t _ _ _) = Just $ InstDoc t
- doc_loc (NewtypeInstD _ _ t _ _ _) = Just $ InstDoc t
- doc_loc (TySynInstD (TySynEqn _ t _)) = Just $ InstDoc t
-
- -- Declarations that can't have documentation attached to
- -- ValDs that aren't a simple variable pattern
- doc_loc (ValD _ _ _) = Nothing
- doc_loc (KiSigD _ _) = Nothing
- doc_loc (PragmaD _) = Nothing
- doc_loc (RoleAnnotD _ _) = Nothing
- doc_loc (StandaloneDerivD _ _ _) = Nothing
- doc_loc (DefaultSigD _ _) = Nothing
- doc_loc (ImplicitParamBindD _ _) = Nothing
- doc_loc (DefaultD _) = Nothing
-
--- | Variant of 'withDecDoc' that applies the same documentation to
--- multiple declarations. Useful for documenting quoted declarations.
-withDecsDoc :: String -> Q [Dec] -> Q [Dec]
-withDecsDoc doc decs = decs >>= mapM (withDecDoc doc . pure)
-
--- | Variant of 'funD' that attaches Haddock documentation.
-funD_doc :: Name -> [Q Clause]
- -> Maybe String -- ^ Documentation to attach to function
- -> [Maybe String] -- ^ Documentation to attach to arguments
- -> Q Dec
-funD_doc nm cs mfun_doc arg_docs = do
- qAddModFinalizer $ sequence_
- [putDoc (ArgDoc nm i) s | (i, Just s) <- zip [0..] arg_docs]
- let dec = funD nm cs
- case mfun_doc of
- Just fun_doc -> withDecDoc fun_doc dec
- Nothing -> funD nm cs
-
--- | Variant of 'dataD' that attaches Haddock documentation.
-dataD_doc :: Q Cxt -> Name -> [Q (TyVarBndr BndrVis)] -> Maybe (Q Kind)
- -> [(Q Con, Maybe String, [Maybe String])]
- -- ^ List of constructors, documentation for the constructor, and
- -- documentation for the arguments
- -> [Q DerivClause]
- -> Maybe String
- -- ^ Documentation to attach to the data declaration
- -> Q Dec
-dataD_doc ctxt tc tvs ksig cons_with_docs derivs mdoc = do
- qAddModFinalizer $ mapM_ docCons cons_with_docs
- let dec = dataD ctxt tc tvs ksig (map (\(con, _, _) -> con) cons_with_docs) derivs
- maybe dec (flip withDecDoc dec) mdoc
-
--- | Variant of 'newtypeD' that attaches Haddock documentation.
-newtypeD_doc :: Q Cxt -> Name -> [Q (TyVarBndr BndrVis)] -> Maybe (Q Kind)
- -> (Q Con, Maybe String, [Maybe String])
- -- ^ The constructor, documentation for the constructor, and
- -- documentation for the arguments
- -> [Q DerivClause]
- -> Maybe String
- -- ^ Documentation to attach to the newtype declaration
- -> Q Dec
-newtypeD_doc ctxt tc tvs ksig con_with_docs@(con, _, _) derivs mdoc = do
- qAddModFinalizer $ docCons con_with_docs
- let dec = newtypeD ctxt tc tvs ksig con derivs
- maybe dec (flip withDecDoc dec) mdoc
-
--- | Variant of 'typeDataD' that attaches Haddock documentation.
-typeDataD_doc :: Name -> [Q (TyVarBndr BndrVis)] -> Maybe (Q Kind)
- -> [(Q Con, Maybe String, [Maybe String])]
- -- ^ List of constructors, documentation for the constructor, and
- -- documentation for the arguments
- -> Maybe String
- -- ^ Documentation to attach to the data declaration
- -> Q Dec
-typeDataD_doc tc tvs ksig cons_with_docs mdoc = do
- qAddModFinalizer $ mapM_ docCons cons_with_docs
- let dec = typeDataD tc tvs ksig (map (\(con, _, _) -> con) cons_with_docs)
- maybe dec (flip withDecDoc dec) mdoc
-
--- | Variant of 'dataInstD' that attaches Haddock documentation.
-dataInstD_doc :: Q Cxt -> (Maybe [Q (TyVarBndr ())]) -> Q Type -> Maybe (Q Kind)
- -> [(Q Con, Maybe String, [Maybe String])]
- -- ^ List of constructors, documentation for the constructor, and
- -- documentation for the arguments
- -> [Q DerivClause]
- -> Maybe String
- -- ^ Documentation to attach to the instance declaration
- -> Q Dec
-dataInstD_doc ctxt mb_bndrs ty ksig cons_with_docs derivs mdoc = do
- qAddModFinalizer $ mapM_ docCons cons_with_docs
- let dec = dataInstD ctxt mb_bndrs ty ksig (map (\(con, _, _) -> con) cons_with_docs)
- derivs
- maybe dec (flip withDecDoc dec) mdoc
-
--- | Variant of 'newtypeInstD' that attaches Haddock documentation.
-newtypeInstD_doc :: Q Cxt -> (Maybe [Q (TyVarBndr ())]) -> Q Type
- -> Maybe (Q Kind)
- -> (Q Con, Maybe String, [Maybe String])
- -- ^ The constructor, documentation for the constructor, and
- -- documentation for the arguments
- -> [Q DerivClause]
- -> Maybe String
- -- ^ Documentation to attach to the instance declaration
- -> Q Dec
-newtypeInstD_doc ctxt mb_bndrs ty ksig con_with_docs@(con, _, _) derivs mdoc = do
- qAddModFinalizer $ docCons con_with_docs
- let dec = newtypeInstD ctxt mb_bndrs ty ksig con derivs
- maybe dec (flip withDecDoc dec) mdoc
-
--- | Variant of 'patSynD' that attaches Haddock documentation.
-patSynD_doc :: Name -> Q PatSynArgs -> Q PatSynDir -> Q Pat
- -> Maybe String -- ^ Documentation to attach to the pattern synonym
- -> [Maybe String] -- ^ Documentation to attach to the pattern arguments
- -> Q Dec
-patSynD_doc name args dir pat mdoc arg_docs = do
- qAddModFinalizer $ sequence_
- [putDoc (ArgDoc name i) s | (i, Just s) <- zip [0..] arg_docs]
- let dec = patSynD name args dir pat
- maybe dec (flip withDecDoc dec) mdoc
--- | Document a data/newtype constructor with its arguments.
-docCons :: (Q Con, Maybe String, [Maybe String]) -> Q ()
-docCons (c, md, arg_docs) = do
- c' <- c
- -- Attach docs to the constructors
- sequence_ [ putDoc (DeclDoc nm) d | Just d <- [md], nm <- get_cons_names c' ]
- -- Attach docs to the arguments
- case c' of
- -- Record selector documentation isn't stored in the argument map,
- -- but in the declaration map instead
- RecC _ var_bang_types ->
- sequence_ [ putDoc (DeclDoc nm) arg_doc
- | (Just arg_doc, (nm, _, _)) <- zip arg_docs var_bang_types
- ]
- _ ->
- sequence_ [ putDoc (ArgDoc nm i) arg_doc
- | nm <- get_cons_names c'
- , (i, Just arg_doc) <- zip [0..] arg_docs
- ]
+import GHC.Internal.TH.Lib
diff --git a/libraries/template-haskell/Language/Haskell/TH/Ppr.hs b/libraries/template-haskell/Language/Haskell/TH/Ppr.hs
index 2801ba2fc1ea742d6d6806c54b0f1f317bfef814..49ed1576466ff4f1159a2d1da611e421d00cdda3 100644
--- a/libraries/template-haskell/Language/Haskell/TH/Ppr.hs
+++ b/libraries/template-haskell/Language/Haskell/TH/Ppr.hs
@@ -1,1075 +1,9 @@
{-# LANGUAGE Safe #-}
-{-# LANGUAGE LambdaCase #-}
+
-- | contains a prettyprinter for the
-- Template Haskell datatypes
-
-module Language.Haskell.TH.Ppr where
- -- All of the exports from this module should
- -- be "public" functions. The main module TH
- -- re-exports them all.
-
-import Text.PrettyPrint (render)
-import Language.Haskell.TH.PprLib
-import Language.Haskell.TH.Syntax
-import Data.Word ( Word8 )
-import Data.Char ( toLower, chr)
-import GHC.Show ( showMultiLineString )
-import GHC.Lexeme( isVarSymChar )
-import Data.Ratio ( numerator, denominator )
-import Data.Foldable ( toList )
-import Prelude hiding ((<>))
-
-nestDepth :: Int
-nestDepth = 4
-
-type Precedence = Int
-appPrec, opPrec, unopPrec, funPrec, qualPrec, sigPrec, noPrec :: Precedence
-appPrec = 6 -- Argument of a function or type application
-opPrec = 5 -- Argument of an infix operator
-unopPrec = 4 -- Argument of an unresolved infix operator
-funPrec = 3 -- Argument of a function arrow
-qualPrec = 2 -- Forall-qualified type or result of a function arrow
-sigPrec = 1 -- Argument of an explicit type signature
-noPrec = 0 -- Others
-
-parensIf :: Bool -> Doc -> Doc
-parensIf True d = parens d
-parensIf False d = d
-
-------------------------------
-
-pprint :: Ppr a => a -> String
-pprint x = render $ to_HPJ_Doc $ ppr x
-
-class Ppr a where
- ppr :: a -> Doc
- ppr_list :: [a] -> Doc
- ppr_list = vcat . map ppr
-
-instance Ppr a => Ppr [a] where
- ppr x = ppr_list x
-
-------------------------------
-instance Ppr Name where
- ppr v = pprName v
-
-------------------------------
-instance Ppr Info where
- ppr (TyConI d) = ppr d
- ppr (ClassI d is) = ppr d $$ vcat (map ppr is)
- ppr (FamilyI d is) = ppr d $$ vcat (map ppr is)
- ppr (PrimTyConI name arity is_unlifted)
- = text "Primitive"
- <+> (if is_unlifted then text "unlifted" else empty)
- <+> text "type constructor" <+> quotes (ppr name)
- <+> parens (text "arity" <+> int arity)
- ppr (ClassOpI v ty cls)
- = text "Class op from" <+> ppr cls <> colon <+> ppr_sig v ty
- ppr (DataConI v ty tc)
- = text "Constructor from" <+> ppr tc <> colon <+> ppr_sig v ty
- ppr (PatSynI nm ty) = pprPatSynSig nm ty
- ppr (TyVarI v ty)
- = text "Type variable" <+> ppr v <+> equals <+> ppr ty
- ppr (VarI v ty mb_d)
- = vcat [ppr_sig v ty,
- case mb_d of { Nothing -> empty; Just d -> ppr d }]
-
-ppr_sig :: Name -> Type -> Doc
-ppr_sig v ty = pprName' Applied v <+> dcolon <+> ppr ty
-
-pprFixity :: Name -> Fixity -> NamespaceSpecifier -> Doc
-pprFixity _ f _ | f == defaultFixity = empty
-pprFixity v (Fixity i d) ns_spec
- = ppr_fix d <+> int i <+> pprNamespaceSpecifier ns_spec <+> pprName' Infix v
- where ppr_fix InfixR = text "infixr"
- ppr_fix InfixL = text "infixl"
- ppr_fix InfixN = text "infix"
-
-pprNamespaceSpecifier :: NamespaceSpecifier -> Doc
-pprNamespaceSpecifier NoNamespaceSpecifier = empty
-pprNamespaceSpecifier TypeNamespaceSpecifier = text "type"
-pprNamespaceSpecifier DataNamespaceSpecifier = text "data"
-
--- | Pretty prints a pattern synonym type signature
-pprPatSynSig :: Name -> PatSynType -> Doc
-pprPatSynSig nm ty
- = text "pattern" <+> pprPrefixOcc nm <+> dcolon <+> pprPatSynType ty
-
--- | Pretty prints a pattern synonym's type; follows the usual
--- conventions to print a pattern synonym type compactly, yet
--- unambiguously. See the note on 'PatSynType' and the section on
--- pattern synonyms in the GHC user's guide for more information.
-pprPatSynType :: PatSynType -> Doc
-pprPatSynType ty@(ForallT uniTys reqs ty'@(ForallT exTys provs ty''))
- | null exTys, null provs = ppr (ForallT uniTys reqs ty'')
- | null uniTys, null reqs = noreqs <+> ppr ty'
- | null reqs = pprForallBndrs uniTys <+> noreqs <+> ppr ty'
- | otherwise = ppr ty
- where noreqs = text "() =>"
- pprForallBndrs tvs = text "forall" <+> hsep (map ppr tvs) <+> text "."
-pprPatSynType ty = ppr ty
-
-------------------------------
-instance Ppr Module where
- ppr (Module pkg m) = text (pkgString pkg) <+> text (modString m)
-
-instance Ppr ModuleInfo where
- ppr (ModuleInfo imps) = text "Module" <+> vcat (map ppr imps)
-
-------------------------------
-instance Ppr Exp where
- ppr = pprExp noPrec
-
-pprPrefixOcc :: Name -> Doc
--- Print operators with parens around them
-pprPrefixOcc n = parensIf (isSymOcc n) (ppr n)
-
-isSymOcc :: Name -> Bool
-isSymOcc n
- = case nameBase n of
- [] -> True -- Empty name; weird
- (c:_) -> isVarSymChar c
- -- c.f. isVarSymChar in GHC itself
-
-pprInfixExp :: Exp -> Doc
-pprInfixExp (VarE v) = pprName' Infix v
-pprInfixExp (ConE v) = pprName' Infix v
-pprInfixExp (UnboundVarE v) = pprName' Infix v
--- This case will only ever be reached in exceptional circumstances.
--- For example, when printing an error message in case of a malformed expression.
-pprInfixExp e = text "`" <> ppr e <> text "`"
-
-pprExp :: Precedence -> Exp -> Doc
-pprExp _ (VarE v) = pprName' Applied v
-pprExp _ (ConE c) = pprName' Applied c
-pprExp i (LitE l) = pprLit i l
-pprExp i (AppE e1 e2) = parensIf (i >= appPrec) $ pprExp opPrec e1
- <+> pprExp appPrec e2
-pprExp i (AppTypeE e t)
- = parensIf (i >= appPrec) $ pprExp opPrec e <+> char '@' <> pprParendType t
-pprExp _ (ParensE e) = parens (pprExp noPrec e)
-pprExp i (UInfixE e1 op e2)
- = parensIf (i > unopPrec) $ pprExp unopPrec e1
- <+> pprInfixExp op
- <+> pprExp unopPrec e2
-pprExp i (InfixE (Just e1) op (Just e2))
- = parensIf (i >= opPrec) $ pprExp opPrec e1
- <+> pprInfixExp op
- <+> pprExp opPrec e2
-pprExp _ (InfixE me1 op me2) = parens $ pprMaybeExp noPrec me1
- <+> pprInfixExp op
- <+> pprMaybeExp noPrec me2
-pprExp i (LamE [] e) = pprExp i e -- #13856
-pprExp i (LamE ps e) = parensIf (i > noPrec) $ char '\\' <> hsep (map (pprPat appPrec) ps)
- <+> text "->" <+> ppr e
-pprExp i (LamCaseE ms)
- = parensIf (i > noPrec) $ text "\\case" $$ braces (semiSep ms)
-pprExp i (LamCasesE ms)
- = parensIf (i > noPrec) $ text "\\cases" $$ braces (semi_sep ms)
- where semi_sep = sep . punctuate semi . map (pprClause False)
-pprExp i (TupE es)
- | [Just e] <- es
- = pprExp i (ConE (tupleDataName 1) `AppE` e)
- | otherwise
- = parens (commaSepWith (pprMaybeExp noPrec) es)
-pprExp _ (UnboxedTupE es) = hashParens (commaSepWith (pprMaybeExp noPrec) es)
-pprExp _ (UnboxedSumE e alt arity) = unboxedSumBars (ppr e) alt arity
--- Nesting in Cond is to avoid potential problems in do statements
-pprExp i (CondE guard true false)
- = parensIf (i > noPrec) $ sep [text "if" <+> ppr guard,
- nest 1 $ text "then" <+> ppr true,
- nest 1 $ text "else" <+> ppr false]
-pprExp i (MultiIfE alts)
- = parensIf (i > noPrec) $ vcat $
- case alts of
- [] -> [text "if {}"]
- (alt : alts') -> text "if" <+> pprGuarded arrow alt
- : map (nest 3 . pprGuarded arrow) alts'
-pprExp i (LetE ds_ e) = parensIf (i > noPrec) $ text "let" <+> pprDecs ds_
- $$ text " in" <+> ppr e
- where
- pprDecs [] = empty
- pprDecs [d] = ppr d
- pprDecs ds = braces (semiSep ds)
-
-pprExp i (CaseE e ms)
- = parensIf (i > noPrec) $ text "case" <+> ppr e <+> text "of"
- $$ braces (semiSep ms)
-pprExp i (DoE m ss_) = parensIf (i > noPrec) $
- pprQualifier m <> text "do" <+> pprStms ss_
- where
- pprQualifier Nothing = empty
- pprQualifier (Just modName) = text (modString modName) <> char '.'
- pprStms [] = empty
- pprStms [s] = ppr s
- pprStms ss = braces (semiSep ss)
-pprExp i (MDoE m ss_) = parensIf (i > noPrec) $
- pprQualifier m <> text "mdo" <+> pprStms ss_
- where
- pprQualifier Nothing = empty
- pprQualifier (Just modName) = text (modString modName) <> char '.'
- pprStms [] = empty
- pprStms [s] = ppr s
- pprStms ss = braces (semiSep ss)
-
-pprExp _ (CompE []) = text "<<Empty CompExp>>"
--- This will probably break with fixity declarations - would need a ';'
-pprExp _ (CompE ss) =
- if null ss'
- -- If there are no statements in a list comprehension besides the last
- -- one, we simply treat it like a normal list.
- then text "[" <> ppr s <> text "]"
- else text "[" <> ppr s
- <+> bar
- <+> commaSep ss'
- <> text "]"
- where s = last ss
- ss' = init ss
-pprExp _ (ArithSeqE d) = ppr d
-pprExp _ (ListE es) = brackets (commaSep es)
-pprExp i (SigE e t) = parensIf (i > noPrec) $ pprExp sigPrec e
- <+> dcolon <+> pprType sigPrec t
-pprExp _ (RecConE nm fs) = pprName' Applied nm <> braces (pprFields fs)
-pprExp _ (RecUpdE e fs) = pprExp appPrec e <> braces (pprFields fs)
-pprExp i (StaticE e) = parensIf (i >= appPrec) $
- text "static"<+> pprExp appPrec e
-pprExp _ (UnboundVarE v) = pprName' Applied v
-pprExp _ (LabelE s) = text "#" <> text s
-pprExp _ (ImplicitParamVarE n) = text ('?' : n)
-pprExp _ (GetFieldE e f) = pprExp appPrec e <> text ('.': f)
-pprExp _ (ProjectionE xs) = parens $ hcat $ map ((char '.'<>) . text) $ toList xs
-pprExp _ (TypedBracketE e) = text "[||" <> ppr e <> text "||]"
-pprExp _ (TypedSpliceE e) = text "$$" <> pprExp appPrec e
-pprExp i (TypeE t) = parensIf (i > noPrec) $ text "type" <+> ppr t
-
-pprFields :: [(Name,Exp)] -> Doc
-pprFields = sep . punctuate comma . map (\(s,e) -> pprName' Applied s <+> equals <+> ppr e)
-
-pprMaybeExp :: Precedence -> Maybe Exp -> Doc
-pprMaybeExp _ Nothing = empty
-pprMaybeExp i (Just e) = pprExp i e
-
-------------------------------
-instance Ppr Stmt where
- ppr (BindS p e) = ppr p <+> text "<-" <+> ppr e
- ppr (LetS ds) = text "let" <+> (braces (semiSep ds))
- ppr (NoBindS e) = ppr e
- ppr (ParS sss) = sep $ punctuate bar
- $ map commaSep sss
- ppr (RecS ss) = text "rec" <+> (braces (semiSep ss))
-
-------------------------------
-instance Ppr Match where
- ppr (Match p rhs ds) = pprMatchPat p <+> pprBody False rhs
- $$ where_clause ds
-
-pprMatchPat :: Pat -> Doc
--- Everything except pattern signatures bind more tightly than (->)
-pprMatchPat p@(SigP {}) = parens (ppr p)
-pprMatchPat p = ppr p
-
-------------------------------
-pprGuarded :: Doc -> (Guard, Exp) -> Doc
-pprGuarded eqDoc (guard, expr) = case guard of
- NormalG guardExpr -> bar <+> ppr guardExpr <+> eqDoc <+> ppr expr
- PatG stmts -> bar <+> vcat (punctuate comma $ map ppr stmts) $$
- nest nestDepth (eqDoc <+> ppr expr)
-
-------------------------------
-pprBody :: Bool -> Body -> Doc
-pprBody eq body = case body of
- GuardedB xs -> nest nestDepth $ vcat $ map (pprGuarded eqDoc) xs
- NormalB e -> eqDoc <+> ppr e
- where eqDoc | eq = equals
- | otherwise = arrow
-
-------------------------------
-pprClause :: Bool -> Clause -> Doc
-pprClause eqDoc (Clause ps rhs ds)
- = hsep (map (pprPat appPrec) ps) <+> pprBody eqDoc rhs
- $$ where_clause ds
-
-------------------------------
-instance Ppr Lit where
- ppr = pprLit noPrec
-
-pprLit :: Precedence -> Lit -> Doc
-pprLit i (IntPrimL x) = parensIf (i > noPrec && x < 0)
- (integer x <> char '#')
-pprLit _ (WordPrimL x) = integer x <> text "##"
-pprLit i (FloatPrimL x) = parensIf (i > noPrec && x < 0)
- (float (fromRational x) <> char '#')
-pprLit i (DoublePrimL x) = parensIf (i > noPrec && x < 0)
- (double (fromRational x) <> text "##")
-pprLit i (IntegerL x) = parensIf (i > noPrec && x < 0) (integer x)
-pprLit _ (CharL c) = text (show c)
-pprLit _ (CharPrimL c) = text (show c) <> char '#'
-pprLit _ (StringL s) = pprString s
-pprLit _ (StringPrimL s) = pprString (bytesToString s) <> char '#'
-pprLit _ (BytesPrimL {}) = pprString "<binary data>"
-pprLit i (RationalL rat)
- | withoutFactor 2 (withoutFactor 5 $ denominator rat) /= 1
- -- if the denominator has prime factors other than 2 and 5
- -- or can't be represented as Double, show as fraction
- = parensIf (i > noPrec) $
- integer (numerator rat) <+> char '/' <+> integer (denominator rat)
- | rat /= 0 && (zeroes < -2 || zeroes > 6),
- let (n, d) = properFraction (rat / magnitude)
- -- if < 0.01 or >= 100_000_000, use scientific notation
- = parensIf (i > noPrec && rat < 0)
- (integer n
- <> (if d == 0 then empty else char '.' <> decimals (abs d))
- <> char 'e' <> integer zeroes)
- | let (n, d) = properFraction rat
- = parensIf (i > noPrec && rat < 0)
- (integer n <> char '.'
- <> if d == 0 then char '0' else decimals (abs d))
- where zeroes :: Integer
- zeroes = log10 (abs rat)
- log10 :: Rational -> Integer
- log10 x
- | x >= 10 = 1 + log10 (x / 10)
- | x < 1 = -1 + log10 (x * 10)
- | otherwise = 0
- magnitude :: Rational
- magnitude = 10 ^^ zeroes
- withoutFactor :: Integer -> Integer -> Integer
- withoutFactor _ 0 = 0
- withoutFactor p n
- | (n', 0) <- divMod n p = withoutFactor p n'
- | otherwise = n
- -- | Expects the argument 0 <= x < 1
- decimals :: Rational -> Doc
- decimals x
- | x == 0 = empty
- | otherwise = integer n <> decimals d
- where (n, d) = properFraction (x * 10)
-
-bytesToString :: [Word8] -> String
-bytesToString = map (chr . fromIntegral)
-
-pprString :: String -> Doc
--- Print newlines as newlines with Haskell string escape notation,
--- not as '\n'. For other non-printables use regular escape notation.
-pprString s = vcat (map text (showMultiLineString s))
-
-------------------------------
-instance Ppr Pat where
- ppr = pprPat noPrec
-
-pprPat :: Precedence -> Pat -> Doc
-pprPat i (LitP l) = pprLit i l
-pprPat _ (VarP v) = pprName' Applied v
-pprPat i (TupP ps)
- | [_] <- ps
- = pprPat i (ConP (tupleDataName 1) [] ps)
- | otherwise
- = parens (commaSep ps)
-pprPat _ (UnboxedTupP ps) = hashParens (commaSep ps)
-pprPat _ (UnboxedSumP p alt arity) = unboxedSumBars (ppr p) alt arity
-pprPat i (ConP s ts ps) = parensIf (i >= appPrec) $
- pprName' Applied s
- <+> sep (map (\t -> char '@' <> pprParendType t) ts)
- <+> sep (map (pprPat appPrec) ps)
-pprPat _ (ParensP p) = parens $ pprPat noPrec p
-pprPat i (UInfixP p1 n p2)
- = parensIf (i > unopPrec) (pprPat unopPrec p1 <+>
- pprName' Infix n <+>
- pprPat unopPrec p2)
-pprPat i (InfixP p1 n p2)
- = parensIf (i >= opPrec) (pprPat opPrec p1 <+>
- pprName' Infix n <+>
- pprPat opPrec p2)
-pprPat i (TildeP p) = parensIf (i > noPrec) $ char '~' <> pprPat appPrec p
-pprPat i (BangP p) = parensIf (i > noPrec) $ char '!' <> pprPat appPrec p
-pprPat i (AsP v p) = parensIf (i > noPrec) $ ppr v <> text "@"
- <> pprPat appPrec p
-pprPat _ WildP = text "_"
-pprPat _ (RecP nm fs)
- = parens $ pprName' Applied nm
- <+> braces (sep $ punctuate comma $
- map (\(s,p) -> pprName' Applied s <+> equals <+> ppr p) fs)
-pprPat _ (ListP ps) = brackets (commaSep ps)
-pprPat i (SigP p t) = parensIf (i > noPrec) $ ppr p <+> dcolon <+> ppr t
-pprPat _ (ViewP e p) = parens $ pprExp noPrec e <+> text "->" <+> pprPat noPrec p
-pprPat _ (TypeP t) = parens $ text "type" <+> ppr t
-pprPat _ (InvisP t) = parens $ text "@" <+> ppr t
-
-------------------------------
-instance Ppr Dec where
- ppr = ppr_dec True
-
-ppr_dec :: Bool -- ^ declaration on the toplevel?
- -> Dec
- -> Doc
-ppr_dec isTop (FunD f cs) = layout $ map (\c -> pprPrefixOcc f <+> ppr c) cs
- where
- layout :: [Doc] -> Doc
- layout = if isTop then vcat else semiSepWith id
-ppr_dec _ (ValD p r ds) = ppr p <+> pprBody True r
- $$ where_clause ds
-ppr_dec _ (TySynD t xs rhs)
- = ppr_tySyn empty (Just t) (hsep (map ppr xs)) rhs
-ppr_dec isTop (DataD ctxt t xs ksig cs decs)
- = ppr_data isTop empty ctxt (Just t) (hsep (map ppr xs)) ksig cs decs
-ppr_dec isTop (NewtypeD ctxt t xs ksig c decs)
- = ppr_newtype isTop empty ctxt (Just t) (sep (map ppr xs)) ksig c decs
-ppr_dec isTop (TypeDataD t xs ksig cs)
- = ppr_type_data isTop empty [] (Just t) (hsep (map ppr xs)) ksig cs []
-ppr_dec _ (ClassD ctxt c xs fds ds)
- = text "class" <+> pprCxt ctxt <+> pprName' Applied c <+> hsep (map ppr xs) <+> ppr fds
- $$ where_clause ds
-ppr_dec _ (InstanceD o ctxt i ds) =
- text "instance" <+> maybe empty ppr_overlap o <+> pprCxt ctxt <+> ppr i
- $$ where_clause ds
-ppr_dec _ (SigD f t) = pprPrefixOcc f <+> dcolon <+> ppr t
-ppr_dec _ (KiSigD f k) = text "type" <+> pprPrefixOcc f <+> dcolon <+> ppr k
-ppr_dec _ (ForeignD f) = ppr f
-ppr_dec _ (InfixD fx ns_spec n) = pprFixity n fx ns_spec
-ppr_dec _ (DefaultD tys) =
- text "default" <+> parens (sep $ punctuate comma $ map ppr tys)
-ppr_dec _ (PragmaD p) = ppr p
-ppr_dec isTop (DataFamilyD tc tvs kind)
- = text "data" <+> maybeFamily <+> pprName' Applied tc <+> hsep (map ppr tvs) <+> maybeKind
- where
- maybeFamily | isTop = text "family"
- | otherwise = empty
- maybeKind | (Just k') <- kind = dcolon <+> ppr k'
- | otherwise = empty
-ppr_dec isTop (DataInstD ctxt bndrs ty ksig cs decs)
- = ppr_data isTop (maybeInst <+> ppr_bndrs bndrs)
- ctxt Nothing (ppr ty) ksig cs decs
- where
- maybeInst | isTop = text "instance"
- | otherwise = empty
-ppr_dec isTop (NewtypeInstD ctxt bndrs ty ksig c decs)
- = ppr_newtype isTop (maybeInst <+> ppr_bndrs bndrs)
- ctxt Nothing (ppr ty) ksig c decs
- where
- maybeInst | isTop = text "instance"
- | otherwise = empty
-ppr_dec isTop (TySynInstD (TySynEqn mb_bndrs ty rhs))
- = ppr_tySyn (maybeInst <+> ppr_bndrs mb_bndrs)
- Nothing (ppr ty) rhs
- where
- maybeInst | isTop = text "instance"
- | otherwise = empty
-ppr_dec isTop (OpenTypeFamilyD tfhead)
- = text "type" <+> maybeFamily <+> ppr_tf_head tfhead
- where
- maybeFamily | isTop = text "family"
- | otherwise = empty
-ppr_dec _ (ClosedTypeFamilyD tfhead eqns)
- = hang (text "type family" <+> ppr_tf_head tfhead <+> text "where")
- nestDepth (vcat (map ppr_eqn eqns))
- where
- ppr_eqn (TySynEqn mb_bndrs lhs rhs)
- = ppr_bndrs mb_bndrs <+> ppr lhs <+> text "=" <+> ppr rhs
-ppr_dec _ (RoleAnnotD name roles)
- = hsep [ text "type role", pprName' Applied name ] <+> hsep (map ppr roles)
-ppr_dec _ (StandaloneDerivD ds cxt ty)
- = hsep [ text "deriving"
- , maybe empty ppr_deriv_strategy ds
- , text "instance"
- , pprCxt cxt
- , ppr ty ]
-ppr_dec _ (DefaultSigD n ty)
- = hsep [ text "default", pprPrefixOcc n, dcolon, ppr ty ]
-ppr_dec _ (PatSynD name args dir pat)
- = text "pattern" <+> pprNameArgs <+> ppr dir <+> pprPatRHS
- where
- pprNameArgs | InfixPatSyn a1 a2 <- args = ppr a1 <+> pprName' Infix name <+> ppr a2
- | otherwise = pprName' Applied name <+> ppr args
- pprPatRHS | ExplBidir cls <- dir = hang (ppr pat <+> text "where")
- nestDepth
- (vcat $ (pprName' Applied name <+>) . ppr <$> cls)
- | otherwise = ppr pat
-ppr_dec _ (PatSynSigD name ty)
- = pprPatSynSig name ty
-ppr_dec _ (ImplicitParamBindD n e)
- = hsep [text ('?' : n), text "=", ppr e]
-
-ppr_deriv_strategy :: DerivStrategy -> Doc
-ppr_deriv_strategy ds =
- case ds of
- StockStrategy -> text "stock"
- AnyclassStrategy -> text "anyclass"
- NewtypeStrategy -> text "newtype"
- ViaStrategy ty -> text "via" <+> pprParendType ty
-
-ppr_overlap :: Overlap -> Doc
-ppr_overlap o = text $
- case o of
- Overlaps -> "{-# OVERLAPS #-}"
- Overlappable -> "{-# OVERLAPPABLE #-}"
- Overlapping -> "{-# OVERLAPPING #-}"
- Incoherent -> "{-# INCOHERENT #-}"
-
-ppr_data :: Bool -- ^ declaration on the toplevel?
- -> Doc -> Cxt -> Maybe Name -> Doc -> Maybe Kind -> [Con] -> [DerivClause]
- -> Doc
-ppr_data = ppr_typedef "data"
-
-ppr_newtype :: Bool -- ^ declaration on the toplevel?
- -> Doc -> Cxt -> Maybe Name -> Doc -> Maybe Kind -> Con -> [DerivClause]
- -> Doc
-ppr_newtype isTop maybeInst ctxt t argsDoc ksig c decs
- = ppr_typedef "newtype" isTop maybeInst ctxt t argsDoc ksig [c] decs
-
-ppr_type_data :: Bool -- ^ declaration on the toplevel?
- -> Doc -> Cxt -> Maybe Name -> Doc -> Maybe Kind -> [Con] -> [DerivClause]
- -> Doc
-ppr_type_data = ppr_typedef "type data"
-
-ppr_typedef :: String -> Bool -> Doc -> Cxt -> Maybe Name -> Doc -> Maybe Kind -> [Con] -> [DerivClause] -> Doc
-ppr_typedef data_or_newtype isTop maybeInst ctxt t argsDoc ksig cs decs
- = sep [text data_or_newtype <+> maybeInst
- <+> pprCxt ctxt
- <+> case t of
- Just n -> pprName' Applied n <+> argsDoc
- Nothing -> argsDoc
- <+> ksigDoc <+> maybeWhere,
- nest nestDepth (layout (pref $ map ppr cs)),
- if null decs
- then empty
- else nest nestDepth
- $ vcat $ map ppr_deriv_clause decs]
- where
- pref :: [Doc] -> [Doc]
- pref xs | isGadtDecl = xs
- pref [] = [] -- No constructors; can't happen in H98
- pref (d:ds) = (char '=' <+> d):map (bar <+>) ds
-
- layout :: [Doc] -> Doc
- layout | isGadtDecl && not isTop = braces . semiSepWith id
- | otherwise = vcat
-
- maybeWhere :: Doc
- maybeWhere | isGadtDecl = text "where"
- | otherwise = empty
-
- isGadtDecl :: Bool
- isGadtDecl = not (null cs) && all isGadtCon cs
- where isGadtCon (GadtC _ _ _ ) = True
- isGadtCon (RecGadtC _ _ _) = True
- isGadtCon (ForallC _ _ x ) = isGadtCon x
- isGadtCon _ = False
-
- ksigDoc = case ksig of
- Nothing -> empty
- Just k -> dcolon <+> ppr k
-
-
-ppr_deriv_clause :: DerivClause -> Doc
-ppr_deriv_clause (DerivClause ds ctxt)
- = text "deriving" <+> pp_strat_before
- <+> ppr_cxt_preds appPrec ctxt
- <+> pp_strat_after
- where
- -- @via@ is unique in that in comes /after/ the class being derived,
- -- so we must special-case it.
- (pp_strat_before, pp_strat_after) =
- case ds of
- Just (via@ViaStrategy{}) -> (empty, ppr_deriv_strategy via)
- _ -> (maybe empty ppr_deriv_strategy ds, empty)
-
-ppr_tySyn :: Doc -> Maybe Name -> Doc -> Type -> Doc
-ppr_tySyn maybeInst t argsDoc rhs
- = text "type" <+> maybeInst
- <+> case t of
- Just n -> pprName' Applied n <+> argsDoc
- Nothing -> argsDoc
- <+> text "=" <+> ppr rhs
-
-ppr_tf_head :: TypeFamilyHead -> Doc
-ppr_tf_head (TypeFamilyHead tc tvs res inj)
- = pprName' Applied tc <+> hsep (map ppr tvs) <+> ppr res <+> maybeInj
- where
- maybeInj | (Just inj') <- inj = ppr inj'
- | otherwise = empty
-
-ppr_bndrs :: PprFlag flag => Maybe [TyVarBndr flag] -> Doc
-ppr_bndrs (Just bndrs) = text "forall" <+> sep (map ppr bndrs) <> text "."
-ppr_bndrs Nothing = empty
-
-------------------------------
-instance Ppr FunDep where
- ppr (FunDep xs ys) = hsep (map ppr xs) <+> text "->" <+> hsep (map ppr ys)
- ppr_list [] = empty
- ppr_list xs = bar <+> commaSep xs
-
-------------------------------
-instance Ppr FamilyResultSig where
- ppr NoSig = empty
- ppr (KindSig k) = dcolon <+> ppr k
- ppr (TyVarSig bndr) = text "=" <+> ppr bndr
-
-------------------------------
-instance Ppr InjectivityAnn where
- ppr (InjectivityAnn lhs rhs) =
- bar <+> ppr lhs <+> text "->" <+> hsep (map ppr rhs)
-
-------------------------------
-instance Ppr Foreign where
- ppr (ImportF callconv safety impent as typ)
- = text "foreign import"
- <+> showtextl callconv
- <+> showtextl safety
- <+> text (show impent)
- <+> pprName' Applied as
- <+> dcolon <+> ppr typ
- ppr (ExportF callconv expent as typ)
- = text "foreign export"
- <+> showtextl callconv
- <+> text (show expent)
- <+> pprName' Applied as
- <+> dcolon <+> ppr typ
-
-------------------------------
-instance Ppr Pragma where
- ppr (InlineP n inline rm phases)
- = text "{-#"
- <+> ppr inline
- <+> ppr rm
- <+> ppr phases
- <+> pprName' Applied n
- <+> text "#-}"
- ppr (OpaqueP n)
- = text "{-# OPAQUE" <+> pprName' Applied n <+> text "#-}"
- ppr (SpecialiseP n ty inline phases)
- = text "{-# SPECIALISE"
- <+> maybe empty ppr inline
- <+> ppr phases
- <+> sep [ pprName' Applied n <+> dcolon
- , nest 2 $ ppr ty ]
- <+> text "#-}"
- ppr (SpecialiseInstP inst)
- = text "{-# SPECIALISE instance" <+> ppr inst <+> text "#-}"
- ppr (RuleP n ty_bndrs tm_bndrs lhs rhs phases)
- = sep [ text "{-# RULES" <+> pprString n <+> ppr phases
- , nest 4 $ ppr_ty_forall ty_bndrs <+> ppr_tm_forall ty_bndrs
- <+> ppr lhs
- , nest 4 $ char '=' <+> ppr rhs <+> text "#-}" ]
- where ppr_ty_forall Nothing = empty
- ppr_ty_forall (Just bndrs) = text "forall"
- <+> fsep (map ppr bndrs)
- <+> char '.'
- ppr_tm_forall Nothing | null tm_bndrs = empty
- ppr_tm_forall _ = text "forall"
- <+> fsep (map ppr tm_bndrs)
- <+> char '.'
- ppr (AnnP tgt expr)
- = text "{-# ANN" <+> target1 tgt <+> ppr expr <+> text "#-}"
- where target1 ModuleAnnotation = text "module"
- target1 (TypeAnnotation t) = text "type" <+> pprName' Applied t
- target1 (ValueAnnotation v) = pprName' Applied v
- ppr (LineP line file)
- = text "{-# LINE" <+> int line <+> text (show file) <+> text "#-}"
- ppr (CompleteP cls mty)
- = text "{-# COMPLETE" <+> (fsep $ punctuate comma $ map (pprName' Applied) cls)
- <+> maybe empty (\ty -> dcolon <+> pprName' Applied ty) mty <+> text "#-}"
- ppr (SCCP nm str)
- = text "{-# SCC" <+> pprName' Applied nm <+> maybe empty pprString str <+> text "#-}"
-
-------------------------------
-instance Ppr Inline where
- ppr NoInline = text "NOINLINE"
- ppr Inline = text "INLINE"
- ppr Inlinable = text "INLINABLE"
-
-------------------------------
-instance Ppr RuleMatch where
- ppr ConLike = text "CONLIKE"
- ppr FunLike = empty
-
-------------------------------
-instance Ppr Phases where
- ppr AllPhases = empty
- ppr (FromPhase i) = brackets $ int i
- ppr (BeforePhase i) = brackets $ char '~' <> int i
-
-------------------------------
-instance Ppr RuleBndr where
- ppr (RuleVar n) = ppr n
- ppr (TypedRuleVar n ty) = parens $ ppr n <+> dcolon <+> ppr ty
-
-------------------------------
-instance Ppr Clause where
- ppr = pprClause True
-
-------------------------------
-instance Ppr Con where
- ppr (NormalC c sts) = pprName' Applied c <+> sep (map pprBangType sts)
-
- ppr (RecC c vsts)
- = pprName' Applied c <+> braces (sep (punctuate comma $ map pprVarBangType vsts))
-
- ppr (InfixC st1 c st2) = pprBangType st1
- <+> pprName' Infix c
- <+> pprBangType st2
-
- ppr (ForallC ns ctxt (GadtC cs sts ty))
- = commaSepApplied cs <+> dcolon <+> pprForall ns ctxt
- <+> pprGadtRHS sts ty
-
- ppr (ForallC ns ctxt (RecGadtC cs vsts ty))
- = commaSepApplied cs <+> dcolon <+> pprForall ns ctxt
- <+> pprRecFields vsts ty
-
- ppr (ForallC ns ctxt con)
- = pprForall ns ctxt <+> ppr con
-
- ppr (GadtC cs sts ty)
- = commaSepApplied cs <+> dcolon <+> pprGadtRHS sts ty
-
- ppr (RecGadtC cs vsts ty)
- = commaSepApplied cs <+> dcolon <+> pprRecFields vsts ty
-
-instance Ppr PatSynDir where
- ppr Unidir = text "<-"
- ppr ImplBidir = text "="
- ppr (ExplBidir _) = text "<-"
- -- the ExplBidir's clauses are pretty printed together with the
- -- entire pattern synonym; so only print the direction here.
-
-instance Ppr PatSynArgs where
- ppr (PrefixPatSyn args) = sep $ map ppr args
- ppr (InfixPatSyn a1 a2) = ppr a1 <+> ppr a2
- ppr (RecordPatSyn sels) = braces $ sep (punctuate comma (map (pprName' Applied) sels))
-
-commaSepApplied :: [Name] -> Doc
-commaSepApplied = commaSepWith (pprName' Applied)
-
-pprForall :: [TyVarBndr Specificity] -> Cxt -> Doc
-pprForall = pprForall' ForallInvis
-
-pprForallVis :: [TyVarBndr ()] -> Cxt -> Doc
-pprForallVis = pprForall' ForallVis
-
-pprForall' :: PprFlag flag => ForallVisFlag -> [TyVarBndr flag] -> Cxt -> Doc
-pprForall' fvf tvs cxt
- -- even in the case without any tvs, there could be a non-empty
- -- context cxt (e.g., in the case of pattern synonyms, where there
- -- are multiple forall binders and contexts).
- | [] <- tvs = pprCxt cxt
- | otherwise = text "forall" <+> hsep (map ppr tvs)
- <+> separator <+> pprCxt cxt
- where
- separator = case fvf of
- ForallVis -> text "->"
- ForallInvis -> char '.'
-
-pprRecFields :: [(Name, Strict, Type)] -> Type -> Doc
-pprRecFields vsts ty
- = braces (sep (punctuate comma $ map pprVarBangType vsts))
- <+> arrow <+> ppr ty
-
-pprGadtRHS :: [(Strict, Type)] -> Type -> Doc
-pprGadtRHS [] ty
- = ppr ty
-pprGadtRHS sts ty
- = sep (punctuate (space <> arrow) (map pprBangType sts))
- <+> arrow <+> ppr ty
-
-------------------------------
-pprVarBangType :: VarBangType -> Doc
--- Slight infelicity: with print non-atomic type with parens
-pprVarBangType (v, bang, t) = pprName' Applied v <+> dcolon <+> pprBangType (bang, t)
-
-------------------------------
-pprBangType :: BangType -> Doc
--- Make sure we print
---
--- Con {-# UNPACK #-} a
---
--- rather than
---
--- Con {-# UNPACK #-}a
---
--- when there's no strictness annotation. If there is a strictness annotation,
--- it's okay to not put a space between it and the type.
-pprBangType (bt@(Bang _ NoSourceStrictness), t) = ppr bt <+> pprParendType t
-pprBangType (bt, t) = ppr bt <> pprParendType t
-
-------------------------------
-instance Ppr Bang where
- ppr (Bang su ss) = ppr su <+> ppr ss
-
-------------------------------
-instance Ppr SourceUnpackedness where
- ppr NoSourceUnpackedness = empty
- ppr SourceNoUnpack = text "{-# NOUNPACK #-}"
- ppr SourceUnpack = text "{-# UNPACK #-}"
-
-------------------------------
-instance Ppr SourceStrictness where
- ppr NoSourceStrictness = empty
- ppr SourceLazy = char '~'
- ppr SourceStrict = char '!'
-
-------------------------------
-instance Ppr DecidedStrictness where
- ppr DecidedLazy = empty
- ppr DecidedStrict = char '!'
- ppr DecidedUnpack = text "{-# UNPACK #-} !"
-
-------------------------------
-{-# DEPRECATED pprVarStrictType
- "As of @template-haskell-2.11.0.0@, 'VarStrictType' has been replaced by 'VarBangType'. Please use 'pprVarBangType' instead." #-}
-pprVarStrictType :: (Name, Strict, Type) -> Doc
-pprVarStrictType = pprVarBangType
-
-------------------------------
-{-# DEPRECATED pprStrictType
- "As of @template-haskell-2.11.0.0@, 'StrictType' has been replaced by 'BangType'. Please use 'pprBangType' instead." #-}
-pprStrictType :: (Strict, Type) -> Doc
-pprStrictType = pprBangType
-
-------------------------------
-pprType :: Precedence -> Type -> Doc
-pprType _ (VarT v) = pprName' Applied v
--- `Applied` is used here instead of `ppr` because of infix names (#13887)
-pprType _ (ConT c) = pprName' Applied c
-pprType _ (TupleT 0) = text "()"
-pprType p (TupleT 1) = pprType p (ConT (tupleTypeName 1))
-pprType _ (TupleT n) = parens (hcat (replicate (n-1) comma))
-pprType _ (UnboxedTupleT n) = hashParens $ hcat $ replicate (n-1) comma
-pprType _ (UnboxedSumT arity) = hashParens $ hcat $ replicate (arity-1) bar
-pprType _ ArrowT = parens (text "->")
-pprType _ MulArrowT = text "FUN"
-pprType _ ListT = text "[]"
-pprType _ (LitT l) = pprTyLit l
-pprType _ (PromotedT c) = text "'" <> pprName' Applied c
-pprType _ (PromotedTupleT 0) = text "'()"
-pprType p (PromotedTupleT 1) = pprType p (PromotedT (tupleDataName 1))
-pprType _ (PromotedTupleT n) = quoteParens (hcat (replicate (n-1) comma))
-pprType _ PromotedNilT = text "'[]"
-pprType _ PromotedConsT = text "'(:)"
-pprType _ StarT = char '*'
-pprType _ ConstraintT = text "Constraint"
-pprType _ (SigT ty k) = parens (ppr ty <+> text "::" <+> ppr k)
-pprType _ WildCardT = char '_'
-pprType p t@(InfixT {}) = pprInfixT p t
-pprType p t@(UInfixT {}) = pprInfixT p t
-pprType p t@(PromotedInfixT {}) = pprInfixT p t
-pprType p t@(PromotedUInfixT {}) = pprInfixT p t
-pprType _ (ParensT t) = parens (pprType noPrec t)
-pprType p (ImplicitParamT n ty) =
- parensIf (p >= sigPrec) $ text ('?':n) <+> text "::" <+> pprType sigPrec ty
-pprType _ EqualityT = text "(~)"
-pprType p (ForallT tvars ctxt ty) =
- parensIf (p >= funPrec) $ sep [pprForall tvars ctxt, pprType qualPrec ty]
-pprType p (ForallVisT tvars ty) =
- parensIf (p >= funPrec) $ sep [pprForallVis tvars [], pprType qualPrec ty]
-pprType p t@AppT{} = pprTyApp p (split t)
-pprType p t@AppKindT{} = pprTyApp p (split t)
-
-------------------------------
-pprParendType :: Type -> Doc
-pprParendType = pprType appPrec
-
-pprInfixT :: Precedence -> Type -> Doc
-pprInfixT p = \case
- InfixT x n y -> with x n y "" opPrec
- UInfixT x n y -> with x n y "" unopPrec
- PromotedInfixT x n y -> with x n y "'" opPrec
- PromotedUInfixT x n y -> with x n y "'" unopPrec
- t -> pprParendType t
- where
- with x n y prefix p' =
- parensIf
- (p >= p')
- (pprType opPrec x <+> text prefix <> pprName' Infix n <+> pprType opPrec y)
-
-instance Ppr Type where
- ppr = pprType noPrec
-instance Ppr TypeArg where
- ppr (TANormal ty) = ppr ty
- ppr (TyArg ki) = char '@' <> parensIf (isStarT ki) (ppr ki)
-
-pprParendTypeArg :: TypeArg -> Doc
-pprParendTypeArg (TANormal ty) = pprParendType ty
-pprParendTypeArg (TyArg ki) = char '@' <> parensIf (isStarT ki) (pprParendType ki)
-
-isStarT :: Type -> Bool
-isStarT StarT = True
-isStarT _ = False
-
-{- Note [Pretty-printing kind signatures]
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-GHC's parser only recognises a kind signature in a type when there are
-parens around it. E.g. the parens are required here:
- f :: (Int :: *)
- type instance F Int = (Bool :: *)
-So we always print a SigT with parens (see #10050). -}
-
-pprTyApp :: Precedence -> (Type, [TypeArg]) -> Doc
-pprTyApp p app@(MulArrowT, [TANormal (PromotedT c), TANormal arg1, TANormal arg2])
- | p >= funPrec = parens (pprTyApp noPrec app)
- | c == oneName = sep [pprFunArgType arg1 <+> text "%1 ->", pprType qualPrec arg2]
- | c == manyName = sep [pprFunArgType arg1 <+> text "->", pprType qualPrec arg2]
-pprTyApp p (MulArrowT, [TANormal argm, TANormal arg1, TANormal arg2]) =
- parensIf (p >= funPrec) $
- sep [pprFunArgType arg1 <+> text "%" <> pprType appPrec argm <+> text "->",
- pprType qualPrec arg2]
-pprTyApp p (ArrowT, [TANormal arg1, TANormal arg2]) =
- parensIf (p >= funPrec) $
- sep [pprFunArgType arg1 <+> text "->", pprType qualPrec arg2]
-pprTyApp p (EqualityT, [TANormal arg1, TANormal arg2]) =
- parensIf (p >= opPrec) $
- sep [pprType opPrec arg1 <+> text "~", pprType opPrec arg2]
-pprTyApp _ (ListT, [TANormal arg]) = brackets (pprType noPrec arg)
-pprTyApp p (TupleT 1, args) = pprTyApp p (ConT (tupleTypeName 1), args)
-pprTyApp _ (TupleT n, args)
- | length args == n, Just args' <- traverse fromTANormal args
- = parens (commaSep args')
-pprTyApp p (PromotedTupleT 1, args) = pprTyApp p (PromotedT (tupleDataName 1), args)
-pprTyApp _ (PromotedTupleT n, args)
- | length args == n, Just args' <- traverse fromTANormal args
- = quoteParens (commaSep args')
-pprTyApp p (fun, args) =
- parensIf (p >= appPrec) $ pprParendType fun <+> sep (map pprParendTypeArg args)
-
-fromTANormal :: TypeArg -> Maybe Type
-fromTANormal (TANormal arg) = Just arg
-fromTANormal (TyArg _) = Nothing
-
--- Print the type to the left of @->@. Everything except forall and (->) binds more tightly than (->).
-pprFunArgType :: Type -> Doc
-pprFunArgType = pprType funPrec
-
-data ForallVisFlag = ForallVis -- forall a -> {...}
- | ForallInvis -- forall a. {...}
- deriving Show
-
-data TypeArg = TANormal Type
- | TyArg Kind
-
-split :: Type -> (Type, [TypeArg]) -- Split into function and args
-split t = go t []
- where go (AppT t1 t2) args = go t1 (TANormal t2:args)
- go (AppKindT ty ki) args = go ty (TyArg ki:args)
- go ty args = (ty, args)
-
-pprTyLit :: TyLit -> Doc
-pprTyLit (NumTyLit n) = integer n
-pprTyLit (StrTyLit s) = text (show s)
-pprTyLit (CharTyLit c) = text (show c)
-
-instance Ppr TyLit where
- ppr = pprTyLit
-
-------------------------------
-class PprFlag flag where
- pprTyVarBndr :: (TyVarBndr flag) -> Doc
-
-instance PprFlag () where
- pprTyVarBndr (PlainTV nm ()) = ppr nm
- pprTyVarBndr (KindedTV nm () k) = parens (ppr nm <+> dcolon <+> ppr k)
-
-instance PprFlag Specificity where
- pprTyVarBndr (PlainTV nm SpecifiedSpec) = ppr nm
- pprTyVarBndr (PlainTV nm InferredSpec) = braces (ppr nm)
- pprTyVarBndr (KindedTV nm SpecifiedSpec k) = parens (ppr nm <+> dcolon <+> ppr k)
- pprTyVarBndr (KindedTV nm InferredSpec k) = braces (ppr nm <+> dcolon <+> ppr k)
-
-instance PprFlag BndrVis where
- pprTyVarBndr (PlainTV nm vis) = pprBndrVis vis (ppr nm)
- pprTyVarBndr (KindedTV nm vis k) = pprBndrVis vis (parens (ppr nm <+> dcolon <+> ppr k))
-
-pprBndrVis :: BndrVis -> Doc -> Doc
-pprBndrVis BndrReq d = d
-pprBndrVis BndrInvis d = char '@' <> d
-
-instance PprFlag flag => Ppr (TyVarBndr flag) where
- ppr bndr = pprTyVarBndr bndr
-
-instance Ppr Role where
- ppr NominalR = text "nominal"
- ppr RepresentationalR = text "representational"
- ppr PhantomR = text "phantom"
- ppr InferR = text "_"
-
-------------------------------
-pprCxt :: Cxt -> Doc
-pprCxt [] = empty
-pprCxt ts = ppr_cxt_preds funPrec ts <+> text "=>"
-
-ppr_cxt_preds :: Precedence -> Cxt -> Doc
-ppr_cxt_preds _ [] = text "()"
-ppr_cxt_preds p [t] = pprType p t
-ppr_cxt_preds _ ts = parens (commaSep ts)
-
-------------------------------
-instance Ppr Range where
- ppr = brackets . pprRange
- where pprRange :: Range -> Doc
- pprRange (FromR e) = ppr e <+> text ".."
- pprRange (FromThenR e1 e2) = ppr e1 <> text ","
- <+> ppr e2 <+> text ".."
- pprRange (FromToR e1 e2) = ppr e1 <+> text ".." <+> ppr e2
- pprRange (FromThenToR e1 e2 e3) = ppr e1 <> text ","
- <+> ppr e2 <+> text ".."
- <+> ppr e3
-
-------------------------------
-where_clause :: [Dec] -> Doc
-where_clause [] = empty
-where_clause ds = nest nestDepth $ text "where" <+> braces (semiSepWith (ppr_dec False) ds)
-
-showtextl :: Show a => a -> Doc
-showtextl = text . map toLower . show
-
-hashParens :: Doc -> Doc
-hashParens d = text "(# " <> d <> text " #)"
-
-quoteParens :: Doc -> Doc
-quoteParens d = text "'(" <> d <> text ")"
-
------------------------------
-instance Ppr Loc where
- ppr (Loc { loc_module = md
- , loc_package = pkg
- , loc_start = (start_ln, start_col)
- , loc_end = (end_ln, end_col) })
- = hcat [ text pkg, colon, text md, colon
- , parens $ int start_ln <> comma <> int start_col
- , text "-"
- , parens $ int end_ln <> comma <> int end_col ]
-
--- Takes a separator and a pretty-printing function and prints a list of things
--- separated by the separator followed by space.
-sepWith :: Doc -> (a -> Doc) -> [a] -> Doc
-sepWith sepDoc pprFun = sep . punctuate sepDoc . map pprFun
-
--- Takes a list of printable things and prints them separated by commas followed
--- by space.
-commaSep :: Ppr a => [a] -> Doc
-commaSep = commaSepWith ppr
-
--- Takes a list of things and prints them with the given pretty-printing
--- function, separated by commas followed by space.
-commaSepWith :: (a -> Doc) -> [a] -> Doc
-commaSepWith pprFun = sepWith comma pprFun
-
--- Takes a list of printable things and prints them separated by semicolons
--- followed by space.
-semiSep :: Ppr a => [a] -> Doc
-semiSep = sep . punctuate semi . map ppr
-
--- Takes a list of things and prints them with the given pretty-printing
--- function, separated by semicolons followed by space.
-semiSepWith :: (a -> Doc) -> [a] -> Doc
-semiSepWith pprFun = sepWith semi pprFun
-
--- Prints out the series of vertical bars that wraps an expression or pattern
--- used in an unboxed sum.
-unboxedSumBars :: Doc -> SumAlt -> SumArity -> Doc
-unboxedSumBars d alt arity = hashParens $
- bars (alt-1) <> d <> bars (arity - alt)
+module Language.Haskell.TH.Ppr
+ ( module GHC.Internal.TH.Ppr )
where
- bars i = hsep (replicate i bar)
--- Text containing the vertical bar character.
-bar :: Doc
-bar = char '|'
+import GHC.Internal.TH.Ppr
diff --git a/libraries/template-haskell/Language/Haskell/TH/PprLib.hs b/libraries/template-haskell/Language/Haskell/TH/PprLib.hs
index 84315ac63b527eecc9bffdec9b6dd0c65ddbe721..5d40557a77ff8a91202ddd12734dca1571f84851 100644
--- a/libraries/template-haskell/Language/Haskell/TH/PprLib.hs
+++ b/libraries/template-haskell/Language/Haskell/TH/PprLib.hs
@@ -1,226 +1,8 @@
-{-# LANGUAGE FlexibleInstances, Safe #-}
+{-# LANGUAGE Safe #-}
-- | Monadic front-end to Text.PrettyPrint
+module Language.Haskell.TH.PprLib
+ ( module GHC.Internal.TH.PprLib )
+ where
-module Language.Haskell.TH.PprLib (
-
- -- * The document type
- Doc, -- Abstract, instance of Show
- PprM,
-
- -- * Primitive Documents
- empty,
- semi, comma, colon, dcolon, space, equals, arrow,
- lparen, rparen, lbrack, rbrack, lbrace, rbrace,
-
- -- * Converting values into documents
- text, char, ptext,
- int, integer, float, double, rational,
-
- -- * Wrapping documents in delimiters
- parens, brackets, braces, quotes, doubleQuotes,
-
- -- * Combining documents
- (<>), (<+>), hcat, hsep,
- ($$), ($+$), vcat,
- sep, cat,
- fsep, fcat,
- nest,
- hang, punctuate,
-
- -- * Predicates on documents
- isEmpty,
-
- to_HPJ_Doc, pprName, pprName'
- ) where
-
-
-import Language.Haskell.TH.Syntax
- (Uniq, Name(..), showName', NameFlavour(..), NameIs(..))
-import qualified Text.PrettyPrint as HPJ
-import Control.Monad (liftM, liftM2, ap)
-import Language.Haskell.TH.Lib.Map ( Map )
-import qualified Language.Haskell.TH.Lib.Map as Map ( lookup, insert, empty )
-import Prelude hiding ((<>))
-
-infixl 6 <>
-infixl 6 <+>
-infixl 5 $$, $+$
-
--- ---------------------------------------------------------------------------
--- The interface
-
--- The primitive Doc values
-
-instance Show Doc where
- show d = HPJ.render (to_HPJ_Doc d)
-
-isEmpty :: Doc -> PprM Bool; -- ^ Returns 'True' if the document is empty
-
-empty :: Doc; -- ^ An empty document
-semi :: Doc; -- ^ A ';' character
-comma :: Doc; -- ^ A ',' character
-colon :: Doc; -- ^ A ':' character
-dcolon :: Doc; -- ^ A "::" string
-space :: Doc; -- ^ A space character
-equals :: Doc; -- ^ A '=' character
-arrow :: Doc; -- ^ A "->" string
-lparen :: Doc; -- ^ A '(' character
-rparen :: Doc; -- ^ A ')' character
-lbrack :: Doc; -- ^ A '[' character
-rbrack :: Doc; -- ^ A ']' character
-lbrace :: Doc; -- ^ A '{' character
-rbrace :: Doc; -- ^ A '}' character
-
-text :: String -> Doc
-ptext :: String -> Doc
-char :: Char -> Doc
-int :: Int -> Doc
-integer :: Integer -> Doc
-float :: Float -> Doc
-double :: Double -> Doc
-rational :: Rational -> Doc
-
-
-parens :: Doc -> Doc; -- ^ Wrap document in @(...)@
-brackets :: Doc -> Doc; -- ^ Wrap document in @[...]@
-braces :: Doc -> Doc; -- ^ Wrap document in @{...}@
-quotes :: Doc -> Doc; -- ^ Wrap document in @\'...\'@
-doubleQuotes :: Doc -> Doc; -- ^ Wrap document in @\"...\"@
-
--- Combining @Doc@ values
-
-(<>) :: Doc -> Doc -> Doc; -- ^Beside
-hcat :: [Doc] -> Doc; -- ^List version of '<>'
-(<+>) :: Doc -> Doc -> Doc; -- ^Beside, separated by space
-hsep :: [Doc] -> Doc; -- ^List version of '<+>'
-
-($$) :: Doc -> Doc -> Doc; -- ^Above; if there is no
- -- overlap it \"dovetails\" the two
-($+$) :: Doc -> Doc -> Doc; -- ^Above, without dovetailing.
-vcat :: [Doc] -> Doc; -- ^List version of '$$'
-
-cat :: [Doc] -> Doc; -- ^ Either hcat or vcat
-sep :: [Doc] -> Doc; -- ^ Either hsep or vcat
-fcat :: [Doc] -> Doc; -- ^ \"Paragraph fill\" version of cat
-fsep :: [Doc] -> Doc; -- ^ \"Paragraph fill\" version of sep
-
-nest :: Int -> Doc -> Doc; -- ^ Nested
-
-
--- GHC-specific ones.
-
-hang :: Doc -> Int -> Doc -> Doc; -- ^ @hang d1 n d2 = sep [d1, nest n d2]@
-punctuate :: Doc -> [Doc] -> [Doc]
- -- ^ @punctuate p [d1, ... dn] = [d1 \<> p, d2 \<> p, ... dn-1 \<> p, dn]@
-
--- ---------------------------------------------------------------------------
--- The "implementation"
-
-type State = (Map Name Name, Uniq)
-data PprM a = PprM { runPprM :: State -> (a, State) }
-
-pprName :: Name -> Doc
-pprName = pprName' Alone
-
-pprName' :: NameIs -> Name -> Doc
-pprName' ni n@(Name o (NameU _))
- = PprM $ \s@(fm, i)
- -> let (n', s') = case Map.lookup n fm of
- Just d -> (d, s)
- Nothing -> let n'' = Name o (NameU i)
- in (n'', (Map.insert n n'' fm, i + 1))
- in (HPJ.text $ showName' ni n', s')
-pprName' ni n = text $ showName' ni n
-
-{-
-instance Show Name where
- show (Name occ (NameU u)) = occString occ ++ "_" ++ show (I# u)
- show (Name occ NameS) = occString occ
- show (Name occ (NameG ns m)) = modString m ++ "." ++ occString occ
-
-data Name = Name OccName NameFlavour
-
-data NameFlavour
- | NameU Int# -- A unique local name
--}
-
-to_HPJ_Doc :: Doc -> HPJ.Doc
-to_HPJ_Doc d = fst $ runPprM d (Map.empty, 0)
-
-instance Functor PprM where
- fmap = liftM
-
-instance Applicative PprM where
- pure x = PprM $ \s -> (x, s)
- (<*>) = ap
-
-instance Monad PprM where
- m >>= k = PprM $ \s -> let (x, s') = runPprM m s
- in runPprM (k x) s'
-
-type Doc = PprM HPJ.Doc
-
--- The primitive Doc values
-
-isEmpty = liftM HPJ.isEmpty
-
-empty = return HPJ.empty
-semi = return HPJ.semi
-comma = return HPJ.comma
-colon = return HPJ.colon
-dcolon = return $ HPJ.text "::"
-space = return HPJ.space
-equals = return HPJ.equals
-arrow = return $ HPJ.text "->"
-lparen = return HPJ.lparen
-rparen = return HPJ.rparen
-lbrack = return HPJ.lbrack
-rbrack = return HPJ.rbrack
-lbrace = return HPJ.lbrace
-rbrace = return HPJ.rbrace
-
-text = return . HPJ.text
-ptext = return . HPJ.ptext
-char = return . HPJ.char
-int = return . HPJ.int
-integer = return . HPJ.integer
-float = return . HPJ.float
-double = return . HPJ.double
-rational = return . HPJ.rational
-
-
-parens = liftM HPJ.parens
-brackets = liftM HPJ.brackets
-braces = liftM HPJ.braces
-quotes = liftM HPJ.quotes
-doubleQuotes = liftM HPJ.doubleQuotes
-
--- Combining @Doc@ values
-
-(<>) = liftM2 (HPJ.<>)
-hcat = liftM HPJ.hcat . sequence
-(<+>) = liftM2 (HPJ.<+>)
-hsep = liftM HPJ.hsep . sequence
-
-($$) = liftM2 (HPJ.$$)
-($+$) = liftM2 (HPJ.$+$)
-vcat = liftM HPJ.vcat . sequence
-
-cat = liftM HPJ.cat . sequence
-sep = liftM HPJ.sep . sequence
-fcat = liftM HPJ.fcat . sequence
-fsep = liftM HPJ.fsep . sequence
-
-nest n = liftM (HPJ.nest n)
-
-hang d1 n d2 = do d1' <- d1
- d2' <- d2
- return (HPJ.hang d1' n d2')
-
--- punctuate uses the same definition as Text.PrettyPrint
-punctuate _ [] = []
-punctuate p (d:ds) = go d ds
- where
- go d' [] = [d']
- go d' (e:es) = (d' <> p) : go e es
+import GHC.Internal.TH.PprLib
diff --git a/libraries/template-haskell/Language/Haskell/TH/Quote.hs b/libraries/template-haskell/Language/Haskell/TH/Quote.hs
index 329741ebe901b08696f377f6edf6af0b51528f99..fc9560945f934fc2883290b205a7d7bb419c0861 100644
--- a/libraries/template-haskell/Language/Haskell/TH/Quote.hs
+++ b/libraries/template-haskell/Language/Haskell/TH/Quote.hs
@@ -1,4 +1,4 @@
-{-# LANGUAGE RankNTypes, ScopedTypeVariables, Safe #-}
+{-# LANGUAGE Safe #-}
{- |
Module : Language.Haskell.TH.Quote
Description : Quasi-quoting support for Template Haskell
@@ -13,33 +13,17 @@ extension is enabled, and some utility functions for manipulating
quasiquoters. Nota bene: this package does not define any parsers,
that is up to you.
-}
-module Language.Haskell.TH.Quote(
- QuasiQuoter(..),
- quoteFile,
- -- * For backwards compatibility
- dataToQa, dataToExpQ, dataToPatQ
- ) where
+module Language.Haskell.TH.Quote
+ ( QuasiQuoter(..)
+ , quoteFile
+ -- * For backwards compatibility
+ ,dataToQa, dataToExpQ, dataToPatQ
+ ) where
-import Language.Haskell.TH.Syntax
-import Prelude
+import GHC.Internal.TH.Syntax
+import GHC.Internal.TH.Quote
+import GHC.Internal.TH.Lift
--- | The 'QuasiQuoter' type, a value @q@ of this type can be used
--- in the syntax @[q| ... string to parse ...|]@. In fact, for
--- convenience, a 'QuasiQuoter' actually defines multiple quasiquoters
--- to be used in different splice contexts; if you are only interested
--- in defining a quasiquoter to be used for expressions, you would
--- define a 'QuasiQuoter' with only 'quoteExp', and leave the other
--- fields stubbed out with errors.
-data QuasiQuoter = QuasiQuoter {
- -- | Quasi-quoter for expressions, invoked by quotes like @lhs = $[q|...]@
- quoteExp :: String -> Q Exp,
- -- | Quasi-quoter for patterns, invoked by quotes like @f $[q|...] = rhs@
- quotePat :: String -> Q Pat,
- -- | Quasi-quoter for types, invoked by quotes like @f :: $[q|...]@
- quoteType :: String -> Q Type,
- -- | Quasi-quoter for declarations, invoked by top-level quotes
- quoteDec :: String -> Q [Dec]
- }
-- | 'quoteFile' takes a 'QuasiQuoter' and lifts it into one that read
-- the data out of a file. For example, suppose @asmq@ is an
@@ -48,10 +32,10 @@ data QuasiQuoter = QuasiQuoter {
-- the quote [asmq_f|foo.s|] will take input from file @"foo.s"@ instead
-- of the inline text
quoteFile :: QuasiQuoter -> QuasiQuoter
-quoteFile (QuasiQuoter { quoteExp = qe, quotePat = qp, quoteType = qt, quoteDec = qd })
+quoteFile (QuasiQuoter { quoteExp = qe, quotePat = qp, quoteType = qt, quoteDec = qd })
= QuasiQuoter { quoteExp = get qe, quotePat = get qp, quoteType = get qt, quoteDec = get qd }
where
get :: (String -> Q a) -> String -> Q a
- get old_quoter file_name = do { file_cts <- runIO (readFile file_name)
+ get old_quoter file_name = do { file_cts <- runIO (readFile file_name)
; addDependentFile file_name
; old_quoter file_cts }
diff --git a/libraries/template-haskell/Language/Haskell/TH/Syntax.hs b/libraries/template-haskell/Language/Haskell/TH/Syntax.hs
index 95aba3e034b2725c513329432278994d8d53f1a0..22e92e6c5fe61652026cfdd65867b8839718f492 100644
--- a/libraries/template-haskell/Language/Haskell/TH/Syntax.hs
+++ b/libraries/template-haskell/Language/Haskell/TH/Syntax.hs
@@ -1,20 +1,44 @@
+{-# LANGUAGE MagicHash #-}
+{-# LANGUAGE UnboxedTuples #-}
+{-# LANGUAGE TemplateHaskellQuotes #-}
+{-# LANGUAGE Trustworthy #-}
module Language.Haskell.TH.Syntax
- ( module Language.Haskell.TH.Lib.Syntax
+ ( module GHC.Internal.TH.Syntax
+ , makeRelativeToProject
+ , module GHC.Internal.TH.Lift
+ , addrToByteArrayName
+ , addrToByteArray
)
where
-import Language.Haskell.TH.Lib.Syntax
+import GHC.Internal.TH.Syntax
+import GHC.Internal.TH.Lift
+import System.FilePath
+import Data.Array.Byte
+import GHC.Exts
+import GHC.ST
+
+-- This module completely re-exports 'GHC.Internal.TH.Syntax',
+-- and exports additionally functions that depend on filepath.
+
+-- | The input is a filepath, which if relative is offset by the package root.
+makeRelativeToProject :: FilePath -> Q FilePath
+makeRelativeToProject fp | isRelative fp = do
+ root <- getPackageRoot
+ return (root </> fp)
+makeRelativeToProject fp = return fp
+
+-- The following two defintions are copied from 'Data.Byte.Array'
+-- in order to preserve the old export list of 'TH.Syntax'.
+-- They will soon be removed as part of #24782.
+
+addrToByteArrayName :: Name
+addrToByteArrayName = 'addrToByteArray
+
+addrToByteArray :: Int -> Addr# -> ByteArray
+addrToByteArray (I# len) addr = runST $ ST $
+ \s -> case newByteArray# len s of
+ (# s', mb #) -> case copyAddrToByteArray# addr mb 0# len s' of
+ s'' -> case unsafeFreezeByteArray# mb s'' of
+ (# s''', ret #) -> (# s''', ByteArray ret #)
--- The only difference between this module and Language.Haskell.TH.Lib.Syntax
--- (which it reexports fully) is that this module depends on the Internal
--- module.
---
--- We did this to fix #22229: a module importing the Syntax module to use
--- DeriveLift (Lift is defined there) would lead GHC to load the
--- interface file for the Internal module (where wired-in TH things live),
--- but the Internal module might not be built yet at this point. Adding an
--- explicit dependency from Syntax to Internal fixes this. We do this with a
--- module reexport because Internal actually depends on Syntax.
---
--- See Note [Tracking dependencies on primitives] in GHC.Internal.Base, wrinkle W4.
-import Language.Haskell.TH.Lib.Internal ()
diff --git a/libraries/template-haskell/template-haskell.cabal.in b/libraries/template-haskell/template-haskell.cabal.in
index 6b2061c12f8c766d48d7221451f2503215aeda23..2d1d9cdd28abd532bd155160c7cae64a8bd38bd5 100644
--- a/libraries/template-haskell/template-haskell.cabal.in
+++ b/libraries/template-haskell/template-haskell.cabal.in
@@ -1,8 +1,8 @@
--- WARNING: template-haskell@Suffix@.cabal is automatically generated from ../template-haskell/template-haskell.cabal.in by
+-- WARNING: template-haskell.cabal is automatically generated from template-haskell.cabal.in by
-- ../../configure. Make sure you are editing template-haskell.cabal.in, not
--- template-haskell@Suffix@.cabal.
+-- template-haskell.cabal.
-name: template-haskell@Suffix@
+name: template-haskell
version: 2.22.0.0
-- NOTE: Don't forget to update ./changelog.md
license: BSD3
@@ -20,15 +20,6 @@ description:
See <http://www.haskell.org/haskellwiki/Template_Haskell> for more
information.
-Flag bootstrap
- Description:
- Enabled when building the stage1 compiler in order to vendor the in-tree
- `template-haskell` library (including its dependency `ghc-boot-th`), while
- allowing dependencies to depend on the boot `template-haskell` library.
- See Note [Bootstrapping Template Haskell]
- Default: False
- Manual: True
-
extra-source-files: changelog.md
source-repository head
@@ -52,37 +43,24 @@ Library
exposed-modules:
Language.Haskell.TH
Language.Haskell.TH.Lib
+ Language.Haskell.TH.Lib.Internal
Language.Haskell.TH.Ppr
Language.Haskell.TH.PprLib
Language.Haskell.TH.Quote
Language.Haskell.TH.Syntax
Language.Haskell.TH.LanguageExtensions
Language.Haskell.TH.CodeDo
- Language.Haskell.TH.Lib.Internal
- Language.Haskell.TH.Lib.Syntax
-
- other-modules:
- Language.Haskell.TH.Lib.Map
build-depends:
base >= 4.11 && < 4.21,
- ghc-boot-th@Suffix@ == @ProjectVersionMunged@,
- ghc-prim,
- pretty == 1.1.*
+ ghc-boot-th == @ProjectVersionMunged@
other-modules:
System.FilePath
System.FilePath.Posix
System.FilePath.Windows
- hs-source-dirs: @SourceRoot@/vendored-filepath @SourceRoot@
+ hs-source-dirs: ./vendored-filepath .
default-extensions:
ImplicitPrelude
ghc-options: -Wall
-
- if flag(bootstrap)
- cpp-options: -DBOOTSTRAP_TH
- else
- -- We need to set the unit ID to template-haskell (without a
- -- version number) as it's magic.
- ghc-options: -this-unit-id template-haskell
diff --git a/testsuite/tests/deriving/should_compile/T14682.stderr b/testsuite/tests/deriving/should_compile/T14682.stderr
index 6ca6b90f76c295fc2e934513409b0991f1ef2f03..94aa8ae46f25161fe4e4a7ba8f49196da6623f4d 100644
--- a/testsuite/tests/deriving/should_compile/T14682.stderr
+++ b/testsuite/tests/deriving/should_compile/T14682.stderr
@@ -12,17 +12,16 @@ Derived class instances:
((GHC.Internal.Base..)
GHC.Internal.Show.showSpace (GHC.Internal.Show.showsPrec 11 b2))))
- instance Language.Haskell.TH.Lib.Syntax.Lift T14682.Foo where
- Language.Haskell.TH.Lib.Syntax.lift (T14682.Foo a1 a2)
+ instance GHC.Internal.TH.Lift.Lift T14682.Foo where
+ GHC.Internal.TH.Lift.lift (T14682.Foo a1 a2)
= [| T14682.Foo
- $(Language.Haskell.TH.Lib.Syntax.lift a1)
- $(Language.Haskell.TH.Lib.Syntax.lift a2) |]
- pending(rn) [<spn, Language.Haskell.TH.Lib.Syntax.lift a2>,
- <spn, Language.Haskell.TH.Lib.Syntax.lift a1>]
- Language.Haskell.TH.Lib.Syntax.liftTyped (T14682.Foo a1 a2)
+ $(GHC.Internal.TH.Lift.lift a1) $(GHC.Internal.TH.Lift.lift a2) |]
+ pending(rn) [<spn, GHC.Internal.TH.Lift.lift a2>,
+ <spn, GHC.Internal.TH.Lift.lift a1>]
+ GHC.Internal.TH.Lift.liftTyped (T14682.Foo a1 a2)
= [|| T14682.Foo
- $$(Language.Haskell.TH.Lib.Syntax.liftTyped a1)
- $$(Language.Haskell.TH.Lib.Syntax.liftTyped a2) ||]
+ $$(GHC.Internal.TH.Lift.liftTyped a1)
+ $$(GHC.Internal.TH.Lift.liftTyped a2) ||]
instance GHC.Internal.Data.Data.Data T14682.Foo where
GHC.Internal.Data.Data.gfoldl k z (T14682.Foo a1 a2)
diff --git a/testsuite/tests/deriving/should_compile/drv-empty-data.stderr b/testsuite/tests/deriving/should_compile/drv-empty-data.stderr
index 0fb0d6a6c41a969050f2b4f0d937967708ce7e21..77b8f7388a15b93a6679a6419063361475178a34 100644
--- a/testsuite/tests/deriving/should_compile/drv-empty-data.stderr
+++ b/testsuite/tests/deriving/should_compile/drv-empty-data.stderr
@@ -52,12 +52,10 @@ Derived class instances:
GHC.Internal.Generics.to1 (GHC.Internal.Generics.M1 x)
= case x of x -> case x of {}
- instance Language.Haskell.TH.Lib.Syntax.Lift
- (DrvEmptyData.Void a) where
- Language.Haskell.TH.Lib.Syntax.lift z
- = GHC.Internal.Base.pure (case z of {})
- Language.Haskell.TH.Lib.Syntax.liftTyped z
- = Language.Haskell.TH.Lib.Syntax.unsafeCodeCoerce
+ instance GHC.Internal.TH.Lift.Lift (DrvEmptyData.Void a) where
+ GHC.Internal.TH.Lift.lift z = GHC.Internal.Base.pure (case z of {})
+ GHC.Internal.TH.Lift.liftTyped z
+ = GHC.Internal.TH.Syntax.unsafeCodeCoerce
(GHC.Internal.Base.pure (case z of {}))
$tVoid :: GHC.Internal.Data.Data.DataType
diff --git a/testsuite/tests/driver/T20604/T20604.stdout b/testsuite/tests/driver/T20604/T20604.stdout
index 83e89b07e851e49a430af765ab94802860e8dfb6..59e41d640c745f22b345ab9f4f4c1edb81e00fd3 100644
--- a/testsuite/tests/driver/T20604/T20604.stdout
+++ b/testsuite/tests/driver/T20604/T20604.stdout
@@ -1,11 +1,5 @@
A1
A
-addDependentFile "/home/ben/ghc/ghc-compare-2/_build/stage1/lib/../lib/x86_64-linux-ghc-9.9.20230815/libHSghc-prim-0.10.0-inplace-ghc9.9.20230815.so" 1403aed32fb9af243c4cc949007c846c
-addDependentFile "/home/ben/ghc/ghc-compare-2/_build/stage1/lib/../lib/x86_64-linux-ghc-9.9.20230815/libHSghc-bignum-1.3-inplace-ghc9.9.20230815.so" 54293f8faab737bac998f6e1a1248db8
-addDependentFile "/home/ben/ghc/ghc-compare-2/_build/stage1/lib/../lib/x86_64-linux-ghc-9.9.20230815/libHSghc-internal-0.1.0.0-inplace-ghc9.9.20230815.so" a5c0e962d84d9044d44df4698becddcc
-addDependentFile "/home/ben/ghc/ghc-compare-2/_build/stage1/lib/../lib/x86_64-linux-ghc-9.9.20230815/libHSbase-4.19.0.0-inplace-ghc9.9.20230815.so" 4a90ed136fe0f89e5d0360daded517bd
-addDependentFile "/home/ben/ghc/ghc-compare-2/_build/stage1/lib/../lib/x86_64-linux-ghc-9.9.20230815/libHSghc-boot-th-9.9-inplace-ghc9.9.20230815.so" e338655f71b1d37fdfdd2504b7de6e76
-addDependentFile "/home/ben/ghc/ghc-compare-2/_build/stage1/lib/../lib/x86_64-linux-ghc-9.9.20230815/libHSarray-0.5.6.0-inplace-ghc9.9.20230815.so" 6943478e8adaa043abf7a2b38dd435a2
-addDependentFile "/home/ben/ghc/ghc-compare-2/_build/stage1/lib/../lib/x86_64-linux-ghc-9.9.20230815/libHSdeepseq-1.5.0.0-inplace-ghc9.9.20230815.so" 9974eb196694990ac6bb3c2591405de0
-addDependentFile "/home/ben/ghc/ghc-compare-2/_build/stage1/lib/../lib/x86_64-linux-ghc-9.9.20230815/libHSpretty-1.1.3.6-inplace-ghc9.9.20230815.so" 1eefc21514f5584086f62b70aa554b7d
-addDependentFile "/home/ben/ghc/ghc-compare-2/_build/stage1/lib/../lib/x86_64-linux-ghc-9.9.20230815/libHStemplate-haskell-2.21.0.0-inplace-ghc9.9.20230815.so" f85c86eb94dcce1eacd739b6e991ba2d
+addDependentFile "/home/teo/git/ghc/_build/stage1/lib/../lib/x86_64-linux-ghc-9.11.20240508/libHSghc-prim-0.11.0-inplace-ghc9.11.20240508.so" a63ccfcae8455a0abc22cfbd2ee0fee4
+addDependentFile "/home/teo/git/ghc/_build/stage1/lib/../lib/x86_64-linux-ghc-9.11.20240508/libHSghc-bignum-1.3-inplace-ghc9.11.20240508.so" fe8ae214b210d7ae50739f9b74c6d3bc
+addDependentFile "/home/teo/git/ghc/_build/stage1/lib/../lib/x86_64-linux-ghc-9.11.20240508/libHSghc-internal-9.1001.0-inplace-ghc9.11.20240508.so" cce9e35d3fb6c65a080cdb8a570f3caf
diff --git a/testsuite/tests/interface-stability/base-exports.stdout b/testsuite/tests/interface-stability/base-exports.stdout
index 467ab80b9ca327ddd1e96fd0e8b435e9b311529e..968f297ea5289bcad9f6311cd6a2ee6f97369cdd 100644
--- a/testsuite/tests/interface-stability/base-exports.stdout
+++ b/testsuite/tests/interface-stability/base-exports.stdout
@@ -10891,7 +10891,6 @@ module Unsafe.Coerce where
-- Instances:
-instance Control.Monad.IO.Class.MonadIO GHC.Types.IO -- Defined in ‘Control.Monad.IO.Class’
instance [safe] Control.Monad.Zip.MonadZip GHC.Internal.Data.Ord.Down -- Defined in ‘Control.Monad.Zip’
instance [safe] Control.Monad.Zip.MonadZip GHC.Internal.Data.Semigroup.Internal.Dual -- Defined in ‘Control.Monad.Zip’
instance [safe] Control.Monad.Zip.MonadZip GHC.Internal.Data.Monoid.First -- Defined in ‘Control.Monad.Zip’
@@ -11391,6 +11390,7 @@ instance GHC.Internal.Control.Monad.Fix.MonadFix Data.Semigroup.First -- Defined
instance GHC.Internal.Control.Monad.Fix.MonadFix Data.Semigroup.Last -- Defined in ‘Data.Semigroup’
instance GHC.Internal.Control.Monad.Fix.MonadFix Data.Semigroup.Max -- Defined in ‘Data.Semigroup’
instance GHC.Internal.Control.Monad.Fix.MonadFix Data.Semigroup.Min -- Defined in ‘Data.Semigroup’
+instance GHC.Internal.Control.Monad.IO.Class.MonadIO GHC.Types.IO -- Defined in ‘GHC.Internal.Control.Monad.IO.Class’
instance forall (a :: * -> * -> *) b c. (ghc-internal-9.1001.0:GHC.Internal.Data.Typeable.Internal.Typeable a, ghc-internal-9.1001.0:GHC.Internal.Data.Typeable.Internal.Typeable b, ghc-internal-9.1001.0:GHC.Internal.Data.Typeable.Internal.Typeable c, GHC.Internal.Data.Data.Data (a b c)) => GHC.Internal.Data.Data.Data (Control.Applicative.WrappedArrow a b c) -- Defined in ‘Control.Applicative’
instance forall (m :: * -> *) a. (ghc-internal-9.1001.0:GHC.Internal.Data.Typeable.Internal.Typeable m, ghc-internal-9.1001.0:GHC.Internal.Data.Typeable.Internal.Typeable a, GHC.Internal.Data.Data.Data (m a)) => GHC.Internal.Data.Data.Data (Control.Applicative.WrappedMonad m a) -- Defined in ‘Control.Applicative’
instance forall a. GHC.Internal.Data.Data.Data a => GHC.Internal.Data.Data.Data (GHC.Internal.Functor.ZipList.ZipList a) -- Defined in ‘GHC.Internal.Functor.ZipList’
@@ -12535,6 +12535,8 @@ instance [safe] GHC.Internal.Show.Show System.Timeout.Timeout -- Defined in ‘S
instance GHC.Internal.Show.Show GHC.Internal.Text.Read.Lex.Lexeme -- Defined in ‘GHC.Internal.Text.Read.Lex’
instance GHC.Internal.Show.Show GHC.Internal.Text.Read.Lex.Number -- Defined in ‘GHC.Internal.Text.Read.Lex’
instance GHC.Internal.StaticPtr.IsStatic GHC.Internal.StaticPtr.StaticPtr -- Defined in ‘GHC.Internal.StaticPtr’
+instance GHC.Internal.TH.Lift.Lift Data.Array.Byte.ByteArray -- Defined in ‘Data.Array.Byte’
+instance forall k (a :: k). GHC.Internal.TH.Lift.Lift (Data.Fixed.Fixed a) -- Defined in ‘Data.Fixed’
instance forall a. GHC.Classes.Eq a => GHC.Classes.Eq (GHC.Internal.Base.NonEmpty a) -- Defined in ‘GHC.Internal.Base’
instance GHC.Classes.Eq GHC.Internal.Base.Void -- Defined in ‘GHC.Internal.Base’
instance forall a k (b :: k). GHC.Classes.Eq a => GHC.Classes.Eq (GHC.Internal.Data.Functor.Const.Const a b) -- Defined in ‘GHC.Internal.Data.Functor.Const’
diff --git a/testsuite/tests/interface-stability/base-exports.stdout-javascript-unknown-ghcjs b/testsuite/tests/interface-stability/base-exports.stdout-javascript-unknown-ghcjs
index 9941a4915634be4b4548ad935c6b6c0aced32a83..ef4bcf866fa6149877f34fd9a937e58b59b29708 100644
--- a/testsuite/tests/interface-stability/base-exports.stdout-javascript-unknown-ghcjs
+++ b/testsuite/tests/interface-stability/base-exports.stdout-javascript-unknown-ghcjs
@@ -13932,7 +13932,6 @@ module Unsafe.Coerce where
-- Instances:
-instance Control.Monad.IO.Class.MonadIO GHC.Types.IO -- Defined in ‘Control.Monad.IO.Class’
instance [safe] Control.Monad.Zip.MonadZip GHC.Internal.Data.Ord.Down -- Defined in ‘Control.Monad.Zip’
instance [safe] Control.Monad.Zip.MonadZip GHC.Internal.Data.Semigroup.Internal.Dual -- Defined in ‘Control.Monad.Zip’
instance [safe] Control.Monad.Zip.MonadZip GHC.Internal.Data.Monoid.First -- Defined in ‘Control.Monad.Zip’
@@ -14426,6 +14425,7 @@ instance GHC.Internal.Control.Monad.Fix.MonadFix Data.Semigroup.First -- Defined
instance GHC.Internal.Control.Monad.Fix.MonadFix Data.Semigroup.Last -- Defined in ‘Data.Semigroup’
instance GHC.Internal.Control.Monad.Fix.MonadFix Data.Semigroup.Max -- Defined in ‘Data.Semigroup’
instance GHC.Internal.Control.Monad.Fix.MonadFix Data.Semigroup.Min -- Defined in ‘Data.Semigroup’
+instance GHC.Internal.Control.Monad.IO.Class.MonadIO GHC.Types.IO -- Defined in ‘GHC.Internal.Control.Monad.IO.Class’
instance forall (a :: * -> * -> *) b c. (ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.Typeable a, ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.Typeable b, ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.Typeable c, GHC.Internal.Data.Data.Data (a b c)) => GHC.Internal.Data.Data.Data (Control.Applicative.WrappedArrow a b c) -- Defined in ‘Control.Applicative’
instance forall (m :: * -> *) a. (ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.Typeable m, ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.Typeable a, GHC.Internal.Data.Data.Data (m a)) => GHC.Internal.Data.Data.Data (Control.Applicative.WrappedMonad m a) -- Defined in ‘Control.Applicative’
instance forall a. GHC.Internal.Data.Data.Data a => GHC.Internal.Data.Data.Data (GHC.Internal.Functor.ZipList.ZipList a) -- Defined in ‘GHC.Internal.Functor.ZipList’
@@ -15567,6 +15567,8 @@ instance [safe] GHC.Internal.Show.Show System.Timeout.Timeout -- Defined in ‘S
instance GHC.Internal.Show.Show GHC.Internal.Text.Read.Lex.Lexeme -- Defined in ‘GHC.Internal.Text.Read.Lex’
instance GHC.Internal.Show.Show GHC.Internal.Text.Read.Lex.Number -- Defined in ‘GHC.Internal.Text.Read.Lex’
instance GHC.Internal.StaticPtr.IsStatic GHC.Internal.StaticPtr.StaticPtr -- Defined in ‘GHC.Internal.StaticPtr’
+instance GHC.Internal.TH.Lift.Lift Data.Array.Byte.ByteArray -- Defined in ‘Data.Array.Byte’
+instance forall k (a :: k). GHC.Internal.TH.Lift.Lift (Data.Fixed.Fixed a) -- Defined in ‘Data.Fixed’
instance forall a. GHC.Classes.Eq a => GHC.Classes.Eq (GHC.Internal.Base.NonEmpty a) -- Defined in ‘GHC.Internal.Base’
instance GHC.Classes.Eq GHC.Internal.Base.Void -- Defined in ‘GHC.Internal.Base’
instance forall a k (b :: k). GHC.Classes.Eq a => GHC.Classes.Eq (GHC.Internal.Data.Functor.Const.Const a b) -- Defined in ‘GHC.Internal.Data.Functor.Const’
diff --git a/testsuite/tests/interface-stability/base-exports.stdout-mingw32 b/testsuite/tests/interface-stability/base-exports.stdout-mingw32
index 37720c2871aed330826ed2d12daa43aeaa79822f..b288c0684ff2e9458b6711e2ae2d8ebffc8d683d 100644
--- a/testsuite/tests/interface-stability/base-exports.stdout-mingw32
+++ b/testsuite/tests/interface-stability/base-exports.stdout-mingw32
@@ -11159,7 +11159,6 @@ module Unsafe.Coerce where
-- Instances:
-instance Control.Monad.IO.Class.MonadIO GHC.Types.IO -- Defined in ‘Control.Monad.IO.Class’
instance [safe] Control.Monad.Zip.MonadZip GHC.Internal.Data.Ord.Down -- Defined in ‘Control.Monad.Zip’
instance [safe] Control.Monad.Zip.MonadZip GHC.Internal.Data.Semigroup.Internal.Dual -- Defined in ‘Control.Monad.Zip’
instance [safe] Control.Monad.Zip.MonadZip GHC.Internal.Data.Monoid.First -- Defined in ‘Control.Monad.Zip’
@@ -11655,6 +11654,7 @@ instance GHC.Internal.Control.Monad.Fix.MonadFix Data.Semigroup.First -- Defined
instance GHC.Internal.Control.Monad.Fix.MonadFix Data.Semigroup.Last -- Defined in ‘Data.Semigroup’
instance GHC.Internal.Control.Monad.Fix.MonadFix Data.Semigroup.Max -- Defined in ‘Data.Semigroup’
instance GHC.Internal.Control.Monad.Fix.MonadFix Data.Semigroup.Min -- Defined in ‘Data.Semigroup’
+instance GHC.Internal.Control.Monad.IO.Class.MonadIO GHC.Types.IO -- Defined in ‘GHC.Internal.Control.Monad.IO.Class’
instance forall (a :: * -> * -> *) b c. (ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.Typeable a, ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.Typeable b, ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.Typeable c, GHC.Internal.Data.Data.Data (a b c)) => GHC.Internal.Data.Data.Data (Control.Applicative.WrappedArrow a b c) -- Defined in ‘Control.Applicative’
instance forall (m :: * -> *) a. (ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.Typeable m, ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.Typeable a, GHC.Internal.Data.Data.Data (m a)) => GHC.Internal.Data.Data.Data (Control.Applicative.WrappedMonad m a) -- Defined in ‘Control.Applicative’
instance forall a. GHC.Internal.Data.Data.Data a => GHC.Internal.Data.Data.Data (GHC.Internal.Functor.ZipList.ZipList a) -- Defined in ‘GHC.Internal.Functor.ZipList’
@@ -12813,6 +12813,8 @@ instance [safe] GHC.Internal.Show.Show System.Timeout.Timeout -- Defined in ‘S
instance GHC.Internal.Show.Show GHC.Internal.Text.Read.Lex.Lexeme -- Defined in ‘GHC.Internal.Text.Read.Lex’
instance GHC.Internal.Show.Show GHC.Internal.Text.Read.Lex.Number -- Defined in ‘GHC.Internal.Text.Read.Lex’
instance GHC.Internal.StaticPtr.IsStatic GHC.Internal.StaticPtr.StaticPtr -- Defined in ‘GHC.Internal.StaticPtr’
+instance GHC.Internal.TH.Lift.Lift Data.Array.Byte.ByteArray -- Defined in ‘Data.Array.Byte’
+instance forall k (a :: k). GHC.Internal.TH.Lift.Lift (Data.Fixed.Fixed a) -- Defined in ‘Data.Fixed’
instance forall a. GHC.Classes.Eq a => GHC.Classes.Eq (GHC.Internal.Base.NonEmpty a) -- Defined in ‘GHC.Internal.Base’
instance GHC.Classes.Eq GHC.Internal.Base.Void -- Defined in ‘GHC.Internal.Base’
instance forall a k (b :: k). GHC.Classes.Eq a => GHC.Classes.Eq (GHC.Internal.Data.Functor.Const.Const a b) -- Defined in ‘GHC.Internal.Data.Functor.Const’
diff --git a/testsuite/tests/interface-stability/base-exports.stdout-ws-32 b/testsuite/tests/interface-stability/base-exports.stdout-ws-32
index 467ab80b9ca327ddd1e96fd0e8b435e9b311529e..968f297ea5289bcad9f6311cd6a2ee6f97369cdd 100644
--- a/testsuite/tests/interface-stability/base-exports.stdout-ws-32
+++ b/testsuite/tests/interface-stability/base-exports.stdout-ws-32
@@ -10891,7 +10891,6 @@ module Unsafe.Coerce where
-- Instances:
-instance Control.Monad.IO.Class.MonadIO GHC.Types.IO -- Defined in ‘Control.Monad.IO.Class’
instance [safe] Control.Monad.Zip.MonadZip GHC.Internal.Data.Ord.Down -- Defined in ‘Control.Monad.Zip’
instance [safe] Control.Monad.Zip.MonadZip GHC.Internal.Data.Semigroup.Internal.Dual -- Defined in ‘Control.Monad.Zip’
instance [safe] Control.Monad.Zip.MonadZip GHC.Internal.Data.Monoid.First -- Defined in ‘Control.Monad.Zip’
@@ -11391,6 +11390,7 @@ instance GHC.Internal.Control.Monad.Fix.MonadFix Data.Semigroup.First -- Defined
instance GHC.Internal.Control.Monad.Fix.MonadFix Data.Semigroup.Last -- Defined in ‘Data.Semigroup’
instance GHC.Internal.Control.Monad.Fix.MonadFix Data.Semigroup.Max -- Defined in ‘Data.Semigroup’
instance GHC.Internal.Control.Monad.Fix.MonadFix Data.Semigroup.Min -- Defined in ‘Data.Semigroup’
+instance GHC.Internal.Control.Monad.IO.Class.MonadIO GHC.Types.IO -- Defined in ‘GHC.Internal.Control.Monad.IO.Class’
instance forall (a :: * -> * -> *) b c. (ghc-internal-9.1001.0:GHC.Internal.Data.Typeable.Internal.Typeable a, ghc-internal-9.1001.0:GHC.Internal.Data.Typeable.Internal.Typeable b, ghc-internal-9.1001.0:GHC.Internal.Data.Typeable.Internal.Typeable c, GHC.Internal.Data.Data.Data (a b c)) => GHC.Internal.Data.Data.Data (Control.Applicative.WrappedArrow a b c) -- Defined in ‘Control.Applicative’
instance forall (m :: * -> *) a. (ghc-internal-9.1001.0:GHC.Internal.Data.Typeable.Internal.Typeable m, ghc-internal-9.1001.0:GHC.Internal.Data.Typeable.Internal.Typeable a, GHC.Internal.Data.Data.Data (m a)) => GHC.Internal.Data.Data.Data (Control.Applicative.WrappedMonad m a) -- Defined in ‘Control.Applicative’
instance forall a. GHC.Internal.Data.Data.Data a => GHC.Internal.Data.Data.Data (GHC.Internal.Functor.ZipList.ZipList a) -- Defined in ‘GHC.Internal.Functor.ZipList’
@@ -12535,6 +12535,8 @@ instance [safe] GHC.Internal.Show.Show System.Timeout.Timeout -- Defined in ‘S
instance GHC.Internal.Show.Show GHC.Internal.Text.Read.Lex.Lexeme -- Defined in ‘GHC.Internal.Text.Read.Lex’
instance GHC.Internal.Show.Show GHC.Internal.Text.Read.Lex.Number -- Defined in ‘GHC.Internal.Text.Read.Lex’
instance GHC.Internal.StaticPtr.IsStatic GHC.Internal.StaticPtr.StaticPtr -- Defined in ‘GHC.Internal.StaticPtr’
+instance GHC.Internal.TH.Lift.Lift Data.Array.Byte.ByteArray -- Defined in ‘Data.Array.Byte’
+instance forall k (a :: k). GHC.Internal.TH.Lift.Lift (Data.Fixed.Fixed a) -- Defined in ‘Data.Fixed’
instance forall a. GHC.Classes.Eq a => GHC.Classes.Eq (GHC.Internal.Base.NonEmpty a) -- Defined in ‘GHC.Internal.Base’
instance GHC.Classes.Eq GHC.Internal.Base.Void -- Defined in ‘GHC.Internal.Base’
instance forall a k (b :: k). GHC.Classes.Eq a => GHC.Classes.Eq (GHC.Internal.Data.Functor.Const.Const a b) -- Defined in ‘GHC.Internal.Data.Functor.Const’
diff --git a/testsuite/tests/interface-stability/template-haskell-exports.stdout b/testsuite/tests/interface-stability/template-haskell-exports.stdout
index 3c2bda6976cc526e8ead6449f87baa6f167f1b5b..ac5865c5f07db771c8ac0058f8b950eefbbd5cdc 100644
--- a/testsuite/tests/interface-stability/template-haskell-exports.stdout
+++ b/testsuite/tests/interface-stability/template-haskell-exports.stdout
@@ -2,7 +2,7 @@
module Language.Haskell.TH where
-- Safety: Safe
type AnnLookup :: *
- data AnnLookup = AnnLookupModule Language.Haskell.TH.Lib.Syntax.Module | AnnLookupName Name
+ data AnnLookup = AnnLookupModule GHC.Internal.TH.Syntax.Module | AnnLookupName Name
type AnnTarget :: *
data AnnTarget = ModuleAnnotation | TypeAnnotation Name | ValueAnnotation Name
type Arity :: *
@@ -108,8 +108,8 @@ module Language.Haskell.TH where
| MultiIfE [(Guard, Exp)]
| LetE [Dec] Exp
| CaseE Exp [Match]
- | DoE (GHC.Internal.Maybe.Maybe Language.Haskell.TH.Lib.Syntax.ModName) [Stmt]
- | MDoE (GHC.Internal.Maybe.Maybe Language.Haskell.TH.Lib.Syntax.ModName) [Stmt]
+ | DoE (GHC.Internal.Maybe.Maybe GHC.Internal.TH.Syntax.ModName) [Stmt]
+ | MDoE (GHC.Internal.Maybe.Maybe GHC.Internal.TH.Syntax.ModName) [Stmt]
| CompE [Stmt]
| ArithSeqE Range
| ListE [Exp]
@@ -298,15 +298,15 @@ module Language.Haskell.TH where
type KindQ :: *
type KindQ = Q Kind
type Lit :: *
- data Lit = CharL GHC.Types.Char | StringL GHC.Internal.Base.String | IntegerL GHC.Num.Integer.Integer | RationalL GHC.Internal.Real.Rational | IntPrimL GHC.Num.Integer.Integer | WordPrimL GHC.Num.Integer.Integer | FloatPrimL GHC.Internal.Real.Rational | DoublePrimL GHC.Internal.Real.Rational | StringPrimL [GHC.Internal.Word.Word8] | BytesPrimL Language.Haskell.TH.Lib.Syntax.Bytes | CharPrimL GHC.Types.Char
+ data Lit = CharL GHC.Types.Char | StringL GHC.Internal.Base.String | IntegerL GHC.Num.Integer.Integer | RationalL GHC.Internal.Real.Rational | IntPrimL GHC.Num.Integer.Integer | WordPrimL GHC.Num.Integer.Integer | FloatPrimL GHC.Internal.Real.Rational | DoublePrimL GHC.Internal.Real.Rational | StringPrimL [GHC.Internal.Word.Word8] | BytesPrimL GHC.Internal.TH.Syntax.Bytes | CharPrimL GHC.Types.Char
type Loc :: *
- data Loc = Loc {loc_filename :: GHC.Internal.Base.String, loc_package :: GHC.Internal.Base.String, loc_module :: GHC.Internal.Base.String, loc_start :: Language.Haskell.TH.Lib.Syntax.CharPos, loc_end :: Language.Haskell.TH.Lib.Syntax.CharPos}
+ data Loc = Loc {loc_filename :: GHC.Internal.Base.String, loc_package :: GHC.Internal.Base.String, loc_module :: GHC.Internal.Base.String, loc_start :: GHC.Internal.TH.Syntax.CharPos, loc_end :: GHC.Internal.TH.Syntax.CharPos}
type Match :: *
data Match = Match Pat Body [Dec]
type MatchQ :: *
type MatchQ = Q Match
type ModuleInfo :: *
- data ModuleInfo = ModuleInfo [Language.Haskell.TH.Lib.Syntax.Module]
+ data ModuleInfo = ModuleInfo [GHC.Internal.TH.Syntax.Module]
type Name :: *
data Name = ...
type NameSpace :: *
@@ -335,8 +335,8 @@ module Language.Haskell.TH where
data Phases = AllPhases | FromPhase GHC.Types.Int | BeforePhase GHC.Types.Int
type Ppr :: * -> Constraint
class Ppr a where
- ppr :: a -> Language.Haskell.TH.PprLib.Doc
- ppr_list :: [a] -> Language.Haskell.TH.PprLib.Doc
+ ppr :: a -> GHC.Internal.TH.PprLib.Doc
+ ppr_list :: [a] -> GHC.Internal.TH.PprLib.Doc
{-# MINIMAL ppr #-}
type Pragma :: *
data Pragma = InlineP Name Inline RuleMatch Phases | OpaqueP Name | SpecialiseP Name Type (GHC.Internal.Maybe.Maybe Inline) Phases | SpecialiseInstP Type | RuleP GHC.Internal.Base.String (GHC.Internal.Maybe.Maybe [TyVarBndr ()]) [RuleBndr] Exp Exp Phases | AnnP AnnTarget Exp | LineP GHC.Types.Int GHC.Internal.Base.String | CompleteP [Name] (GHC.Internal.Maybe.Maybe Name) | SCCP Name (GHC.Internal.Maybe.Maybe GHC.Internal.Base.String)
@@ -382,14 +382,14 @@ module Language.Haskell.TH where
type Strict :: *
type Strict = Bang
type StrictTypeQ :: *
- type StrictTypeQ = Q Language.Haskell.TH.Lib.Syntax.StrictType
+ type StrictTypeQ = Q GHC.Internal.TH.Syntax.StrictType
type SumAlt :: *
type SumAlt = GHC.Types.Int
type SumArity :: *
type SumArity = GHC.Types.Int
type role TExp nominal
type TExp :: forall (r :: GHC.Types.RuntimeRep). TYPE r -> *
- newtype TExp a = Language.Haskell.TH.Lib.Syntax.TExp {unType :: Exp}
+ newtype TExp a = GHC.Internal.TH.Syntax.TExp {unType :: Exp}
type TExpQ :: forall (r :: GHC.Types.RuntimeRep). TYPE r -> *
type TExpQ a = Q (TExp a)
type TyLit :: *
@@ -421,7 +421,7 @@ module Language.Haskell.TH where
type VarBangTypeQ :: *
type VarBangTypeQ = Q VarBangType
type VarStrictTypeQ :: *
- type VarStrictTypeQ = Q Language.Haskell.TH.Lib.Syntax.VarStrictType
+ type VarStrictTypeQ = Q GHC.Internal.TH.Syntax.VarStrictType
anyclassStrategy :: forall (m :: * -> *). Quote m => m DerivStrategy
appE :: forall (m :: * -> *). Quote m => m Exp -> m Exp -> m Exp
appK :: Kind -> Kind -> Kind
@@ -441,7 +441,7 @@ module Language.Haskell.TH where
bindS :: forall (m :: * -> *). Quote m => m Pat -> m Exp -> m Stmt
bndrInvis :: BndrVis
bndrReq :: BndrVis
- bytesPrimL :: Language.Haskell.TH.Lib.Syntax.Bytes -> Lit
+ bytesPrimL :: GHC.Internal.TH.Syntax.Bytes -> Lit
cApi :: Callconv
cCall :: Callconv
caseE :: forall (m :: * -> *). Quote m => m Exp -> [m Match] -> m Exp
@@ -494,7 +494,7 @@ module Language.Haskell.TH where
funD :: forall (m :: * -> *). Quote m => Name -> [m Clause] -> m Dec
funD_doc :: Name -> [Q Clause] -> GHC.Internal.Maybe.Maybe GHC.Internal.Base.String -> [GHC.Internal.Maybe.Maybe GHC.Internal.Base.String] -> Q Dec
funDep :: [Name] -> [Name] -> FunDep
- gadtC :: forall (m :: * -> *). Quote m => [Name] -> [m Language.Haskell.TH.Lib.Syntax.StrictType] -> m Type -> m Con
+ gadtC :: forall (m :: * -> *). Quote m => [Name] -> [m GHC.Internal.TH.Syntax.StrictType] -> m Type -> m Con
getDoc :: DocLoc -> Q (GHC.Internal.Maybe.Maybe GHC.Internal.Base.String)
getFieldE :: forall (m :: * -> *). Quote m => m Exp -> GHC.Internal.Base.String -> m Exp
guardedB :: forall (m :: * -> *). Quote m => [m (Guard, Exp)] -> m Body
@@ -503,7 +503,7 @@ module Language.Haskell.TH where
implicitParamBindD :: forall (m :: * -> *). Quote m => GHC.Internal.Base.String -> m Exp -> m Dec
implicitParamT :: forall (m :: * -> *). Quote m => GHC.Internal.Base.String -> m Type -> m Type
implicitParamVarE :: forall (m :: * -> *). Quote m => GHC.Internal.Base.String -> m Exp
- inferR :: Language.Haskell.TH.Lib.Internal.Role
+ inferR :: GHC.Internal.TH.Lib.Role
inferredSpec :: Specificity
infixApp :: forall (m :: * -> *). Quote m => m Exp -> m Exp -> m Exp -> m Exp
infixC :: forall (m :: * -> *). Quote m => m (Bang, Type) -> Name -> m (Bang, Type) -> m Con
@@ -514,7 +514,7 @@ module Language.Haskell.TH where
infixPatSyn :: forall (m :: * -> *). Quote m => Name -> Name -> m PatSynArgs
infixRD :: forall (m :: * -> *). Quote m => GHC.Types.Int -> Name -> m Dec
infixT :: forall (m :: * -> *). Quote m => m Type -> Name -> m Type -> m Type
- injectivityAnn :: Name -> [Name] -> Language.Haskell.TH.Lib.Internal.InjectivityAnn
+ injectivityAnn :: Name -> [Name] -> GHC.Internal.TH.Lib.InjectivityAnn
instanceD :: forall (m :: * -> *). Quote m => m Cxt -> m Type -> [m Dec] -> m Dec
instanceWithOverlapD :: forall (m :: * -> *). Quote m => GHC.Internal.Maybe.Maybe Overlap -> m Cxt -> m Type -> [m Dec] -> m Dec
intPrimL :: GHC.Num.Integer.Integer -> Lit
@@ -552,7 +552,7 @@ module Language.Haskell.TH where
match :: forall (m :: * -> *). Quote m => m Pat -> m Body -> [m Dec] -> m Match
maxPrecedence :: GHC.Types.Int
mdoE :: forall (m :: * -> *). Quote m => [m Stmt] -> m Exp
- mkBytes :: GHC.Internal.ForeignPtr.ForeignPtr GHC.Internal.Word.Word8 -> GHC.Types.Word -> GHC.Types.Word -> Language.Haskell.TH.Lib.Syntax.Bytes
+ mkBytes :: GHC.Internal.ForeignPtr.ForeignPtr GHC.Internal.Word.Word8 -> GHC.Types.Word -> GHC.Types.Word -> GHC.Internal.TH.Syntax.Bytes
mkName :: GHC.Internal.Base.String -> Name
moduleAnnotation :: AnnTarget
mulArrowT :: forall (m :: * -> *). Quote m => m Type
@@ -571,7 +571,7 @@ module Language.Haskell.TH where
noSig :: FamilyResultSig
noSourceStrictness :: forall (m :: * -> *). Quote m => m SourceStrictness
noSourceUnpackedness :: forall (m :: * -> *). Quote m => m SourceUnpackedness
- nominalR :: Language.Haskell.TH.Lib.Internal.Role
+ nominalR :: GHC.Internal.TH.Lib.Role
normalB :: forall (m :: * -> *). Quote m => m Exp -> m Body
normalC :: forall (m :: * -> *). Quote m => Name -> [m BangType] -> m Con
normalG :: forall (m :: * -> *). Quote m => m Exp -> m Guard
@@ -588,14 +588,14 @@ module Language.Haskell.TH where
patSynD :: forall (m :: * -> *). Quote m => Name -> m PatSynArgs -> m PatSynDir -> m Pat -> m Dec
patSynD_doc :: Name -> Q PatSynArgs -> Q PatSynDir -> Q Pat -> GHC.Internal.Maybe.Maybe GHC.Internal.Base.String -> [GHC.Internal.Maybe.Maybe GHC.Internal.Base.String] -> Q Dec
patSynSigD :: forall (m :: * -> *). Quote m => Name -> m Type -> m Dec
- phantomR :: Language.Haskell.TH.Lib.Internal.Role
+ phantomR :: GHC.Internal.TH.Lib.Role
plainBndrTV :: forall (m :: * -> *). Quote m => Name -> BndrVis -> m (TyVarBndr BndrVis)
plainInvisTV :: forall (m :: * -> *). Quote m => Name -> Specificity -> m (TyVarBndr Specificity)
plainTV :: forall flag. DefaultBndrFlag flag => Name -> TyVarBndr flag
- pprExp :: Language.Haskell.TH.Ppr.Precedence -> Exp -> Language.Haskell.TH.PprLib.Doc
- pprLit :: Language.Haskell.TH.Ppr.Precedence -> Lit -> Language.Haskell.TH.PprLib.Doc
- pprParendType :: Type -> Language.Haskell.TH.PprLib.Doc
- pprPat :: Language.Haskell.TH.Ppr.Precedence -> Pat -> Language.Haskell.TH.PprLib.Doc
+ pprExp :: GHC.Internal.TH.Ppr.Precedence -> Exp -> GHC.Internal.TH.PprLib.Doc
+ pprLit :: GHC.Internal.TH.Ppr.Precedence -> Lit -> GHC.Internal.TH.PprLib.Doc
+ pprParendType :: Type -> GHC.Internal.TH.PprLib.Doc
+ pprPat :: GHC.Internal.TH.Ppr.Precedence -> Pat -> GHC.Internal.TH.PprLib.Doc
pprint :: forall a. Ppr a => a -> GHC.Internal.Base.String
pragAnnD :: forall (m :: * -> *). Quote m => AnnTarget -> m Exp -> m Dec
pragCompleteD :: forall (m :: * -> *). Quote m => [Name] -> GHC.Internal.Maybe.Maybe Name -> m Dec
@@ -618,7 +618,7 @@ module Language.Haskell.TH where
rationalL :: GHC.Internal.Real.Rational -> Lit
recC :: forall (m :: * -> *). Quote m => Name -> [m VarBangType] -> m Con
recConE :: forall (m :: * -> *). Quote m => Name -> [m (Name, Exp)] -> m Exp
- recGadtC :: forall (m :: * -> *). Quote m => [Name] -> [m Language.Haskell.TH.Lib.Syntax.VarStrictType] -> m Type -> m Con
+ recGadtC :: forall (m :: * -> *). Quote m => [Name] -> [m GHC.Internal.TH.Syntax.VarStrictType] -> m Type -> m Con
recP :: forall (m :: * -> *). Quote m => Name -> [m FieldPat] -> m Pat
recS :: forall (m :: * -> *). Quote m => [m Stmt] -> m Stmt
recUpdE :: forall (m :: * -> *). Quote m => m Exp -> [m (Name, Exp)] -> m Exp
@@ -629,17 +629,17 @@ module Language.Haskell.TH where
reifyConStrictness :: Name -> Q [DecidedStrictness]
reifyFixity :: Name -> Q (GHC.Internal.Maybe.Maybe Fixity)
reifyInstances :: Name -> [Type] -> Q [InstanceDec]
- reifyModule :: Language.Haskell.TH.Lib.Syntax.Module -> Q ModuleInfo
+ reifyModule :: GHC.Internal.TH.Syntax.Module -> Q ModuleInfo
reifyRoles :: Name -> Q [Role]
reifyType :: Name -> Q Type
report :: GHC.Types.Bool -> GHC.Internal.Base.String -> Q ()
reportError :: GHC.Internal.Base.String -> Q ()
reportWarning :: GHC.Internal.Base.String -> Q ()
- representationalR :: Language.Haskell.TH.Lib.Internal.Role
- roleAnnotD :: forall (m :: * -> *). Quote m => Name -> [Language.Haskell.TH.Lib.Internal.Role] -> m Dec
+ representationalR :: GHC.Internal.TH.Lib.Role
+ roleAnnotD :: forall (m :: * -> *). Quote m => Name -> [GHC.Internal.TH.Lib.Role] -> m Dec
ruleVar :: forall (m :: * -> *). Quote m => Name -> m RuleBndr
runIO :: forall a. GHC.Types.IO a -> Q a
- runQ :: forall (m :: * -> *) a. Language.Haskell.TH.Lib.Syntax.Quasi m => Q a -> m a
+ runQ :: forall (m :: * -> *) a. GHC.Internal.TH.Syntax.Quasi m => Q a -> m a
safe :: Safety
sectionL :: forall (m :: * -> *). Quote m => m Exp -> m Exp -> m Exp
sectionR :: forall (m :: * -> *). Quote m => m Exp -> m Exp -> m Exp
@@ -659,11 +659,11 @@ module Language.Haskell.TH where
stdCall :: Callconv
stockStrategy :: forall (m :: * -> *). Quote m => m DerivStrategy
strTyLit :: forall (m :: * -> *). Quote m => GHC.Internal.Base.String -> m TyLit
- strictType :: forall (m :: * -> *). Quote m => m Strict -> m Type -> m Language.Haskell.TH.Lib.Syntax.StrictType
+ strictType :: forall (m :: * -> *). Quote m => m Strict -> m Type -> m GHC.Internal.TH.Syntax.StrictType
stringE :: forall (m :: * -> *). Quote m => GHC.Internal.Base.String -> m Exp
stringL :: GHC.Internal.Base.String -> Lit
stringPrimL :: [GHC.Internal.Word.Word8] -> Lit
- thisModule :: Q Language.Haskell.TH.Lib.Syntax.Module
+ thisModule :: Q GHC.Internal.TH.Syntax.Module
tildeP :: forall (m :: * -> *). Quote m => m Pat -> m Pat
tupE :: forall (m :: * -> *). Quote m => [m Exp] -> m Exp
tupP :: forall (m :: * -> *). Quote m => [m Pat] -> m Pat
@@ -708,7 +708,7 @@ module Language.Haskell.TH where
varE :: forall (m :: * -> *). Quote m => Name -> m Exp
varK :: Name -> Kind
varP :: forall (m :: * -> *). Quote m => Name -> m Pat
- varStrictType :: forall (m :: * -> *). Quote m => Name -> m Language.Haskell.TH.Lib.Syntax.StrictType -> m Language.Haskell.TH.Lib.Syntax.VarStrictType
+ varStrictType :: forall (m :: * -> *). Quote m => Name -> m GHC.Internal.TH.Syntax.StrictType -> m GHC.Internal.TH.Syntax.VarStrictType
varT :: forall (m :: * -> *). Quote m => Name -> m Type
viaStrategy :: forall (m :: * -> *). Quote m => m Type -> m DerivStrategy
viewP :: forall (m :: * -> *). Quote m => m Exp -> m Pat -> m Pat
@@ -720,8 +720,8 @@ module Language.Haskell.TH where
module Language.Haskell.TH.CodeDo where
-- Safety: Safe-Inferred
- (>>) :: forall (m :: * -> *) a b. GHC.Internal.Base.Monad m => m a -> Language.Haskell.TH.Lib.Syntax.Code m b -> Language.Haskell.TH.Lib.Syntax.Code m b
- (>>=) :: forall (m :: * -> *) a b. GHC.Internal.Base.Monad m => m a -> (a -> Language.Haskell.TH.Lib.Syntax.Code m b) -> Language.Haskell.TH.Lib.Syntax.Code m b
+ (>>) :: forall (m :: * -> *) a b. GHC.Internal.Base.Monad m => m a -> GHC.Internal.TH.Syntax.Code m b -> GHC.Internal.TH.Syntax.Code m b
+ (>>=) :: forall (m :: * -> *) a b. GHC.Internal.Base.Monad m => m a -> (a -> GHC.Internal.TH.Syntax.Code m b) -> GHC.Internal.TH.Syntax.Code m b
module Language.Haskell.TH.LanguageExtensions where
-- Safety: Safe
@@ -861,1193 +861,676 @@ module Language.Haskell.TH.LanguageExtensions where
module Language.Haskell.TH.Lib where
-- Safety: Safe
type BangQ :: *
- type BangQ = Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Bang
+ type BangQ = GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Bang
type BangTypeQ :: *
- type BangTypeQ = Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.BangType
+ type BangTypeQ = GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.BangType
type BodyQ :: *
- type BodyQ = Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Body
+ type BodyQ = GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Body
type ClauseQ :: *
- type ClauseQ = Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Clause
+ type ClauseQ = GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Clause
type CodeQ :: forall (r :: GHC.Types.RuntimeRep). TYPE r -> *
- type CodeQ = Language.Haskell.TH.Lib.Syntax.Code Language.Haskell.TH.Lib.Syntax.Q :: forall (r :: GHC.Types.RuntimeRep). TYPE r -> *
+ type CodeQ = GHC.Internal.TH.Syntax.Code GHC.Internal.TH.Syntax.Q :: forall (r :: GHC.Types.RuntimeRep). TYPE r -> *
type ConQ :: *
- type ConQ = Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Con
+ type ConQ = GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Con
type CxtQ :: *
- type CxtQ = Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Cxt
+ type CxtQ = GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Cxt
type DecQ :: *
- type DecQ = Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Dec
+ type DecQ = GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Dec
type DecsQ :: *
- type DecsQ = Language.Haskell.TH.Lib.Syntax.Q [Language.Haskell.TH.Lib.Syntax.Dec]
+ type DecsQ = GHC.Internal.TH.Syntax.Q [GHC.Internal.TH.Syntax.Dec]
type DefaultBndrFlag :: * -> Constraint
class DefaultBndrFlag flag where
defaultBndrFlag :: flag
{-# MINIMAL defaultBndrFlag #-}
type DerivClause :: *
- data DerivClause = DerivClause (GHC.Internal.Maybe.Maybe DerivStrategy) Language.Haskell.TH.Lib.Syntax.Cxt
+ data DerivClause = DerivClause (GHC.Internal.Maybe.Maybe DerivStrategy) GHC.Internal.TH.Syntax.Cxt
type DerivClauseQ :: *
- type DerivClauseQ = Language.Haskell.TH.Lib.Syntax.Q DerivClause
+ type DerivClauseQ = GHC.Internal.TH.Syntax.Q DerivClause
type DerivStrategy :: *
- data DerivStrategy = StockStrategy | AnyclassStrategy | NewtypeStrategy | ViaStrategy Language.Haskell.TH.Lib.Syntax.Type
+ data DerivStrategy = StockStrategy | AnyclassStrategy | NewtypeStrategy | ViaStrategy GHC.Internal.TH.Syntax.Type
type DerivStrategyQ :: *
- type DerivStrategyQ = Language.Haskell.TH.Lib.Syntax.Q DerivStrategy
+ type DerivStrategyQ = GHC.Internal.TH.Syntax.Q DerivStrategy
type ExpQ :: *
- type ExpQ = Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Exp
+ type ExpQ = GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Exp
type FamilyResultSigQ :: *
- type FamilyResultSigQ = Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.FamilyResultSig
+ type FamilyResultSigQ = GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.FamilyResultSig
type FieldExpQ :: *
- type FieldExpQ = Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.FieldExp
+ type FieldExpQ = GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.FieldExp
type FieldPatQ :: *
- type FieldPatQ = Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.FieldPat
+ type FieldPatQ = GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.FieldPat
type GuardQ :: *
- type GuardQ = Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Guard
+ type GuardQ = GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Guard
type InfoQ :: *
- type InfoQ = Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Info
+ type InfoQ = GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Info
type KindQ :: *
- type KindQ = Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Kind
+ type KindQ = GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Kind
type MatchQ :: *
- type MatchQ = Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Match
+ type MatchQ = GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Match
type Overlap :: *
data Overlap = Overlappable | Overlapping | Overlaps | Incoherent
type PatQ :: *
- type PatQ = Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Pat
+ type PatQ = GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Pat
type PatSynArgsQ :: *
- type PatSynArgsQ = Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.PatSynArgs
+ type PatSynArgsQ = GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.PatSynArgs
type PatSynDirQ :: *
- type PatSynDirQ = Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.PatSynDir
+ type PatSynDirQ = GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.PatSynDir
type PredQ :: *
- type PredQ = Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Pred
+ type PredQ = GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Pred
type RangeQ :: *
- type RangeQ = Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Range
+ type RangeQ = GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Range
type RuleBndrQ :: *
- type RuleBndrQ = Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.RuleBndr
+ type RuleBndrQ = GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.RuleBndr
type SourceStrictnessQ :: *
- type SourceStrictnessQ = Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.SourceStrictness
+ type SourceStrictnessQ = GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.SourceStrictness
type SourceUnpackednessQ :: *
- type SourceUnpackednessQ = Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.SourceUnpackedness
+ type SourceUnpackednessQ = GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.SourceUnpackedness
type StmtQ :: *
- type StmtQ = Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Stmt
+ type StmtQ = GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Stmt
type StrictTypeQ :: *
- type StrictTypeQ = Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.StrictType
+ type StrictTypeQ = GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.StrictType
type TExpQ :: forall (r :: GHC.Types.RuntimeRep). TYPE r -> *
- type TExpQ a = Language.Haskell.TH.Lib.Syntax.Q (Language.Haskell.TH.Lib.Syntax.TExp a)
+ type TExpQ a = GHC.Internal.TH.Syntax.Q (GHC.Internal.TH.Syntax.TExp a)
type TyLitQ :: *
- type TyLitQ = Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.TyLit
+ type TyLitQ = GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.TyLit
type TySynEqnQ :: *
- type TySynEqnQ = Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.TySynEqn
+ type TySynEqnQ = GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.TySynEqn
type TyVarBndrSpec :: *
- type TyVarBndrSpec = Language.Haskell.TH.Lib.Syntax.TyVarBndr Language.Haskell.TH.Lib.Syntax.Specificity
+ type TyVarBndrSpec = GHC.Internal.TH.Syntax.TyVarBndr GHC.Internal.TH.Syntax.Specificity
type TyVarBndrUnit :: *
- type TyVarBndrUnit = Language.Haskell.TH.Lib.Syntax.TyVarBndr ()
+ type TyVarBndrUnit = GHC.Internal.TH.Syntax.TyVarBndr ()
type TyVarBndrVis :: *
- type TyVarBndrVis = Language.Haskell.TH.Lib.Syntax.TyVarBndr Language.Haskell.TH.Lib.Syntax.BndrVis
+ type TyVarBndrVis = GHC.Internal.TH.Syntax.TyVarBndr GHC.Internal.TH.Syntax.BndrVis
type TypeQ :: *
- type TypeQ = Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Type
+ type TypeQ = GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Type
type VarBangTypeQ :: *
- type VarBangTypeQ = Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.VarBangType
+ type VarBangTypeQ = GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.VarBangType
type VarStrictTypeQ :: *
- type VarStrictTypeQ = Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.VarStrictType
- anyclassStrategy :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m DerivStrategy
- appE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Exp
- appK :: Language.Haskell.TH.Lib.Syntax.Kind -> Language.Haskell.TH.Lib.Syntax.Kind -> Language.Haskell.TH.Lib.Syntax.Kind
- appKindT :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Type -> m Language.Haskell.TH.Lib.Syntax.Kind -> m Language.Haskell.TH.Lib.Syntax.Type
- appT :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Type -> m Language.Haskell.TH.Lib.Syntax.Type -> m Language.Haskell.TH.Lib.Syntax.Type
- appTypeE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Type -> m Language.Haskell.TH.Lib.Syntax.Exp
- appsE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => [m Language.Haskell.TH.Lib.Syntax.Exp] -> m Language.Haskell.TH.Lib.Syntax.Exp
- arithSeqE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Range -> m Language.Haskell.TH.Lib.Syntax.Exp
- arrowK :: Language.Haskell.TH.Lib.Syntax.Kind
- arrowT :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Type
- asP :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> m Language.Haskell.TH.Lib.Syntax.Pat -> m Language.Haskell.TH.Lib.Syntax.Pat
- bang :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.SourceUnpackedness -> m Language.Haskell.TH.Lib.Syntax.SourceStrictness -> m Language.Haskell.TH.Lib.Syntax.Bang
- bangP :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Pat -> m Language.Haskell.TH.Lib.Syntax.Pat
- bangType :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Bang -> m Language.Haskell.TH.Lib.Syntax.Type -> m Language.Haskell.TH.Lib.Syntax.BangType
- bindS :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Pat -> m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Stmt
- bndrInvis :: Language.Haskell.TH.Lib.Syntax.BndrVis
- bndrReq :: Language.Haskell.TH.Lib.Syntax.BndrVis
- bytesPrimL :: Language.Haskell.TH.Lib.Syntax.Bytes -> Language.Haskell.TH.Lib.Syntax.Lit
- cApi :: Language.Haskell.TH.Lib.Syntax.Callconv
- cCall :: Language.Haskell.TH.Lib.Syntax.Callconv
- caseE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Exp -> [m Language.Haskell.TH.Lib.Syntax.Match] -> m Language.Haskell.TH.Lib.Syntax.Exp
- charL :: GHC.Types.Char -> Language.Haskell.TH.Lib.Syntax.Lit
- charPrimL :: GHC.Types.Char -> Language.Haskell.TH.Lib.Syntax.Lit
- charTyLit :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => GHC.Types.Char -> m Language.Haskell.TH.Lib.Syntax.TyLit
- classD :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Cxt -> Language.Haskell.TH.Lib.Syntax.Name -> [Language.Haskell.TH.Lib.Syntax.TyVarBndr Language.Haskell.TH.Lib.Syntax.BndrVis] -> [Language.Haskell.TH.Lib.Syntax.FunDep] -> [m Language.Haskell.TH.Lib.Syntax.Dec] -> m Language.Haskell.TH.Lib.Syntax.Dec
- classP :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> [m Language.Haskell.TH.Lib.Syntax.Type] -> m Language.Haskell.TH.Lib.Syntax.Pred
- clause :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => [m Language.Haskell.TH.Lib.Syntax.Pat] -> m Language.Haskell.TH.Lib.Syntax.Body -> [m Language.Haskell.TH.Lib.Syntax.Dec] -> m Language.Haskell.TH.Lib.Syntax.Clause
- closedTypeFamilyD :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> [Language.Haskell.TH.Lib.Syntax.TyVarBndr Language.Haskell.TH.Lib.Syntax.BndrVis] -> Language.Haskell.TH.Lib.Syntax.FamilyResultSig -> GHC.Internal.Maybe.Maybe Language.Haskell.TH.Lib.Syntax.InjectivityAnn -> [m Language.Haskell.TH.Lib.Syntax.TySynEqn] -> m Language.Haskell.TH.Lib.Syntax.Dec
- compE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => [m Language.Haskell.TH.Lib.Syntax.Stmt] -> m Language.Haskell.TH.Lib.Syntax.Exp
- conE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> m Language.Haskell.TH.Lib.Syntax.Exp
- conK :: Language.Haskell.TH.Lib.Syntax.Name -> Language.Haskell.TH.Lib.Syntax.Kind
- conP :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> [m Language.Haskell.TH.Lib.Syntax.Pat] -> m Language.Haskell.TH.Lib.Syntax.Pat
- conT :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> m Language.Haskell.TH.Lib.Syntax.Type
- condE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Exp
- constraintK :: Language.Haskell.TH.Lib.Syntax.Kind
- cxt :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => [m Language.Haskell.TH.Lib.Syntax.Pred] -> m Language.Haskell.TH.Lib.Syntax.Cxt
- dataD :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Cxt -> Language.Haskell.TH.Lib.Syntax.Name -> [Language.Haskell.TH.Lib.Syntax.TyVarBndr Language.Haskell.TH.Lib.Syntax.BndrVis] -> GHC.Internal.Maybe.Maybe Language.Haskell.TH.Lib.Syntax.Kind -> [m Language.Haskell.TH.Lib.Syntax.Con] -> [m DerivClause] -> m Language.Haskell.TH.Lib.Syntax.Dec
- dataD_doc ::
- Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Cxt
- -> Language.Haskell.TH.Lib.Syntax.Name -> [Language.Haskell.TH.Lib.Syntax.Q (Language.Haskell.TH.Lib.Syntax.TyVarBndr Language.Haskell.TH.Lib.Syntax.BndrVis)] -> GHC.Internal.Maybe.Maybe (Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Kind) -> [(Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Con, GHC.Internal.Maybe.Maybe GHC.Internal.Base.String, [GHC.Internal.Maybe.Maybe GHC.Internal.Base.String])] -> [Language.Haskell.TH.Lib.Syntax.Q DerivClause] -> GHC.Internal.Maybe.Maybe GHC.Internal.Base.String -> Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Dec
- dataFamilyD :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> [Language.Haskell.TH.Lib.Syntax.TyVarBndr Language.Haskell.TH.Lib.Syntax.BndrVis] -> GHC.Internal.Maybe.Maybe Language.Haskell.TH.Lib.Syntax.Kind -> m Language.Haskell.TH.Lib.Syntax.Dec
- dataInstD :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Cxt -> Language.Haskell.TH.Lib.Syntax.Name -> [m Language.Haskell.TH.Lib.Syntax.Type] -> GHC.Internal.Maybe.Maybe Language.Haskell.TH.Lib.Syntax.Kind -> [m Language.Haskell.TH.Lib.Syntax.Con] -> [m DerivClause] -> m Language.Haskell.TH.Lib.Syntax.Dec
- dataInstD_doc ::
- Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Cxt
- -> GHC.Internal.Maybe.Maybe [Language.Haskell.TH.Lib.Syntax.Q (Language.Haskell.TH.Lib.Syntax.TyVarBndr ())] -> Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Type -> GHC.Internal.Maybe.Maybe (Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Kind) -> [(Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Con, GHC.Internal.Maybe.Maybe GHC.Internal.Base.String, [GHC.Internal.Maybe.Maybe GHC.Internal.Base.String])] -> [Language.Haskell.TH.Lib.Syntax.Q DerivClause] -> GHC.Internal.Maybe.Maybe GHC.Internal.Base.String -> Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Dec
- defaultD :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => [m Language.Haskell.TH.Lib.Syntax.Type] -> m Language.Haskell.TH.Lib.Syntax.Dec
- defaultSigD :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> m Language.Haskell.TH.Lib.Syntax.Type -> m Language.Haskell.TH.Lib.Syntax.Dec
- derivClause :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => GHC.Internal.Maybe.Maybe DerivStrategy -> [m Language.Haskell.TH.Lib.Syntax.Pred] -> m DerivClause
- doE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => [m Language.Haskell.TH.Lib.Syntax.Stmt] -> m Language.Haskell.TH.Lib.Syntax.Exp
- doublePrimL :: GHC.Internal.Real.Rational -> Language.Haskell.TH.Lib.Syntax.Lit
- dyn :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => GHC.Internal.Base.String -> m Language.Haskell.TH.Lib.Syntax.Exp
- equalP :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Type -> m Language.Haskell.TH.Lib.Syntax.Type -> m Language.Haskell.TH.Lib.Syntax.Pred
- equalityT :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Type
- explBidir :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => [m Language.Haskell.TH.Lib.Syntax.Clause] -> m Language.Haskell.TH.Lib.Syntax.PatSynDir
- fieldExp :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> m Language.Haskell.TH.Lib.Syntax.Exp -> m (Language.Haskell.TH.Lib.Syntax.Name, Language.Haskell.TH.Lib.Syntax.Exp)
- fieldPat :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> m Language.Haskell.TH.Lib.Syntax.Pat -> m Language.Haskell.TH.Lib.Syntax.FieldPat
- floatPrimL :: GHC.Internal.Real.Rational -> Language.Haskell.TH.Lib.Syntax.Lit
- forImpD :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Callconv -> Language.Haskell.TH.Lib.Syntax.Safety -> GHC.Internal.Base.String -> Language.Haskell.TH.Lib.Syntax.Name -> m Language.Haskell.TH.Lib.Syntax.Type -> m Language.Haskell.TH.Lib.Syntax.Dec
- forallC :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => [Language.Haskell.TH.Lib.Syntax.TyVarBndr Language.Haskell.TH.Lib.Syntax.Specificity] -> m Language.Haskell.TH.Lib.Syntax.Cxt -> m Language.Haskell.TH.Lib.Syntax.Con -> m Language.Haskell.TH.Lib.Syntax.Con
- forallT :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => [Language.Haskell.TH.Lib.Syntax.TyVarBndr Language.Haskell.TH.Lib.Syntax.Specificity] -> m Language.Haskell.TH.Lib.Syntax.Cxt -> m Language.Haskell.TH.Lib.Syntax.Type -> m Language.Haskell.TH.Lib.Syntax.Type
- forallVisT :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => [m (Language.Haskell.TH.Lib.Syntax.TyVarBndr ())] -> m Language.Haskell.TH.Lib.Syntax.Type -> m Language.Haskell.TH.Lib.Syntax.Type
- fromE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Exp
- fromR :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Range
- fromThenE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Exp
- fromThenR :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Range
- fromThenToE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Exp
- fromThenToR :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Range
- fromToE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Exp
- fromToR :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Range
- funD :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> [m Language.Haskell.TH.Lib.Syntax.Clause] -> m Language.Haskell.TH.Lib.Syntax.Dec
- funD_doc :: Language.Haskell.TH.Lib.Syntax.Name -> [Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Clause] -> GHC.Internal.Maybe.Maybe GHC.Internal.Base.String -> [GHC.Internal.Maybe.Maybe GHC.Internal.Base.String] -> Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Dec
- funDep :: [Language.Haskell.TH.Lib.Syntax.Name] -> [Language.Haskell.TH.Lib.Syntax.Name] -> Language.Haskell.TH.Lib.Syntax.FunDep
- gadtC :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => [Language.Haskell.TH.Lib.Syntax.Name] -> [m Language.Haskell.TH.Lib.Syntax.StrictType] -> m Language.Haskell.TH.Lib.Syntax.Type -> m Language.Haskell.TH.Lib.Syntax.Con
- getFieldE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Exp -> GHC.Internal.Base.String -> m Language.Haskell.TH.Lib.Syntax.Exp
- guardedB :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => [m (Language.Haskell.TH.Lib.Syntax.Guard, Language.Haskell.TH.Lib.Syntax.Exp)] -> m Language.Haskell.TH.Lib.Syntax.Body
- implBidir :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.PatSynDir
- implicitParamBindD :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => GHC.Internal.Base.String -> m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Dec
- implicitParamT :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => GHC.Internal.Base.String -> m Language.Haskell.TH.Lib.Syntax.Type -> m Language.Haskell.TH.Lib.Syntax.Type
- implicitParamVarE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => GHC.Internal.Base.String -> m Language.Haskell.TH.Lib.Syntax.Exp
- inferR :: Language.Haskell.TH.Lib.Internal.Role
- inferredSpec :: Language.Haskell.TH.Lib.Syntax.Specificity
- infixApp :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Exp
- infixC :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m (Language.Haskell.TH.Lib.Syntax.Bang, Language.Haskell.TH.Lib.Syntax.Type) -> Language.Haskell.TH.Lib.Syntax.Name -> m (Language.Haskell.TH.Lib.Syntax.Bang, Language.Haskell.TH.Lib.Syntax.Type) -> m Language.Haskell.TH.Lib.Syntax.Con
- infixE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => GHC.Internal.Maybe.Maybe (m Language.Haskell.TH.Lib.Syntax.Exp) -> m Language.Haskell.TH.Lib.Syntax.Exp -> GHC.Internal.Maybe.Maybe (m Language.Haskell.TH.Lib.Syntax.Exp) -> m Language.Haskell.TH.Lib.Syntax.Exp
- infixLD :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => GHC.Types.Int -> Language.Haskell.TH.Lib.Syntax.Name -> m Language.Haskell.TH.Lib.Syntax.Dec
- infixND :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => GHC.Types.Int -> Language.Haskell.TH.Lib.Syntax.Name -> m Language.Haskell.TH.Lib.Syntax.Dec
- infixP :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Pat -> Language.Haskell.TH.Lib.Syntax.Name -> m Language.Haskell.TH.Lib.Syntax.Pat -> m Language.Haskell.TH.Lib.Syntax.Pat
- infixPatSyn :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> Language.Haskell.TH.Lib.Syntax.Name -> m Language.Haskell.TH.Lib.Syntax.PatSynArgs
- infixRD :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => GHC.Types.Int -> Language.Haskell.TH.Lib.Syntax.Name -> m Language.Haskell.TH.Lib.Syntax.Dec
- infixT :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Type -> Language.Haskell.TH.Lib.Syntax.Name -> m Language.Haskell.TH.Lib.Syntax.Type -> m Language.Haskell.TH.Lib.Syntax.Type
- injectivityAnn :: Language.Haskell.TH.Lib.Syntax.Name -> [Language.Haskell.TH.Lib.Syntax.Name] -> Language.Haskell.TH.Lib.Internal.InjectivityAnn
- instanceD :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Cxt -> m Language.Haskell.TH.Lib.Syntax.Type -> [m Language.Haskell.TH.Lib.Syntax.Dec] -> m Language.Haskell.TH.Lib.Syntax.Dec
- instanceWithOverlapD :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => GHC.Internal.Maybe.Maybe Overlap -> m Language.Haskell.TH.Lib.Syntax.Cxt -> m Language.Haskell.TH.Lib.Syntax.Type -> [m Language.Haskell.TH.Lib.Syntax.Dec] -> m Language.Haskell.TH.Lib.Syntax.Dec
- intPrimL :: GHC.Num.Integer.Integer -> Language.Haskell.TH.Lib.Syntax.Lit
- integerL :: GHC.Num.Integer.Integer -> Language.Haskell.TH.Lib.Syntax.Lit
- interruptible :: Language.Haskell.TH.Lib.Syntax.Safety
- invisP :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Type -> m Language.Haskell.TH.Lib.Syntax.Pat
- isStrict :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Strict
- javaScript :: Language.Haskell.TH.Lib.Syntax.Callconv
- kiSigD :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> m Language.Haskell.TH.Lib.Syntax.Kind -> m Language.Haskell.TH.Lib.Syntax.Dec
- kindSig :: Language.Haskell.TH.Lib.Syntax.Kind -> Language.Haskell.TH.Lib.Syntax.FamilyResultSig
- kindedBndrTV :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> Language.Haskell.TH.Lib.Syntax.BndrVis -> m Language.Haskell.TH.Lib.Syntax.Kind -> m (Language.Haskell.TH.Lib.Syntax.TyVarBndr Language.Haskell.TH.Lib.Syntax.BndrVis)
- kindedInvisTV :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> Language.Haskell.TH.Lib.Syntax.Specificity -> m Language.Haskell.TH.Lib.Syntax.Kind -> m (Language.Haskell.TH.Lib.Syntax.TyVarBndr Language.Haskell.TH.Lib.Syntax.Specificity)
- kindedTV :: forall flag. DefaultBndrFlag flag => Language.Haskell.TH.Lib.Syntax.Name -> Language.Haskell.TH.Lib.Syntax.Kind -> Language.Haskell.TH.Lib.Syntax.TyVarBndr flag
- labelE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => GHC.Internal.Base.String -> m Language.Haskell.TH.Lib.Syntax.Exp
- lam1E :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Pat -> m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Exp
- lamCaseE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => [m Language.Haskell.TH.Lib.Syntax.Match] -> m Language.Haskell.TH.Lib.Syntax.Exp
- lamCasesE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => [m Language.Haskell.TH.Lib.Syntax.Clause] -> m Language.Haskell.TH.Lib.Syntax.Exp
- lamE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => [m Language.Haskell.TH.Lib.Syntax.Pat] -> m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Exp
- letE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => [m Language.Haskell.TH.Lib.Syntax.Dec] -> m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Exp
- letS :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => [m Language.Haskell.TH.Lib.Syntax.Dec] -> m Language.Haskell.TH.Lib.Syntax.Stmt
- listE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => [m Language.Haskell.TH.Lib.Syntax.Exp] -> m Language.Haskell.TH.Lib.Syntax.Exp
- listK :: Language.Haskell.TH.Lib.Syntax.Kind
- listP :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => [m Language.Haskell.TH.Lib.Syntax.Pat] -> m Language.Haskell.TH.Lib.Syntax.Pat
- listT :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Type
- litE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Lit -> m Language.Haskell.TH.Lib.Syntax.Exp
- litP :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Lit -> m Language.Haskell.TH.Lib.Syntax.Pat
- litT :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.TyLit -> m Language.Haskell.TH.Lib.Syntax.Type
- match :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Pat -> m Language.Haskell.TH.Lib.Syntax.Body -> [m Language.Haskell.TH.Lib.Syntax.Dec] -> m Language.Haskell.TH.Lib.Syntax.Match
- mdoE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => [m Language.Haskell.TH.Lib.Syntax.Stmt] -> m Language.Haskell.TH.Lib.Syntax.Exp
- mkBytes :: GHC.Internal.ForeignPtr.ForeignPtr GHC.Internal.Word.Word8 -> GHC.Types.Word -> GHC.Types.Word -> Language.Haskell.TH.Lib.Syntax.Bytes
- moduleAnnotation :: Language.Haskell.TH.Lib.Syntax.AnnTarget
- mulArrowT :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Type
- multiIfE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => [m (Language.Haskell.TH.Lib.Syntax.Guard, Language.Haskell.TH.Lib.Syntax.Exp)] -> m Language.Haskell.TH.Lib.Syntax.Exp
- newtypeD :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Cxt -> Language.Haskell.TH.Lib.Syntax.Name -> [Language.Haskell.TH.Lib.Syntax.TyVarBndr Language.Haskell.TH.Lib.Syntax.BndrVis] -> GHC.Internal.Maybe.Maybe Language.Haskell.TH.Lib.Syntax.Kind -> m Language.Haskell.TH.Lib.Syntax.Con -> [m DerivClause] -> m Language.Haskell.TH.Lib.Syntax.Dec
- newtypeD_doc ::
- Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Cxt
- -> Language.Haskell.TH.Lib.Syntax.Name -> [Language.Haskell.TH.Lib.Syntax.Q (Language.Haskell.TH.Lib.Syntax.TyVarBndr Language.Haskell.TH.Lib.Syntax.BndrVis)] -> GHC.Internal.Maybe.Maybe (Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Kind) -> (Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Con, GHC.Internal.Maybe.Maybe GHC.Internal.Base.String, [GHC.Internal.Maybe.Maybe GHC.Internal.Base.String]) -> [Language.Haskell.TH.Lib.Syntax.Q DerivClause] -> GHC.Internal.Maybe.Maybe GHC.Internal.Base.String -> Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Dec
- newtypeInstD :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Cxt -> Language.Haskell.TH.Lib.Syntax.Name -> [m Language.Haskell.TH.Lib.Syntax.Type] -> GHC.Internal.Maybe.Maybe Language.Haskell.TH.Lib.Syntax.Kind -> m Language.Haskell.TH.Lib.Syntax.Con -> [m DerivClause] -> m Language.Haskell.TH.Lib.Syntax.Dec
- newtypeInstD_doc ::
- Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Cxt
- -> GHC.Internal.Maybe.Maybe [Language.Haskell.TH.Lib.Syntax.Q (Language.Haskell.TH.Lib.Syntax.TyVarBndr ())] -> Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Type -> GHC.Internal.Maybe.Maybe (Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Kind) -> (Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Con, GHC.Internal.Maybe.Maybe GHC.Internal.Base.String, [GHC.Internal.Maybe.Maybe GHC.Internal.Base.String]) -> [Language.Haskell.TH.Lib.Syntax.Q DerivClause] -> GHC.Internal.Maybe.Maybe GHC.Internal.Base.String -> Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Dec
- newtypeStrategy :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m DerivStrategy
- noBindS :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Stmt
- noSig :: Language.Haskell.TH.Lib.Syntax.FamilyResultSig
- noSourceStrictness :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.SourceStrictness
- noSourceUnpackedness :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.SourceUnpackedness
- nominalR :: Language.Haskell.TH.Lib.Internal.Role
- normalB :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Body
- normalC :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> [m Language.Haskell.TH.Lib.Syntax.BangType] -> m Language.Haskell.TH.Lib.Syntax.Con
- normalG :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Guard
- normalGE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Exp -> m (Language.Haskell.TH.Lib.Syntax.Guard, Language.Haskell.TH.Lib.Syntax.Exp)
- notStrict :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Strict
- numTyLit :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => GHC.Num.Integer.Integer -> m Language.Haskell.TH.Lib.Syntax.TyLit
- openTypeFamilyD :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> [Language.Haskell.TH.Lib.Syntax.TyVarBndr Language.Haskell.TH.Lib.Syntax.BndrVis] -> Language.Haskell.TH.Lib.Syntax.FamilyResultSig -> GHC.Internal.Maybe.Maybe Language.Haskell.TH.Lib.Syntax.InjectivityAnn -> m Language.Haskell.TH.Lib.Syntax.Dec
- parS :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => [[m Language.Haskell.TH.Lib.Syntax.Stmt]] -> m Language.Haskell.TH.Lib.Syntax.Stmt
- parensE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Exp
- parensP :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Pat -> m Language.Haskell.TH.Lib.Syntax.Pat
- parensT :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Type -> m Language.Haskell.TH.Lib.Syntax.Type
- patG :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => [m Language.Haskell.TH.Lib.Syntax.Stmt] -> m Language.Haskell.TH.Lib.Syntax.Guard
- patGE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => [m Language.Haskell.TH.Lib.Syntax.Stmt] -> m Language.Haskell.TH.Lib.Syntax.Exp -> m (Language.Haskell.TH.Lib.Syntax.Guard, Language.Haskell.TH.Lib.Syntax.Exp)
- patSynD :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> m Language.Haskell.TH.Lib.Syntax.PatSynArgs -> m Language.Haskell.TH.Lib.Syntax.PatSynDir -> m Language.Haskell.TH.Lib.Syntax.Pat -> m Language.Haskell.TH.Lib.Syntax.Dec
- patSynD_doc :: Language.Haskell.TH.Lib.Syntax.Name -> Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.PatSynArgs -> Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.PatSynDir -> Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Pat -> GHC.Internal.Maybe.Maybe GHC.Internal.Base.String -> [GHC.Internal.Maybe.Maybe GHC.Internal.Base.String] -> Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Dec
- patSynSigD :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> m Language.Haskell.TH.Lib.Syntax.Type -> m Language.Haskell.TH.Lib.Syntax.Dec
- phantomR :: Language.Haskell.TH.Lib.Internal.Role
- plainBndrTV :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> Language.Haskell.TH.Lib.Syntax.BndrVis -> m (Language.Haskell.TH.Lib.Syntax.TyVarBndr Language.Haskell.TH.Lib.Syntax.BndrVis)
- plainInvisTV :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> Language.Haskell.TH.Lib.Syntax.Specificity -> m (Language.Haskell.TH.Lib.Syntax.TyVarBndr Language.Haskell.TH.Lib.Syntax.Specificity)
- plainTV :: forall flag. DefaultBndrFlag flag => Language.Haskell.TH.Lib.Syntax.Name -> Language.Haskell.TH.Lib.Syntax.TyVarBndr flag
- pragAnnD :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.AnnTarget -> m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Dec
- pragCompleteD :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => [Language.Haskell.TH.Lib.Syntax.Name] -> GHC.Internal.Maybe.Maybe Language.Haskell.TH.Lib.Syntax.Name -> m Language.Haskell.TH.Lib.Syntax.Dec
- pragInlD :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> Language.Haskell.TH.Lib.Syntax.Inline -> Language.Haskell.TH.Lib.Syntax.RuleMatch -> Language.Haskell.TH.Lib.Syntax.Phases -> m Language.Haskell.TH.Lib.Syntax.Dec
- pragLineD :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => GHC.Types.Int -> GHC.Internal.Base.String -> m Language.Haskell.TH.Lib.Syntax.Dec
- pragRuleD :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => GHC.Internal.Base.String -> [m Language.Haskell.TH.Lib.Syntax.RuleBndr] -> m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Exp -> Language.Haskell.TH.Lib.Syntax.Phases -> m Language.Haskell.TH.Lib.Syntax.Dec
- pragSpecD :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> m Language.Haskell.TH.Lib.Syntax.Type -> Language.Haskell.TH.Lib.Syntax.Phases -> m Language.Haskell.TH.Lib.Syntax.Dec
- pragSpecInlD :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> m Language.Haskell.TH.Lib.Syntax.Type -> Language.Haskell.TH.Lib.Syntax.Inline -> Language.Haskell.TH.Lib.Syntax.Phases -> m Language.Haskell.TH.Lib.Syntax.Dec
- pragSpecInstD :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Type -> m Language.Haskell.TH.Lib.Syntax.Dec
- prefixPatSyn :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => [Language.Haskell.TH.Lib.Syntax.Name] -> m Language.Haskell.TH.Lib.Syntax.PatSynArgs
- prim :: Language.Haskell.TH.Lib.Syntax.Callconv
- projectionE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => GHC.Internal.Base.NonEmpty GHC.Internal.Base.String -> m Language.Haskell.TH.Lib.Syntax.Exp
- promotedConsT :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Type
- promotedInfixT :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Type -> Language.Haskell.TH.Lib.Syntax.Name -> m Language.Haskell.TH.Lib.Syntax.Type -> m Language.Haskell.TH.Lib.Syntax.Type
- promotedNilT :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Type
- promotedT :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> m Language.Haskell.TH.Lib.Syntax.Type
- promotedTupleT :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => GHC.Types.Int -> m Language.Haskell.TH.Lib.Syntax.Type
- promotedUInfixT :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Type -> Language.Haskell.TH.Lib.Syntax.Name -> m Language.Haskell.TH.Lib.Syntax.Type -> m Language.Haskell.TH.Lib.Syntax.Type
- rationalL :: GHC.Internal.Real.Rational -> Language.Haskell.TH.Lib.Syntax.Lit
- recC :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> [m Language.Haskell.TH.Lib.Syntax.VarBangType] -> m Language.Haskell.TH.Lib.Syntax.Con
- recConE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> [m (Language.Haskell.TH.Lib.Syntax.Name, Language.Haskell.TH.Lib.Syntax.Exp)] -> m Language.Haskell.TH.Lib.Syntax.Exp
- recGadtC :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => [Language.Haskell.TH.Lib.Syntax.Name] -> [m Language.Haskell.TH.Lib.Syntax.VarStrictType] -> m Language.Haskell.TH.Lib.Syntax.Type -> m Language.Haskell.TH.Lib.Syntax.Con
- recP :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> [m Language.Haskell.TH.Lib.Syntax.FieldPat] -> m Language.Haskell.TH.Lib.Syntax.Pat
- recS :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => [m Language.Haskell.TH.Lib.Syntax.Stmt] -> m Language.Haskell.TH.Lib.Syntax.Stmt
- recUpdE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Exp -> [m (Language.Haskell.TH.Lib.Syntax.Name, Language.Haskell.TH.Lib.Syntax.Exp)] -> m Language.Haskell.TH.Lib.Syntax.Exp
- recordPatSyn :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => [Language.Haskell.TH.Lib.Syntax.Name] -> m Language.Haskell.TH.Lib.Syntax.PatSynArgs
- representationalR :: Language.Haskell.TH.Lib.Internal.Role
- roleAnnotD :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> [Language.Haskell.TH.Lib.Internal.Role] -> m Language.Haskell.TH.Lib.Syntax.Dec
- ruleVar :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> m Language.Haskell.TH.Lib.Syntax.RuleBndr
- safe :: Language.Haskell.TH.Lib.Syntax.Safety
- sectionL :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Exp
- sectionR :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Exp
- sigD :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> m Language.Haskell.TH.Lib.Syntax.Type -> m Language.Haskell.TH.Lib.Syntax.Dec
- sigE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Type -> m Language.Haskell.TH.Lib.Syntax.Exp
- sigP :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Pat -> m Language.Haskell.TH.Lib.Syntax.Type -> m Language.Haskell.TH.Lib.Syntax.Pat
- sigT :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Type -> Language.Haskell.TH.Lib.Syntax.Kind -> m Language.Haskell.TH.Lib.Syntax.Type
- sourceLazy :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.SourceStrictness
- sourceNoUnpack :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.SourceUnpackedness
- sourceStrict :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.SourceStrictness
- sourceUnpack :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.SourceUnpackedness
- specifiedSpec :: Language.Haskell.TH.Lib.Syntax.Specificity
- standaloneDerivD :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Cxt -> m Language.Haskell.TH.Lib.Syntax.Type -> m Language.Haskell.TH.Lib.Syntax.Dec
- standaloneDerivWithStrategyD :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => GHC.Internal.Maybe.Maybe DerivStrategy -> m Language.Haskell.TH.Lib.Syntax.Cxt -> m Language.Haskell.TH.Lib.Syntax.Type -> m Language.Haskell.TH.Lib.Syntax.Dec
- starK :: Language.Haskell.TH.Lib.Syntax.Kind
- staticE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Exp
- stdCall :: Language.Haskell.TH.Lib.Syntax.Callconv
- stockStrategy :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m DerivStrategy
- strTyLit :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => GHC.Internal.Base.String -> m Language.Haskell.TH.Lib.Syntax.TyLit
- strictType :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Strict -> m Language.Haskell.TH.Lib.Syntax.Type -> m Language.Haskell.TH.Lib.Syntax.StrictType
- stringE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => GHC.Internal.Base.String -> m Language.Haskell.TH.Lib.Syntax.Exp
- stringL :: GHC.Internal.Base.String -> Language.Haskell.TH.Lib.Syntax.Lit
- stringPrimL :: [GHC.Internal.Word.Word8] -> Language.Haskell.TH.Lib.Syntax.Lit
- thisModule :: Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Module
- tildeP :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Pat -> m Language.Haskell.TH.Lib.Syntax.Pat
- tupE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => [m Language.Haskell.TH.Lib.Syntax.Exp] -> m Language.Haskell.TH.Lib.Syntax.Exp
- tupP :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => [m Language.Haskell.TH.Lib.Syntax.Pat] -> m Language.Haskell.TH.Lib.Syntax.Pat
- tupleK :: GHC.Types.Int -> Language.Haskell.TH.Lib.Syntax.Kind
- tupleT :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => GHC.Types.Int -> m Language.Haskell.TH.Lib.Syntax.Type
- tySynD :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> [Language.Haskell.TH.Lib.Syntax.TyVarBndr Language.Haskell.TH.Lib.Syntax.BndrVis] -> m Language.Haskell.TH.Lib.Syntax.Type -> m Language.Haskell.TH.Lib.Syntax.Dec
- tySynEqn :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => GHC.Internal.Maybe.Maybe [Language.Haskell.TH.Lib.Syntax.TyVarBndr ()] -> m Language.Haskell.TH.Lib.Syntax.Type -> m Language.Haskell.TH.Lib.Syntax.Type -> m Language.Haskell.TH.Lib.Syntax.TySynEqn
- tySynInstD :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.TySynEqn -> m Language.Haskell.TH.Lib.Syntax.Dec
- tyVarSig :: Language.Haskell.TH.Lib.Syntax.TyVarBndr () -> Language.Haskell.TH.Lib.Syntax.FamilyResultSig
- typeAnnotation :: Language.Haskell.TH.Lib.Syntax.Name -> Language.Haskell.TH.Lib.Syntax.AnnTarget
- typeDataD :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> [Language.Haskell.TH.Lib.Syntax.TyVarBndr Language.Haskell.TH.Lib.Syntax.BndrVis] -> GHC.Internal.Maybe.Maybe Language.Haskell.TH.Lib.Syntax.Kind -> [m Language.Haskell.TH.Lib.Syntax.Con] -> m Language.Haskell.TH.Lib.Syntax.Dec
- typeDataD_doc :: Language.Haskell.TH.Lib.Syntax.Name -> [Language.Haskell.TH.Lib.Syntax.Q (Language.Haskell.TH.Lib.Syntax.TyVarBndr Language.Haskell.TH.Lib.Syntax.BndrVis)] -> GHC.Internal.Maybe.Maybe (Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Kind) -> [(Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Con, GHC.Internal.Maybe.Maybe GHC.Internal.Base.String, [GHC.Internal.Maybe.Maybe GHC.Internal.Base.String])] -> GHC.Internal.Maybe.Maybe GHC.Internal.Base.String -> Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Dec
- typeE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Type -> m Language.Haskell.TH.Lib.Syntax.Exp
- typeP :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Type -> m Language.Haskell.TH.Lib.Syntax.Pat
- typedBracketE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Exp
- typedRuleVar :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> m Language.Haskell.TH.Lib.Syntax.Type -> m Language.Haskell.TH.Lib.Syntax.RuleBndr
- typedSpliceE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Exp
- uInfixE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Exp
- uInfixP :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Pat -> Language.Haskell.TH.Lib.Syntax.Name -> m Language.Haskell.TH.Lib.Syntax.Pat -> m Language.Haskell.TH.Lib.Syntax.Pat
- uInfixT :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Type -> Language.Haskell.TH.Lib.Syntax.Name -> m Language.Haskell.TH.Lib.Syntax.Type -> m Language.Haskell.TH.Lib.Syntax.Type
- unboundVarE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> m Language.Haskell.TH.Lib.Syntax.Exp
- unboxedSumE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Exp -> Language.Haskell.TH.Lib.Syntax.SumAlt -> Language.Haskell.TH.Lib.Syntax.SumArity -> m Language.Haskell.TH.Lib.Syntax.Exp
- unboxedSumP :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Pat -> Language.Haskell.TH.Lib.Syntax.SumAlt -> Language.Haskell.TH.Lib.Syntax.SumArity -> m Language.Haskell.TH.Lib.Syntax.Pat
- unboxedSumT :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.SumArity -> m Language.Haskell.TH.Lib.Syntax.Type
- unboxedTupE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => [m Language.Haskell.TH.Lib.Syntax.Exp] -> m Language.Haskell.TH.Lib.Syntax.Exp
- unboxedTupP :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => [m Language.Haskell.TH.Lib.Syntax.Pat] -> m Language.Haskell.TH.Lib.Syntax.Pat
- unboxedTupleT :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => GHC.Types.Int -> m Language.Haskell.TH.Lib.Syntax.Type
- unidir :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.PatSynDir
- unpacked :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Strict
- unsafe :: Language.Haskell.TH.Lib.Syntax.Safety
- valD :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Pat -> m Language.Haskell.TH.Lib.Syntax.Body -> [m Language.Haskell.TH.Lib.Syntax.Dec] -> m Language.Haskell.TH.Lib.Syntax.Dec
- valueAnnotation :: Language.Haskell.TH.Lib.Syntax.Name -> Language.Haskell.TH.Lib.Syntax.AnnTarget
- varBangType :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> m Language.Haskell.TH.Lib.Syntax.BangType -> m Language.Haskell.TH.Lib.Syntax.VarBangType
- varE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> m Language.Haskell.TH.Lib.Syntax.Exp
- varK :: Language.Haskell.TH.Lib.Syntax.Name -> Language.Haskell.TH.Lib.Syntax.Kind
- varP :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> m Language.Haskell.TH.Lib.Syntax.Pat
- varStrictType :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> m Language.Haskell.TH.Lib.Syntax.StrictType -> m Language.Haskell.TH.Lib.Syntax.VarStrictType
- varT :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> m Language.Haskell.TH.Lib.Syntax.Type
- viaStrategy :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Type -> m DerivStrategy
- viewP :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Pat -> m Language.Haskell.TH.Lib.Syntax.Pat
- wildCardT :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Type
- wildP :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Pat
- withDecDoc :: GHC.Internal.Base.String -> Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Dec -> Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Dec
- withDecsDoc :: GHC.Internal.Base.String -> Language.Haskell.TH.Lib.Syntax.Q [Language.Haskell.TH.Lib.Syntax.Dec] -> Language.Haskell.TH.Lib.Syntax.Q [Language.Haskell.TH.Lib.Syntax.Dec]
- wordPrimL :: GHC.Num.Integer.Integer -> Language.Haskell.TH.Lib.Syntax.Lit
+ type VarStrictTypeQ = GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.VarStrictType
+ anyclassStrategy :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m DerivStrategy
+ appE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Exp
+ appK :: GHC.Internal.TH.Syntax.Kind -> GHC.Internal.TH.Syntax.Kind -> GHC.Internal.TH.Syntax.Kind
+ appKindT :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Type -> m GHC.Internal.TH.Syntax.Kind -> m GHC.Internal.TH.Syntax.Type
+ appT :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Type -> m GHC.Internal.TH.Syntax.Type -> m GHC.Internal.TH.Syntax.Type
+ appTypeE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Type -> m GHC.Internal.TH.Syntax.Exp
+ appsE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => [m GHC.Internal.TH.Syntax.Exp] -> m GHC.Internal.TH.Syntax.Exp
+ arithSeqE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Range -> m GHC.Internal.TH.Syntax.Exp
+ arrowK :: GHC.Internal.TH.Syntax.Kind
+ arrowT :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Type
+ asP :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> m GHC.Internal.TH.Syntax.Pat -> m GHC.Internal.TH.Syntax.Pat
+ bang :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.SourceUnpackedness -> m GHC.Internal.TH.Syntax.SourceStrictness -> m GHC.Internal.TH.Syntax.Bang
+ bangP :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Pat -> m GHC.Internal.TH.Syntax.Pat
+ bangType :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Bang -> m GHC.Internal.TH.Syntax.Type -> m GHC.Internal.TH.Syntax.BangType
+ bindS :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Pat -> m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Stmt
+ bndrInvis :: GHC.Internal.TH.Syntax.BndrVis
+ bndrReq :: GHC.Internal.TH.Syntax.BndrVis
+ bytesPrimL :: GHC.Internal.TH.Syntax.Bytes -> GHC.Internal.TH.Syntax.Lit
+ cApi :: GHC.Internal.TH.Syntax.Callconv
+ cCall :: GHC.Internal.TH.Syntax.Callconv
+ caseE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Exp -> [m GHC.Internal.TH.Syntax.Match] -> m GHC.Internal.TH.Syntax.Exp
+ charL :: GHC.Types.Char -> GHC.Internal.TH.Syntax.Lit
+ charPrimL :: GHC.Types.Char -> GHC.Internal.TH.Syntax.Lit
+ charTyLit :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Types.Char -> m GHC.Internal.TH.Syntax.TyLit
+ classD :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Cxt -> GHC.Internal.TH.Syntax.Name -> [GHC.Internal.TH.Syntax.TyVarBndr GHC.Internal.TH.Syntax.BndrVis] -> [GHC.Internal.TH.Syntax.FunDep] -> [m GHC.Internal.TH.Syntax.Dec] -> m GHC.Internal.TH.Syntax.Dec
+ classP :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> [m GHC.Internal.TH.Syntax.Type] -> m GHC.Internal.TH.Syntax.Pred
+ clause :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => [m GHC.Internal.TH.Syntax.Pat] -> m GHC.Internal.TH.Syntax.Body -> [m GHC.Internal.TH.Syntax.Dec] -> m GHC.Internal.TH.Syntax.Clause
+ closedTypeFamilyD :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> [GHC.Internal.TH.Syntax.TyVarBndr GHC.Internal.TH.Syntax.BndrVis] -> GHC.Internal.TH.Syntax.FamilyResultSig -> GHC.Internal.Maybe.Maybe GHC.Internal.TH.Syntax.InjectivityAnn -> [m GHC.Internal.TH.Syntax.TySynEqn] -> m GHC.Internal.TH.Syntax.Dec
+ compE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => [m GHC.Internal.TH.Syntax.Stmt] -> m GHC.Internal.TH.Syntax.Exp
+ conE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> m GHC.Internal.TH.Syntax.Exp
+ conK :: GHC.Internal.TH.Syntax.Name -> GHC.Internal.TH.Syntax.Kind
+ conP :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> [m GHC.Internal.TH.Syntax.Pat] -> m GHC.Internal.TH.Syntax.Pat
+ conT :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> m GHC.Internal.TH.Syntax.Type
+ condE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Exp
+ constraintK :: GHC.Internal.TH.Syntax.Kind
+ cxt :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => [m GHC.Internal.TH.Syntax.Pred] -> m GHC.Internal.TH.Syntax.Cxt
+ dataD :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Cxt -> GHC.Internal.TH.Syntax.Name -> [GHC.Internal.TH.Syntax.TyVarBndr GHC.Internal.TH.Syntax.BndrVis] -> GHC.Internal.Maybe.Maybe GHC.Internal.TH.Syntax.Kind -> [m GHC.Internal.TH.Syntax.Con] -> [m DerivClause] -> m GHC.Internal.TH.Syntax.Dec
+ dataD_doc :: GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Cxt -> GHC.Internal.TH.Syntax.Name -> [GHC.Internal.TH.Syntax.Q (GHC.Internal.TH.Syntax.TyVarBndr GHC.Internal.TH.Syntax.BndrVis)] -> GHC.Internal.Maybe.Maybe (GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Kind) -> [(GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Con, GHC.Internal.Maybe.Maybe GHC.Internal.Base.String, [GHC.Internal.Maybe.Maybe GHC.Internal.Base.String])] -> [GHC.Internal.TH.Syntax.Q DerivClause] -> GHC.Internal.Maybe.Maybe GHC.Internal.Base.String -> GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Dec
+ dataFamilyD :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> [GHC.Internal.TH.Syntax.TyVarBndr GHC.Internal.TH.Syntax.BndrVis] -> GHC.Internal.Maybe.Maybe GHC.Internal.TH.Syntax.Kind -> m GHC.Internal.TH.Syntax.Dec
+ dataInstD :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Cxt -> GHC.Internal.TH.Syntax.Name -> [m GHC.Internal.TH.Syntax.Type] -> GHC.Internal.Maybe.Maybe GHC.Internal.TH.Syntax.Kind -> [m GHC.Internal.TH.Syntax.Con] -> [m DerivClause] -> m GHC.Internal.TH.Syntax.Dec
+ dataInstD_doc :: GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Cxt -> GHC.Internal.Maybe.Maybe [GHC.Internal.TH.Syntax.Q (GHC.Internal.TH.Syntax.TyVarBndr ())] -> GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Type -> GHC.Internal.Maybe.Maybe (GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Kind) -> [(GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Con, GHC.Internal.Maybe.Maybe GHC.Internal.Base.String, [GHC.Internal.Maybe.Maybe GHC.Internal.Base.String])] -> [GHC.Internal.TH.Syntax.Q DerivClause] -> GHC.Internal.Maybe.Maybe GHC.Internal.Base.String -> GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Dec
+ defaultD :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => [m GHC.Internal.TH.Syntax.Type] -> m GHC.Internal.TH.Syntax.Dec
+ defaultSigD :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> m GHC.Internal.TH.Syntax.Type -> m GHC.Internal.TH.Syntax.Dec
+ derivClause :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.Maybe.Maybe DerivStrategy -> [m GHC.Internal.TH.Syntax.Pred] -> m DerivClause
+ doE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => [m GHC.Internal.TH.Syntax.Stmt] -> m GHC.Internal.TH.Syntax.Exp
+ doublePrimL :: GHC.Internal.Real.Rational -> GHC.Internal.TH.Syntax.Lit
+ dyn :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.Base.String -> m GHC.Internal.TH.Syntax.Exp
+ equalP :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Type -> m GHC.Internal.TH.Syntax.Type -> m GHC.Internal.TH.Syntax.Pred
+ equalityT :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Type
+ explBidir :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => [m GHC.Internal.TH.Syntax.Clause] -> m GHC.Internal.TH.Syntax.PatSynDir
+ fieldExp :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> m GHC.Internal.TH.Syntax.Exp -> m (GHC.Internal.TH.Syntax.Name, GHC.Internal.TH.Syntax.Exp)
+ fieldPat :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> m GHC.Internal.TH.Syntax.Pat -> m GHC.Internal.TH.Syntax.FieldPat
+ floatPrimL :: GHC.Internal.Real.Rational -> GHC.Internal.TH.Syntax.Lit
+ forImpD :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Callconv -> GHC.Internal.TH.Syntax.Safety -> GHC.Internal.Base.String -> GHC.Internal.TH.Syntax.Name -> m GHC.Internal.TH.Syntax.Type -> m GHC.Internal.TH.Syntax.Dec
+ forallC :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => [GHC.Internal.TH.Syntax.TyVarBndr GHC.Internal.TH.Syntax.Specificity] -> m GHC.Internal.TH.Syntax.Cxt -> m GHC.Internal.TH.Syntax.Con -> m GHC.Internal.TH.Syntax.Con
+ forallT :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => [GHC.Internal.TH.Syntax.TyVarBndr GHC.Internal.TH.Syntax.Specificity] -> m GHC.Internal.TH.Syntax.Cxt -> m GHC.Internal.TH.Syntax.Type -> m GHC.Internal.TH.Syntax.Type
+ forallVisT :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => [m (GHC.Internal.TH.Syntax.TyVarBndr ())] -> m GHC.Internal.TH.Syntax.Type -> m GHC.Internal.TH.Syntax.Type
+ fromE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Exp
+ fromR :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Range
+ fromThenE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Exp
+ fromThenR :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Range
+ fromThenToE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Exp
+ fromThenToR :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Range
+ fromToE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Exp
+ fromToR :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Range
+ funD :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> [m GHC.Internal.TH.Syntax.Clause] -> m GHC.Internal.TH.Syntax.Dec
+ funD_doc :: GHC.Internal.TH.Syntax.Name -> [GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Clause] -> GHC.Internal.Maybe.Maybe GHC.Internal.Base.String -> [GHC.Internal.Maybe.Maybe GHC.Internal.Base.String] -> GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Dec
+ funDep :: [GHC.Internal.TH.Syntax.Name] -> [GHC.Internal.TH.Syntax.Name] -> GHC.Internal.TH.Syntax.FunDep
+ gadtC :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => [GHC.Internal.TH.Syntax.Name] -> [m GHC.Internal.TH.Syntax.StrictType] -> m GHC.Internal.TH.Syntax.Type -> m GHC.Internal.TH.Syntax.Con
+ getFieldE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Exp -> GHC.Internal.Base.String -> m GHC.Internal.TH.Syntax.Exp
+ guardedB :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => [m (GHC.Internal.TH.Syntax.Guard, GHC.Internal.TH.Syntax.Exp)] -> m GHC.Internal.TH.Syntax.Body
+ implBidir :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.PatSynDir
+ implicitParamBindD :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.Base.String -> m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Dec
+ implicitParamT :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.Base.String -> m GHC.Internal.TH.Syntax.Type -> m GHC.Internal.TH.Syntax.Type
+ implicitParamVarE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.Base.String -> m GHC.Internal.TH.Syntax.Exp
+ inferR :: GHC.Internal.TH.Lib.Role
+ inferredSpec :: GHC.Internal.TH.Syntax.Specificity
+ infixApp :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Exp
+ infixC :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m (GHC.Internal.TH.Syntax.Bang, GHC.Internal.TH.Syntax.Type) -> GHC.Internal.TH.Syntax.Name -> m (GHC.Internal.TH.Syntax.Bang, GHC.Internal.TH.Syntax.Type) -> m GHC.Internal.TH.Syntax.Con
+ infixE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.Maybe.Maybe (m GHC.Internal.TH.Syntax.Exp) -> m GHC.Internal.TH.Syntax.Exp -> GHC.Internal.Maybe.Maybe (m GHC.Internal.TH.Syntax.Exp) -> m GHC.Internal.TH.Syntax.Exp
+ infixLD :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Types.Int -> GHC.Internal.TH.Syntax.Name -> m GHC.Internal.TH.Syntax.Dec
+ infixND :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Types.Int -> GHC.Internal.TH.Syntax.Name -> m GHC.Internal.TH.Syntax.Dec
+ infixP :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Pat -> GHC.Internal.TH.Syntax.Name -> m GHC.Internal.TH.Syntax.Pat -> m GHC.Internal.TH.Syntax.Pat
+ infixPatSyn :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> GHC.Internal.TH.Syntax.Name -> m GHC.Internal.TH.Syntax.PatSynArgs
+ infixRD :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Types.Int -> GHC.Internal.TH.Syntax.Name -> m GHC.Internal.TH.Syntax.Dec
+ infixT :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Type -> GHC.Internal.TH.Syntax.Name -> m GHC.Internal.TH.Syntax.Type -> m GHC.Internal.TH.Syntax.Type
+ injectivityAnn :: GHC.Internal.TH.Syntax.Name -> [GHC.Internal.TH.Syntax.Name] -> GHC.Internal.TH.Lib.InjectivityAnn
+ instanceD :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Cxt -> m GHC.Internal.TH.Syntax.Type -> [m GHC.Internal.TH.Syntax.Dec] -> m GHC.Internal.TH.Syntax.Dec
+ instanceWithOverlapD :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.Maybe.Maybe Overlap -> m GHC.Internal.TH.Syntax.Cxt -> m GHC.Internal.TH.Syntax.Type -> [m GHC.Internal.TH.Syntax.Dec] -> m GHC.Internal.TH.Syntax.Dec
+ intPrimL :: GHC.Num.Integer.Integer -> GHC.Internal.TH.Syntax.Lit
+ integerL :: GHC.Num.Integer.Integer -> GHC.Internal.TH.Syntax.Lit
+ interruptible :: GHC.Internal.TH.Syntax.Safety
+ invisP :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Type -> m GHC.Internal.TH.Syntax.Pat
+ isStrict :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Strict
+ javaScript :: GHC.Internal.TH.Syntax.Callconv
+ kiSigD :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> m GHC.Internal.TH.Syntax.Kind -> m GHC.Internal.TH.Syntax.Dec
+ kindSig :: GHC.Internal.TH.Syntax.Kind -> GHC.Internal.TH.Syntax.FamilyResultSig
+ kindedBndrTV :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> GHC.Internal.TH.Syntax.BndrVis -> m GHC.Internal.TH.Syntax.Kind -> m (GHC.Internal.TH.Syntax.TyVarBndr GHC.Internal.TH.Syntax.BndrVis)
+ kindedInvisTV :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> GHC.Internal.TH.Syntax.Specificity -> m GHC.Internal.TH.Syntax.Kind -> m (GHC.Internal.TH.Syntax.TyVarBndr GHC.Internal.TH.Syntax.Specificity)
+ kindedTV :: forall flag. DefaultBndrFlag flag => GHC.Internal.TH.Syntax.Name -> GHC.Internal.TH.Syntax.Kind -> GHC.Internal.TH.Syntax.TyVarBndr flag
+ labelE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.Base.String -> m GHC.Internal.TH.Syntax.Exp
+ lam1E :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Pat -> m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Exp
+ lamCaseE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => [m GHC.Internal.TH.Syntax.Match] -> m GHC.Internal.TH.Syntax.Exp
+ lamCasesE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => [m GHC.Internal.TH.Syntax.Clause] -> m GHC.Internal.TH.Syntax.Exp
+ lamE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => [m GHC.Internal.TH.Syntax.Pat] -> m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Exp
+ letE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => [m GHC.Internal.TH.Syntax.Dec] -> m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Exp
+ letS :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => [m GHC.Internal.TH.Syntax.Dec] -> m GHC.Internal.TH.Syntax.Stmt
+ listE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => [m GHC.Internal.TH.Syntax.Exp] -> m GHC.Internal.TH.Syntax.Exp
+ listK :: GHC.Internal.TH.Syntax.Kind
+ listP :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => [m GHC.Internal.TH.Syntax.Pat] -> m GHC.Internal.TH.Syntax.Pat
+ listT :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Type
+ litE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Lit -> m GHC.Internal.TH.Syntax.Exp
+ litP :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Lit -> m GHC.Internal.TH.Syntax.Pat
+ litT :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.TyLit -> m GHC.Internal.TH.Syntax.Type
+ match :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Pat -> m GHC.Internal.TH.Syntax.Body -> [m GHC.Internal.TH.Syntax.Dec] -> m GHC.Internal.TH.Syntax.Match
+ mdoE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => [m GHC.Internal.TH.Syntax.Stmt] -> m GHC.Internal.TH.Syntax.Exp
+ mkBytes :: GHC.Internal.ForeignPtr.ForeignPtr GHC.Internal.Word.Word8 -> GHC.Types.Word -> GHC.Types.Word -> GHC.Internal.TH.Syntax.Bytes
+ moduleAnnotation :: GHC.Internal.TH.Syntax.AnnTarget
+ mulArrowT :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Type
+ multiIfE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => [m (GHC.Internal.TH.Syntax.Guard, GHC.Internal.TH.Syntax.Exp)] -> m GHC.Internal.TH.Syntax.Exp
+ newtypeD :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Cxt -> GHC.Internal.TH.Syntax.Name -> [GHC.Internal.TH.Syntax.TyVarBndr GHC.Internal.TH.Syntax.BndrVis] -> GHC.Internal.Maybe.Maybe GHC.Internal.TH.Syntax.Kind -> m GHC.Internal.TH.Syntax.Con -> [m DerivClause] -> m GHC.Internal.TH.Syntax.Dec
+ newtypeD_doc :: GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Cxt -> GHC.Internal.TH.Syntax.Name -> [GHC.Internal.TH.Syntax.Q (GHC.Internal.TH.Syntax.TyVarBndr GHC.Internal.TH.Syntax.BndrVis)] -> GHC.Internal.Maybe.Maybe (GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Kind) -> (GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Con, GHC.Internal.Maybe.Maybe GHC.Internal.Base.String, [GHC.Internal.Maybe.Maybe GHC.Internal.Base.String]) -> [GHC.Internal.TH.Syntax.Q DerivClause] -> GHC.Internal.Maybe.Maybe GHC.Internal.Base.String -> GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Dec
+ newtypeInstD :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Cxt -> GHC.Internal.TH.Syntax.Name -> [m GHC.Internal.TH.Syntax.Type] -> GHC.Internal.Maybe.Maybe GHC.Internal.TH.Syntax.Kind -> m GHC.Internal.TH.Syntax.Con -> [m DerivClause] -> m GHC.Internal.TH.Syntax.Dec
+ newtypeInstD_doc :: GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Cxt -> GHC.Internal.Maybe.Maybe [GHC.Internal.TH.Syntax.Q (GHC.Internal.TH.Syntax.TyVarBndr ())] -> GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Type -> GHC.Internal.Maybe.Maybe (GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Kind) -> (GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Con, GHC.Internal.Maybe.Maybe GHC.Internal.Base.String, [GHC.Internal.Maybe.Maybe GHC.Internal.Base.String]) -> [GHC.Internal.TH.Syntax.Q DerivClause] -> GHC.Internal.Maybe.Maybe GHC.Internal.Base.String -> GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Dec
+ newtypeStrategy :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m DerivStrategy
+ noBindS :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Stmt
+ noSig :: GHC.Internal.TH.Syntax.FamilyResultSig
+ noSourceStrictness :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.SourceStrictness
+ noSourceUnpackedness :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.SourceUnpackedness
+ nominalR :: GHC.Internal.TH.Lib.Role
+ normalB :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Body
+ normalC :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> [m GHC.Internal.TH.Syntax.BangType] -> m GHC.Internal.TH.Syntax.Con
+ normalG :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Guard
+ normalGE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Exp -> m (GHC.Internal.TH.Syntax.Guard, GHC.Internal.TH.Syntax.Exp)
+ notStrict :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Strict
+ numTyLit :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Num.Integer.Integer -> m GHC.Internal.TH.Syntax.TyLit
+ openTypeFamilyD :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> [GHC.Internal.TH.Syntax.TyVarBndr GHC.Internal.TH.Syntax.BndrVis] -> GHC.Internal.TH.Syntax.FamilyResultSig -> GHC.Internal.Maybe.Maybe GHC.Internal.TH.Syntax.InjectivityAnn -> m GHC.Internal.TH.Syntax.Dec
+ parS :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => [[m GHC.Internal.TH.Syntax.Stmt]] -> m GHC.Internal.TH.Syntax.Stmt
+ parensE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Exp
+ parensP :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Pat -> m GHC.Internal.TH.Syntax.Pat
+ parensT :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Type -> m GHC.Internal.TH.Syntax.Type
+ patG :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => [m GHC.Internal.TH.Syntax.Stmt] -> m GHC.Internal.TH.Syntax.Guard
+ patGE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => [m GHC.Internal.TH.Syntax.Stmt] -> m GHC.Internal.TH.Syntax.Exp -> m (GHC.Internal.TH.Syntax.Guard, GHC.Internal.TH.Syntax.Exp)
+ patSynD :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> m GHC.Internal.TH.Syntax.PatSynArgs -> m GHC.Internal.TH.Syntax.PatSynDir -> m GHC.Internal.TH.Syntax.Pat -> m GHC.Internal.TH.Syntax.Dec
+ patSynD_doc :: GHC.Internal.TH.Syntax.Name -> GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.PatSynArgs -> GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.PatSynDir -> GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Pat -> GHC.Internal.Maybe.Maybe GHC.Internal.Base.String -> [GHC.Internal.Maybe.Maybe GHC.Internal.Base.String] -> GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Dec
+ patSynSigD :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> m GHC.Internal.TH.Syntax.Type -> m GHC.Internal.TH.Syntax.Dec
+ phantomR :: GHC.Internal.TH.Lib.Role
+ plainBndrTV :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> GHC.Internal.TH.Syntax.BndrVis -> m (GHC.Internal.TH.Syntax.TyVarBndr GHC.Internal.TH.Syntax.BndrVis)
+ plainInvisTV :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> GHC.Internal.TH.Syntax.Specificity -> m (GHC.Internal.TH.Syntax.TyVarBndr GHC.Internal.TH.Syntax.Specificity)
+ plainTV :: forall flag. DefaultBndrFlag flag => GHC.Internal.TH.Syntax.Name -> GHC.Internal.TH.Syntax.TyVarBndr flag
+ pragAnnD :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.AnnTarget -> m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Dec
+ pragCompleteD :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => [GHC.Internal.TH.Syntax.Name] -> GHC.Internal.Maybe.Maybe GHC.Internal.TH.Syntax.Name -> m GHC.Internal.TH.Syntax.Dec
+ pragInlD :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> GHC.Internal.TH.Syntax.Inline -> GHC.Internal.TH.Syntax.RuleMatch -> GHC.Internal.TH.Syntax.Phases -> m GHC.Internal.TH.Syntax.Dec
+ pragLineD :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Types.Int -> GHC.Internal.Base.String -> m GHC.Internal.TH.Syntax.Dec
+ pragRuleD :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.Base.String -> [m GHC.Internal.TH.Syntax.RuleBndr] -> m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Exp -> GHC.Internal.TH.Syntax.Phases -> m GHC.Internal.TH.Syntax.Dec
+ pragSpecD :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> m GHC.Internal.TH.Syntax.Type -> GHC.Internal.TH.Syntax.Phases -> m GHC.Internal.TH.Syntax.Dec
+ pragSpecInlD :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> m GHC.Internal.TH.Syntax.Type -> GHC.Internal.TH.Syntax.Inline -> GHC.Internal.TH.Syntax.Phases -> m GHC.Internal.TH.Syntax.Dec
+ pragSpecInstD :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Type -> m GHC.Internal.TH.Syntax.Dec
+ prefixPatSyn :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => [GHC.Internal.TH.Syntax.Name] -> m GHC.Internal.TH.Syntax.PatSynArgs
+ prim :: GHC.Internal.TH.Syntax.Callconv
+ projectionE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.Base.NonEmpty GHC.Internal.Base.String -> m GHC.Internal.TH.Syntax.Exp
+ promotedConsT :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Type
+ promotedInfixT :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Type -> GHC.Internal.TH.Syntax.Name -> m GHC.Internal.TH.Syntax.Type -> m GHC.Internal.TH.Syntax.Type
+ promotedNilT :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Type
+ promotedT :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> m GHC.Internal.TH.Syntax.Type
+ promotedTupleT :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Types.Int -> m GHC.Internal.TH.Syntax.Type
+ promotedUInfixT :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Type -> GHC.Internal.TH.Syntax.Name -> m GHC.Internal.TH.Syntax.Type -> m GHC.Internal.TH.Syntax.Type
+ rationalL :: GHC.Internal.Real.Rational -> GHC.Internal.TH.Syntax.Lit
+ recC :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> [m GHC.Internal.TH.Syntax.VarBangType] -> m GHC.Internal.TH.Syntax.Con
+ recConE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> [m (GHC.Internal.TH.Syntax.Name, GHC.Internal.TH.Syntax.Exp)] -> m GHC.Internal.TH.Syntax.Exp
+ recGadtC :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => [GHC.Internal.TH.Syntax.Name] -> [m GHC.Internal.TH.Syntax.VarStrictType] -> m GHC.Internal.TH.Syntax.Type -> m GHC.Internal.TH.Syntax.Con
+ recP :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> [m GHC.Internal.TH.Syntax.FieldPat] -> m GHC.Internal.TH.Syntax.Pat
+ recS :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => [m GHC.Internal.TH.Syntax.Stmt] -> m GHC.Internal.TH.Syntax.Stmt
+ recUpdE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Exp -> [m (GHC.Internal.TH.Syntax.Name, GHC.Internal.TH.Syntax.Exp)] -> m GHC.Internal.TH.Syntax.Exp
+ recordPatSyn :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => [GHC.Internal.TH.Syntax.Name] -> m GHC.Internal.TH.Syntax.PatSynArgs
+ representationalR :: GHC.Internal.TH.Lib.Role
+ roleAnnotD :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> [GHC.Internal.TH.Lib.Role] -> m GHC.Internal.TH.Syntax.Dec
+ ruleVar :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> m GHC.Internal.TH.Syntax.RuleBndr
+ safe :: GHC.Internal.TH.Syntax.Safety
+ sectionL :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Exp
+ sectionR :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Exp
+ sigD :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> m GHC.Internal.TH.Syntax.Type -> m GHC.Internal.TH.Syntax.Dec
+ sigE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Type -> m GHC.Internal.TH.Syntax.Exp
+ sigP :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Pat -> m GHC.Internal.TH.Syntax.Type -> m GHC.Internal.TH.Syntax.Pat
+ sigT :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Type -> GHC.Internal.TH.Syntax.Kind -> m GHC.Internal.TH.Syntax.Type
+ sourceLazy :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.SourceStrictness
+ sourceNoUnpack :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.SourceUnpackedness
+ sourceStrict :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.SourceStrictness
+ sourceUnpack :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.SourceUnpackedness
+ specifiedSpec :: GHC.Internal.TH.Syntax.Specificity
+ standaloneDerivD :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Cxt -> m GHC.Internal.TH.Syntax.Type -> m GHC.Internal.TH.Syntax.Dec
+ standaloneDerivWithStrategyD :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.Maybe.Maybe DerivStrategy -> m GHC.Internal.TH.Syntax.Cxt -> m GHC.Internal.TH.Syntax.Type -> m GHC.Internal.TH.Syntax.Dec
+ starK :: GHC.Internal.TH.Syntax.Kind
+ staticE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Exp
+ stdCall :: GHC.Internal.TH.Syntax.Callconv
+ stockStrategy :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m DerivStrategy
+ strTyLit :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.Base.String -> m GHC.Internal.TH.Syntax.TyLit
+ strictType :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Strict -> m GHC.Internal.TH.Syntax.Type -> m GHC.Internal.TH.Syntax.StrictType
+ stringE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.Base.String -> m GHC.Internal.TH.Syntax.Exp
+ stringL :: GHC.Internal.Base.String -> GHC.Internal.TH.Syntax.Lit
+ stringPrimL :: [GHC.Internal.Word.Word8] -> GHC.Internal.TH.Syntax.Lit
+ thisModule :: GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Module
+ tildeP :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Pat -> m GHC.Internal.TH.Syntax.Pat
+ tupE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => [m GHC.Internal.TH.Syntax.Exp] -> m GHC.Internal.TH.Syntax.Exp
+ tupP :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => [m GHC.Internal.TH.Syntax.Pat] -> m GHC.Internal.TH.Syntax.Pat
+ tupleK :: GHC.Types.Int -> GHC.Internal.TH.Syntax.Kind
+ tupleT :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Types.Int -> m GHC.Internal.TH.Syntax.Type
+ tySynD :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> [GHC.Internal.TH.Syntax.TyVarBndr GHC.Internal.TH.Syntax.BndrVis] -> m GHC.Internal.TH.Syntax.Type -> m GHC.Internal.TH.Syntax.Dec
+ tySynEqn :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.Maybe.Maybe [GHC.Internal.TH.Syntax.TyVarBndr ()] -> m GHC.Internal.TH.Syntax.Type -> m GHC.Internal.TH.Syntax.Type -> m GHC.Internal.TH.Syntax.TySynEqn
+ tySynInstD :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.TySynEqn -> m GHC.Internal.TH.Syntax.Dec
+ tyVarSig :: GHC.Internal.TH.Syntax.TyVarBndr () -> GHC.Internal.TH.Syntax.FamilyResultSig
+ typeAnnotation :: GHC.Internal.TH.Syntax.Name -> GHC.Internal.TH.Syntax.AnnTarget
+ typeDataD :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> [GHC.Internal.TH.Syntax.TyVarBndr GHC.Internal.TH.Syntax.BndrVis] -> GHC.Internal.Maybe.Maybe GHC.Internal.TH.Syntax.Kind -> [m GHC.Internal.TH.Syntax.Con] -> m GHC.Internal.TH.Syntax.Dec
+ typeDataD_doc :: GHC.Internal.TH.Syntax.Name -> [GHC.Internal.TH.Syntax.Q (GHC.Internal.TH.Syntax.TyVarBndr GHC.Internal.TH.Syntax.BndrVis)] -> GHC.Internal.Maybe.Maybe (GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Kind) -> [(GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Con, GHC.Internal.Maybe.Maybe GHC.Internal.Base.String, [GHC.Internal.Maybe.Maybe GHC.Internal.Base.String])] -> GHC.Internal.Maybe.Maybe GHC.Internal.Base.String -> GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Dec
+ typeE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Type -> m GHC.Internal.TH.Syntax.Exp
+ typeP :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Type -> m GHC.Internal.TH.Syntax.Pat
+ typedBracketE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Exp
+ typedRuleVar :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> m GHC.Internal.TH.Syntax.Type -> m GHC.Internal.TH.Syntax.RuleBndr
+ typedSpliceE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Exp
+ uInfixE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Exp
+ uInfixP :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Pat -> GHC.Internal.TH.Syntax.Name -> m GHC.Internal.TH.Syntax.Pat -> m GHC.Internal.TH.Syntax.Pat
+ uInfixT :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Type -> GHC.Internal.TH.Syntax.Name -> m GHC.Internal.TH.Syntax.Type -> m GHC.Internal.TH.Syntax.Type
+ unboundVarE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> m GHC.Internal.TH.Syntax.Exp
+ unboxedSumE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Exp -> GHC.Internal.TH.Syntax.SumAlt -> GHC.Internal.TH.Syntax.SumArity -> m GHC.Internal.TH.Syntax.Exp
+ unboxedSumP :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Pat -> GHC.Internal.TH.Syntax.SumAlt -> GHC.Internal.TH.Syntax.SumArity -> m GHC.Internal.TH.Syntax.Pat
+ unboxedSumT :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.SumArity -> m GHC.Internal.TH.Syntax.Type
+ unboxedTupE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => [m GHC.Internal.TH.Syntax.Exp] -> m GHC.Internal.TH.Syntax.Exp
+ unboxedTupP :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => [m GHC.Internal.TH.Syntax.Pat] -> m GHC.Internal.TH.Syntax.Pat
+ unboxedTupleT :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Types.Int -> m GHC.Internal.TH.Syntax.Type
+ unidir :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.PatSynDir
+ unpacked :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Strict
+ unsafe :: GHC.Internal.TH.Syntax.Safety
+ valD :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Pat -> m GHC.Internal.TH.Syntax.Body -> [m GHC.Internal.TH.Syntax.Dec] -> m GHC.Internal.TH.Syntax.Dec
+ valueAnnotation :: GHC.Internal.TH.Syntax.Name -> GHC.Internal.TH.Syntax.AnnTarget
+ varBangType :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> m GHC.Internal.TH.Syntax.BangType -> m GHC.Internal.TH.Syntax.VarBangType
+ varE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> m GHC.Internal.TH.Syntax.Exp
+ varK :: GHC.Internal.TH.Syntax.Name -> GHC.Internal.TH.Syntax.Kind
+ varP :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> m GHC.Internal.TH.Syntax.Pat
+ varStrictType :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> m GHC.Internal.TH.Syntax.StrictType -> m GHC.Internal.TH.Syntax.VarStrictType
+ varT :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> m GHC.Internal.TH.Syntax.Type
+ viaStrategy :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Type -> m DerivStrategy
+ viewP :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Pat -> m GHC.Internal.TH.Syntax.Pat
+ wildCardT :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Type
+ wildP :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Pat
+ withDecDoc :: GHC.Internal.Base.String -> GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Dec -> GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Dec
+ withDecsDoc :: GHC.Internal.Base.String -> GHC.Internal.TH.Syntax.Q [GHC.Internal.TH.Syntax.Dec] -> GHC.Internal.TH.Syntax.Q [GHC.Internal.TH.Syntax.Dec]
+ wordPrimL :: GHC.Num.Integer.Integer -> GHC.Internal.TH.Syntax.Lit
module Language.Haskell.TH.Lib.Internal where
- -- Safety: Trustworthy
+ -- Safety: Safe
type BangQ :: *
- type BangQ = Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Bang
+ type BangQ = GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Bang
type BangTypeQ :: *
- type BangTypeQ = Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.BangType
+ type BangTypeQ = GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.BangType
type BodyQ :: *
- type BodyQ = Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Body
+ type BodyQ = GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Body
type ClauseQ :: *
- type ClauseQ = Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Clause
+ type ClauseQ = GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Clause
type CodeQ :: forall (r :: GHC.Types.RuntimeRep). TYPE r -> *
- type CodeQ = Language.Haskell.TH.Lib.Syntax.Code Language.Haskell.TH.Lib.Syntax.Q :: forall (r :: GHC.Types.RuntimeRep). TYPE r -> *
+ type CodeQ = GHC.Internal.TH.Syntax.Code GHC.Internal.TH.Syntax.Q :: forall (r :: GHC.Types.RuntimeRep). TYPE r -> *
type ConQ :: *
- type ConQ = Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Con
+ type ConQ = GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Con
type CxtQ :: *
- type CxtQ = Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Cxt
+ type CxtQ = GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Cxt
type DecQ :: *
- type DecQ = Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Dec
+ type DecQ = GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Dec
type Decs :: *
- type Decs = [Language.Haskell.TH.Lib.Syntax.Dec]
+ type Decs = [GHC.Internal.TH.Syntax.Dec]
type DecsQ :: *
- type DecsQ = Language.Haskell.TH.Lib.Syntax.Q [Language.Haskell.TH.Lib.Syntax.Dec]
+ type DecsQ = GHC.Internal.TH.Syntax.Q [GHC.Internal.TH.Syntax.Dec]
type DerivClauseQ :: *
- type DerivClauseQ = Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.DerivClause
+ type DerivClauseQ = GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.DerivClause
type DerivStrategyQ :: *
- type DerivStrategyQ = Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.DerivStrategy
+ type DerivStrategyQ = GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.DerivStrategy
type ExpQ :: *
- type ExpQ = Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Exp
+ type ExpQ = GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Exp
type FamilyResultSigQ :: *
- type FamilyResultSigQ = Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.FamilyResultSig
+ type FamilyResultSigQ = GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.FamilyResultSig
type FieldExpQ :: *
- type FieldExpQ = Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.FieldExp
+ type FieldExpQ = GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.FieldExp
type FieldPatQ :: *
- type FieldPatQ = Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.FieldPat
+ type FieldPatQ = GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.FieldPat
type GuardQ :: *
- type GuardQ = Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Guard
+ type GuardQ = GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Guard
type InfoQ :: *
- type InfoQ = Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Info
+ type InfoQ = GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Info
type InjectivityAnn :: *
- type InjectivityAnn = Language.Haskell.TH.Lib.Syntax.InjectivityAnn
+ type InjectivityAnn = GHC.Internal.TH.Syntax.InjectivityAnn
type KindQ :: *
- type KindQ = Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Kind
+ type KindQ = GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Kind
type MatchQ :: *
- type MatchQ = Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Match
+ type MatchQ = GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Match
type PatQ :: *
- type PatQ = Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Pat
+ type PatQ = GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Pat
type PatSynArgsQ :: *
- type PatSynArgsQ = Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.PatSynArgs
+ type PatSynArgsQ = GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.PatSynArgs
type PatSynDirQ :: *
- type PatSynDirQ = Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.PatSynDir
+ type PatSynDirQ = GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.PatSynDir
type PredQ :: *
- type PredQ = Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Pred
+ type PredQ = GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Pred
type RangeQ :: *
- type RangeQ = Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Range
+ type RangeQ = GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Range
type Role :: *
- type Role = Language.Haskell.TH.Lib.Syntax.Role
+ type Role = GHC.Internal.TH.Syntax.Role
type RuleBndrQ :: *
- type RuleBndrQ = Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.RuleBndr
+ type RuleBndrQ = GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.RuleBndr
type SourceStrictnessQ :: *
- type SourceStrictnessQ = Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.SourceStrictness
+ type SourceStrictnessQ = GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.SourceStrictness
type SourceUnpackednessQ :: *
- type SourceUnpackednessQ = Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.SourceUnpackedness
+ type SourceUnpackednessQ = GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.SourceUnpackedness
type StmtQ :: *
- type StmtQ = Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Stmt
+ type StmtQ = GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Stmt
type StrictTypeQ :: *
- type StrictTypeQ = Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.StrictType
+ type StrictTypeQ = GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.StrictType
type TExpQ :: forall (r :: GHC.Types.RuntimeRep). TYPE r -> *
- type TExpQ a = Language.Haskell.TH.Lib.Syntax.Q (Language.Haskell.TH.Lib.Syntax.TExp a)
+ type TExpQ a = GHC.Internal.TH.Syntax.Q (GHC.Internal.TH.Syntax.TExp a)
type TyLitQ :: *
- type TyLitQ = Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.TyLit
+ type TyLitQ = GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.TyLit
type TySynEqnQ :: *
- type TySynEqnQ = Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.TySynEqn
+ type TySynEqnQ = GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.TySynEqn
type TyVarBndrSpec :: *
- type TyVarBndrSpec = Language.Haskell.TH.Lib.Syntax.TyVarBndr Language.Haskell.TH.Lib.Syntax.Specificity
+ type TyVarBndrSpec = GHC.Internal.TH.Syntax.TyVarBndr GHC.Internal.TH.Syntax.Specificity
type TyVarBndrUnit :: *
- type TyVarBndrUnit = Language.Haskell.TH.Lib.Syntax.TyVarBndr ()
+ type TyVarBndrUnit = GHC.Internal.TH.Syntax.TyVarBndr ()
type TyVarBndrVis :: *
- type TyVarBndrVis = Language.Haskell.TH.Lib.Syntax.TyVarBndr Language.Haskell.TH.Lib.Syntax.BndrVis
+ type TyVarBndrVis = GHC.Internal.TH.Syntax.TyVarBndr GHC.Internal.TH.Syntax.BndrVis
type TypeQ :: *
- type TypeQ = Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Type
+ type TypeQ = GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Type
type VarBangTypeQ :: *
- type VarBangTypeQ = Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.VarBangType
+ type VarBangTypeQ = GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.VarBangType
type VarStrictTypeQ :: *
- type VarStrictTypeQ = Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.VarStrictType
- anyclassStrategy :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.DerivStrategy
- appE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Exp
- appK :: Language.Haskell.TH.Lib.Syntax.Kind -> Language.Haskell.TH.Lib.Syntax.Kind -> Language.Haskell.TH.Lib.Syntax.Kind
- appKindT :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Type -> m Language.Haskell.TH.Lib.Syntax.Kind -> m Language.Haskell.TH.Lib.Syntax.Type
- appT :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Type -> m Language.Haskell.TH.Lib.Syntax.Type -> m Language.Haskell.TH.Lib.Syntax.Type
- appTypeE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Type -> m Language.Haskell.TH.Lib.Syntax.Exp
- appsE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => [m Language.Haskell.TH.Lib.Syntax.Exp] -> m Language.Haskell.TH.Lib.Syntax.Exp
- arithSeqE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Range -> m Language.Haskell.TH.Lib.Syntax.Exp
- arrowK :: Language.Haskell.TH.Lib.Syntax.Kind
- arrowT :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Type
- asP :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> m Language.Haskell.TH.Lib.Syntax.Pat -> m Language.Haskell.TH.Lib.Syntax.Pat
- bang :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.SourceUnpackedness -> m Language.Haskell.TH.Lib.Syntax.SourceStrictness -> m Language.Haskell.TH.Lib.Syntax.Bang
- bangP :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Pat -> m Language.Haskell.TH.Lib.Syntax.Pat
- bangType :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Bang -> m Language.Haskell.TH.Lib.Syntax.Type -> m Language.Haskell.TH.Lib.Syntax.BangType
- bindS :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Pat -> m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Stmt
- bndrInvis :: Language.Haskell.TH.Lib.Syntax.BndrVis
- bndrReq :: Language.Haskell.TH.Lib.Syntax.BndrVis
- bytesPrimL :: Language.Haskell.TH.Lib.Syntax.Bytes -> Language.Haskell.TH.Lib.Syntax.Lit
- cApi :: Language.Haskell.TH.Lib.Syntax.Callconv
- cCall :: Language.Haskell.TH.Lib.Syntax.Callconv
- caseE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Exp -> [m Language.Haskell.TH.Lib.Syntax.Match] -> m Language.Haskell.TH.Lib.Syntax.Exp
- charL :: GHC.Types.Char -> Language.Haskell.TH.Lib.Syntax.Lit
- charPrimL :: GHC.Types.Char -> Language.Haskell.TH.Lib.Syntax.Lit
- charTyLit :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => GHC.Types.Char -> m Language.Haskell.TH.Lib.Syntax.TyLit
- classD :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Cxt -> Language.Haskell.TH.Lib.Syntax.Name -> [m (Language.Haskell.TH.Lib.Syntax.TyVarBndr Language.Haskell.TH.Lib.Syntax.BndrVis)] -> [Language.Haskell.TH.Lib.Syntax.FunDep] -> [m Language.Haskell.TH.Lib.Syntax.Dec] -> m Language.Haskell.TH.Lib.Syntax.Dec
- classP :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> [m Language.Haskell.TH.Lib.Syntax.Type] -> m Language.Haskell.TH.Lib.Syntax.Pred
- clause :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => [m Language.Haskell.TH.Lib.Syntax.Pat] -> m Language.Haskell.TH.Lib.Syntax.Body -> [m Language.Haskell.TH.Lib.Syntax.Dec] -> m Language.Haskell.TH.Lib.Syntax.Clause
- closedTypeFamilyD :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> [m (Language.Haskell.TH.Lib.Syntax.TyVarBndr Language.Haskell.TH.Lib.Syntax.BndrVis)] -> m Language.Haskell.TH.Lib.Syntax.FamilyResultSig -> GHC.Internal.Maybe.Maybe InjectivityAnn -> [m Language.Haskell.TH.Lib.Syntax.TySynEqn] -> m Language.Haskell.TH.Lib.Syntax.Dec
- compE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => [m Language.Haskell.TH.Lib.Syntax.Stmt] -> m Language.Haskell.TH.Lib.Syntax.Exp
- conE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> m Language.Haskell.TH.Lib.Syntax.Exp
- conK :: Language.Haskell.TH.Lib.Syntax.Name -> Language.Haskell.TH.Lib.Syntax.Kind
- conP :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> [m Language.Haskell.TH.Lib.Syntax.Type] -> [m Language.Haskell.TH.Lib.Syntax.Pat] -> m Language.Haskell.TH.Lib.Syntax.Pat
- conT :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> m Language.Haskell.TH.Lib.Syntax.Type
- condE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Exp
- constraintK :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Kind
- cxt :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => [m Language.Haskell.TH.Lib.Syntax.Pred] -> m Language.Haskell.TH.Lib.Syntax.Cxt
- dataD :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Cxt -> Language.Haskell.TH.Lib.Syntax.Name -> [m (Language.Haskell.TH.Lib.Syntax.TyVarBndr Language.Haskell.TH.Lib.Syntax.BndrVis)] -> GHC.Internal.Maybe.Maybe (m Language.Haskell.TH.Lib.Syntax.Kind) -> [m Language.Haskell.TH.Lib.Syntax.Con] -> [m Language.Haskell.TH.Lib.Syntax.DerivClause] -> m Language.Haskell.TH.Lib.Syntax.Dec
- dataD_doc ::
- Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Cxt
- -> Language.Haskell.TH.Lib.Syntax.Name -> [Language.Haskell.TH.Lib.Syntax.Q (Language.Haskell.TH.Lib.Syntax.TyVarBndr Language.Haskell.TH.Lib.Syntax.BndrVis)] -> GHC.Internal.Maybe.Maybe (Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Kind) -> [(Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Con, GHC.Internal.Maybe.Maybe GHC.Internal.Base.String, [GHC.Internal.Maybe.Maybe GHC.Internal.Base.String])] -> [Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.DerivClause] -> GHC.Internal.Maybe.Maybe GHC.Internal.Base.String -> Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Dec
- dataFamilyD :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> [m (Language.Haskell.TH.Lib.Syntax.TyVarBndr Language.Haskell.TH.Lib.Syntax.BndrVis)] -> GHC.Internal.Maybe.Maybe (m Language.Haskell.TH.Lib.Syntax.Kind) -> m Language.Haskell.TH.Lib.Syntax.Dec
- dataInstD :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Cxt -> GHC.Internal.Maybe.Maybe [m (Language.Haskell.TH.Lib.Syntax.TyVarBndr ())] -> m Language.Haskell.TH.Lib.Syntax.Type -> GHC.Internal.Maybe.Maybe (m Language.Haskell.TH.Lib.Syntax.Kind) -> [m Language.Haskell.TH.Lib.Syntax.Con] -> [m Language.Haskell.TH.Lib.Syntax.DerivClause] -> m Language.Haskell.TH.Lib.Syntax.Dec
- dataInstD_doc ::
- Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Cxt
- -> GHC.Internal.Maybe.Maybe [Language.Haskell.TH.Lib.Syntax.Q (Language.Haskell.TH.Lib.Syntax.TyVarBndr ())] -> Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Type -> GHC.Internal.Maybe.Maybe (Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Kind) -> [(Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Con, GHC.Internal.Maybe.Maybe GHC.Internal.Base.String, [GHC.Internal.Maybe.Maybe GHC.Internal.Base.String])] -> [Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.DerivClause] -> GHC.Internal.Maybe.Maybe GHC.Internal.Base.String -> Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Dec
- defaultD :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => [m Language.Haskell.TH.Lib.Syntax.Type] -> m Language.Haskell.TH.Lib.Syntax.Dec
- defaultSigD :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> m Language.Haskell.TH.Lib.Syntax.Type -> m Language.Haskell.TH.Lib.Syntax.Dec
- derivClause :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => GHC.Internal.Maybe.Maybe (m Language.Haskell.TH.Lib.Syntax.DerivStrategy) -> [m Language.Haskell.TH.Lib.Syntax.Pred] -> m Language.Haskell.TH.Lib.Syntax.DerivClause
- doE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => GHC.Internal.Maybe.Maybe Language.Haskell.TH.Lib.Syntax.ModName -> [m Language.Haskell.TH.Lib.Syntax.Stmt] -> m Language.Haskell.TH.Lib.Syntax.Exp
- docCons :: (Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Con, GHC.Internal.Maybe.Maybe GHC.Internal.Base.String, [GHC.Internal.Maybe.Maybe GHC.Internal.Base.String]) -> Language.Haskell.TH.Lib.Syntax.Q ()
- doublePrimL :: GHC.Internal.Real.Rational -> Language.Haskell.TH.Lib.Syntax.Lit
- dyn :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => GHC.Internal.Base.String -> m Language.Haskell.TH.Lib.Syntax.Exp
- equalP :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Type -> m Language.Haskell.TH.Lib.Syntax.Type -> m Language.Haskell.TH.Lib.Syntax.Pred
- equalityT :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Type
- explBidir :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => [m Language.Haskell.TH.Lib.Syntax.Clause] -> m Language.Haskell.TH.Lib.Syntax.PatSynDir
- fieldExp :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> m Language.Haskell.TH.Lib.Syntax.Exp -> m (Language.Haskell.TH.Lib.Syntax.Name, Language.Haskell.TH.Lib.Syntax.Exp)
- fieldPat :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> m Language.Haskell.TH.Lib.Syntax.Pat -> m Language.Haskell.TH.Lib.Syntax.FieldPat
- floatPrimL :: GHC.Internal.Real.Rational -> Language.Haskell.TH.Lib.Syntax.Lit
- forImpD :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Callconv -> Language.Haskell.TH.Lib.Syntax.Safety -> GHC.Internal.Base.String -> Language.Haskell.TH.Lib.Syntax.Name -> m Language.Haskell.TH.Lib.Syntax.Type -> m Language.Haskell.TH.Lib.Syntax.Dec
- forallC :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => [m (Language.Haskell.TH.Lib.Syntax.TyVarBndr Language.Haskell.TH.Lib.Syntax.Specificity)] -> m Language.Haskell.TH.Lib.Syntax.Cxt -> m Language.Haskell.TH.Lib.Syntax.Con -> m Language.Haskell.TH.Lib.Syntax.Con
- forallT :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => [m (Language.Haskell.TH.Lib.Syntax.TyVarBndr Language.Haskell.TH.Lib.Syntax.Specificity)] -> m Language.Haskell.TH.Lib.Syntax.Cxt -> m Language.Haskell.TH.Lib.Syntax.Type -> m Language.Haskell.TH.Lib.Syntax.Type
- forallVisT :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => [m (Language.Haskell.TH.Lib.Syntax.TyVarBndr ())] -> m Language.Haskell.TH.Lib.Syntax.Type -> m Language.Haskell.TH.Lib.Syntax.Type
- fromE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Exp
- fromR :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Range
- fromThenE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Exp
- fromThenR :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Range
- fromThenToE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Exp
- fromThenToR :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Range
- fromToE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Exp
- fromToR :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Range
- funD :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> [m Language.Haskell.TH.Lib.Syntax.Clause] -> m Language.Haskell.TH.Lib.Syntax.Dec
- funD_doc :: Language.Haskell.TH.Lib.Syntax.Name -> [Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Clause] -> GHC.Internal.Maybe.Maybe GHC.Internal.Base.String -> [GHC.Internal.Maybe.Maybe GHC.Internal.Base.String] -> Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Dec
- funDep :: [Language.Haskell.TH.Lib.Syntax.Name] -> [Language.Haskell.TH.Lib.Syntax.Name] -> Language.Haskell.TH.Lib.Syntax.FunDep
- gadtC :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => [Language.Haskell.TH.Lib.Syntax.Name] -> [m Language.Haskell.TH.Lib.Syntax.StrictType] -> m Language.Haskell.TH.Lib.Syntax.Type -> m Language.Haskell.TH.Lib.Syntax.Con
- getFieldE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Exp -> GHC.Internal.Base.String -> m Language.Haskell.TH.Lib.Syntax.Exp
- guardedB :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => [m (Language.Haskell.TH.Lib.Syntax.Guard, Language.Haskell.TH.Lib.Syntax.Exp)] -> m Language.Haskell.TH.Lib.Syntax.Body
- implBidir :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.PatSynDir
- implicitParamBindD :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => GHC.Internal.Base.String -> m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Dec
- implicitParamT :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => GHC.Internal.Base.String -> m Language.Haskell.TH.Lib.Syntax.Type -> m Language.Haskell.TH.Lib.Syntax.Type
- implicitParamVarE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => GHC.Internal.Base.String -> m Language.Haskell.TH.Lib.Syntax.Exp
+ type VarStrictTypeQ = GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.VarStrictType
+ anyclassStrategy :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.DerivStrategy
+ appE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Exp
+ appK :: GHC.Internal.TH.Syntax.Kind -> GHC.Internal.TH.Syntax.Kind -> GHC.Internal.TH.Syntax.Kind
+ appKindT :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Type -> m GHC.Internal.TH.Syntax.Kind -> m GHC.Internal.TH.Syntax.Type
+ appT :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Type -> m GHC.Internal.TH.Syntax.Type -> m GHC.Internal.TH.Syntax.Type
+ appTypeE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Type -> m GHC.Internal.TH.Syntax.Exp
+ appsE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => [m GHC.Internal.TH.Syntax.Exp] -> m GHC.Internal.TH.Syntax.Exp
+ arithSeqE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Range -> m GHC.Internal.TH.Syntax.Exp
+ arrowK :: GHC.Internal.TH.Syntax.Kind
+ arrowT :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Type
+ asP :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> m GHC.Internal.TH.Syntax.Pat -> m GHC.Internal.TH.Syntax.Pat
+ bang :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.SourceUnpackedness -> m GHC.Internal.TH.Syntax.SourceStrictness -> m GHC.Internal.TH.Syntax.Bang
+ bangP :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Pat -> m GHC.Internal.TH.Syntax.Pat
+ bangType :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Bang -> m GHC.Internal.TH.Syntax.Type -> m GHC.Internal.TH.Syntax.BangType
+ bindS :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Pat -> m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Stmt
+ bndrInvis :: GHC.Internal.TH.Syntax.BndrVis
+ bndrReq :: GHC.Internal.TH.Syntax.BndrVis
+ bytesPrimL :: GHC.Internal.TH.Syntax.Bytes -> GHC.Internal.TH.Syntax.Lit
+ cApi :: GHC.Internal.TH.Syntax.Callconv
+ cCall :: GHC.Internal.TH.Syntax.Callconv
+ caseE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Exp -> [m GHC.Internal.TH.Syntax.Match] -> m GHC.Internal.TH.Syntax.Exp
+ charL :: GHC.Types.Char -> GHC.Internal.TH.Syntax.Lit
+ charPrimL :: GHC.Types.Char -> GHC.Internal.TH.Syntax.Lit
+ charTyLit :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Types.Char -> m GHC.Internal.TH.Syntax.TyLit
+ classD :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Cxt -> GHC.Internal.TH.Syntax.Name -> [m (GHC.Internal.TH.Syntax.TyVarBndr GHC.Internal.TH.Syntax.BndrVis)] -> [GHC.Internal.TH.Syntax.FunDep] -> [m GHC.Internal.TH.Syntax.Dec] -> m GHC.Internal.TH.Syntax.Dec
+ classP :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> [m GHC.Internal.TH.Syntax.Type] -> m GHC.Internal.TH.Syntax.Pred
+ clause :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => [m GHC.Internal.TH.Syntax.Pat] -> m GHC.Internal.TH.Syntax.Body -> [m GHC.Internal.TH.Syntax.Dec] -> m GHC.Internal.TH.Syntax.Clause
+ closedTypeFamilyD :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> [m (GHC.Internal.TH.Syntax.TyVarBndr GHC.Internal.TH.Syntax.BndrVis)] -> m GHC.Internal.TH.Syntax.FamilyResultSig -> GHC.Internal.Maybe.Maybe InjectivityAnn -> [m GHC.Internal.TH.Syntax.TySynEqn] -> m GHC.Internal.TH.Syntax.Dec
+ compE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => [m GHC.Internal.TH.Syntax.Stmt] -> m GHC.Internal.TH.Syntax.Exp
+ conE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> m GHC.Internal.TH.Syntax.Exp
+ conK :: GHC.Internal.TH.Syntax.Name -> GHC.Internal.TH.Syntax.Kind
+ conP :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> [m GHC.Internal.TH.Syntax.Type] -> [m GHC.Internal.TH.Syntax.Pat] -> m GHC.Internal.TH.Syntax.Pat
+ conT :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> m GHC.Internal.TH.Syntax.Type
+ condE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Exp
+ constraintK :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Kind
+ cxt :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => [m GHC.Internal.TH.Syntax.Pred] -> m GHC.Internal.TH.Syntax.Cxt
+ dataD :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Cxt -> GHC.Internal.TH.Syntax.Name -> [m (GHC.Internal.TH.Syntax.TyVarBndr GHC.Internal.TH.Syntax.BndrVis)] -> GHC.Internal.Maybe.Maybe (m GHC.Internal.TH.Syntax.Kind) -> [m GHC.Internal.TH.Syntax.Con] -> [m GHC.Internal.TH.Syntax.DerivClause] -> m GHC.Internal.TH.Syntax.Dec
+ dataD_doc :: GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Cxt -> GHC.Internal.TH.Syntax.Name -> [GHC.Internal.TH.Syntax.Q (GHC.Internal.TH.Syntax.TyVarBndr GHC.Internal.TH.Syntax.BndrVis)] -> GHC.Internal.Maybe.Maybe (GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Kind) -> [(GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Con, GHC.Internal.Maybe.Maybe GHC.Internal.Base.String, [GHC.Internal.Maybe.Maybe GHC.Internal.Base.String])] -> [GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.DerivClause] -> GHC.Internal.Maybe.Maybe GHC.Internal.Base.String -> GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Dec
+ dataFamilyD :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> [m (GHC.Internal.TH.Syntax.TyVarBndr GHC.Internal.TH.Syntax.BndrVis)] -> GHC.Internal.Maybe.Maybe (m GHC.Internal.TH.Syntax.Kind) -> m GHC.Internal.TH.Syntax.Dec
+ dataInstD :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Cxt -> GHC.Internal.Maybe.Maybe [m (GHC.Internal.TH.Syntax.TyVarBndr ())] -> m GHC.Internal.TH.Syntax.Type -> GHC.Internal.Maybe.Maybe (m GHC.Internal.TH.Syntax.Kind) -> [m GHC.Internal.TH.Syntax.Con] -> [m GHC.Internal.TH.Syntax.DerivClause] -> m GHC.Internal.TH.Syntax.Dec
+ dataInstD_doc :: GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Cxt -> GHC.Internal.Maybe.Maybe [GHC.Internal.TH.Syntax.Q (GHC.Internal.TH.Syntax.TyVarBndr ())] -> GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Type -> GHC.Internal.Maybe.Maybe (GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Kind) -> [(GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Con, GHC.Internal.Maybe.Maybe GHC.Internal.Base.String, [GHC.Internal.Maybe.Maybe GHC.Internal.Base.String])] -> [GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.DerivClause] -> GHC.Internal.Maybe.Maybe GHC.Internal.Base.String -> GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Dec
+ defaultD :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => [m GHC.Internal.TH.Syntax.Type] -> m GHC.Internal.TH.Syntax.Dec
+ defaultSigD :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> m GHC.Internal.TH.Syntax.Type -> m GHC.Internal.TH.Syntax.Dec
+ derivClause :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.Maybe.Maybe (m GHC.Internal.TH.Syntax.DerivStrategy) -> [m GHC.Internal.TH.Syntax.Pred] -> m GHC.Internal.TH.Syntax.DerivClause
+ doE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.Maybe.Maybe GHC.Internal.TH.Syntax.ModName -> [m GHC.Internal.TH.Syntax.Stmt] -> m GHC.Internal.TH.Syntax.Exp
+ docCons :: (GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Con, GHC.Internal.Maybe.Maybe GHC.Internal.Base.String, [GHC.Internal.Maybe.Maybe GHC.Internal.Base.String]) -> GHC.Internal.TH.Syntax.Q ()
+ doublePrimL :: GHC.Internal.Real.Rational -> GHC.Internal.TH.Syntax.Lit
+ dyn :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.Base.String -> m GHC.Internal.TH.Syntax.Exp
+ equalP :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Type -> m GHC.Internal.TH.Syntax.Type -> m GHC.Internal.TH.Syntax.Pred
+ equalityT :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Type
+ explBidir :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => [m GHC.Internal.TH.Syntax.Clause] -> m GHC.Internal.TH.Syntax.PatSynDir
+ fieldExp :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> m GHC.Internal.TH.Syntax.Exp -> m (GHC.Internal.TH.Syntax.Name, GHC.Internal.TH.Syntax.Exp)
+ fieldPat :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> m GHC.Internal.TH.Syntax.Pat -> m GHC.Internal.TH.Syntax.FieldPat
+ floatPrimL :: GHC.Internal.Real.Rational -> GHC.Internal.TH.Syntax.Lit
+ forImpD :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Callconv -> GHC.Internal.TH.Syntax.Safety -> GHC.Internal.Base.String -> GHC.Internal.TH.Syntax.Name -> m GHC.Internal.TH.Syntax.Type -> m GHC.Internal.TH.Syntax.Dec
+ forallC :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => [m (GHC.Internal.TH.Syntax.TyVarBndr GHC.Internal.TH.Syntax.Specificity)] -> m GHC.Internal.TH.Syntax.Cxt -> m GHC.Internal.TH.Syntax.Con -> m GHC.Internal.TH.Syntax.Con
+ forallT :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => [m (GHC.Internal.TH.Syntax.TyVarBndr GHC.Internal.TH.Syntax.Specificity)] -> m GHC.Internal.TH.Syntax.Cxt -> m GHC.Internal.TH.Syntax.Type -> m GHC.Internal.TH.Syntax.Type
+ forallVisT :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => [m (GHC.Internal.TH.Syntax.TyVarBndr ())] -> m GHC.Internal.TH.Syntax.Type -> m GHC.Internal.TH.Syntax.Type
+ fromE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Exp
+ fromR :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Range
+ fromThenE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Exp
+ fromThenR :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Range
+ fromThenToE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Exp
+ fromThenToR :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Range
+ fromToE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Exp
+ fromToR :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Range
+ funD :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> [m GHC.Internal.TH.Syntax.Clause] -> m GHC.Internal.TH.Syntax.Dec
+ funD_doc :: GHC.Internal.TH.Syntax.Name -> [GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Clause] -> GHC.Internal.Maybe.Maybe GHC.Internal.Base.String -> [GHC.Internal.Maybe.Maybe GHC.Internal.Base.String] -> GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Dec
+ funDep :: [GHC.Internal.TH.Syntax.Name] -> [GHC.Internal.TH.Syntax.Name] -> GHC.Internal.TH.Syntax.FunDep
+ gadtC :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => [GHC.Internal.TH.Syntax.Name] -> [m GHC.Internal.TH.Syntax.StrictType] -> m GHC.Internal.TH.Syntax.Type -> m GHC.Internal.TH.Syntax.Con
+ getFieldE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Exp -> GHC.Internal.Base.String -> m GHC.Internal.TH.Syntax.Exp
+ guardedB :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => [m (GHC.Internal.TH.Syntax.Guard, GHC.Internal.TH.Syntax.Exp)] -> m GHC.Internal.TH.Syntax.Body
+ implBidir :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.PatSynDir
+ implicitParamBindD :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.Base.String -> m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Dec
+ implicitParamT :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.Base.String -> m GHC.Internal.TH.Syntax.Type -> m GHC.Internal.TH.Syntax.Type
+ implicitParamVarE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.Base.String -> m GHC.Internal.TH.Syntax.Exp
inferR :: Role
- inferredSpec :: Language.Haskell.TH.Lib.Syntax.Specificity
- infixApp :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Exp
- infixC :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m (Language.Haskell.TH.Lib.Syntax.Bang, Language.Haskell.TH.Lib.Syntax.Type) -> Language.Haskell.TH.Lib.Syntax.Name -> m (Language.Haskell.TH.Lib.Syntax.Bang, Language.Haskell.TH.Lib.Syntax.Type) -> m Language.Haskell.TH.Lib.Syntax.Con
- infixE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => GHC.Internal.Maybe.Maybe (m Language.Haskell.TH.Lib.Syntax.Exp) -> m Language.Haskell.TH.Lib.Syntax.Exp -> GHC.Internal.Maybe.Maybe (m Language.Haskell.TH.Lib.Syntax.Exp) -> m Language.Haskell.TH.Lib.Syntax.Exp
- infixLD :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => GHC.Types.Int -> Language.Haskell.TH.Lib.Syntax.Name -> m Language.Haskell.TH.Lib.Syntax.Dec
- infixLWithSpecD :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => GHC.Types.Int -> Language.Haskell.TH.Lib.Syntax.NamespaceSpecifier -> Language.Haskell.TH.Lib.Syntax.Name -> m Language.Haskell.TH.Lib.Syntax.Dec
- infixND :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => GHC.Types.Int -> Language.Haskell.TH.Lib.Syntax.Name -> m Language.Haskell.TH.Lib.Syntax.Dec
- infixNWithSpecD :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => GHC.Types.Int -> Language.Haskell.TH.Lib.Syntax.NamespaceSpecifier -> Language.Haskell.TH.Lib.Syntax.Name -> m Language.Haskell.TH.Lib.Syntax.Dec
- infixP :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Pat -> Language.Haskell.TH.Lib.Syntax.Name -> m Language.Haskell.TH.Lib.Syntax.Pat -> m Language.Haskell.TH.Lib.Syntax.Pat
- infixPatSyn :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> Language.Haskell.TH.Lib.Syntax.Name -> m Language.Haskell.TH.Lib.Syntax.PatSynArgs
- infixRD :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => GHC.Types.Int -> Language.Haskell.TH.Lib.Syntax.Name -> m Language.Haskell.TH.Lib.Syntax.Dec
- infixRWithSpecD :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => GHC.Types.Int -> Language.Haskell.TH.Lib.Syntax.NamespaceSpecifier -> Language.Haskell.TH.Lib.Syntax.Name -> m Language.Haskell.TH.Lib.Syntax.Dec
- infixT :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Type -> Language.Haskell.TH.Lib.Syntax.Name -> m Language.Haskell.TH.Lib.Syntax.Type -> m Language.Haskell.TH.Lib.Syntax.Type
- injectivityAnn :: Language.Haskell.TH.Lib.Syntax.Name -> [Language.Haskell.TH.Lib.Syntax.Name] -> InjectivityAnn
- instanceD :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Cxt -> m Language.Haskell.TH.Lib.Syntax.Type -> [m Language.Haskell.TH.Lib.Syntax.Dec] -> m Language.Haskell.TH.Lib.Syntax.Dec
- instanceWithOverlapD :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => GHC.Internal.Maybe.Maybe Language.Haskell.TH.Lib.Syntax.Overlap -> m Language.Haskell.TH.Lib.Syntax.Cxt -> m Language.Haskell.TH.Lib.Syntax.Type -> [m Language.Haskell.TH.Lib.Syntax.Dec] -> m Language.Haskell.TH.Lib.Syntax.Dec
- intPrimL :: GHC.Num.Integer.Integer -> Language.Haskell.TH.Lib.Syntax.Lit
- integerL :: GHC.Num.Integer.Integer -> Language.Haskell.TH.Lib.Syntax.Lit
- interruptible :: Language.Haskell.TH.Lib.Syntax.Safety
- invisP :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Type -> m Language.Haskell.TH.Lib.Syntax.Pat
- isStrict :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Strict
- javaScript :: Language.Haskell.TH.Lib.Syntax.Callconv
- kiSigD :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> m Language.Haskell.TH.Lib.Syntax.Kind -> m Language.Haskell.TH.Lib.Syntax.Dec
- kindSig :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Kind -> m Language.Haskell.TH.Lib.Syntax.FamilyResultSig
- kindedBndrTV :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> Language.Haskell.TH.Lib.Syntax.BndrVis -> m Language.Haskell.TH.Lib.Syntax.Kind -> m (Language.Haskell.TH.Lib.Syntax.TyVarBndr Language.Haskell.TH.Lib.Syntax.BndrVis)
- kindedInvisTV :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> Language.Haskell.TH.Lib.Syntax.Specificity -> m Language.Haskell.TH.Lib.Syntax.Kind -> m (Language.Haskell.TH.Lib.Syntax.TyVarBndr Language.Haskell.TH.Lib.Syntax.Specificity)
- kindedTV :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> m Language.Haskell.TH.Lib.Syntax.Kind -> m (Language.Haskell.TH.Lib.Syntax.TyVarBndr ())
- labelE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => GHC.Internal.Base.String -> m Language.Haskell.TH.Lib.Syntax.Exp
- lam1E :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Pat -> m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Exp
- lamCaseE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => [m Language.Haskell.TH.Lib.Syntax.Match] -> m Language.Haskell.TH.Lib.Syntax.Exp
- lamCasesE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => [m Language.Haskell.TH.Lib.Syntax.Clause] -> m Language.Haskell.TH.Lib.Syntax.Exp
- lamE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => [m Language.Haskell.TH.Lib.Syntax.Pat] -> m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Exp
- letE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => [m Language.Haskell.TH.Lib.Syntax.Dec] -> m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Exp
- letS :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => [m Language.Haskell.TH.Lib.Syntax.Dec] -> m Language.Haskell.TH.Lib.Syntax.Stmt
- listE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => [m Language.Haskell.TH.Lib.Syntax.Exp] -> m Language.Haskell.TH.Lib.Syntax.Exp
- listK :: Language.Haskell.TH.Lib.Syntax.Kind
- listP :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => [m Language.Haskell.TH.Lib.Syntax.Pat] -> m Language.Haskell.TH.Lib.Syntax.Pat
- listT :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Type
- litE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Lit -> m Language.Haskell.TH.Lib.Syntax.Exp
- litP :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Lit -> m Language.Haskell.TH.Lib.Syntax.Pat
- litT :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.TyLit -> m Language.Haskell.TH.Lib.Syntax.Type
- match :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Pat -> m Language.Haskell.TH.Lib.Syntax.Body -> [m Language.Haskell.TH.Lib.Syntax.Dec] -> m Language.Haskell.TH.Lib.Syntax.Match
- mdoE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => GHC.Internal.Maybe.Maybe Language.Haskell.TH.Lib.Syntax.ModName -> [m Language.Haskell.TH.Lib.Syntax.Stmt] -> m Language.Haskell.TH.Lib.Syntax.Exp
- moduleAnnotation :: Language.Haskell.TH.Lib.Syntax.AnnTarget
- mulArrowT :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Type
- multiIfE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => [m (Language.Haskell.TH.Lib.Syntax.Guard, Language.Haskell.TH.Lib.Syntax.Exp)] -> m Language.Haskell.TH.Lib.Syntax.Exp
- newtypeD :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Cxt -> Language.Haskell.TH.Lib.Syntax.Name -> [m (Language.Haskell.TH.Lib.Syntax.TyVarBndr Language.Haskell.TH.Lib.Syntax.BndrVis)] -> GHC.Internal.Maybe.Maybe (m Language.Haskell.TH.Lib.Syntax.Kind) -> m Language.Haskell.TH.Lib.Syntax.Con -> [m Language.Haskell.TH.Lib.Syntax.DerivClause] -> m Language.Haskell.TH.Lib.Syntax.Dec
- newtypeD_doc ::
- Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Cxt
- -> Language.Haskell.TH.Lib.Syntax.Name -> [Language.Haskell.TH.Lib.Syntax.Q (Language.Haskell.TH.Lib.Syntax.TyVarBndr Language.Haskell.TH.Lib.Syntax.BndrVis)] -> GHC.Internal.Maybe.Maybe (Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Kind) -> (Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Con, GHC.Internal.Maybe.Maybe GHC.Internal.Base.String, [GHC.Internal.Maybe.Maybe GHC.Internal.Base.String]) -> [Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.DerivClause] -> GHC.Internal.Maybe.Maybe GHC.Internal.Base.String -> Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Dec
- newtypeInstD :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Cxt -> GHC.Internal.Maybe.Maybe [m (Language.Haskell.TH.Lib.Syntax.TyVarBndr ())] -> m Language.Haskell.TH.Lib.Syntax.Type -> GHC.Internal.Maybe.Maybe (m Language.Haskell.TH.Lib.Syntax.Kind) -> m Language.Haskell.TH.Lib.Syntax.Con -> [m Language.Haskell.TH.Lib.Syntax.DerivClause] -> m Language.Haskell.TH.Lib.Syntax.Dec
- newtypeInstD_doc ::
- Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Cxt
- -> GHC.Internal.Maybe.Maybe [Language.Haskell.TH.Lib.Syntax.Q (Language.Haskell.TH.Lib.Syntax.TyVarBndr ())] -> Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Type -> GHC.Internal.Maybe.Maybe (Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Kind) -> (Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Con, GHC.Internal.Maybe.Maybe GHC.Internal.Base.String, [GHC.Internal.Maybe.Maybe GHC.Internal.Base.String]) -> [Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.DerivClause] -> GHC.Internal.Maybe.Maybe GHC.Internal.Base.String -> Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Dec
- newtypeStrategy :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.DerivStrategy
- noBindS :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Stmt
- noSig :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.FamilyResultSig
- noSourceStrictness :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.SourceStrictness
- noSourceUnpackedness :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.SourceUnpackedness
+ inferredSpec :: GHC.Internal.TH.Syntax.Specificity
+ infixApp :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Exp
+ infixC :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m (GHC.Internal.TH.Syntax.Bang, GHC.Internal.TH.Syntax.Type) -> GHC.Internal.TH.Syntax.Name -> m (GHC.Internal.TH.Syntax.Bang, GHC.Internal.TH.Syntax.Type) -> m GHC.Internal.TH.Syntax.Con
+ infixE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.Maybe.Maybe (m GHC.Internal.TH.Syntax.Exp) -> m GHC.Internal.TH.Syntax.Exp -> GHC.Internal.Maybe.Maybe (m GHC.Internal.TH.Syntax.Exp) -> m GHC.Internal.TH.Syntax.Exp
+ infixLD :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Types.Int -> GHC.Internal.TH.Syntax.Name -> m GHC.Internal.TH.Syntax.Dec
+ infixLWithSpecD :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Types.Int -> GHC.Internal.TH.Syntax.NamespaceSpecifier -> GHC.Internal.TH.Syntax.Name -> m GHC.Internal.TH.Syntax.Dec
+ infixND :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Types.Int -> GHC.Internal.TH.Syntax.Name -> m GHC.Internal.TH.Syntax.Dec
+ infixNWithSpecD :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Types.Int -> GHC.Internal.TH.Syntax.NamespaceSpecifier -> GHC.Internal.TH.Syntax.Name -> m GHC.Internal.TH.Syntax.Dec
+ infixP :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Pat -> GHC.Internal.TH.Syntax.Name -> m GHC.Internal.TH.Syntax.Pat -> m GHC.Internal.TH.Syntax.Pat
+ infixPatSyn :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> GHC.Internal.TH.Syntax.Name -> m GHC.Internal.TH.Syntax.PatSynArgs
+ infixRD :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Types.Int -> GHC.Internal.TH.Syntax.Name -> m GHC.Internal.TH.Syntax.Dec
+ infixRWithSpecD :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Types.Int -> GHC.Internal.TH.Syntax.NamespaceSpecifier -> GHC.Internal.TH.Syntax.Name -> m GHC.Internal.TH.Syntax.Dec
+ infixT :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Type -> GHC.Internal.TH.Syntax.Name -> m GHC.Internal.TH.Syntax.Type -> m GHC.Internal.TH.Syntax.Type
+ injectivityAnn :: GHC.Internal.TH.Syntax.Name -> [GHC.Internal.TH.Syntax.Name] -> InjectivityAnn
+ instanceD :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Cxt -> m GHC.Internal.TH.Syntax.Type -> [m GHC.Internal.TH.Syntax.Dec] -> m GHC.Internal.TH.Syntax.Dec
+ instanceWithOverlapD :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.Maybe.Maybe GHC.Internal.TH.Syntax.Overlap -> m GHC.Internal.TH.Syntax.Cxt -> m GHC.Internal.TH.Syntax.Type -> [m GHC.Internal.TH.Syntax.Dec] -> m GHC.Internal.TH.Syntax.Dec
+ intPrimL :: GHC.Num.Integer.Integer -> GHC.Internal.TH.Syntax.Lit
+ integerL :: GHC.Num.Integer.Integer -> GHC.Internal.TH.Syntax.Lit
+ interruptible :: GHC.Internal.TH.Syntax.Safety
+ invisP :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Type -> m GHC.Internal.TH.Syntax.Pat
+ isStrict :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Strict
+ javaScript :: GHC.Internal.TH.Syntax.Callconv
+ kiSigD :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> m GHC.Internal.TH.Syntax.Kind -> m GHC.Internal.TH.Syntax.Dec
+ kindSig :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Kind -> m GHC.Internal.TH.Syntax.FamilyResultSig
+ kindedBndrTV :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> GHC.Internal.TH.Syntax.BndrVis -> m GHC.Internal.TH.Syntax.Kind -> m (GHC.Internal.TH.Syntax.TyVarBndr GHC.Internal.TH.Syntax.BndrVis)
+ kindedInvisTV :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> GHC.Internal.TH.Syntax.Specificity -> m GHC.Internal.TH.Syntax.Kind -> m (GHC.Internal.TH.Syntax.TyVarBndr GHC.Internal.TH.Syntax.Specificity)
+ kindedTV :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> m GHC.Internal.TH.Syntax.Kind -> m (GHC.Internal.TH.Syntax.TyVarBndr ())
+ labelE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.Base.String -> m GHC.Internal.TH.Syntax.Exp
+ lam1E :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Pat -> m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Exp
+ lamCaseE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => [m GHC.Internal.TH.Syntax.Match] -> m GHC.Internal.TH.Syntax.Exp
+ lamCasesE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => [m GHC.Internal.TH.Syntax.Clause] -> m GHC.Internal.TH.Syntax.Exp
+ lamE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => [m GHC.Internal.TH.Syntax.Pat] -> m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Exp
+ letE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => [m GHC.Internal.TH.Syntax.Dec] -> m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Exp
+ letS :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => [m GHC.Internal.TH.Syntax.Dec] -> m GHC.Internal.TH.Syntax.Stmt
+ listE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => [m GHC.Internal.TH.Syntax.Exp] -> m GHC.Internal.TH.Syntax.Exp
+ listK :: GHC.Internal.TH.Syntax.Kind
+ listP :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => [m GHC.Internal.TH.Syntax.Pat] -> m GHC.Internal.TH.Syntax.Pat
+ listT :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Type
+ litE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Lit -> m GHC.Internal.TH.Syntax.Exp
+ litP :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Lit -> m GHC.Internal.TH.Syntax.Pat
+ litT :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.TyLit -> m GHC.Internal.TH.Syntax.Type
+ match :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Pat -> m GHC.Internal.TH.Syntax.Body -> [m GHC.Internal.TH.Syntax.Dec] -> m GHC.Internal.TH.Syntax.Match
+ mdoE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.Maybe.Maybe GHC.Internal.TH.Syntax.ModName -> [m GHC.Internal.TH.Syntax.Stmt] -> m GHC.Internal.TH.Syntax.Exp
+ moduleAnnotation :: GHC.Internal.TH.Syntax.AnnTarget
+ mulArrowT :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Type
+ multiIfE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => [m (GHC.Internal.TH.Syntax.Guard, GHC.Internal.TH.Syntax.Exp)] -> m GHC.Internal.TH.Syntax.Exp
+ newtypeD :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Cxt -> GHC.Internal.TH.Syntax.Name -> [m (GHC.Internal.TH.Syntax.TyVarBndr GHC.Internal.TH.Syntax.BndrVis)] -> GHC.Internal.Maybe.Maybe (m GHC.Internal.TH.Syntax.Kind) -> m GHC.Internal.TH.Syntax.Con -> [m GHC.Internal.TH.Syntax.DerivClause] -> m GHC.Internal.TH.Syntax.Dec
+ newtypeD_doc :: GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Cxt -> GHC.Internal.TH.Syntax.Name -> [GHC.Internal.TH.Syntax.Q (GHC.Internal.TH.Syntax.TyVarBndr GHC.Internal.TH.Syntax.BndrVis)] -> GHC.Internal.Maybe.Maybe (GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Kind) -> (GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Con, GHC.Internal.Maybe.Maybe GHC.Internal.Base.String, [GHC.Internal.Maybe.Maybe GHC.Internal.Base.String]) -> [GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.DerivClause] -> GHC.Internal.Maybe.Maybe GHC.Internal.Base.String -> GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Dec
+ newtypeInstD :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Cxt -> GHC.Internal.Maybe.Maybe [m (GHC.Internal.TH.Syntax.TyVarBndr ())] -> m GHC.Internal.TH.Syntax.Type -> GHC.Internal.Maybe.Maybe (m GHC.Internal.TH.Syntax.Kind) -> m GHC.Internal.TH.Syntax.Con -> [m GHC.Internal.TH.Syntax.DerivClause] -> m GHC.Internal.TH.Syntax.Dec
+ newtypeInstD_doc :: GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Cxt -> GHC.Internal.Maybe.Maybe [GHC.Internal.TH.Syntax.Q (GHC.Internal.TH.Syntax.TyVarBndr ())] -> GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Type -> GHC.Internal.Maybe.Maybe (GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Kind) -> (GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Con, GHC.Internal.Maybe.Maybe GHC.Internal.Base.String, [GHC.Internal.Maybe.Maybe GHC.Internal.Base.String]) -> [GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.DerivClause] -> GHC.Internal.Maybe.Maybe GHC.Internal.Base.String -> GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Dec
+ newtypeStrategy :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.DerivStrategy
+ noBindS :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Stmt
+ noSig :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.FamilyResultSig
+ noSourceStrictness :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.SourceStrictness
+ noSourceUnpackedness :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.SourceUnpackedness
nominalR :: Role
- normalB :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Body
- normalC :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> [m Language.Haskell.TH.Lib.Syntax.BangType] -> m Language.Haskell.TH.Lib.Syntax.Con
- normalG :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Guard
- normalGE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Exp -> m (Language.Haskell.TH.Lib.Syntax.Guard, Language.Haskell.TH.Lib.Syntax.Exp)
- notStrict :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Strict
- numTyLit :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => GHC.Num.Integer.Integer -> m Language.Haskell.TH.Lib.Syntax.TyLit
- openTypeFamilyD :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> [m (Language.Haskell.TH.Lib.Syntax.TyVarBndr Language.Haskell.TH.Lib.Syntax.BndrVis)] -> m Language.Haskell.TH.Lib.Syntax.FamilyResultSig -> GHC.Internal.Maybe.Maybe InjectivityAnn -> m Language.Haskell.TH.Lib.Syntax.Dec
- parS :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => [[m Language.Haskell.TH.Lib.Syntax.Stmt]] -> m Language.Haskell.TH.Lib.Syntax.Stmt
- parensE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Exp
- parensP :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Pat -> m Language.Haskell.TH.Lib.Syntax.Pat
- parensT :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Type -> m Language.Haskell.TH.Lib.Syntax.Type
- patG :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => [m Language.Haskell.TH.Lib.Syntax.Stmt] -> m Language.Haskell.TH.Lib.Syntax.Guard
- patGE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => [m Language.Haskell.TH.Lib.Syntax.Stmt] -> m Language.Haskell.TH.Lib.Syntax.Exp -> m (Language.Haskell.TH.Lib.Syntax.Guard, Language.Haskell.TH.Lib.Syntax.Exp)
- patSynD :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> m Language.Haskell.TH.Lib.Syntax.PatSynArgs -> m Language.Haskell.TH.Lib.Syntax.PatSynDir -> m Language.Haskell.TH.Lib.Syntax.Pat -> m Language.Haskell.TH.Lib.Syntax.Dec
- patSynD_doc :: Language.Haskell.TH.Lib.Syntax.Name -> Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.PatSynArgs -> Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.PatSynDir -> Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Pat -> GHC.Internal.Maybe.Maybe GHC.Internal.Base.String -> [GHC.Internal.Maybe.Maybe GHC.Internal.Base.String] -> Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Dec
- patSynSigD :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> m Language.Haskell.TH.Lib.Syntax.Type -> m Language.Haskell.TH.Lib.Syntax.Dec
+ normalB :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Body
+ normalC :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> [m GHC.Internal.TH.Syntax.BangType] -> m GHC.Internal.TH.Syntax.Con
+ normalG :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Guard
+ normalGE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Exp -> m (GHC.Internal.TH.Syntax.Guard, GHC.Internal.TH.Syntax.Exp)
+ notStrict :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Strict
+ numTyLit :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Num.Integer.Integer -> m GHC.Internal.TH.Syntax.TyLit
+ openTypeFamilyD :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> [m (GHC.Internal.TH.Syntax.TyVarBndr GHC.Internal.TH.Syntax.BndrVis)] -> m GHC.Internal.TH.Syntax.FamilyResultSig -> GHC.Internal.Maybe.Maybe InjectivityAnn -> m GHC.Internal.TH.Syntax.Dec
+ parS :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => [[m GHC.Internal.TH.Syntax.Stmt]] -> m GHC.Internal.TH.Syntax.Stmt
+ parensE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Exp
+ parensP :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Pat -> m GHC.Internal.TH.Syntax.Pat
+ parensT :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Type -> m GHC.Internal.TH.Syntax.Type
+ patG :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => [m GHC.Internal.TH.Syntax.Stmt] -> m GHC.Internal.TH.Syntax.Guard
+ patGE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => [m GHC.Internal.TH.Syntax.Stmt] -> m GHC.Internal.TH.Syntax.Exp -> m (GHC.Internal.TH.Syntax.Guard, GHC.Internal.TH.Syntax.Exp)
+ patSynD :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> m GHC.Internal.TH.Syntax.PatSynArgs -> m GHC.Internal.TH.Syntax.PatSynDir -> m GHC.Internal.TH.Syntax.Pat -> m GHC.Internal.TH.Syntax.Dec
+ patSynD_doc :: GHC.Internal.TH.Syntax.Name -> GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.PatSynArgs -> GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.PatSynDir -> GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Pat -> GHC.Internal.Maybe.Maybe GHC.Internal.Base.String -> [GHC.Internal.Maybe.Maybe GHC.Internal.Base.String] -> GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Dec
+ patSynSigD :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> m GHC.Internal.TH.Syntax.Type -> m GHC.Internal.TH.Syntax.Dec
phantomR :: Role
- plainBndrTV :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> Language.Haskell.TH.Lib.Syntax.BndrVis -> m (Language.Haskell.TH.Lib.Syntax.TyVarBndr Language.Haskell.TH.Lib.Syntax.BndrVis)
- plainInvisTV :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> Language.Haskell.TH.Lib.Syntax.Specificity -> m (Language.Haskell.TH.Lib.Syntax.TyVarBndr Language.Haskell.TH.Lib.Syntax.Specificity)
- plainTV :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> m (Language.Haskell.TH.Lib.Syntax.TyVarBndr ())
- pragAnnD :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.AnnTarget -> m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Dec
- pragCompleteD :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => [Language.Haskell.TH.Lib.Syntax.Name] -> GHC.Internal.Maybe.Maybe Language.Haskell.TH.Lib.Syntax.Name -> m Language.Haskell.TH.Lib.Syntax.Dec
- pragInlD :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> Language.Haskell.TH.Lib.Syntax.Inline -> Language.Haskell.TH.Lib.Syntax.RuleMatch -> Language.Haskell.TH.Lib.Syntax.Phases -> m Language.Haskell.TH.Lib.Syntax.Dec
- pragLineD :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => GHC.Types.Int -> GHC.Internal.Base.String -> m Language.Haskell.TH.Lib.Syntax.Dec
- pragOpaqueD :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> m Language.Haskell.TH.Lib.Syntax.Dec
- pragRuleD :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => GHC.Internal.Base.String -> GHC.Internal.Maybe.Maybe [m (Language.Haskell.TH.Lib.Syntax.TyVarBndr ())] -> [m Language.Haskell.TH.Lib.Syntax.RuleBndr] -> m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Exp -> Language.Haskell.TH.Lib.Syntax.Phases -> m Language.Haskell.TH.Lib.Syntax.Dec
- pragSCCFunD :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> m Language.Haskell.TH.Lib.Syntax.Dec
- pragSCCFunNamedD :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> GHC.Internal.Base.String -> m Language.Haskell.TH.Lib.Syntax.Dec
- pragSpecD :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> m Language.Haskell.TH.Lib.Syntax.Type -> Language.Haskell.TH.Lib.Syntax.Phases -> m Language.Haskell.TH.Lib.Syntax.Dec
- pragSpecInlD :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> m Language.Haskell.TH.Lib.Syntax.Type -> Language.Haskell.TH.Lib.Syntax.Inline -> Language.Haskell.TH.Lib.Syntax.Phases -> m Language.Haskell.TH.Lib.Syntax.Dec
- pragSpecInstD :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Type -> m Language.Haskell.TH.Lib.Syntax.Dec
- prefixPatSyn :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => [Language.Haskell.TH.Lib.Syntax.Name] -> m Language.Haskell.TH.Lib.Syntax.PatSynArgs
- prim :: Language.Haskell.TH.Lib.Syntax.Callconv
- projectionE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => GHC.Internal.Base.NonEmpty GHC.Internal.Base.String -> m Language.Haskell.TH.Lib.Syntax.Exp
- promotedConsT :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Type
- promotedInfixT :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Type -> Language.Haskell.TH.Lib.Syntax.Name -> m Language.Haskell.TH.Lib.Syntax.Type -> m Language.Haskell.TH.Lib.Syntax.Type
- promotedNilT :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Type
- promotedT :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> m Language.Haskell.TH.Lib.Syntax.Type
- promotedTupleT :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => GHC.Types.Int -> m Language.Haskell.TH.Lib.Syntax.Type
- promotedUInfixT :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Type -> Language.Haskell.TH.Lib.Syntax.Name -> m Language.Haskell.TH.Lib.Syntax.Type -> m Language.Haskell.TH.Lib.Syntax.Type
- rationalL :: GHC.Internal.Real.Rational -> Language.Haskell.TH.Lib.Syntax.Lit
- recC :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> [m Language.Haskell.TH.Lib.Syntax.VarBangType] -> m Language.Haskell.TH.Lib.Syntax.Con
- recConE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> [m (Language.Haskell.TH.Lib.Syntax.Name, Language.Haskell.TH.Lib.Syntax.Exp)] -> m Language.Haskell.TH.Lib.Syntax.Exp
- recGadtC :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => [Language.Haskell.TH.Lib.Syntax.Name] -> [m Language.Haskell.TH.Lib.Syntax.VarStrictType] -> m Language.Haskell.TH.Lib.Syntax.Type -> m Language.Haskell.TH.Lib.Syntax.Con
- recP :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> [m Language.Haskell.TH.Lib.Syntax.FieldPat] -> m Language.Haskell.TH.Lib.Syntax.Pat
- recS :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => [m Language.Haskell.TH.Lib.Syntax.Stmt] -> m Language.Haskell.TH.Lib.Syntax.Stmt
- recUpdE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Exp -> [m (Language.Haskell.TH.Lib.Syntax.Name, Language.Haskell.TH.Lib.Syntax.Exp)] -> m Language.Haskell.TH.Lib.Syntax.Exp
- recordPatSyn :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => [Language.Haskell.TH.Lib.Syntax.Name] -> m Language.Haskell.TH.Lib.Syntax.PatSynArgs
+ plainBndrTV :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> GHC.Internal.TH.Syntax.BndrVis -> m (GHC.Internal.TH.Syntax.TyVarBndr GHC.Internal.TH.Syntax.BndrVis)
+ plainInvisTV :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> GHC.Internal.TH.Syntax.Specificity -> m (GHC.Internal.TH.Syntax.TyVarBndr GHC.Internal.TH.Syntax.Specificity)
+ plainTV :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> m (GHC.Internal.TH.Syntax.TyVarBndr ())
+ pragAnnD :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.AnnTarget -> m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Dec
+ pragCompleteD :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => [GHC.Internal.TH.Syntax.Name] -> GHC.Internal.Maybe.Maybe GHC.Internal.TH.Syntax.Name -> m GHC.Internal.TH.Syntax.Dec
+ pragInlD :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> GHC.Internal.TH.Syntax.Inline -> GHC.Internal.TH.Syntax.RuleMatch -> GHC.Internal.TH.Syntax.Phases -> m GHC.Internal.TH.Syntax.Dec
+ pragLineD :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Types.Int -> GHC.Internal.Base.String -> m GHC.Internal.TH.Syntax.Dec
+ pragOpaqueD :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> m GHC.Internal.TH.Syntax.Dec
+ pragRuleD :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.Base.String -> GHC.Internal.Maybe.Maybe [m (GHC.Internal.TH.Syntax.TyVarBndr ())] -> [m GHC.Internal.TH.Syntax.RuleBndr] -> m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Exp -> GHC.Internal.TH.Syntax.Phases -> m GHC.Internal.TH.Syntax.Dec
+ pragSCCFunD :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> m GHC.Internal.TH.Syntax.Dec
+ pragSCCFunNamedD :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> GHC.Internal.Base.String -> m GHC.Internal.TH.Syntax.Dec
+ pragSpecD :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> m GHC.Internal.TH.Syntax.Type -> GHC.Internal.TH.Syntax.Phases -> m GHC.Internal.TH.Syntax.Dec
+ pragSpecInlD :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> m GHC.Internal.TH.Syntax.Type -> GHC.Internal.TH.Syntax.Inline -> GHC.Internal.TH.Syntax.Phases -> m GHC.Internal.TH.Syntax.Dec
+ pragSpecInstD :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Type -> m GHC.Internal.TH.Syntax.Dec
+ prefixPatSyn :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => [GHC.Internal.TH.Syntax.Name] -> m GHC.Internal.TH.Syntax.PatSynArgs
+ prim :: GHC.Internal.TH.Syntax.Callconv
+ projectionE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.Base.NonEmpty GHC.Internal.Base.String -> m GHC.Internal.TH.Syntax.Exp
+ promotedConsT :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Type
+ promotedInfixT :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Type -> GHC.Internal.TH.Syntax.Name -> m GHC.Internal.TH.Syntax.Type -> m GHC.Internal.TH.Syntax.Type
+ promotedNilT :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Type
+ promotedT :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> m GHC.Internal.TH.Syntax.Type
+ promotedTupleT :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Types.Int -> m GHC.Internal.TH.Syntax.Type
+ promotedUInfixT :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Type -> GHC.Internal.TH.Syntax.Name -> m GHC.Internal.TH.Syntax.Type -> m GHC.Internal.TH.Syntax.Type
+ rationalL :: GHC.Internal.Real.Rational -> GHC.Internal.TH.Syntax.Lit
+ recC :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> [m GHC.Internal.TH.Syntax.VarBangType] -> m GHC.Internal.TH.Syntax.Con
+ recConE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> [m (GHC.Internal.TH.Syntax.Name, GHC.Internal.TH.Syntax.Exp)] -> m GHC.Internal.TH.Syntax.Exp
+ recGadtC :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => [GHC.Internal.TH.Syntax.Name] -> [m GHC.Internal.TH.Syntax.VarStrictType] -> m GHC.Internal.TH.Syntax.Type -> m GHC.Internal.TH.Syntax.Con
+ recP :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> [m GHC.Internal.TH.Syntax.FieldPat] -> m GHC.Internal.TH.Syntax.Pat
+ recS :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => [m GHC.Internal.TH.Syntax.Stmt] -> m GHC.Internal.TH.Syntax.Stmt
+ recUpdE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Exp -> [m (GHC.Internal.TH.Syntax.Name, GHC.Internal.TH.Syntax.Exp)] -> m GHC.Internal.TH.Syntax.Exp
+ recordPatSyn :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => [GHC.Internal.TH.Syntax.Name] -> m GHC.Internal.TH.Syntax.PatSynArgs
representationalR :: Role
- roleAnnotD :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> [Role] -> m Language.Haskell.TH.Lib.Syntax.Dec
- ruleVar :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> m Language.Haskell.TH.Lib.Syntax.RuleBndr
- safe :: Language.Haskell.TH.Lib.Syntax.Safety
- sectionL :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Exp
- sectionR :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Exp
- sigD :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> m Language.Haskell.TH.Lib.Syntax.Type -> m Language.Haskell.TH.Lib.Syntax.Dec
- sigE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Type -> m Language.Haskell.TH.Lib.Syntax.Exp
- sigP :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Pat -> m Language.Haskell.TH.Lib.Syntax.Type -> m Language.Haskell.TH.Lib.Syntax.Pat
- sigT :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Type -> m Language.Haskell.TH.Lib.Syntax.Kind -> m Language.Haskell.TH.Lib.Syntax.Type
- sourceLazy :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.SourceStrictness
- sourceNoUnpack :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.SourceUnpackedness
- sourceStrict :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.SourceStrictness
- sourceUnpack :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.SourceUnpackedness
- specifiedSpec :: Language.Haskell.TH.Lib.Syntax.Specificity
- standaloneDerivD :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Cxt -> m Language.Haskell.TH.Lib.Syntax.Type -> m Language.Haskell.TH.Lib.Syntax.Dec
- standaloneDerivWithStrategyD :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => GHC.Internal.Maybe.Maybe (m Language.Haskell.TH.Lib.Syntax.DerivStrategy) -> m Language.Haskell.TH.Lib.Syntax.Cxt -> m Language.Haskell.TH.Lib.Syntax.Type -> m Language.Haskell.TH.Lib.Syntax.Dec
- starK :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Kind
- staticE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Exp
- stdCall :: Language.Haskell.TH.Lib.Syntax.Callconv
- stockStrategy :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.DerivStrategy
- strTyLit :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => GHC.Internal.Base.String -> m Language.Haskell.TH.Lib.Syntax.TyLit
- strictType :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Strict -> m Language.Haskell.TH.Lib.Syntax.Type -> m Language.Haskell.TH.Lib.Syntax.StrictType
- stringE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => GHC.Internal.Base.String -> m Language.Haskell.TH.Lib.Syntax.Exp
- stringL :: GHC.Internal.Base.String -> Language.Haskell.TH.Lib.Syntax.Lit
- stringPrimL :: [GHC.Internal.Word.Word8] -> Language.Haskell.TH.Lib.Syntax.Lit
- thisModule :: Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Module
- tildeP :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Pat -> m Language.Haskell.TH.Lib.Syntax.Pat
- tupE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => [GHC.Internal.Maybe.Maybe (m Language.Haskell.TH.Lib.Syntax.Exp)] -> m Language.Haskell.TH.Lib.Syntax.Exp
- tupP :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => [m Language.Haskell.TH.Lib.Syntax.Pat] -> m Language.Haskell.TH.Lib.Syntax.Pat
- tupleK :: GHC.Types.Int -> Language.Haskell.TH.Lib.Syntax.Kind
- tupleT :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => GHC.Types.Int -> m Language.Haskell.TH.Lib.Syntax.Type
- tySynD :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> [m (Language.Haskell.TH.Lib.Syntax.TyVarBndr Language.Haskell.TH.Lib.Syntax.BndrVis)] -> m Language.Haskell.TH.Lib.Syntax.Type -> m Language.Haskell.TH.Lib.Syntax.Dec
- tySynEqn :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => GHC.Internal.Maybe.Maybe [m (Language.Haskell.TH.Lib.Syntax.TyVarBndr ())] -> m Language.Haskell.TH.Lib.Syntax.Type -> m Language.Haskell.TH.Lib.Syntax.Type -> m Language.Haskell.TH.Lib.Syntax.TySynEqn
- tySynInstD :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.TySynEqn -> m Language.Haskell.TH.Lib.Syntax.Dec
- tyVarSig :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m (Language.Haskell.TH.Lib.Syntax.TyVarBndr ()) -> m Language.Haskell.TH.Lib.Syntax.FamilyResultSig
- typeAnnotation :: Language.Haskell.TH.Lib.Syntax.Name -> Language.Haskell.TH.Lib.Syntax.AnnTarget
- typeDataD :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> [m (Language.Haskell.TH.Lib.Syntax.TyVarBndr Language.Haskell.TH.Lib.Syntax.BndrVis)] -> GHC.Internal.Maybe.Maybe (m Language.Haskell.TH.Lib.Syntax.Kind) -> [m Language.Haskell.TH.Lib.Syntax.Con] -> m Language.Haskell.TH.Lib.Syntax.Dec
- typeDataD_doc :: Language.Haskell.TH.Lib.Syntax.Name -> [Language.Haskell.TH.Lib.Syntax.Q (Language.Haskell.TH.Lib.Syntax.TyVarBndr Language.Haskell.TH.Lib.Syntax.BndrVis)] -> GHC.Internal.Maybe.Maybe (Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Kind) -> [(Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Con, GHC.Internal.Maybe.Maybe GHC.Internal.Base.String, [GHC.Internal.Maybe.Maybe GHC.Internal.Base.String])] -> GHC.Internal.Maybe.Maybe GHC.Internal.Base.String -> Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Dec
- typeE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Type -> m Language.Haskell.TH.Lib.Syntax.Exp
- typeP :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Type -> m Language.Haskell.TH.Lib.Syntax.Pat
- typedBracketE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Exp
- typedRuleVar :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> m Language.Haskell.TH.Lib.Syntax.Type -> m Language.Haskell.TH.Lib.Syntax.RuleBndr
- typedSpliceE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Exp
- uInfixE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Exp
- uInfixP :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Pat -> Language.Haskell.TH.Lib.Syntax.Name -> m Language.Haskell.TH.Lib.Syntax.Pat -> m Language.Haskell.TH.Lib.Syntax.Pat
- uInfixT :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Type -> Language.Haskell.TH.Lib.Syntax.Name -> m Language.Haskell.TH.Lib.Syntax.Type -> m Language.Haskell.TH.Lib.Syntax.Type
- unboundVarE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> m Language.Haskell.TH.Lib.Syntax.Exp
- unboxedSumE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Exp -> Language.Haskell.TH.Lib.Syntax.SumAlt -> Language.Haskell.TH.Lib.Syntax.SumArity -> m Language.Haskell.TH.Lib.Syntax.Exp
- unboxedSumP :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Pat -> Language.Haskell.TH.Lib.Syntax.SumAlt -> Language.Haskell.TH.Lib.Syntax.SumArity -> m Language.Haskell.TH.Lib.Syntax.Pat
- unboxedSumT :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.SumArity -> m Language.Haskell.TH.Lib.Syntax.Type
- unboxedTupE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => [GHC.Internal.Maybe.Maybe (m Language.Haskell.TH.Lib.Syntax.Exp)] -> m Language.Haskell.TH.Lib.Syntax.Exp
- unboxedTupP :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => [m Language.Haskell.TH.Lib.Syntax.Pat] -> m Language.Haskell.TH.Lib.Syntax.Pat
- unboxedTupleT :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => GHC.Types.Int -> m Language.Haskell.TH.Lib.Syntax.Type
- unidir :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.PatSynDir
- unpacked :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Strict
- unsafe :: Language.Haskell.TH.Lib.Syntax.Safety
- valD :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Pat -> m Language.Haskell.TH.Lib.Syntax.Body -> [m Language.Haskell.TH.Lib.Syntax.Dec] -> m Language.Haskell.TH.Lib.Syntax.Dec
- valueAnnotation :: Language.Haskell.TH.Lib.Syntax.Name -> Language.Haskell.TH.Lib.Syntax.AnnTarget
- varBangType :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> m Language.Haskell.TH.Lib.Syntax.BangType -> m Language.Haskell.TH.Lib.Syntax.VarBangType
- varE :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> m Language.Haskell.TH.Lib.Syntax.Exp
- varK :: Language.Haskell.TH.Lib.Syntax.Name -> Language.Haskell.TH.Lib.Syntax.Kind
- varP :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> m Language.Haskell.TH.Lib.Syntax.Pat
- varStrictType :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> m Language.Haskell.TH.Lib.Syntax.StrictType -> m Language.Haskell.TH.Lib.Syntax.VarStrictType
- varT :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => Language.Haskell.TH.Lib.Syntax.Name -> m Language.Haskell.TH.Lib.Syntax.Type
- viaStrategy :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Type -> m Language.Haskell.TH.Lib.Syntax.DerivStrategy
- viewP :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Exp -> m Language.Haskell.TH.Lib.Syntax.Pat -> m Language.Haskell.TH.Lib.Syntax.Pat
- wildCardT :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Type
- wildP :: forall (m :: * -> *). Language.Haskell.TH.Lib.Syntax.Quote m => m Language.Haskell.TH.Lib.Syntax.Pat
- withDecDoc :: GHC.Internal.Base.String -> Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Dec -> Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Dec
- withDecsDoc :: GHC.Internal.Base.String -> Language.Haskell.TH.Lib.Syntax.Q [Language.Haskell.TH.Lib.Syntax.Dec] -> Language.Haskell.TH.Lib.Syntax.Q [Language.Haskell.TH.Lib.Syntax.Dec]
- wordPrimL :: GHC.Num.Integer.Integer -> Language.Haskell.TH.Lib.Syntax.Lit
-
-module Language.Haskell.TH.Lib.Syntax where
- -- Safety: Trustworthy
- type AnnLookup :: *
- data AnnLookup = AnnLookupModule Module | AnnLookupName Name
- type AnnTarget :: *
- data AnnTarget = ModuleAnnotation | TypeAnnotation Name | ValueAnnotation Name
- type Arity :: *
- type Arity = GHC.Types.Int
- type Bang :: *
- data Bang = Bang SourceUnpackedness SourceStrictness
- type BangType :: *
- type BangType = (Bang, Type)
- type BndrVis :: *
- data BndrVis = BndrReq | BndrInvis
- type Body :: *
- data Body = GuardedB [(Guard, Exp)] | NormalB Exp
- type Bytes :: *
- data Bytes = Bytes {bytesPtr :: GHC.Internal.ForeignPtr.ForeignPtr GHC.Internal.Word.Word8, bytesOffset :: GHC.Types.Word, bytesSize :: GHC.Types.Word}
- type Callconv :: *
- data Callconv = CCall | StdCall | CApi | Prim | JavaScript
- type CharPos :: *
- type CharPos = (GHC.Types.Int, GHC.Types.Int)
- type Clause :: *
- data Clause = Clause [Pat] Body [Dec]
- type role Code representational nominal
- type Code :: (* -> *) -> forall (r :: GHC.Types.RuntimeRep). TYPE r -> *
- newtype Code m a = Code {examineCode :: m (TExp a)}
- type Con :: *
- data Con = NormalC Name [BangType] | RecC Name [VarBangType] | InfixC BangType Name BangType | ForallC [TyVarBndr Specificity] Cxt Con | GadtC [Name] [BangType] Type | RecGadtC [Name] [VarBangType] Type
- type Cxt :: *
- type Cxt = [Pred]
- type Dec :: *
- data Dec
- = FunD Name [Clause]
- | ValD Pat Body [Dec]
- | DataD Cxt Name [TyVarBndr BndrVis] (GHC.Internal.Maybe.Maybe Kind) [Con] [DerivClause]
- | NewtypeD Cxt Name [TyVarBndr BndrVis] (GHC.Internal.Maybe.Maybe Kind) Con [DerivClause]
- | TypeDataD Name [TyVarBndr BndrVis] (GHC.Internal.Maybe.Maybe Kind) [Con]
- | TySynD Name [TyVarBndr BndrVis] Type
- | ClassD Cxt Name [TyVarBndr BndrVis] [FunDep] [Dec]
- | InstanceD (GHC.Internal.Maybe.Maybe Overlap) Cxt Type [Dec]
- | SigD Name Type
- | KiSigD Name Kind
- | ForeignD Foreign
- | InfixD Fixity NamespaceSpecifier Name
- | DefaultD [Type]
- | PragmaD Pragma
- | DataFamilyD Name [TyVarBndr BndrVis] (GHC.Internal.Maybe.Maybe Kind)
- | DataInstD Cxt (GHC.Internal.Maybe.Maybe [TyVarBndr ()]) Type (GHC.Internal.Maybe.Maybe Kind) [Con] [DerivClause]
- | NewtypeInstD Cxt (GHC.Internal.Maybe.Maybe [TyVarBndr ()]) Type (GHC.Internal.Maybe.Maybe Kind) Con [DerivClause]
- | TySynInstD TySynEqn
- | OpenTypeFamilyD TypeFamilyHead
- | ClosedTypeFamilyD TypeFamilyHead [TySynEqn]
- | RoleAnnotD Name [Role]
- | StandaloneDerivD (GHC.Internal.Maybe.Maybe DerivStrategy) Cxt Type
- | DefaultSigD Name Type
- | PatSynD Name PatSynArgs PatSynDir Pat
- | PatSynSigD Name PatSynType
- | ImplicitParamBindD GHC.Internal.Base.String Exp
- type DecidedStrictness :: *
- data DecidedStrictness = DecidedLazy | DecidedStrict | DecidedUnpack
- type DerivClause :: *
- data DerivClause = DerivClause (GHC.Internal.Maybe.Maybe DerivStrategy) Cxt
- type DerivStrategy :: *
- data DerivStrategy = StockStrategy | AnyclassStrategy | NewtypeStrategy | ViaStrategy Type
- type DocLoc :: *
- data DocLoc = ModuleDoc | DeclDoc Name | ArgDoc Name GHC.Types.Int | InstDoc Type
- type Exp :: *
- data Exp
- = VarE Name
- | ConE Name
- | LitE Lit
- | AppE Exp Exp
- | AppTypeE Exp Type
- | InfixE (GHC.Internal.Maybe.Maybe Exp) Exp (GHC.Internal.Maybe.Maybe Exp)
- | UInfixE Exp Exp Exp
- | ParensE Exp
- | LamE [Pat] Exp
- | LamCaseE [Match]
- | LamCasesE [Clause]
- | TupE [GHC.Internal.Maybe.Maybe Exp]
- | UnboxedTupE [GHC.Internal.Maybe.Maybe Exp]
- | UnboxedSumE Exp SumAlt SumArity
- | CondE Exp Exp Exp
- | MultiIfE [(Guard, Exp)]
- | LetE [Dec] Exp
- | CaseE Exp [Match]
- | DoE (GHC.Internal.Maybe.Maybe ModName) [Stmt]
- | MDoE (GHC.Internal.Maybe.Maybe ModName) [Stmt]
- | CompE [Stmt]
- | ArithSeqE Range
- | ListE [Exp]
- | SigE Exp Type
- | RecConE Name [FieldExp]
- | RecUpdE Exp [FieldExp]
- | StaticE Exp
- | UnboundVarE Name
- | LabelE GHC.Internal.Base.String
- | ImplicitParamVarE GHC.Internal.Base.String
- | GetFieldE Exp GHC.Internal.Base.String
- | ProjectionE (GHC.Internal.Base.NonEmpty GHC.Internal.Base.String)
- | TypedBracketE Exp
- | TypedSpliceE Exp
- | TypeE Type
- type Extension :: *
- data Extension
- = Cpp
- | OverlappingInstances
- | UndecidableInstances
- | IncoherentInstances
- | UndecidableSuperClasses
- | MonomorphismRestriction
- | MonoLocalBinds
- | DeepSubsumption
- | RelaxedPolyRec
- | ExtendedDefaultRules
- | ForeignFunctionInterface
- | UnliftedFFITypes
- | InterruptibleFFI
- | CApiFFI
- | GHCForeignImportPrim
- | JavaScriptFFI
- | ParallelArrays
- | Arrows
- | TemplateHaskell
- | TemplateHaskellQuotes
- | QualifiedDo
- | QuasiQuotes
- | ImplicitParams
- | ImplicitPrelude
- | ScopedTypeVariables
- | AllowAmbiguousTypes
- | UnboxedTuples
- | UnboxedSums
- | UnliftedNewtypes
- | UnliftedDatatypes
- | BangPatterns
- | TypeFamilies
- | TypeFamilyDependencies
- | TypeInType
- | OverloadedStrings
- | OverloadedLists
- | NumDecimals
- | DisambiguateRecordFields
- | RecordWildCards
- | NamedFieldPuns
- | ViewPatterns
- | GADTs
- | GADTSyntax
- | NPlusKPatterns
- | DoAndIfThenElse
- | BlockArguments
- | RebindableSyntax
- | ConstraintKinds
- | PolyKinds
- | DataKinds
- | TypeData
- | InstanceSigs
- | ApplicativeDo
- | LinearTypes
- | RequiredTypeArguments
- | StandaloneDeriving
- | DeriveDataTypeable
- | AutoDeriveTypeable
- | DeriveFunctor
- | DeriveTraversable
- | DeriveFoldable
- | DeriveGeneric
- | DefaultSignatures
- | DeriveAnyClass
- | DeriveLift
- | DerivingStrategies
- | DerivingVia
- | TypeSynonymInstances
- | FlexibleContexts
- | FlexibleInstances
- | ConstrainedClassMethods
- | MultiParamTypeClasses
- | NullaryTypeClasses
- | FunctionalDependencies
- | UnicodeSyntax
- | ExistentialQuantification
- | MagicHash
- | EmptyDataDecls
- | KindSignatures
- | RoleAnnotations
- | ParallelListComp
- | TransformListComp
- | MonadComprehensions
- | GeneralizedNewtypeDeriving
- | RecursiveDo
- | PostfixOperators
- | TupleSections
- | PatternGuards
- | LiberalTypeSynonyms
- | RankNTypes
- | ImpredicativeTypes
- | TypeOperators
- | ExplicitNamespaces
- | PackageImports
- | ExplicitForAll
- | AlternativeLayoutRule
- | AlternativeLayoutRuleTransitional
- | DatatypeContexts
- | NondecreasingIndentation
- | RelaxedLayout
- | TraditionalRecordSyntax
- | LambdaCase
- | MultiWayIf
- | BinaryLiterals
- | NegativeLiterals
- | HexFloatLiterals
- | DuplicateRecordFields
- | OverloadedLabels
- | EmptyCase
- | PatternSynonyms
- | PartialTypeSignatures
- | NamedWildCards
- | StaticPointers
- | TypeApplications
- | Strict
- | StrictData
- | EmptyDataDeriving
- | NumericUnderscores
- | QuantifiedConstraints
- | StarIsType
- | ImportQualifiedPost
- | CUSKs
- | StandaloneKindSignatures
- | LexicalNegation
- | FieldSelectors
- | OverloadedRecordDot
- | OverloadedRecordUpdate
- | TypeAbstractions
- | ExtendedLiterals
- | ListTuplePuns
- type FamilyResultSig :: *
- data FamilyResultSig = NoSig | KindSig Kind | TyVarSig (TyVarBndr ())
- type FieldExp :: *
- type FieldExp = (Name, Exp)
- type FieldPat :: *
- type FieldPat = (Name, Pat)
- type Fixity :: *
- data Fixity = Fixity GHC.Types.Int FixityDirection
- type FixityDirection :: *
- data FixityDirection = InfixL | InfixR | InfixN
- type Foreign :: *
- data Foreign = ImportF Callconv Safety GHC.Internal.Base.String Name Type | ExportF Callconv GHC.Internal.Base.String Name Type
- type ForeignSrcLang :: *
- data ForeignSrcLang = LangC | LangCxx | LangObjc | LangObjcxx | LangAsm | LangJs | RawObject
- type FunDep :: *
- data FunDep = FunDep [Name] [Name]
- type Guard :: *
- data Guard = NormalG Exp | PatG [Stmt]
- type Info :: *
- data Info = ClassI Dec [InstanceDec] | ClassOpI Name Type ParentName | TyConI Dec | FamilyI Dec [InstanceDec] | PrimTyConI Name Arity Unlifted | DataConI Name Type ParentName | PatSynI Name PatSynType | VarI Name Type (GHC.Internal.Maybe.Maybe Dec) | TyVarI Name Type
- type InjectivityAnn :: *
- data InjectivityAnn = InjectivityAnn Name [Name]
- type Inline :: *
- data Inline = NoInline | Inline | Inlinable
- type InstanceDec :: *
- type InstanceDec = Dec
- type Kind :: *
- type Kind = Type
- type Lift :: forall (r :: GHC.Types.RuntimeRep). TYPE r -> Constraint
- class Lift t where
- lift :: forall (m :: * -> *). Quote m => t -> m Exp
- default lift :: forall (m :: * -> *). (r ~ GHC.Types.LiftedRep, Quote m) => t -> m Exp
- liftTyped :: forall (m :: * -> *). Quote m => t -> Code m t
- {-# MINIMAL liftTyped #-}
- type Lit :: *
- data Lit = CharL GHC.Types.Char | StringL GHC.Internal.Base.String | IntegerL GHC.Num.Integer.Integer | RationalL GHC.Internal.Real.Rational | IntPrimL GHC.Num.Integer.Integer | WordPrimL GHC.Num.Integer.Integer | FloatPrimL GHC.Internal.Real.Rational | DoublePrimL GHC.Internal.Real.Rational | StringPrimL [GHC.Internal.Word.Word8] | BytesPrimL Bytes | CharPrimL GHC.Types.Char
- type Loc :: *
- data Loc = Loc {loc_filename :: GHC.Internal.Base.String, loc_package :: GHC.Internal.Base.String, loc_module :: GHC.Internal.Base.String, loc_start :: CharPos, loc_end :: CharPos}
- type Match :: *
- data Match = Match Pat Body [Dec]
- type ModName :: *
- newtype ModName = ModName GHC.Internal.Base.String
- type Module :: *
- data Module = Module PkgName ModName
- type ModuleInfo :: *
- data ModuleInfo = ModuleInfo [Module]
- type Name :: *
- data Name = Name OccName NameFlavour
- type NameFlavour :: *
- data NameFlavour = NameS | NameQ ModName | NameU !Uniq | NameL !Uniq | NameG NameSpace PkgName ModName
- type NameIs :: *
- data NameIs = Alone | Applied | Infix
- type NameSpace :: *
- data NameSpace = VarName | DataName | TcClsName | FldName {fldParent :: !GHC.Internal.Base.String}
- type NamespaceSpecifier :: *
- data NamespaceSpecifier = NoNamespaceSpecifier | TypeNamespaceSpecifier | DataNamespaceSpecifier
- type OccName :: *
- newtype OccName = OccName GHC.Internal.Base.String
- type Overlap :: *
- data Overlap = Overlappable | Overlapping | Overlaps | Incoherent
- type ParentName :: *
- type ParentName = Name
- type Pat :: *
- data Pat = LitP Lit | VarP Name | TupP [Pat] | UnboxedTupP [Pat] | UnboxedSumP Pat SumAlt SumArity | ConP Name [Type] [Pat] | InfixP Pat Name Pat | UInfixP Pat Name Pat | ParensP Pat | TildeP Pat | BangP Pat | AsP Name Pat | WildP | RecP Name [FieldPat] | ListP [Pat] | SigP Pat Type | ViewP Exp Pat | TypeP Type | InvisP Type
- type PatSynArgs :: *
- data PatSynArgs = PrefixPatSyn [Name] | InfixPatSyn Name Name | RecordPatSyn [Name]
- type PatSynDir :: *
- data PatSynDir = Unidir | ImplBidir | ExplBidir [Clause]
- type PatSynType :: *
- type PatSynType = Type
- type Phases :: *
- data Phases = AllPhases | FromPhase GHC.Types.Int | BeforePhase GHC.Types.Int
- type PkgName :: *
- newtype PkgName = PkgName GHC.Internal.Base.String
- type Pragma :: *
- data Pragma = InlineP Name Inline RuleMatch Phases | OpaqueP Name | SpecialiseP Name Type (GHC.Internal.Maybe.Maybe Inline) Phases | SpecialiseInstP Type | RuleP GHC.Internal.Base.String (GHC.Internal.Maybe.Maybe [TyVarBndr ()]) [RuleBndr] Exp Exp Phases | AnnP AnnTarget Exp | LineP GHC.Types.Int GHC.Internal.Base.String | CompleteP [Name] (GHC.Internal.Maybe.Maybe Name) | SCCP Name (GHC.Internal.Maybe.Maybe GHC.Internal.Base.String)
- type Pred :: *
- type Pred = Type
- type role Q nominal
- type Q :: * -> *
- newtype Q a = Q {unQ :: forall (m :: * -> *). Quasi m => m a}
- type Quasi :: (* -> *) -> Constraint
- class (Control.Monad.IO.Class.MonadIO m, GHC.Internal.Control.Monad.Fail.MonadFail m) => Quasi m where
- qNewName :: GHC.Internal.Base.String -> m Name
- qReport :: GHC.Types.Bool -> GHC.Internal.Base.String -> m ()
- qRecover :: forall a. m a -> m a -> m a
- qLookupName :: GHC.Types.Bool -> GHC.Internal.Base.String -> m (GHC.Internal.Maybe.Maybe Name)
- qReify :: Name -> m Info
- qReifyFixity :: Name -> m (GHC.Internal.Maybe.Maybe Fixity)
- qReifyType :: Name -> m Type
- qReifyInstances :: Name -> [Type] -> m [Dec]
- qReifyRoles :: Name -> m [Role]
- qReifyAnnotations :: forall a. GHC.Internal.Data.Data.Data a => AnnLookup -> m [a]
- qReifyModule :: Module -> m ModuleInfo
- qReifyConStrictness :: Name -> m [DecidedStrictness]
- qLocation :: m Loc
- qRunIO :: forall a. GHC.Types.IO a -> m a
- qGetPackageRoot :: m GHC.Internal.IO.FilePath
- qAddDependentFile :: GHC.Internal.IO.FilePath -> m ()
- qAddTempFile :: GHC.Internal.Base.String -> m GHC.Internal.IO.FilePath
- qAddTopDecls :: [Dec] -> m ()
- qAddForeignFilePath :: ForeignSrcLang -> GHC.Internal.Base.String -> m ()
- qAddModFinalizer :: Q () -> m ()
- qAddCorePlugin :: GHC.Internal.Base.String -> m ()
- qGetQ :: forall a. ghc-internal-9.1001.0:GHC.Internal.Data.Typeable.Internal.Typeable a => m (GHC.Internal.Maybe.Maybe a)
- qPutQ :: forall a. ghc-internal-9.1001.0:GHC.Internal.Data.Typeable.Internal.Typeable a => a -> m ()
- qIsExtEnabled :: Extension -> m GHC.Types.Bool
- qExtsEnabled :: m [Extension]
- qPutDoc :: DocLoc -> GHC.Internal.Base.String -> m ()
- qGetDoc :: DocLoc -> m (GHC.Internal.Maybe.Maybe GHC.Internal.Base.String)
- {-# MINIMAL qNewName, qReport, qRecover, qLookupName, qReify, qReifyFixity, qReifyType, qReifyInstances, qReifyRoles, qReifyAnnotations, qReifyModule, qReifyConStrictness, qLocation, qGetPackageRoot, qAddDependentFile, qAddTempFile, qAddTopDecls, qAddForeignFilePath, qAddModFinalizer, qAddCorePlugin, qGetQ, qPutQ, qIsExtEnabled, qExtsEnabled, qPutDoc, qGetDoc #-}
- type Quote :: (* -> *) -> Constraint
- class GHC.Internal.Base.Monad m => Quote m where
- newName :: GHC.Internal.Base.String -> m Name
- {-# MINIMAL newName #-}
- type Range :: *
- data Range = FromR Exp | FromThenR Exp Exp | FromToR Exp Exp | FromThenToR Exp Exp Exp
- type Role :: *
- data Role = NominalR | RepresentationalR | PhantomR | InferR
- type RuleBndr :: *
- data RuleBndr = RuleVar Name | TypedRuleVar Name Type
- type RuleMatch :: *
- data RuleMatch = ConLike | FunLike
- type Safety :: *
- data Safety = Unsafe | Safe | Interruptible
- type SourceStrictness :: *
- data SourceStrictness = NoSourceStrictness | SourceLazy | SourceStrict
- type SourceUnpackedness :: *
- data SourceUnpackedness = NoSourceUnpackedness | SourceNoUnpack | SourceUnpack
- type Specificity :: *
- data Specificity = SpecifiedSpec | InferredSpec
- type Stmt :: *
- data Stmt = BindS Pat Exp | LetS [Dec] | NoBindS Exp | ParS [[Stmt]] | RecS [Stmt]
- type Strict :: *
- type Strict = Bang
- type StrictType :: *
- type StrictType = BangType
- type SumAlt :: *
- type SumAlt = GHC.Types.Int
- type SumArity :: *
- type SumArity = GHC.Types.Int
- type role TExp nominal
- type TExp :: forall (r :: GHC.Types.RuntimeRep). TYPE r -> *
- newtype TExp a = TExp {unType :: Exp}
- type TyLit :: *
- data TyLit = NumTyLit GHC.Num.Integer.Integer | StrTyLit GHC.Internal.Base.String | CharTyLit GHC.Types.Char
- type TySynEqn :: *
- data TySynEqn = TySynEqn (GHC.Internal.Maybe.Maybe [TyVarBndr ()]) Type Type
- type TyVarBndr :: * -> *
- data TyVarBndr flag = PlainTV Name flag | KindedTV Name flag Kind
- type Type :: *
- data Type = ForallT [TyVarBndr Specificity] Cxt Type | ForallVisT [TyVarBndr ()] Type | AppT Type Type | AppKindT Type Kind | SigT Type Kind | VarT Name | ConT Name | PromotedT Name | InfixT Type Name Type | UInfixT Type Name Type | PromotedInfixT Type Name Type | PromotedUInfixT Type Name Type | ParensT Type | TupleT GHC.Types.Int | UnboxedTupleT GHC.Types.Int | UnboxedSumT SumArity | ArrowT | MulArrowT | EqualityT | ListT | PromotedTupleT GHC.Types.Int | PromotedNilT | PromotedConsT | StarT | ConstraintT | LitT TyLit | WildCardT | ImplicitParamT GHC.Internal.Base.String Type
- type TypeFamilyHead :: *
- data TypeFamilyHead = TypeFamilyHead Name [TyVarBndr BndrVis] FamilyResultSig (GHC.Internal.Maybe.Maybe InjectivityAnn)
- type Uniq :: *
- type Uniq = GHC.Num.Integer.Integer
- type Unlifted :: *
- type Unlifted = GHC.Types.Bool
- type VarBangType :: *
- type VarBangType = (Name, Bang, Type)
- type VarStrictType :: *
- type VarStrictType = VarBangType
- addCorePlugin :: GHC.Internal.Base.String -> Q ()
- addDependentFile :: GHC.Internal.IO.FilePath -> Q ()
- addForeignFile :: ForeignSrcLang -> GHC.Internal.Base.String -> Q ()
- addForeignFilePath :: ForeignSrcLang -> GHC.Internal.IO.FilePath -> Q ()
- addForeignSource :: ForeignSrcLang -> GHC.Internal.Base.String -> Q ()
- addModFinalizer :: Q () -> Q ()
- addTempFile :: GHC.Internal.Base.String -> Q GHC.Internal.IO.FilePath
- addTopDecls :: [Dec] -> Q ()
- addrToByteArray :: GHC.Types.Int -> GHC.Prim.Addr# -> Data.Array.Byte.ByteArray
- addrToByteArrayName :: Name
- badIO :: forall a. GHC.Internal.Base.String -> GHC.Types.IO a
- bindCode :: forall (m :: * -> *) a (r :: GHC.Types.RuntimeRep) (b :: TYPE r). GHC.Internal.Base.Monad m => m a -> (a -> Code m b) -> Code m b
- bindCode_ :: forall (m :: * -> *) a (r :: GHC.Types.RuntimeRep) (b :: TYPE r). GHC.Internal.Base.Monad m => m a -> Code m b -> Code m b
- cmpEq :: GHC.Types.Ordering -> GHC.Types.Bool
- compareBytes :: Bytes -> Bytes -> GHC.Types.Ordering
- counter :: GHC.Internal.IORef.IORef Uniq
- dataToExpQ :: forall (m :: * -> *) a. (Quote m, GHC.Internal.Data.Data.Data a) => (forall b. GHC.Internal.Data.Data.Data b => b -> GHC.Internal.Maybe.Maybe (m Exp)) -> a -> m Exp
- dataToPatQ :: forall (m :: * -> *) a. (Quote m, GHC.Internal.Data.Data.Data a) => (forall b. GHC.Internal.Data.Data.Data b => b -> GHC.Internal.Maybe.Maybe (m Pat)) -> a -> m Pat
- dataToQa :: forall (m :: * -> *) a k q. (Quote m, GHC.Internal.Data.Data.Data a) => (Name -> k) -> (Lit -> m q) -> (k -> [m q] -> m q) -> (forall b. GHC.Internal.Data.Data.Data b => b -> GHC.Internal.Maybe.Maybe (m q)) -> a -> m q
- defaultFixity :: Fixity
- eqBytes :: Bytes -> Bytes -> GHC.Types.Bool
- extsEnabled :: Q [Extension]
- falseName :: Name
- getDoc :: DocLoc -> Q (GHC.Internal.Maybe.Maybe GHC.Internal.Base.String)
- getPackageRoot :: Q GHC.Internal.IO.FilePath
- getQ :: forall a. ghc-internal-9.1001.0:GHC.Internal.Data.Typeable.Internal.Typeable a => Q (GHC.Internal.Maybe.Maybe a)
- get_cons_names :: Con -> [Name]
- hoistCode :: forall (m :: * -> *) (n :: * -> *) (r :: GHC.Types.RuntimeRep) (a :: TYPE r). GHC.Internal.Base.Monad m => (forall x. m x -> n x) -> Code m a -> Code n a
- isExtEnabled :: Extension -> Q GHC.Types.Bool
- isInstance :: Name -> [Type] -> Q GHC.Types.Bool
- joinCode :: forall (m :: * -> *) (r :: GHC.Types.RuntimeRep) (a :: TYPE r). GHC.Internal.Base.Monad m => m (Code m a) -> Code m a
- justName :: Name
- leftName :: Name
- liftCode :: forall (r :: GHC.Types.RuntimeRep) (a :: TYPE r) (m :: * -> *). m (TExp a) -> Code m a
- liftData :: forall (m :: * -> *) a. (Quote m, GHC.Internal.Data.Data.Data a) => a -> m Exp
- liftString :: forall (m :: * -> *). Quote m => GHC.Internal.Base.String -> m Exp
- location :: Q Loc
- lookupName :: GHC.Types.Bool -> GHC.Internal.Base.String -> Q (GHC.Internal.Maybe.Maybe Name)
- lookupTypeName :: GHC.Internal.Base.String -> Q (GHC.Internal.Maybe.Maybe Name)
- lookupValueName :: GHC.Internal.Base.String -> Q (GHC.Internal.Maybe.Maybe Name)
- makeRelativeToProject :: GHC.Internal.IO.FilePath -> Q GHC.Internal.IO.FilePath
- manyName :: Name
- maxPrecedence :: GHC.Types.Int
- memcmp :: forall a b. GHC.Internal.Ptr.Ptr a -> GHC.Internal.Ptr.Ptr b -> GHC.Internal.Foreign.C.Types.CSize -> GHC.Types.IO GHC.Internal.Foreign.C.Types.CInt
- mkModName :: GHC.Internal.Base.String -> ModName
- mkName :: GHC.Internal.Base.String -> Name
- mkNameG :: NameSpace -> GHC.Internal.Base.String -> GHC.Internal.Base.String -> GHC.Internal.Base.String -> Name
- mkNameG_d :: GHC.Internal.Base.String -> GHC.Internal.Base.String -> GHC.Internal.Base.String -> Name
- mkNameG_fld :: GHC.Internal.Base.String -> GHC.Internal.Base.String -> GHC.Internal.Base.String -> GHC.Internal.Base.String -> Name
- mkNameG_tc :: GHC.Internal.Base.String -> GHC.Internal.Base.String -> GHC.Internal.Base.String -> Name
- mkNameG_v :: GHC.Internal.Base.String -> GHC.Internal.Base.String -> GHC.Internal.Base.String -> Name
- mkNameL :: GHC.Internal.Base.String -> Uniq -> Name
- mkNameQ :: GHC.Internal.Base.String -> GHC.Internal.Base.String -> Name
- mkNameS :: GHC.Internal.Base.String -> Name
- mkNameU :: GHC.Internal.Base.String -> Uniq -> Name
- mkOccName :: GHC.Internal.Base.String -> OccName
- mkPkgName :: GHC.Internal.Base.String -> PkgName
- mk_tup_name :: GHC.Types.Int -> NameSpace -> GHC.Types.Bool -> Name
- modString :: ModName -> GHC.Internal.Base.String
- nameBase :: Name -> GHC.Internal.Base.String
- nameModule :: Name -> GHC.Internal.Maybe.Maybe GHC.Internal.Base.String
- namePackage :: Name -> GHC.Internal.Maybe.Maybe GHC.Internal.Base.String
- nameSpace :: Name -> GHC.Internal.Maybe.Maybe NameSpace
- newDeclarationGroup :: Q [Dec]
- newNameIO :: GHC.Internal.Base.String -> GHC.Types.IO Name
- nonemptyName :: Name
- nothingName :: Name
- occString :: OccName -> GHC.Internal.Base.String
- oneName :: Name
- pkgString :: PkgName -> GHC.Internal.Base.String
- putDoc :: DocLoc -> GHC.Internal.Base.String -> Q ()
- putQ :: forall a. ghc-internal-9.1001.0:GHC.Internal.Data.Typeable.Internal.Typeable a => a -> Q ()
- recover :: forall a. Q a -> Q a -> Q a
- reify :: Name -> Q Info
- reifyAnnotations :: forall a. GHC.Internal.Data.Data.Data a => AnnLookup -> Q [a]
- reifyConStrictness :: Name -> Q [DecidedStrictness]
- reifyFixity :: Name -> Q (GHC.Internal.Maybe.Maybe Fixity)
- reifyInstances :: Name -> [Type] -> Q [InstanceDec]
- reifyModule :: Module -> Q ModuleInfo
- reifyRoles :: Name -> Q [Role]
- reifyType :: Name -> Q Type
- report :: GHC.Types.Bool -> GHC.Internal.Base.String -> Q ()
- reportError :: GHC.Internal.Base.String -> Q ()
- reportWarning :: GHC.Internal.Base.String -> Q ()
- rightName :: Name
- runIO :: forall a. GHC.Types.IO a -> Q a
- runQ :: forall (m :: * -> *) a. Quasi m => Q a -> m a
- sequenceQ :: forall (m :: * -> *) a. GHC.Internal.Base.Monad m => [m a] -> m [a]
- showName :: Name -> GHC.Internal.Base.String
- showName' :: NameIs -> Name -> GHC.Internal.Base.String
- thenCmp :: GHC.Types.Ordering -> GHC.Types.Ordering -> GHC.Types.Ordering
- trueName :: Name
- tupleDataName :: GHC.Types.Int -> Name
- tupleTypeName :: GHC.Types.Int -> Name
- unTypeCode :: forall (r :: GHC.Types.RuntimeRep) (a :: TYPE r) (m :: * -> *). Quote m => Code m a -> m Exp
- unTypeQ :: forall (r :: GHC.Types.RuntimeRep) (a :: TYPE r) (m :: * -> *). Quote m => m (TExp a) -> m Exp
- unboxedSumDataName :: SumAlt -> SumArity -> Name
- unboxedSumTypeName :: SumArity -> Name
- unboxedTupleDataName :: GHC.Types.Int -> Name
- unboxedTupleTypeName :: GHC.Types.Int -> Name
- unsafeCodeCoerce :: forall (r :: GHC.Types.RuntimeRep) (a :: TYPE r) (m :: * -> *). Quote m => m Exp -> Code m a
- unsafeTExpCoerce :: forall (r :: GHC.Types.RuntimeRep) (a :: TYPE r) (m :: * -> *). Quote m => m Exp -> m (TExp a)
+ roleAnnotD :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> [Role] -> m GHC.Internal.TH.Syntax.Dec
+ ruleVar :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> m GHC.Internal.TH.Syntax.RuleBndr
+ safe :: GHC.Internal.TH.Syntax.Safety
+ sectionL :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Exp
+ sectionR :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Exp
+ sigD :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> m GHC.Internal.TH.Syntax.Type -> m GHC.Internal.TH.Syntax.Dec
+ sigE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Type -> m GHC.Internal.TH.Syntax.Exp
+ sigP :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Pat -> m GHC.Internal.TH.Syntax.Type -> m GHC.Internal.TH.Syntax.Pat
+ sigT :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Type -> m GHC.Internal.TH.Syntax.Kind -> m GHC.Internal.TH.Syntax.Type
+ sourceLazy :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.SourceStrictness
+ sourceNoUnpack :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.SourceUnpackedness
+ sourceStrict :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.SourceStrictness
+ sourceUnpack :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.SourceUnpackedness
+ specifiedSpec :: GHC.Internal.TH.Syntax.Specificity
+ standaloneDerivD :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Cxt -> m GHC.Internal.TH.Syntax.Type -> m GHC.Internal.TH.Syntax.Dec
+ standaloneDerivWithStrategyD :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.Maybe.Maybe (m GHC.Internal.TH.Syntax.DerivStrategy) -> m GHC.Internal.TH.Syntax.Cxt -> m GHC.Internal.TH.Syntax.Type -> m GHC.Internal.TH.Syntax.Dec
+ starK :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Kind
+ staticE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Exp
+ stdCall :: GHC.Internal.TH.Syntax.Callconv
+ stockStrategy :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.DerivStrategy
+ strTyLit :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.Base.String -> m GHC.Internal.TH.Syntax.TyLit
+ strictType :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Strict -> m GHC.Internal.TH.Syntax.Type -> m GHC.Internal.TH.Syntax.StrictType
+ stringE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.Base.String -> m GHC.Internal.TH.Syntax.Exp
+ stringL :: GHC.Internal.Base.String -> GHC.Internal.TH.Syntax.Lit
+ stringPrimL :: [GHC.Internal.Word.Word8] -> GHC.Internal.TH.Syntax.Lit
+ thisModule :: GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Module
+ tildeP :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Pat -> m GHC.Internal.TH.Syntax.Pat
+ tupE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => [GHC.Internal.Maybe.Maybe (m GHC.Internal.TH.Syntax.Exp)] -> m GHC.Internal.TH.Syntax.Exp
+ tupP :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => [m GHC.Internal.TH.Syntax.Pat] -> m GHC.Internal.TH.Syntax.Pat
+ tupleK :: GHC.Types.Int -> GHC.Internal.TH.Syntax.Kind
+ tupleT :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Types.Int -> m GHC.Internal.TH.Syntax.Type
+ tySynD :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> [m (GHC.Internal.TH.Syntax.TyVarBndr GHC.Internal.TH.Syntax.BndrVis)] -> m GHC.Internal.TH.Syntax.Type -> m GHC.Internal.TH.Syntax.Dec
+ tySynEqn :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.Maybe.Maybe [m (GHC.Internal.TH.Syntax.TyVarBndr ())] -> m GHC.Internal.TH.Syntax.Type -> m GHC.Internal.TH.Syntax.Type -> m GHC.Internal.TH.Syntax.TySynEqn
+ tySynInstD :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.TySynEqn -> m GHC.Internal.TH.Syntax.Dec
+ tyVarSig :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m (GHC.Internal.TH.Syntax.TyVarBndr ()) -> m GHC.Internal.TH.Syntax.FamilyResultSig
+ typeAnnotation :: GHC.Internal.TH.Syntax.Name -> GHC.Internal.TH.Syntax.AnnTarget
+ typeDataD :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> [m (GHC.Internal.TH.Syntax.TyVarBndr GHC.Internal.TH.Syntax.BndrVis)] -> GHC.Internal.Maybe.Maybe (m GHC.Internal.TH.Syntax.Kind) -> [m GHC.Internal.TH.Syntax.Con] -> m GHC.Internal.TH.Syntax.Dec
+ typeDataD_doc :: GHC.Internal.TH.Syntax.Name -> [GHC.Internal.TH.Syntax.Q (GHC.Internal.TH.Syntax.TyVarBndr GHC.Internal.TH.Syntax.BndrVis)] -> GHC.Internal.Maybe.Maybe (GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Kind) -> [(GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Con, GHC.Internal.Maybe.Maybe GHC.Internal.Base.String, [GHC.Internal.Maybe.Maybe GHC.Internal.Base.String])] -> GHC.Internal.Maybe.Maybe GHC.Internal.Base.String -> GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Dec
+ typeE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Type -> m GHC.Internal.TH.Syntax.Exp
+ typeP :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Type -> m GHC.Internal.TH.Syntax.Pat
+ typedBracketE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Exp
+ typedRuleVar :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> m GHC.Internal.TH.Syntax.Type -> m GHC.Internal.TH.Syntax.RuleBndr
+ typedSpliceE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Exp
+ uInfixE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Exp
+ uInfixP :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Pat -> GHC.Internal.TH.Syntax.Name -> m GHC.Internal.TH.Syntax.Pat -> m GHC.Internal.TH.Syntax.Pat
+ uInfixT :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Type -> GHC.Internal.TH.Syntax.Name -> m GHC.Internal.TH.Syntax.Type -> m GHC.Internal.TH.Syntax.Type
+ unboundVarE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> m GHC.Internal.TH.Syntax.Exp
+ unboxedSumE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Exp -> GHC.Internal.TH.Syntax.SumAlt -> GHC.Internal.TH.Syntax.SumArity -> m GHC.Internal.TH.Syntax.Exp
+ unboxedSumP :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Pat -> GHC.Internal.TH.Syntax.SumAlt -> GHC.Internal.TH.Syntax.SumArity -> m GHC.Internal.TH.Syntax.Pat
+ unboxedSumT :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.SumArity -> m GHC.Internal.TH.Syntax.Type
+ unboxedTupE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => [GHC.Internal.Maybe.Maybe (m GHC.Internal.TH.Syntax.Exp)] -> m GHC.Internal.TH.Syntax.Exp
+ unboxedTupP :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => [m GHC.Internal.TH.Syntax.Pat] -> m GHC.Internal.TH.Syntax.Pat
+ unboxedTupleT :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Types.Int -> m GHC.Internal.TH.Syntax.Type
+ unidir :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.PatSynDir
+ unpacked :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Strict
+ unsafe :: GHC.Internal.TH.Syntax.Safety
+ valD :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Pat -> m GHC.Internal.TH.Syntax.Body -> [m GHC.Internal.TH.Syntax.Dec] -> m GHC.Internal.TH.Syntax.Dec
+ valueAnnotation :: GHC.Internal.TH.Syntax.Name -> GHC.Internal.TH.Syntax.AnnTarget
+ varBangType :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> m GHC.Internal.TH.Syntax.BangType -> m GHC.Internal.TH.Syntax.VarBangType
+ varE :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> m GHC.Internal.TH.Syntax.Exp
+ varK :: GHC.Internal.TH.Syntax.Name -> GHC.Internal.TH.Syntax.Kind
+ varP :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> m GHC.Internal.TH.Syntax.Pat
+ varStrictType :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> m GHC.Internal.TH.Syntax.StrictType -> m GHC.Internal.TH.Syntax.VarStrictType
+ varT :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => GHC.Internal.TH.Syntax.Name -> m GHC.Internal.TH.Syntax.Type
+ viaStrategy :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Type -> m GHC.Internal.TH.Syntax.DerivStrategy
+ viewP :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Exp -> m GHC.Internal.TH.Syntax.Pat -> m GHC.Internal.TH.Syntax.Pat
+ wildCardT :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Type
+ wildP :: forall (m :: * -> *). GHC.Internal.TH.Syntax.Quote m => m GHC.Internal.TH.Syntax.Pat
+ withDecDoc :: GHC.Internal.Base.String -> GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Dec -> GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Dec
+ withDecsDoc :: GHC.Internal.Base.String -> GHC.Internal.TH.Syntax.Q [GHC.Internal.TH.Syntax.Dec] -> GHC.Internal.TH.Syntax.Q [GHC.Internal.TH.Syntax.Dec]
+ wordPrimL :: GHC.Num.Integer.Integer -> GHC.Internal.TH.Syntax.Lit
module Language.Haskell.TH.Ppr where
-- Safety: Safe
@@ -2055,91 +1538,91 @@ module Language.Haskell.TH.Ppr where
data ForallVisFlag = ForallVis | ForallInvis
type Ppr :: * -> Constraint
class Ppr a where
- ppr :: a -> Language.Haskell.TH.PprLib.Doc
- ppr_list :: [a] -> Language.Haskell.TH.PprLib.Doc
+ ppr :: a -> GHC.Internal.TH.PprLib.Doc
+ ppr_list :: [a] -> GHC.Internal.TH.PprLib.Doc
{-# MINIMAL ppr #-}
type PprFlag :: * -> Constraint
class PprFlag flag where
- pprTyVarBndr :: Language.Haskell.TH.Lib.Syntax.TyVarBndr flag -> Language.Haskell.TH.PprLib.Doc
+ pprTyVarBndr :: GHC.Internal.TH.Syntax.TyVarBndr flag -> GHC.Internal.TH.PprLib.Doc
{-# MINIMAL pprTyVarBndr #-}
type Precedence :: *
type Precedence = GHC.Types.Int
type TypeArg :: *
- data TypeArg = TANormal Language.Haskell.TH.Lib.Syntax.Type | TyArg Language.Haskell.TH.Lib.Syntax.Kind
+ data TypeArg = TANormal GHC.Internal.TH.Syntax.Type | TyArg GHC.Internal.TH.Syntax.Kind
appPrec :: Precedence
- bar :: Language.Haskell.TH.PprLib.Doc
+ bar :: GHC.Internal.TH.PprLib.Doc
bytesToString :: [GHC.Internal.Word.Word8] -> GHC.Internal.Base.String
- commaSep :: forall a. Ppr a => [a] -> Language.Haskell.TH.PprLib.Doc
- commaSepApplied :: [Language.Haskell.TH.Lib.Syntax.Name] -> Language.Haskell.TH.PprLib.Doc
- commaSepWith :: forall a. (a -> Language.Haskell.TH.PprLib.Doc) -> [a] -> Language.Haskell.TH.PprLib.Doc
- fromTANormal :: TypeArg -> GHC.Internal.Maybe.Maybe Language.Haskell.TH.Lib.Syntax.Type
+ commaSep :: forall a. Ppr a => [a] -> GHC.Internal.TH.PprLib.Doc
+ commaSepApplied :: [GHC.Internal.TH.Syntax.Name] -> GHC.Internal.TH.PprLib.Doc
+ commaSepWith :: forall a. (a -> GHC.Internal.TH.PprLib.Doc) -> [a] -> GHC.Internal.TH.PprLib.Doc
+ fromTANormal :: TypeArg -> GHC.Internal.Maybe.Maybe GHC.Internal.TH.Syntax.Type
funPrec :: Precedence
- hashParens :: Language.Haskell.TH.PprLib.Doc -> Language.Haskell.TH.PprLib.Doc
- isStarT :: Language.Haskell.TH.Lib.Syntax.Type -> GHC.Types.Bool
- isSymOcc :: Language.Haskell.TH.Lib.Syntax.Name -> GHC.Types.Bool
+ hashParens :: GHC.Internal.TH.PprLib.Doc -> GHC.Internal.TH.PprLib.Doc
+ isStarT :: GHC.Internal.TH.Syntax.Type -> GHC.Types.Bool
+ isSymOcc :: GHC.Internal.TH.Syntax.Name -> GHC.Types.Bool
nestDepth :: GHC.Types.Int
noPrec :: Precedence
opPrec :: Precedence
- parensIf :: GHC.Types.Bool -> Language.Haskell.TH.PprLib.Doc -> Language.Haskell.TH.PprLib.Doc
- pprBangType :: Language.Haskell.TH.Lib.Syntax.BangType -> Language.Haskell.TH.PprLib.Doc
- pprBndrVis :: Language.Haskell.TH.Lib.Syntax.BndrVis -> Language.Haskell.TH.PprLib.Doc -> Language.Haskell.TH.PprLib.Doc
- pprBody :: GHC.Types.Bool -> Language.Haskell.TH.Lib.Syntax.Body -> Language.Haskell.TH.PprLib.Doc
- pprClause :: GHC.Types.Bool -> Language.Haskell.TH.Lib.Syntax.Clause -> Language.Haskell.TH.PprLib.Doc
- pprCxt :: Language.Haskell.TH.Lib.Syntax.Cxt -> Language.Haskell.TH.PprLib.Doc
- pprExp :: Precedence -> Language.Haskell.TH.Lib.Syntax.Exp -> Language.Haskell.TH.PprLib.Doc
- pprFields :: [(Language.Haskell.TH.Lib.Syntax.Name, Language.Haskell.TH.Lib.Syntax.Exp)] -> Language.Haskell.TH.PprLib.Doc
- pprFixity :: Language.Haskell.TH.Lib.Syntax.Name -> Language.Haskell.TH.Lib.Syntax.Fixity -> Language.Haskell.TH.Lib.Syntax.NamespaceSpecifier -> Language.Haskell.TH.PprLib.Doc
- pprForall :: [Language.Haskell.TH.Lib.Syntax.TyVarBndr Language.Haskell.TH.Lib.Syntax.Specificity] -> Language.Haskell.TH.Lib.Syntax.Cxt -> Language.Haskell.TH.PprLib.Doc
- pprForall' :: forall flag. PprFlag flag => ForallVisFlag -> [Language.Haskell.TH.Lib.Syntax.TyVarBndr flag] -> Language.Haskell.TH.Lib.Syntax.Cxt -> Language.Haskell.TH.PprLib.Doc
- pprForallVis :: [Language.Haskell.TH.Lib.Syntax.TyVarBndr ()] -> Language.Haskell.TH.Lib.Syntax.Cxt -> Language.Haskell.TH.PprLib.Doc
- pprFunArgType :: Language.Haskell.TH.Lib.Syntax.Type -> Language.Haskell.TH.PprLib.Doc
- pprGadtRHS :: [(Language.Haskell.TH.Lib.Syntax.Strict, Language.Haskell.TH.Lib.Syntax.Type)] -> Language.Haskell.TH.Lib.Syntax.Type -> Language.Haskell.TH.PprLib.Doc
- pprGuarded :: Language.Haskell.TH.PprLib.Doc -> (Language.Haskell.TH.Lib.Syntax.Guard, Language.Haskell.TH.Lib.Syntax.Exp) -> Language.Haskell.TH.PprLib.Doc
- pprInfixExp :: Language.Haskell.TH.Lib.Syntax.Exp -> Language.Haskell.TH.PprLib.Doc
- pprInfixT :: Precedence -> Language.Haskell.TH.Lib.Syntax.Type -> Language.Haskell.TH.PprLib.Doc
- pprLit :: Precedence -> Language.Haskell.TH.Lib.Syntax.Lit -> Language.Haskell.TH.PprLib.Doc
- pprMatchPat :: Language.Haskell.TH.Lib.Syntax.Pat -> Language.Haskell.TH.PprLib.Doc
- pprMaybeExp :: Precedence -> GHC.Internal.Maybe.Maybe Language.Haskell.TH.Lib.Syntax.Exp -> Language.Haskell.TH.PprLib.Doc
- pprNamespaceSpecifier :: Language.Haskell.TH.Lib.Syntax.NamespaceSpecifier -> Language.Haskell.TH.PprLib.Doc
- pprParendType :: Language.Haskell.TH.Lib.Syntax.Type -> Language.Haskell.TH.PprLib.Doc
- pprParendTypeArg :: TypeArg -> Language.Haskell.TH.PprLib.Doc
- pprPat :: Precedence -> Language.Haskell.TH.Lib.Syntax.Pat -> Language.Haskell.TH.PprLib.Doc
- pprPatSynSig :: Language.Haskell.TH.Lib.Syntax.Name -> Language.Haskell.TH.Lib.Syntax.PatSynType -> Language.Haskell.TH.PprLib.Doc
- pprPatSynType :: Language.Haskell.TH.Lib.Syntax.PatSynType -> Language.Haskell.TH.PprLib.Doc
- pprPrefixOcc :: Language.Haskell.TH.Lib.Syntax.Name -> Language.Haskell.TH.PprLib.Doc
- pprRecFields :: [(Language.Haskell.TH.Lib.Syntax.Name, Language.Haskell.TH.Lib.Syntax.Strict, Language.Haskell.TH.Lib.Syntax.Type)] -> Language.Haskell.TH.Lib.Syntax.Type -> Language.Haskell.TH.PprLib.Doc
- pprStrictType :: (Language.Haskell.TH.Lib.Syntax.Strict, Language.Haskell.TH.Lib.Syntax.Type) -> Language.Haskell.TH.PprLib.Doc
- pprString :: GHC.Internal.Base.String -> Language.Haskell.TH.PprLib.Doc
- pprTyApp :: Precedence -> (Language.Haskell.TH.Lib.Syntax.Type, [TypeArg]) -> Language.Haskell.TH.PprLib.Doc
- pprTyLit :: Language.Haskell.TH.Lib.Syntax.TyLit -> Language.Haskell.TH.PprLib.Doc
- pprType :: Precedence -> Language.Haskell.TH.Lib.Syntax.Type -> Language.Haskell.TH.PprLib.Doc
- pprVarBangType :: Language.Haskell.TH.Lib.Syntax.VarBangType -> Language.Haskell.TH.PprLib.Doc
- pprVarStrictType :: (Language.Haskell.TH.Lib.Syntax.Name, Language.Haskell.TH.Lib.Syntax.Strict, Language.Haskell.TH.Lib.Syntax.Type) -> Language.Haskell.TH.PprLib.Doc
- ppr_bndrs :: forall flag. PprFlag flag => GHC.Internal.Maybe.Maybe [Language.Haskell.TH.Lib.Syntax.TyVarBndr flag] -> Language.Haskell.TH.PprLib.Doc
- ppr_cxt_preds :: Precedence -> Language.Haskell.TH.Lib.Syntax.Cxt -> Language.Haskell.TH.PprLib.Doc
- ppr_data :: GHC.Types.Bool -> Language.Haskell.TH.PprLib.Doc -> Language.Haskell.TH.Lib.Syntax.Cxt -> GHC.Internal.Maybe.Maybe Language.Haskell.TH.Lib.Syntax.Name -> Language.Haskell.TH.PprLib.Doc -> GHC.Internal.Maybe.Maybe Language.Haskell.TH.Lib.Syntax.Kind -> [Language.Haskell.TH.Lib.Syntax.Con] -> [Language.Haskell.TH.Lib.Syntax.DerivClause] -> Language.Haskell.TH.PprLib.Doc
- ppr_dec :: GHC.Types.Bool -> Language.Haskell.TH.Lib.Syntax.Dec -> Language.Haskell.TH.PprLib.Doc
- ppr_deriv_clause :: Language.Haskell.TH.Lib.Syntax.DerivClause -> Language.Haskell.TH.PprLib.Doc
- ppr_deriv_strategy :: Language.Haskell.TH.Lib.Syntax.DerivStrategy -> Language.Haskell.TH.PprLib.Doc
- ppr_newtype :: GHC.Types.Bool -> Language.Haskell.TH.PprLib.Doc -> Language.Haskell.TH.Lib.Syntax.Cxt -> GHC.Internal.Maybe.Maybe Language.Haskell.TH.Lib.Syntax.Name -> Language.Haskell.TH.PprLib.Doc -> GHC.Internal.Maybe.Maybe Language.Haskell.TH.Lib.Syntax.Kind -> Language.Haskell.TH.Lib.Syntax.Con -> [Language.Haskell.TH.Lib.Syntax.DerivClause] -> Language.Haskell.TH.PprLib.Doc
- ppr_overlap :: Language.Haskell.TH.Lib.Syntax.Overlap -> Language.Haskell.TH.PprLib.Doc
- ppr_sig :: Language.Haskell.TH.Lib.Syntax.Name -> Language.Haskell.TH.Lib.Syntax.Type -> Language.Haskell.TH.PprLib.Doc
- ppr_tf_head :: Language.Haskell.TH.Lib.Syntax.TypeFamilyHead -> Language.Haskell.TH.PprLib.Doc
- ppr_tySyn :: Language.Haskell.TH.PprLib.Doc -> GHC.Internal.Maybe.Maybe Language.Haskell.TH.Lib.Syntax.Name -> Language.Haskell.TH.PprLib.Doc -> Language.Haskell.TH.Lib.Syntax.Type -> Language.Haskell.TH.PprLib.Doc
- ppr_type_data :: GHC.Types.Bool -> Language.Haskell.TH.PprLib.Doc -> Language.Haskell.TH.Lib.Syntax.Cxt -> GHC.Internal.Maybe.Maybe Language.Haskell.TH.Lib.Syntax.Name -> Language.Haskell.TH.PprLib.Doc -> GHC.Internal.Maybe.Maybe Language.Haskell.TH.Lib.Syntax.Kind -> [Language.Haskell.TH.Lib.Syntax.Con] -> [Language.Haskell.TH.Lib.Syntax.DerivClause] -> Language.Haskell.TH.PprLib.Doc
- ppr_typedef :: GHC.Internal.Base.String -> GHC.Types.Bool -> Language.Haskell.TH.PprLib.Doc -> Language.Haskell.TH.Lib.Syntax.Cxt -> GHC.Internal.Maybe.Maybe Language.Haskell.TH.Lib.Syntax.Name -> Language.Haskell.TH.PprLib.Doc -> GHC.Internal.Maybe.Maybe Language.Haskell.TH.Lib.Syntax.Kind -> [Language.Haskell.TH.Lib.Syntax.Con] -> [Language.Haskell.TH.Lib.Syntax.DerivClause] -> Language.Haskell.TH.PprLib.Doc
+ parensIf :: GHC.Types.Bool -> GHC.Internal.TH.PprLib.Doc -> GHC.Internal.TH.PprLib.Doc
+ pprBangType :: GHC.Internal.TH.Syntax.BangType -> GHC.Internal.TH.PprLib.Doc
+ pprBndrVis :: GHC.Internal.TH.Syntax.BndrVis -> GHC.Internal.TH.PprLib.Doc -> GHC.Internal.TH.PprLib.Doc
+ pprBody :: GHC.Types.Bool -> GHC.Internal.TH.Syntax.Body -> GHC.Internal.TH.PprLib.Doc
+ pprClause :: GHC.Types.Bool -> GHC.Internal.TH.Syntax.Clause -> GHC.Internal.TH.PprLib.Doc
+ pprCxt :: GHC.Internal.TH.Syntax.Cxt -> GHC.Internal.TH.PprLib.Doc
+ pprExp :: Precedence -> GHC.Internal.TH.Syntax.Exp -> GHC.Internal.TH.PprLib.Doc
+ pprFields :: [(GHC.Internal.TH.Syntax.Name, GHC.Internal.TH.Syntax.Exp)] -> GHC.Internal.TH.PprLib.Doc
+ pprFixity :: GHC.Internal.TH.Syntax.Name -> GHC.Internal.TH.Syntax.Fixity -> GHC.Internal.TH.Syntax.NamespaceSpecifier -> GHC.Internal.TH.PprLib.Doc
+ pprForall :: [GHC.Internal.TH.Syntax.TyVarBndr GHC.Internal.TH.Syntax.Specificity] -> GHC.Internal.TH.Syntax.Cxt -> GHC.Internal.TH.PprLib.Doc
+ pprForall' :: forall flag. PprFlag flag => ForallVisFlag -> [GHC.Internal.TH.Syntax.TyVarBndr flag] -> GHC.Internal.TH.Syntax.Cxt -> GHC.Internal.TH.PprLib.Doc
+ pprForallVis :: [GHC.Internal.TH.Syntax.TyVarBndr ()] -> GHC.Internal.TH.Syntax.Cxt -> GHC.Internal.TH.PprLib.Doc
+ pprFunArgType :: GHC.Internal.TH.Syntax.Type -> GHC.Internal.TH.PprLib.Doc
+ pprGadtRHS :: [(GHC.Internal.TH.Syntax.Strict, GHC.Internal.TH.Syntax.Type)] -> GHC.Internal.TH.Syntax.Type -> GHC.Internal.TH.PprLib.Doc
+ pprGuarded :: GHC.Internal.TH.PprLib.Doc -> (GHC.Internal.TH.Syntax.Guard, GHC.Internal.TH.Syntax.Exp) -> GHC.Internal.TH.PprLib.Doc
+ pprInfixExp :: GHC.Internal.TH.Syntax.Exp -> GHC.Internal.TH.PprLib.Doc
+ pprInfixT :: Precedence -> GHC.Internal.TH.Syntax.Type -> GHC.Internal.TH.PprLib.Doc
+ pprLit :: Precedence -> GHC.Internal.TH.Syntax.Lit -> GHC.Internal.TH.PprLib.Doc
+ pprMatchPat :: GHC.Internal.TH.Syntax.Pat -> GHC.Internal.TH.PprLib.Doc
+ pprMaybeExp :: Precedence -> GHC.Internal.Maybe.Maybe GHC.Internal.TH.Syntax.Exp -> GHC.Internal.TH.PprLib.Doc
+ pprNamespaceSpecifier :: GHC.Internal.TH.Syntax.NamespaceSpecifier -> GHC.Internal.TH.PprLib.Doc
+ pprParendType :: GHC.Internal.TH.Syntax.Type -> GHC.Internal.TH.PprLib.Doc
+ pprParendTypeArg :: TypeArg -> GHC.Internal.TH.PprLib.Doc
+ pprPat :: Precedence -> GHC.Internal.TH.Syntax.Pat -> GHC.Internal.TH.PprLib.Doc
+ pprPatSynSig :: GHC.Internal.TH.Syntax.Name -> GHC.Internal.TH.Syntax.PatSynType -> GHC.Internal.TH.PprLib.Doc
+ pprPatSynType :: GHC.Internal.TH.Syntax.PatSynType -> GHC.Internal.TH.PprLib.Doc
+ pprPrefixOcc :: GHC.Internal.TH.Syntax.Name -> GHC.Internal.TH.PprLib.Doc
+ pprRecFields :: [(GHC.Internal.TH.Syntax.Name, GHC.Internal.TH.Syntax.Strict, GHC.Internal.TH.Syntax.Type)] -> GHC.Internal.TH.Syntax.Type -> GHC.Internal.TH.PprLib.Doc
+ pprStrictType :: (GHC.Internal.TH.Syntax.Strict, GHC.Internal.TH.Syntax.Type) -> GHC.Internal.TH.PprLib.Doc
+ pprString :: GHC.Internal.Base.String -> GHC.Internal.TH.PprLib.Doc
+ pprTyApp :: Precedence -> (GHC.Internal.TH.Syntax.Type, [TypeArg]) -> GHC.Internal.TH.PprLib.Doc
+ pprTyLit :: GHC.Internal.TH.Syntax.TyLit -> GHC.Internal.TH.PprLib.Doc
+ pprType :: Precedence -> GHC.Internal.TH.Syntax.Type -> GHC.Internal.TH.PprLib.Doc
+ pprVarBangType :: GHC.Internal.TH.Syntax.VarBangType -> GHC.Internal.TH.PprLib.Doc
+ pprVarStrictType :: (GHC.Internal.TH.Syntax.Name, GHC.Internal.TH.Syntax.Strict, GHC.Internal.TH.Syntax.Type) -> GHC.Internal.TH.PprLib.Doc
+ ppr_bndrs :: forall flag. PprFlag flag => GHC.Internal.Maybe.Maybe [GHC.Internal.TH.Syntax.TyVarBndr flag] -> GHC.Internal.TH.PprLib.Doc
+ ppr_cxt_preds :: Precedence -> GHC.Internal.TH.Syntax.Cxt -> GHC.Internal.TH.PprLib.Doc
+ ppr_data :: GHC.Types.Bool -> GHC.Internal.TH.PprLib.Doc -> GHC.Internal.TH.Syntax.Cxt -> GHC.Internal.Maybe.Maybe GHC.Internal.TH.Syntax.Name -> GHC.Internal.TH.PprLib.Doc -> GHC.Internal.Maybe.Maybe GHC.Internal.TH.Syntax.Kind -> [GHC.Internal.TH.Syntax.Con] -> [GHC.Internal.TH.Syntax.DerivClause] -> GHC.Internal.TH.PprLib.Doc
+ ppr_dec :: GHC.Types.Bool -> GHC.Internal.TH.Syntax.Dec -> GHC.Internal.TH.PprLib.Doc
+ ppr_deriv_clause :: GHC.Internal.TH.Syntax.DerivClause -> GHC.Internal.TH.PprLib.Doc
+ ppr_deriv_strategy :: GHC.Internal.TH.Syntax.DerivStrategy -> GHC.Internal.TH.PprLib.Doc
+ ppr_newtype :: GHC.Types.Bool -> GHC.Internal.TH.PprLib.Doc -> GHC.Internal.TH.Syntax.Cxt -> GHC.Internal.Maybe.Maybe GHC.Internal.TH.Syntax.Name -> GHC.Internal.TH.PprLib.Doc -> GHC.Internal.Maybe.Maybe GHC.Internal.TH.Syntax.Kind -> GHC.Internal.TH.Syntax.Con -> [GHC.Internal.TH.Syntax.DerivClause] -> GHC.Internal.TH.PprLib.Doc
+ ppr_overlap :: GHC.Internal.TH.Syntax.Overlap -> GHC.Internal.TH.PprLib.Doc
+ ppr_sig :: GHC.Internal.TH.Syntax.Name -> GHC.Internal.TH.Syntax.Type -> GHC.Internal.TH.PprLib.Doc
+ ppr_tf_head :: GHC.Internal.TH.Syntax.TypeFamilyHead -> GHC.Internal.TH.PprLib.Doc
+ ppr_tySyn :: GHC.Internal.TH.PprLib.Doc -> GHC.Internal.Maybe.Maybe GHC.Internal.TH.Syntax.Name -> GHC.Internal.TH.PprLib.Doc -> GHC.Internal.TH.Syntax.Type -> GHC.Internal.TH.PprLib.Doc
+ ppr_type_data :: GHC.Types.Bool -> GHC.Internal.TH.PprLib.Doc -> GHC.Internal.TH.Syntax.Cxt -> GHC.Internal.Maybe.Maybe GHC.Internal.TH.Syntax.Name -> GHC.Internal.TH.PprLib.Doc -> GHC.Internal.Maybe.Maybe GHC.Internal.TH.Syntax.Kind -> [GHC.Internal.TH.Syntax.Con] -> [GHC.Internal.TH.Syntax.DerivClause] -> GHC.Internal.TH.PprLib.Doc
+ ppr_typedef :: GHC.Internal.Base.String -> GHC.Types.Bool -> GHC.Internal.TH.PprLib.Doc -> GHC.Internal.TH.Syntax.Cxt -> GHC.Internal.Maybe.Maybe GHC.Internal.TH.Syntax.Name -> GHC.Internal.TH.PprLib.Doc -> GHC.Internal.Maybe.Maybe GHC.Internal.TH.Syntax.Kind -> [GHC.Internal.TH.Syntax.Con] -> [GHC.Internal.TH.Syntax.DerivClause] -> GHC.Internal.TH.PprLib.Doc
pprint :: forall a. Ppr a => a -> GHC.Internal.Base.String
qualPrec :: Precedence
- quoteParens :: Language.Haskell.TH.PprLib.Doc -> Language.Haskell.TH.PprLib.Doc
- semiSep :: forall a. Ppr a => [a] -> Language.Haskell.TH.PprLib.Doc
- semiSepWith :: forall a. (a -> Language.Haskell.TH.PprLib.Doc) -> [a] -> Language.Haskell.TH.PprLib.Doc
- sepWith :: forall a. Language.Haskell.TH.PprLib.Doc -> (a -> Language.Haskell.TH.PprLib.Doc) -> [a] -> Language.Haskell.TH.PprLib.Doc
- showtextl :: forall a. GHC.Internal.Show.Show a => a -> Language.Haskell.TH.PprLib.Doc
+ quoteParens :: GHC.Internal.TH.PprLib.Doc -> GHC.Internal.TH.PprLib.Doc
+ semiSep :: forall a. Ppr a => [a] -> GHC.Internal.TH.PprLib.Doc
+ semiSepWith :: forall a. (a -> GHC.Internal.TH.PprLib.Doc) -> [a] -> GHC.Internal.TH.PprLib.Doc
+ sepWith :: forall a. GHC.Internal.TH.PprLib.Doc -> (a -> GHC.Internal.TH.PprLib.Doc) -> [a] -> GHC.Internal.TH.PprLib.Doc
+ showtextl :: forall a. GHC.Internal.Show.Show a => a -> GHC.Internal.TH.PprLib.Doc
sigPrec :: Precedence
- split :: Language.Haskell.TH.Lib.Syntax.Type -> (Language.Haskell.TH.Lib.Syntax.Type, [TypeArg])
- unboxedSumBars :: Language.Haskell.TH.PprLib.Doc -> Language.Haskell.TH.Lib.Syntax.SumAlt -> Language.Haskell.TH.Lib.Syntax.SumArity -> Language.Haskell.TH.PprLib.Doc
+ split :: GHC.Internal.TH.Syntax.Type -> (GHC.Internal.TH.Syntax.Type, [TypeArg])
+ unboxedSumBars :: GHC.Internal.TH.PprLib.Doc -> GHC.Internal.TH.Syntax.SumAlt -> GHC.Internal.TH.Syntax.SumArity -> GHC.Internal.TH.PprLib.Doc
unopPrec :: Precedence
- where_clause :: [Language.Haskell.TH.Lib.Syntax.Dec] -> Language.Haskell.TH.PprLib.Doc
+ where_clause :: [GHC.Internal.TH.Syntax.Dec] -> GHC.Internal.TH.PprLib.Doc
module Language.Haskell.TH.PprLib where
-- Safety: Safe
@@ -2177,8 +1660,8 @@ module Language.Haskell.TH.PprLib where
lparen :: Doc
nest :: GHC.Types.Int -> Doc -> Doc
parens :: Doc -> Doc
- pprName :: Language.Haskell.TH.Lib.Syntax.Name -> Doc
- pprName' :: Language.Haskell.TH.Lib.Syntax.NameIs -> Language.Haskell.TH.Lib.Syntax.Name -> Doc
+ pprName :: GHC.Internal.TH.Syntax.Name -> Doc
+ pprName' :: GHC.Internal.TH.Syntax.NameIs -> GHC.Internal.TH.Syntax.Name -> Doc
ptext :: GHC.Internal.Base.String -> Doc
punctuate :: Doc -> [Doc] -> [Doc]
quotes :: Doc -> Doc
@@ -2196,14 +1679,14 @@ module Language.Haskell.TH.PprLib where
module Language.Haskell.TH.Quote where
-- Safety: Safe
type QuasiQuoter :: *
- data QuasiQuoter = QuasiQuoter {quoteExp :: GHC.Internal.Base.String -> Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Exp, quotePat :: GHC.Internal.Base.String -> Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Pat, quoteType :: GHC.Internal.Base.String -> Language.Haskell.TH.Lib.Syntax.Q Language.Haskell.TH.Lib.Syntax.Type, quoteDec :: GHC.Internal.Base.String -> Language.Haskell.TH.Lib.Syntax.Q [Language.Haskell.TH.Lib.Syntax.Dec]}
- dataToExpQ :: forall (m :: * -> *) a. (Language.Haskell.TH.Lib.Syntax.Quote m, GHC.Internal.Data.Data.Data a) => (forall b. GHC.Internal.Data.Data.Data b => b -> GHC.Internal.Maybe.Maybe (m Language.Haskell.TH.Lib.Syntax.Exp)) -> a -> m Language.Haskell.TH.Lib.Syntax.Exp
- dataToPatQ :: forall (m :: * -> *) a. (Language.Haskell.TH.Lib.Syntax.Quote m, GHC.Internal.Data.Data.Data a) => (forall b. GHC.Internal.Data.Data.Data b => b -> GHC.Internal.Maybe.Maybe (m Language.Haskell.TH.Lib.Syntax.Pat)) -> a -> m Language.Haskell.TH.Lib.Syntax.Pat
- dataToQa :: forall (m :: * -> *) a k q. (Language.Haskell.TH.Lib.Syntax.Quote m, GHC.Internal.Data.Data.Data a) => (Language.Haskell.TH.Lib.Syntax.Name -> k) -> (Language.Haskell.TH.Lib.Syntax.Lit -> m q) -> (k -> [m q] -> m q) -> (forall b. GHC.Internal.Data.Data.Data b => b -> GHC.Internal.Maybe.Maybe (m q)) -> a -> m q
+ data QuasiQuoter = QuasiQuoter {quoteExp :: GHC.Internal.Base.String -> GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Exp, quotePat :: GHC.Internal.Base.String -> GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Pat, quoteType :: GHC.Internal.Base.String -> GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Type, quoteDec :: GHC.Internal.Base.String -> GHC.Internal.TH.Syntax.Q [GHC.Internal.TH.Syntax.Dec]}
+ dataToExpQ :: forall (m :: * -> *) a. (GHC.Internal.TH.Syntax.Quote m, GHC.Internal.Data.Data.Data a) => (forall b. GHC.Internal.Data.Data.Data b => b -> GHC.Internal.Maybe.Maybe (m GHC.Internal.TH.Syntax.Exp)) -> a -> m GHC.Internal.TH.Syntax.Exp
+ dataToPatQ :: forall (m :: * -> *) a. (GHC.Internal.TH.Syntax.Quote m, GHC.Internal.Data.Data.Data a) => (forall b. GHC.Internal.Data.Data.Data b => b -> GHC.Internal.Maybe.Maybe (m GHC.Internal.TH.Syntax.Pat)) -> a -> m GHC.Internal.TH.Syntax.Pat
+ dataToQa :: forall (m :: * -> *) a k q. (GHC.Internal.TH.Syntax.Quote m, GHC.Internal.Data.Data.Data a) => (GHC.Internal.TH.Syntax.Name -> k) -> (GHC.Internal.TH.Syntax.Lit -> m q) -> (k -> [m q] -> m q) -> (forall b. GHC.Internal.Data.Data.Data b => b -> GHC.Internal.Maybe.Maybe (m q)) -> a -> m q
quoteFile :: QuasiQuoter -> QuasiQuoter
module Language.Haskell.TH.Syntax where
- -- Safety: Safe-Inferred
+ -- Safety: Trustworthy
type AnnLookup :: *
data AnnLookup = AnnLookupModule Module | AnnLookupName Name
type AnnTarget :: *
@@ -2520,7 +2003,7 @@ module Language.Haskell.TH.Syntax where
type Q :: * -> *
newtype Q a = Q {unQ :: forall (m :: * -> *). Quasi m => m a}
type Quasi :: (* -> *) -> Constraint
- class (Control.Monad.IO.Class.MonadIO m, GHC.Internal.Control.Monad.Fail.MonadFail m) => Quasi m where
+ class (GHC.Internal.Control.Monad.IO.Class.MonadIO m, GHC.Internal.Control.Monad.Fail.MonadFail m) => Quasi m where
qNewName :: GHC.Internal.Base.String -> m Name
qReport :: GHC.Types.Bool -> GHC.Internal.Base.String -> m ()
qRecover :: forall a. m a -> m a -> m a
@@ -2705,398 +2188,396 @@ module Language.Haskell.TH.Syntax where
-- Instances:
-instance Control.Monad.IO.Class.MonadIO Language.Haskell.TH.Lib.Syntax.Q -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Base.Applicative Language.Haskell.TH.Lib.Syntax.Q -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance [safe] GHC.Internal.Base.Applicative Language.Haskell.TH.PprLib.PprM -- Defined in ‘Language.Haskell.TH.PprLib’
-instance GHC.Internal.Base.Functor Language.Haskell.TH.Lib.Syntax.Q -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Base.Functor Language.Haskell.TH.Lib.Syntax.TyVarBndr -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance [safe] GHC.Internal.Base.Functor Language.Haskell.TH.PprLib.PprM -- Defined in ‘Language.Haskell.TH.PprLib’
-instance GHC.Internal.Base.Monad Language.Haskell.TH.Lib.Syntax.Q -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance [safe] GHC.Internal.Base.Monad Language.Haskell.TH.PprLib.PprM -- Defined in ‘Language.Haskell.TH.PprLib’
-instance forall a. GHC.Internal.Base.Monoid a => GHC.Internal.Base.Monoid (Language.Haskell.TH.Lib.Syntax.Q a) -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance forall a. GHC.Internal.Base.Semigroup a => GHC.Internal.Base.Semigroup (Language.Haskell.TH.Lib.Syntax.Q a) -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Control.Monad.Fail.MonadFail Language.Haskell.TH.Lib.Syntax.Q -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Control.Monad.Fix.MonadFix Language.Haskell.TH.Lib.Syntax.Q -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Data.Data.Data Language.Haskell.TH.Lib.Syntax.AnnLookup -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Data.Data.Data Language.Haskell.TH.Lib.Syntax.AnnTarget -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Data.Data.Data Language.Haskell.TH.Lib.Syntax.Bang -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Data.Data.Data Language.Haskell.TH.Lib.Syntax.BndrVis -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Data.Data.Data Language.Haskell.TH.Lib.Syntax.Body -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Data.Data.Data Language.Haskell.TH.Lib.Syntax.Bytes -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Data.Data.Data Language.Haskell.TH.Lib.Syntax.Callconv -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Data.Data.Data Language.Haskell.TH.Lib.Syntax.Clause -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Data.Data.Data Language.Haskell.TH.Lib.Syntax.Con -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Data.Data.Data Language.Haskell.TH.Lib.Syntax.Dec -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Data.Data.Data Language.Haskell.TH.Lib.Syntax.DecidedStrictness -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Data.Data.Data Language.Haskell.TH.Lib.Syntax.DerivClause -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Data.Data.Data Language.Haskell.TH.Lib.Syntax.DerivStrategy -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Data.Data.Data Language.Haskell.TH.Lib.Syntax.DocLoc -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Data.Data.Data Language.Haskell.TH.Lib.Syntax.Exp -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Data.Data.Data Language.Haskell.TH.Lib.Syntax.FamilyResultSig -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Data.Data.Data Language.Haskell.TH.Lib.Syntax.Fixity -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Data.Data.Data Language.Haskell.TH.Lib.Syntax.FixityDirection -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Data.Data.Data Language.Haskell.TH.Lib.Syntax.Foreign -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Data.Data.Data Language.Haskell.TH.Lib.Syntax.FunDep -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Data.Data.Data Language.Haskell.TH.Lib.Syntax.Guard -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Data.Data.Data Language.Haskell.TH.Lib.Syntax.Info -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Data.Data.Data Language.Haskell.TH.Lib.Syntax.InjectivityAnn -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Data.Data.Data Language.Haskell.TH.Lib.Syntax.Inline -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Data.Data.Data Language.Haskell.TH.Lib.Syntax.Lit -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Data.Data.Data Language.Haskell.TH.Lib.Syntax.Loc -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Data.Data.Data Language.Haskell.TH.Lib.Syntax.Match -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Data.Data.Data Language.Haskell.TH.Lib.Syntax.ModName -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Data.Data.Data Language.Haskell.TH.Lib.Syntax.Module -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Data.Data.Data Language.Haskell.TH.Lib.Syntax.ModuleInfo -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Data.Data.Data Language.Haskell.TH.Lib.Syntax.Name -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Data.Data.Data Language.Haskell.TH.Lib.Syntax.NameFlavour -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Data.Data.Data Language.Haskell.TH.Lib.Syntax.NameSpace -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Data.Data.Data Language.Haskell.TH.Lib.Syntax.NamespaceSpecifier -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Data.Data.Data Language.Haskell.TH.Lib.Syntax.OccName -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Data.Data.Data Language.Haskell.TH.Lib.Syntax.Overlap -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Data.Data.Data Language.Haskell.TH.Lib.Syntax.Pat -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Data.Data.Data Language.Haskell.TH.Lib.Syntax.PatSynArgs -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Data.Data.Data Language.Haskell.TH.Lib.Syntax.PatSynDir -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Data.Data.Data Language.Haskell.TH.Lib.Syntax.Phases -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Data.Data.Data Language.Haskell.TH.Lib.Syntax.PkgName -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Data.Data.Data Language.Haskell.TH.Lib.Syntax.Pragma -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Data.Data.Data Language.Haskell.TH.Lib.Syntax.Range -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Data.Data.Data Language.Haskell.TH.Lib.Syntax.Role -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Data.Data.Data Language.Haskell.TH.Lib.Syntax.RuleBndr -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Data.Data.Data Language.Haskell.TH.Lib.Syntax.RuleMatch -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Data.Data.Data Language.Haskell.TH.Lib.Syntax.Safety -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Data.Data.Data Language.Haskell.TH.Lib.Syntax.SourceStrictness -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Data.Data.Data Language.Haskell.TH.Lib.Syntax.SourceUnpackedness -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Data.Data.Data Language.Haskell.TH.Lib.Syntax.Specificity -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Data.Data.Data Language.Haskell.TH.Lib.Syntax.Stmt -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Data.Data.Data Language.Haskell.TH.Lib.Syntax.TyLit -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Data.Data.Data Language.Haskell.TH.Lib.Syntax.TySynEqn -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance forall flag. GHC.Internal.Data.Data.Data flag => GHC.Internal.Data.Data.Data (Language.Haskell.TH.Lib.Syntax.TyVarBndr flag) -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Data.Data.Data Language.Haskell.TH.Lib.Syntax.Type -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Data.Data.Data Language.Haskell.TH.Lib.Syntax.TypeFamilyHead -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Data.Foldable.Foldable Language.Haskell.TH.Lib.Syntax.TyVarBndr -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Data.Traversable.Traversable Language.Haskell.TH.Lib.Syntax.TyVarBndr -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance [safe] GHC.Internal.Enum.Bounded GHC.LanguageExtensions.Type.Extension -- Defined in ‘GHC.LanguageExtensions.Type’
-instance [safe] GHC.Internal.Enum.Enum GHC.LanguageExtensions.Type.Extension -- Defined in ‘GHC.LanguageExtensions.Type’
-instance GHC.Internal.Generics.Generic Language.Haskell.TH.Lib.Syntax.AnnLookup -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Generics.Generic Language.Haskell.TH.Lib.Syntax.AnnTarget -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Generics.Generic Language.Haskell.TH.Lib.Syntax.Bang -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Generics.Generic Language.Haskell.TH.Lib.Syntax.BndrVis -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Generics.Generic Language.Haskell.TH.Lib.Syntax.Body -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Generics.Generic Language.Haskell.TH.Lib.Syntax.Bytes -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Generics.Generic Language.Haskell.TH.Lib.Syntax.Callconv -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Generics.Generic Language.Haskell.TH.Lib.Syntax.Clause -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Generics.Generic Language.Haskell.TH.Lib.Syntax.Con -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Generics.Generic Language.Haskell.TH.Lib.Syntax.Dec -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Generics.Generic Language.Haskell.TH.Lib.Syntax.DecidedStrictness -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Generics.Generic Language.Haskell.TH.Lib.Syntax.DerivClause -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Generics.Generic Language.Haskell.TH.Lib.Syntax.DerivStrategy -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Generics.Generic Language.Haskell.TH.Lib.Syntax.DocLoc -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Generics.Generic Language.Haskell.TH.Lib.Syntax.Exp -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Generics.Generic Language.Haskell.TH.Lib.Syntax.FamilyResultSig -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Generics.Generic Language.Haskell.TH.Lib.Syntax.Fixity -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Generics.Generic Language.Haskell.TH.Lib.Syntax.FixityDirection -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Generics.Generic Language.Haskell.TH.Lib.Syntax.Foreign -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Generics.Generic Language.Haskell.TH.Lib.Syntax.FunDep -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Generics.Generic Language.Haskell.TH.Lib.Syntax.Guard -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Generics.Generic Language.Haskell.TH.Lib.Syntax.Info -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Generics.Generic Language.Haskell.TH.Lib.Syntax.InjectivityAnn -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Generics.Generic Language.Haskell.TH.Lib.Syntax.Inline -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Generics.Generic Language.Haskell.TH.Lib.Syntax.Lit -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Generics.Generic Language.Haskell.TH.Lib.Syntax.Loc -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Generics.Generic Language.Haskell.TH.Lib.Syntax.Match -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Generics.Generic Language.Haskell.TH.Lib.Syntax.ModName -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Generics.Generic Language.Haskell.TH.Lib.Syntax.Module -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Generics.Generic Language.Haskell.TH.Lib.Syntax.ModuleInfo -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Generics.Generic Language.Haskell.TH.Lib.Syntax.Name -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Generics.Generic Language.Haskell.TH.Lib.Syntax.NameFlavour -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Generics.Generic Language.Haskell.TH.Lib.Syntax.NameSpace -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Generics.Generic Language.Haskell.TH.Lib.Syntax.NamespaceSpecifier -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Generics.Generic Language.Haskell.TH.Lib.Syntax.OccName -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Generics.Generic Language.Haskell.TH.Lib.Syntax.Overlap -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Generics.Generic Language.Haskell.TH.Lib.Syntax.Pat -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Generics.Generic Language.Haskell.TH.Lib.Syntax.PatSynArgs -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Generics.Generic Language.Haskell.TH.Lib.Syntax.PatSynDir -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Generics.Generic Language.Haskell.TH.Lib.Syntax.Phases -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Generics.Generic Language.Haskell.TH.Lib.Syntax.PkgName -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Generics.Generic Language.Haskell.TH.Lib.Syntax.Pragma -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Generics.Generic Language.Haskell.TH.Lib.Syntax.Range -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Generics.Generic Language.Haskell.TH.Lib.Syntax.Role -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Generics.Generic Language.Haskell.TH.Lib.Syntax.RuleBndr -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Generics.Generic Language.Haskell.TH.Lib.Syntax.RuleMatch -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Generics.Generic Language.Haskell.TH.Lib.Syntax.Safety -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Generics.Generic Language.Haskell.TH.Lib.Syntax.SourceStrictness -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Generics.Generic Language.Haskell.TH.Lib.Syntax.SourceUnpackedness -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Generics.Generic Language.Haskell.TH.Lib.Syntax.Specificity -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Generics.Generic Language.Haskell.TH.Lib.Syntax.Stmt -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Generics.Generic Language.Haskell.TH.Lib.Syntax.TyLit -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Generics.Generic Language.Haskell.TH.Lib.Syntax.TySynEqn -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance forall flag. GHC.Internal.Generics.Generic (Language.Haskell.TH.Lib.Syntax.TyVarBndr flag) -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Generics.Generic Language.Haskell.TH.Lib.Syntax.Type -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Generics.Generic Language.Haskell.TH.Lib.Syntax.TypeFamilyHead -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance [safe] GHC.Internal.Generics.Generic GHC.LanguageExtensions.Type.Extension -- Defined in ‘GHC.LanguageExtensions.Type’
-instance [safe] GHC.Internal.Generics.Generic GHC.ForeignSrcLang.Type.ForeignSrcLang -- Defined in ‘GHC.ForeignSrcLang.Type’
-instance GHC.Internal.Show.Show Language.Haskell.TH.Lib.Syntax.AnnLookup -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Show.Show Language.Haskell.TH.Lib.Syntax.AnnTarget -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Show.Show Language.Haskell.TH.Lib.Syntax.Bang -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Show.Show Language.Haskell.TH.Lib.Syntax.BndrVis -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Show.Show Language.Haskell.TH.Lib.Syntax.Body -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Show.Show Language.Haskell.TH.Lib.Syntax.Bytes -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Show.Show Language.Haskell.TH.Lib.Syntax.Callconv -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Show.Show Language.Haskell.TH.Lib.Syntax.Clause -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Show.Show Language.Haskell.TH.Lib.Syntax.Con -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Show.Show Language.Haskell.TH.Lib.Syntax.Dec -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Show.Show Language.Haskell.TH.Lib.Syntax.DecidedStrictness -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Show.Show Language.Haskell.TH.Lib.Syntax.DerivClause -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Show.Show Language.Haskell.TH.Lib.Syntax.DerivStrategy -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Show.Show Language.Haskell.TH.Lib.Syntax.DocLoc -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Show.Show Language.Haskell.TH.Lib.Syntax.Exp -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Show.Show Language.Haskell.TH.Lib.Syntax.FamilyResultSig -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Show.Show Language.Haskell.TH.Lib.Syntax.Fixity -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Show.Show Language.Haskell.TH.Lib.Syntax.FixityDirection -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Show.Show Language.Haskell.TH.Lib.Syntax.Foreign -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Show.Show Language.Haskell.TH.Lib.Syntax.FunDep -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Show.Show Language.Haskell.TH.Lib.Syntax.Guard -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Show.Show Language.Haskell.TH.Lib.Syntax.Info -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Show.Show Language.Haskell.TH.Lib.Syntax.InjectivityAnn -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Show.Show Language.Haskell.TH.Lib.Syntax.Inline -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Show.Show Language.Haskell.TH.Lib.Syntax.Lit -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Show.Show Language.Haskell.TH.Lib.Syntax.Loc -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Show.Show Language.Haskell.TH.Lib.Syntax.Match -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Show.Show Language.Haskell.TH.Lib.Syntax.ModName -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Show.Show Language.Haskell.TH.Lib.Syntax.Module -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Show.Show Language.Haskell.TH.Lib.Syntax.ModuleInfo -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Show.Show Language.Haskell.TH.Lib.Syntax.Name -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Show.Show Language.Haskell.TH.Lib.Syntax.NameFlavour -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Show.Show Language.Haskell.TH.Lib.Syntax.NameSpace -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Show.Show Language.Haskell.TH.Lib.Syntax.NamespaceSpecifier -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Show.Show Language.Haskell.TH.Lib.Syntax.OccName -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Show.Show Language.Haskell.TH.Lib.Syntax.Overlap -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Show.Show Language.Haskell.TH.Lib.Syntax.Pat -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Show.Show Language.Haskell.TH.Lib.Syntax.PatSynArgs -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Show.Show Language.Haskell.TH.Lib.Syntax.PatSynDir -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Show.Show Language.Haskell.TH.Lib.Syntax.Phases -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Show.Show Language.Haskell.TH.Lib.Syntax.PkgName -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Show.Show Language.Haskell.TH.Lib.Syntax.Pragma -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Show.Show Language.Haskell.TH.Lib.Syntax.Range -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Show.Show Language.Haskell.TH.Lib.Syntax.Role -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Show.Show Language.Haskell.TH.Lib.Syntax.RuleBndr -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Show.Show Language.Haskell.TH.Lib.Syntax.RuleMatch -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Show.Show Language.Haskell.TH.Lib.Syntax.Safety -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Show.Show Language.Haskell.TH.Lib.Syntax.SourceStrictness -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Show.Show Language.Haskell.TH.Lib.Syntax.SourceUnpackedness -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Show.Show Language.Haskell.TH.Lib.Syntax.Specificity -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Show.Show Language.Haskell.TH.Lib.Syntax.Stmt -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Show.Show Language.Haskell.TH.Lib.Syntax.TyLit -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Show.Show Language.Haskell.TH.Lib.Syntax.TySynEqn -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance forall flag. GHC.Internal.Show.Show flag => GHC.Internal.Show.Show (Language.Haskell.TH.Lib.Syntax.TyVarBndr flag) -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Show.Show Language.Haskell.TH.Lib.Syntax.Type -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Internal.Show.Show Language.Haskell.TH.Lib.Syntax.TypeFamilyHead -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance [safe] GHC.Internal.Show.Show GHC.LanguageExtensions.Type.Extension -- Defined in ‘GHC.LanguageExtensions.Type’
-instance [safe] GHC.Internal.Show.Show Language.Haskell.TH.Ppr.ForallVisFlag -- Defined in ‘Language.Haskell.TH.Ppr’
-instance [safe] GHC.Internal.Show.Show GHC.ForeignSrcLang.Type.ForeignSrcLang -- Defined in ‘GHC.ForeignSrcLang.Type’
-instance [safe] GHC.Internal.Show.Show Language.Haskell.TH.PprLib.Doc -- Defined in ‘Language.Haskell.TH.PprLib’
-instance GHC.Classes.Eq Language.Haskell.TH.Lib.Syntax.AnnLookup -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Eq Language.Haskell.TH.Lib.Syntax.AnnTarget -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Eq Language.Haskell.TH.Lib.Syntax.Bang -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Eq Language.Haskell.TH.Lib.Syntax.BndrVis -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Eq Language.Haskell.TH.Lib.Syntax.Body -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Eq Language.Haskell.TH.Lib.Syntax.Bytes -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Eq Language.Haskell.TH.Lib.Syntax.Callconv -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Eq Language.Haskell.TH.Lib.Syntax.Clause -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Eq Language.Haskell.TH.Lib.Syntax.Con -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Eq Language.Haskell.TH.Lib.Syntax.Dec -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Eq Language.Haskell.TH.Lib.Syntax.DecidedStrictness -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Eq Language.Haskell.TH.Lib.Syntax.DerivClause -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Eq Language.Haskell.TH.Lib.Syntax.DerivStrategy -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Eq Language.Haskell.TH.Lib.Syntax.DocLoc -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Eq Language.Haskell.TH.Lib.Syntax.Exp -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Eq Language.Haskell.TH.Lib.Syntax.FamilyResultSig -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Eq Language.Haskell.TH.Lib.Syntax.Fixity -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Eq Language.Haskell.TH.Lib.Syntax.FixityDirection -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Eq Language.Haskell.TH.Lib.Syntax.Foreign -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Eq Language.Haskell.TH.Lib.Syntax.FunDep -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Eq Language.Haskell.TH.Lib.Syntax.Guard -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Eq Language.Haskell.TH.Lib.Syntax.Info -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Eq Language.Haskell.TH.Lib.Syntax.InjectivityAnn -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Eq Language.Haskell.TH.Lib.Syntax.Inline -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Eq Language.Haskell.TH.Lib.Syntax.Lit -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Eq Language.Haskell.TH.Lib.Syntax.Loc -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Eq Language.Haskell.TH.Lib.Syntax.Match -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Eq Language.Haskell.TH.Lib.Syntax.ModName -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Eq Language.Haskell.TH.Lib.Syntax.Module -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Eq Language.Haskell.TH.Lib.Syntax.ModuleInfo -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Eq Language.Haskell.TH.Lib.Syntax.Name -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Eq Language.Haskell.TH.Lib.Syntax.NameFlavour -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Eq Language.Haskell.TH.Lib.Syntax.NameSpace -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Eq Language.Haskell.TH.Lib.Syntax.NamespaceSpecifier -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Eq Language.Haskell.TH.Lib.Syntax.OccName -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Eq Language.Haskell.TH.Lib.Syntax.Overlap -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Eq Language.Haskell.TH.Lib.Syntax.Pat -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Eq Language.Haskell.TH.Lib.Syntax.PatSynArgs -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Eq Language.Haskell.TH.Lib.Syntax.PatSynDir -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Eq Language.Haskell.TH.Lib.Syntax.Phases -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Eq Language.Haskell.TH.Lib.Syntax.PkgName -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Eq Language.Haskell.TH.Lib.Syntax.Pragma -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Eq Language.Haskell.TH.Lib.Syntax.Range -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Eq Language.Haskell.TH.Lib.Syntax.Role -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Eq Language.Haskell.TH.Lib.Syntax.RuleBndr -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Eq Language.Haskell.TH.Lib.Syntax.RuleMatch -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Eq Language.Haskell.TH.Lib.Syntax.Safety -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Eq Language.Haskell.TH.Lib.Syntax.SourceStrictness -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Eq Language.Haskell.TH.Lib.Syntax.SourceUnpackedness -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Eq Language.Haskell.TH.Lib.Syntax.Specificity -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Eq Language.Haskell.TH.Lib.Syntax.Stmt -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Eq Language.Haskell.TH.Lib.Syntax.TyLit -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Eq Language.Haskell.TH.Lib.Syntax.TySynEqn -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance forall flag. GHC.Classes.Eq flag => GHC.Classes.Eq (Language.Haskell.TH.Lib.Syntax.TyVarBndr flag) -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Eq Language.Haskell.TH.Lib.Syntax.Type -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Eq Language.Haskell.TH.Lib.Syntax.TypeFamilyHead -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance [safe] GHC.Classes.Eq GHC.LanguageExtensions.Type.Extension -- Defined in ‘GHC.LanguageExtensions.Type’
-instance [safe] GHC.Classes.Eq GHC.ForeignSrcLang.Type.ForeignSrcLang -- Defined in ‘GHC.ForeignSrcLang.Type’
-instance GHC.Classes.Ord Language.Haskell.TH.Lib.Syntax.AnnLookup -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Ord Language.Haskell.TH.Lib.Syntax.AnnTarget -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Ord Language.Haskell.TH.Lib.Syntax.Bang -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Ord Language.Haskell.TH.Lib.Syntax.BndrVis -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Ord Language.Haskell.TH.Lib.Syntax.Body -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Ord Language.Haskell.TH.Lib.Syntax.Bytes -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Ord Language.Haskell.TH.Lib.Syntax.Callconv -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Ord Language.Haskell.TH.Lib.Syntax.Clause -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Ord Language.Haskell.TH.Lib.Syntax.Con -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Ord Language.Haskell.TH.Lib.Syntax.Dec -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Ord Language.Haskell.TH.Lib.Syntax.DecidedStrictness -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Ord Language.Haskell.TH.Lib.Syntax.DerivClause -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Ord Language.Haskell.TH.Lib.Syntax.DerivStrategy -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Ord Language.Haskell.TH.Lib.Syntax.DocLoc -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Ord Language.Haskell.TH.Lib.Syntax.Exp -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Ord Language.Haskell.TH.Lib.Syntax.FamilyResultSig -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Ord Language.Haskell.TH.Lib.Syntax.Fixity -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Ord Language.Haskell.TH.Lib.Syntax.FixityDirection -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Ord Language.Haskell.TH.Lib.Syntax.Foreign -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Ord Language.Haskell.TH.Lib.Syntax.FunDep -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Ord Language.Haskell.TH.Lib.Syntax.Guard -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Ord Language.Haskell.TH.Lib.Syntax.Info -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Ord Language.Haskell.TH.Lib.Syntax.InjectivityAnn -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Ord Language.Haskell.TH.Lib.Syntax.Inline -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Ord Language.Haskell.TH.Lib.Syntax.Lit -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Ord Language.Haskell.TH.Lib.Syntax.Loc -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Ord Language.Haskell.TH.Lib.Syntax.Match -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Ord Language.Haskell.TH.Lib.Syntax.ModName -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Ord Language.Haskell.TH.Lib.Syntax.Module -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Ord Language.Haskell.TH.Lib.Syntax.ModuleInfo -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Ord Language.Haskell.TH.Lib.Syntax.Name -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Ord Language.Haskell.TH.Lib.Syntax.NameFlavour -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Ord Language.Haskell.TH.Lib.Syntax.NameSpace -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Ord Language.Haskell.TH.Lib.Syntax.NamespaceSpecifier -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Ord Language.Haskell.TH.Lib.Syntax.OccName -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Ord Language.Haskell.TH.Lib.Syntax.Overlap -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Ord Language.Haskell.TH.Lib.Syntax.Pat -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Ord Language.Haskell.TH.Lib.Syntax.PatSynArgs -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Ord Language.Haskell.TH.Lib.Syntax.PatSynDir -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Ord Language.Haskell.TH.Lib.Syntax.Phases -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Ord Language.Haskell.TH.Lib.Syntax.PkgName -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Ord Language.Haskell.TH.Lib.Syntax.Pragma -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Ord Language.Haskell.TH.Lib.Syntax.Range -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Ord Language.Haskell.TH.Lib.Syntax.Role -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Ord Language.Haskell.TH.Lib.Syntax.RuleBndr -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Ord Language.Haskell.TH.Lib.Syntax.RuleMatch -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Ord Language.Haskell.TH.Lib.Syntax.Safety -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Ord Language.Haskell.TH.Lib.Syntax.SourceStrictness -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Ord Language.Haskell.TH.Lib.Syntax.SourceUnpackedness -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Ord Language.Haskell.TH.Lib.Syntax.Specificity -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Ord Language.Haskell.TH.Lib.Syntax.Stmt -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Ord Language.Haskell.TH.Lib.Syntax.TyLit -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Ord Language.Haskell.TH.Lib.Syntax.TySynEqn -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance forall flag. GHC.Classes.Ord flag => GHC.Classes.Ord (Language.Haskell.TH.Lib.Syntax.TyVarBndr flag) -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Ord Language.Haskell.TH.Lib.Syntax.Type -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance GHC.Classes.Ord Language.Haskell.TH.Lib.Syntax.TypeFamilyHead -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance [safe] GHC.Classes.Ord GHC.LanguageExtensions.Type.Extension -- Defined in ‘GHC.LanguageExtensions.Type’
-instance [safe] Language.Haskell.TH.Lib.DefaultBndrFlag Language.Haskell.TH.Lib.Syntax.BndrVis -- Defined in ‘Language.Haskell.TH.Lib’
-instance [safe] Language.Haskell.TH.Lib.DefaultBndrFlag Language.Haskell.TH.Lib.Syntax.Specificity -- Defined in ‘Language.Haskell.TH.Lib’
+instance GHC.Internal.TH.Ppr.Ppr GHC.Internal.TH.Syntax.Bang -- Defined in ‘GHC.Internal.TH.Ppr’
+instance GHC.Internal.TH.Ppr.Ppr GHC.Internal.TH.Syntax.Clause -- Defined in ‘GHC.Internal.TH.Ppr’
+instance GHC.Internal.TH.Ppr.Ppr GHC.Internal.TH.Syntax.Con -- Defined in ‘GHC.Internal.TH.Ppr’
+instance GHC.Internal.TH.Ppr.Ppr GHC.Internal.TH.Syntax.Dec -- Defined in ‘GHC.Internal.TH.Ppr’
+instance GHC.Internal.TH.Ppr.Ppr GHC.Internal.TH.Syntax.DecidedStrictness -- Defined in ‘GHC.Internal.TH.Ppr’
+instance GHC.Internal.TH.Ppr.Ppr GHC.Internal.TH.Syntax.Exp -- Defined in ‘GHC.Internal.TH.Ppr’
+instance GHC.Internal.TH.Ppr.Ppr GHC.Internal.TH.Syntax.FamilyResultSig -- Defined in ‘GHC.Internal.TH.Ppr’
+instance GHC.Internal.TH.Ppr.Ppr GHC.Internal.TH.Syntax.Foreign -- Defined in ‘GHC.Internal.TH.Ppr’
+instance GHC.Internal.TH.Ppr.Ppr GHC.Internal.TH.Syntax.FunDep -- Defined in ‘GHC.Internal.TH.Ppr’
+instance GHC.Internal.TH.Ppr.Ppr GHC.Internal.TH.Syntax.Info -- Defined in ‘GHC.Internal.TH.Ppr’
+instance GHC.Internal.TH.Ppr.Ppr GHC.Internal.TH.Syntax.InjectivityAnn -- Defined in ‘GHC.Internal.TH.Ppr’
+instance GHC.Internal.TH.Ppr.Ppr GHC.Internal.TH.Syntax.Inline -- Defined in ‘GHC.Internal.TH.Ppr’
+instance forall a. GHC.Internal.TH.Ppr.Ppr a => GHC.Internal.TH.Ppr.Ppr [a] -- Defined in ‘GHC.Internal.TH.Ppr’
+instance GHC.Internal.TH.Ppr.Ppr GHC.Internal.TH.Syntax.Lit -- Defined in ‘GHC.Internal.TH.Ppr’
+instance GHC.Internal.TH.Ppr.Ppr GHC.Internal.TH.Syntax.Loc -- Defined in ‘GHC.Internal.TH.Ppr’
+instance GHC.Internal.TH.Ppr.Ppr GHC.Internal.TH.Syntax.Match -- Defined in ‘GHC.Internal.TH.Ppr’
+instance GHC.Internal.TH.Ppr.Ppr GHC.Internal.TH.Syntax.Module -- Defined in ‘GHC.Internal.TH.Ppr’
+instance GHC.Internal.TH.Ppr.Ppr GHC.Internal.TH.Syntax.ModuleInfo -- Defined in ‘GHC.Internal.TH.Ppr’
+instance GHC.Internal.TH.Ppr.Ppr GHC.Internal.TH.Syntax.Name -- Defined in ‘GHC.Internal.TH.Ppr’
+instance GHC.Internal.TH.Ppr.Ppr GHC.Internal.TH.Syntax.Pat -- Defined in ‘GHC.Internal.TH.Ppr’
+instance GHC.Internal.TH.Ppr.Ppr GHC.Internal.TH.Syntax.PatSynArgs -- Defined in ‘GHC.Internal.TH.Ppr’
+instance GHC.Internal.TH.Ppr.Ppr GHC.Internal.TH.Syntax.PatSynDir -- Defined in ‘GHC.Internal.TH.Ppr’
+instance GHC.Internal.TH.Ppr.Ppr GHC.Internal.TH.Syntax.Phases -- Defined in ‘GHC.Internal.TH.Ppr’
+instance GHC.Internal.TH.Ppr.Ppr GHC.Internal.TH.Syntax.Pragma -- Defined in ‘GHC.Internal.TH.Ppr’
+instance GHC.Internal.TH.Ppr.Ppr GHC.Internal.TH.Syntax.Range -- Defined in ‘GHC.Internal.TH.Ppr’
+instance GHC.Internal.TH.Ppr.Ppr GHC.Internal.TH.Syntax.Role -- Defined in ‘GHC.Internal.TH.Ppr’
+instance GHC.Internal.TH.Ppr.Ppr GHC.Internal.TH.Syntax.RuleBndr -- Defined in ‘GHC.Internal.TH.Ppr’
+instance GHC.Internal.TH.Ppr.Ppr GHC.Internal.TH.Syntax.RuleMatch -- Defined in ‘GHC.Internal.TH.Ppr’
+instance GHC.Internal.TH.Ppr.Ppr GHC.Internal.TH.Syntax.SourceStrictness -- Defined in ‘GHC.Internal.TH.Ppr’
+instance GHC.Internal.TH.Ppr.Ppr GHC.Internal.TH.Syntax.SourceUnpackedness -- Defined in ‘GHC.Internal.TH.Ppr’
+instance GHC.Internal.TH.Ppr.Ppr GHC.Internal.TH.Syntax.Stmt -- Defined in ‘GHC.Internal.TH.Ppr’
+instance GHC.Internal.TH.Ppr.Ppr GHC.Internal.TH.Syntax.TyLit -- Defined in ‘GHC.Internal.TH.Ppr’
+instance forall flag. GHC.Internal.TH.Ppr.PprFlag flag => GHC.Internal.TH.Ppr.Ppr (GHC.Internal.TH.Syntax.TyVarBndr flag) -- Defined in ‘GHC.Internal.TH.Ppr’
+instance GHC.Internal.TH.Ppr.Ppr GHC.Internal.TH.Syntax.Type -- Defined in ‘GHC.Internal.TH.Ppr’
+instance GHC.Internal.TH.Ppr.Ppr GHC.Internal.TH.Ppr.TypeArg -- Defined in ‘GHC.Internal.TH.Ppr’
+instance GHC.Internal.TH.Ppr.PprFlag GHC.Internal.TH.Syntax.BndrVis -- Defined in ‘GHC.Internal.TH.Ppr’
+instance GHC.Internal.TH.Ppr.PprFlag GHC.Internal.TH.Syntax.Specificity -- Defined in ‘GHC.Internal.TH.Ppr’
+instance GHC.Internal.TH.Ppr.PprFlag () -- Defined in ‘GHC.Internal.TH.Ppr’
+instance GHC.Internal.Base.Applicative GHC.Internal.TH.Syntax.Q -- Defined in ‘GHC.Internal.TH.Syntax’
+instance [safe] GHC.Internal.Base.Applicative GHC.Internal.TH.PprLib.PprM -- Defined in ‘GHC.Internal.TH.PprLib’
+instance GHC.Internal.Base.Functor GHC.Internal.TH.Syntax.Q -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Base.Functor GHC.Internal.TH.Syntax.TyVarBndr -- Defined in ‘GHC.Internal.TH.Syntax’
+instance [safe] GHC.Internal.Base.Functor GHC.Internal.TH.PprLib.PprM -- Defined in ‘GHC.Internal.TH.PprLib’
+instance GHC.Internal.Base.Monad GHC.Internal.TH.Syntax.Q -- Defined in ‘GHC.Internal.TH.Syntax’
+instance [safe] GHC.Internal.Base.Monad GHC.Internal.TH.PprLib.PprM -- Defined in ‘GHC.Internal.TH.PprLib’
+instance forall a. GHC.Internal.Base.Monoid a => GHC.Internal.Base.Monoid (GHC.Internal.TH.Syntax.Q a) -- Defined in ‘GHC.Internal.TH.Syntax’
+instance forall a. GHC.Internal.Base.Semigroup a => GHC.Internal.Base.Semigroup (GHC.Internal.TH.Syntax.Q a) -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Control.Monad.Fail.MonadFail GHC.Internal.TH.Syntax.Q -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Control.Monad.Fix.MonadFix GHC.Internal.TH.Syntax.Q -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Control.Monad.IO.Class.MonadIO GHC.Internal.TH.Syntax.Q -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Data.Data.Data GHC.Internal.TH.Syntax.AnnLookup -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Data.Data.Data GHC.Internal.TH.Syntax.AnnTarget -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Data.Data.Data GHC.Internal.TH.Syntax.Bang -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Data.Data.Data GHC.Internal.TH.Syntax.BndrVis -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Data.Data.Data GHC.Internal.TH.Syntax.Body -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Data.Data.Data GHC.Internal.TH.Syntax.Bytes -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Data.Data.Data GHC.Internal.TH.Syntax.Callconv -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Data.Data.Data GHC.Internal.TH.Syntax.Clause -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Data.Data.Data GHC.Internal.TH.Syntax.Con -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Data.Data.Data GHC.Internal.TH.Syntax.Dec -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Data.Data.Data GHC.Internal.TH.Syntax.DecidedStrictness -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Data.Data.Data GHC.Internal.TH.Syntax.DerivClause -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Data.Data.Data GHC.Internal.TH.Syntax.DerivStrategy -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Data.Data.Data GHC.Internal.TH.Syntax.DocLoc -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Data.Data.Data GHC.Internal.TH.Syntax.Exp -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Data.Data.Data GHC.Internal.TH.Syntax.FamilyResultSig -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Data.Data.Data GHC.Internal.TH.Syntax.Fixity -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Data.Data.Data GHC.Internal.TH.Syntax.FixityDirection -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Data.Data.Data GHC.Internal.TH.Syntax.Foreign -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Data.Data.Data GHC.Internal.TH.Syntax.FunDep -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Data.Data.Data GHC.Internal.TH.Syntax.Guard -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Data.Data.Data GHC.Internal.TH.Syntax.Info -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Data.Data.Data GHC.Internal.TH.Syntax.InjectivityAnn -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Data.Data.Data GHC.Internal.TH.Syntax.Inline -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Data.Data.Data GHC.Internal.TH.Syntax.Lit -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Data.Data.Data GHC.Internal.TH.Syntax.Loc -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Data.Data.Data GHC.Internal.TH.Syntax.Match -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Data.Data.Data GHC.Internal.TH.Syntax.ModName -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Data.Data.Data GHC.Internal.TH.Syntax.Module -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Data.Data.Data GHC.Internal.TH.Syntax.ModuleInfo -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Data.Data.Data GHC.Internal.TH.Syntax.Name -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Data.Data.Data GHC.Internal.TH.Syntax.NameFlavour -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Data.Data.Data GHC.Internal.TH.Syntax.NameSpace -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Data.Data.Data GHC.Internal.TH.Syntax.NamespaceSpecifier -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Data.Data.Data GHC.Internal.TH.Syntax.OccName -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Data.Data.Data GHC.Internal.TH.Syntax.Overlap -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Data.Data.Data GHC.Internal.TH.Syntax.Pat -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Data.Data.Data GHC.Internal.TH.Syntax.PatSynArgs -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Data.Data.Data GHC.Internal.TH.Syntax.PatSynDir -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Data.Data.Data GHC.Internal.TH.Syntax.Phases -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Data.Data.Data GHC.Internal.TH.Syntax.PkgName -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Data.Data.Data GHC.Internal.TH.Syntax.Pragma -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Data.Data.Data GHC.Internal.TH.Syntax.Range -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Data.Data.Data GHC.Internal.TH.Syntax.Role -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Data.Data.Data GHC.Internal.TH.Syntax.RuleBndr -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Data.Data.Data GHC.Internal.TH.Syntax.RuleMatch -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Data.Data.Data GHC.Internal.TH.Syntax.Safety -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Data.Data.Data GHC.Internal.TH.Syntax.SourceStrictness -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Data.Data.Data GHC.Internal.TH.Syntax.SourceUnpackedness -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Data.Data.Data GHC.Internal.TH.Syntax.Specificity -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Data.Data.Data GHC.Internal.TH.Syntax.Stmt -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Data.Data.Data GHC.Internal.TH.Syntax.TyLit -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Data.Data.Data GHC.Internal.TH.Syntax.TySynEqn -- Defined in ‘GHC.Internal.TH.Syntax’
+instance forall flag. GHC.Internal.Data.Data.Data flag => GHC.Internal.Data.Data.Data (GHC.Internal.TH.Syntax.TyVarBndr flag) -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Data.Data.Data GHC.Internal.TH.Syntax.Type -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Data.Data.Data GHC.Internal.TH.Syntax.TypeFamilyHead -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Data.Foldable.Foldable GHC.Internal.TH.Syntax.TyVarBndr -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Data.Traversable.Traversable GHC.Internal.TH.Syntax.TyVarBndr -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Enum.Bounded GHC.Internal.LanguageExtensions.Extension -- Defined in ‘GHC.Internal.LanguageExtensions’
+instance GHC.Internal.Enum.Enum GHC.Internal.LanguageExtensions.Extension -- Defined in ‘GHC.Internal.LanguageExtensions’
+instance GHC.Internal.Generics.Generic GHC.Internal.TH.Syntax.AnnLookup -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Generics.Generic GHC.Internal.TH.Syntax.AnnTarget -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Generics.Generic GHC.Internal.TH.Syntax.Bang -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Generics.Generic GHC.Internal.TH.Syntax.BndrVis -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Generics.Generic GHC.Internal.TH.Syntax.Body -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Generics.Generic GHC.Internal.TH.Syntax.Bytes -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Generics.Generic GHC.Internal.TH.Syntax.Callconv -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Generics.Generic GHC.Internal.TH.Syntax.Clause -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Generics.Generic GHC.Internal.TH.Syntax.Con -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Generics.Generic GHC.Internal.TH.Syntax.Dec -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Generics.Generic GHC.Internal.TH.Syntax.DecidedStrictness -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Generics.Generic GHC.Internal.TH.Syntax.DerivClause -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Generics.Generic GHC.Internal.TH.Syntax.DerivStrategy -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Generics.Generic GHC.Internal.TH.Syntax.DocLoc -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Generics.Generic GHC.Internal.TH.Syntax.Exp -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Generics.Generic GHC.Internal.TH.Syntax.FamilyResultSig -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Generics.Generic GHC.Internal.TH.Syntax.Fixity -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Generics.Generic GHC.Internal.TH.Syntax.FixityDirection -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Generics.Generic GHC.Internal.TH.Syntax.Foreign -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Generics.Generic GHC.Internal.TH.Syntax.FunDep -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Generics.Generic GHC.Internal.TH.Syntax.Guard -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Generics.Generic GHC.Internal.TH.Syntax.Info -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Generics.Generic GHC.Internal.TH.Syntax.InjectivityAnn -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Generics.Generic GHC.Internal.TH.Syntax.Inline -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Generics.Generic GHC.Internal.TH.Syntax.Lit -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Generics.Generic GHC.Internal.TH.Syntax.Loc -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Generics.Generic GHC.Internal.TH.Syntax.Match -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Generics.Generic GHC.Internal.TH.Syntax.ModName -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Generics.Generic GHC.Internal.TH.Syntax.Module -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Generics.Generic GHC.Internal.TH.Syntax.ModuleInfo -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Generics.Generic GHC.Internal.TH.Syntax.Name -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Generics.Generic GHC.Internal.TH.Syntax.NameFlavour -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Generics.Generic GHC.Internal.TH.Syntax.NameSpace -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Generics.Generic GHC.Internal.TH.Syntax.NamespaceSpecifier -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Generics.Generic GHC.Internal.TH.Syntax.OccName -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Generics.Generic GHC.Internal.TH.Syntax.Overlap -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Generics.Generic GHC.Internal.TH.Syntax.Pat -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Generics.Generic GHC.Internal.TH.Syntax.PatSynArgs -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Generics.Generic GHC.Internal.TH.Syntax.PatSynDir -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Generics.Generic GHC.Internal.TH.Syntax.Phases -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Generics.Generic GHC.Internal.TH.Syntax.PkgName -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Generics.Generic GHC.Internal.TH.Syntax.Pragma -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Generics.Generic GHC.Internal.TH.Syntax.Range -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Generics.Generic GHC.Internal.TH.Syntax.Role -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Generics.Generic GHC.Internal.TH.Syntax.RuleBndr -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Generics.Generic GHC.Internal.TH.Syntax.RuleMatch -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Generics.Generic GHC.Internal.TH.Syntax.Safety -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Generics.Generic GHC.Internal.TH.Syntax.SourceStrictness -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Generics.Generic GHC.Internal.TH.Syntax.SourceUnpackedness -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Generics.Generic GHC.Internal.TH.Syntax.Specificity -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Generics.Generic GHC.Internal.TH.Syntax.Stmt -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Generics.Generic GHC.Internal.TH.Syntax.TyLit -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Generics.Generic GHC.Internal.TH.Syntax.TySynEqn -- Defined in ‘GHC.Internal.TH.Syntax’
+instance forall flag. GHC.Internal.Generics.Generic (GHC.Internal.TH.Syntax.TyVarBndr flag) -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Generics.Generic GHC.Internal.TH.Syntax.Type -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Generics.Generic GHC.Internal.TH.Syntax.TypeFamilyHead -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Generics.Generic GHC.Internal.LanguageExtensions.Extension -- Defined in ‘GHC.Internal.LanguageExtensions’
+instance GHC.Internal.Generics.Generic GHC.Internal.ForeignSrcLang.ForeignSrcLang -- Defined in ‘GHC.Internal.ForeignSrcLang’
+instance GHC.Internal.Show.Show GHC.Internal.TH.Syntax.AnnLookup -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Show.Show GHC.Internal.TH.Syntax.AnnTarget -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Show.Show GHC.Internal.TH.Syntax.Bang -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Show.Show GHC.Internal.TH.Syntax.BndrVis -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Show.Show GHC.Internal.TH.Syntax.Body -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Show.Show GHC.Internal.TH.Syntax.Bytes -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Show.Show GHC.Internal.TH.Syntax.Callconv -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Show.Show GHC.Internal.TH.Syntax.Clause -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Show.Show GHC.Internal.TH.Syntax.Con -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Show.Show GHC.Internal.TH.Syntax.Dec -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Show.Show GHC.Internal.TH.Syntax.DecidedStrictness -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Show.Show GHC.Internal.TH.Syntax.DerivClause -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Show.Show GHC.Internal.TH.Syntax.DerivStrategy -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Show.Show GHC.Internal.TH.Syntax.DocLoc -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Show.Show GHC.Internal.TH.Syntax.Exp -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Show.Show GHC.Internal.TH.Syntax.FamilyResultSig -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Show.Show GHC.Internal.TH.Syntax.Fixity -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Show.Show GHC.Internal.TH.Syntax.FixityDirection -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Show.Show GHC.Internal.TH.Syntax.Foreign -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Show.Show GHC.Internal.TH.Syntax.FunDep -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Show.Show GHC.Internal.TH.Syntax.Guard -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Show.Show GHC.Internal.TH.Syntax.Info -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Show.Show GHC.Internal.TH.Syntax.InjectivityAnn -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Show.Show GHC.Internal.TH.Syntax.Inline -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Show.Show GHC.Internal.TH.Syntax.Lit -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Show.Show GHC.Internal.TH.Syntax.Loc -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Show.Show GHC.Internal.TH.Syntax.Match -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Show.Show GHC.Internal.TH.Syntax.ModName -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Show.Show GHC.Internal.TH.Syntax.Module -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Show.Show GHC.Internal.TH.Syntax.ModuleInfo -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Show.Show GHC.Internal.TH.Syntax.Name -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Show.Show GHC.Internal.TH.Syntax.NameFlavour -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Show.Show GHC.Internal.TH.Syntax.NameSpace -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Show.Show GHC.Internal.TH.Syntax.NamespaceSpecifier -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Show.Show GHC.Internal.TH.Syntax.OccName -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Show.Show GHC.Internal.TH.Syntax.Overlap -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Show.Show GHC.Internal.TH.Syntax.Pat -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Show.Show GHC.Internal.TH.Syntax.PatSynArgs -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Show.Show GHC.Internal.TH.Syntax.PatSynDir -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Show.Show GHC.Internal.TH.Syntax.Phases -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Show.Show GHC.Internal.TH.Syntax.PkgName -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Show.Show GHC.Internal.TH.Syntax.Pragma -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Show.Show GHC.Internal.TH.Syntax.Range -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Show.Show GHC.Internal.TH.Syntax.Role -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Show.Show GHC.Internal.TH.Syntax.RuleBndr -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Show.Show GHC.Internal.TH.Syntax.RuleMatch -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Show.Show GHC.Internal.TH.Syntax.Safety -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Show.Show GHC.Internal.TH.Syntax.SourceStrictness -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Show.Show GHC.Internal.TH.Syntax.SourceUnpackedness -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Show.Show GHC.Internal.TH.Syntax.Specificity -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Show.Show GHC.Internal.TH.Syntax.Stmt -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Show.Show GHC.Internal.TH.Syntax.TyLit -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Show.Show GHC.Internal.TH.Syntax.TySynEqn -- Defined in ‘GHC.Internal.TH.Syntax’
+instance forall flag. GHC.Internal.Show.Show flag => GHC.Internal.Show.Show (GHC.Internal.TH.Syntax.TyVarBndr flag) -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Show.Show GHC.Internal.TH.Syntax.Type -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Show.Show GHC.Internal.TH.Syntax.TypeFamilyHead -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.Show.Show GHC.Internal.LanguageExtensions.Extension -- Defined in ‘GHC.Internal.LanguageExtensions’
+instance GHC.Internal.Show.Show GHC.Internal.TH.Ppr.ForallVisFlag -- Defined in ‘GHC.Internal.TH.Ppr’
+instance [safe] GHC.Internal.Show.Show GHC.Internal.TH.PprLib.Doc -- Defined in ‘GHC.Internal.TH.PprLib’
+instance GHC.Internal.Show.Show GHC.Internal.ForeignSrcLang.ForeignSrcLang -- Defined in ‘GHC.Internal.ForeignSrcLang’
+instance GHC.Internal.TH.Lift.Lift GHC.Types.Bool -- Defined in ‘GHC.Internal.TH.Lift’
+instance GHC.Internal.TH.Lift.Lift GHC.Types.Char -- Defined in ‘GHC.Internal.TH.Lift’
+instance GHC.Internal.TH.Lift.Lift GHC.Types.Double -- Defined in ‘GHC.Internal.TH.Lift’
+instance forall a b. (GHC.Internal.TH.Lift.Lift a, GHC.Internal.TH.Lift.Lift b) => GHC.Internal.TH.Lift.Lift (GHC.Internal.Data.Either.Either a b) -- Defined in ‘GHC.Internal.TH.Lift’
+instance GHC.Internal.TH.Lift.Lift GHC.Types.Float -- Defined in ‘GHC.Internal.TH.Lift’
+instance GHC.Internal.TH.Lift.Lift GHC.Types.Int -- Defined in ‘GHC.Internal.TH.Lift’
+instance GHC.Internal.TH.Lift.Lift GHC.Internal.Int.Int16 -- Defined in ‘GHC.Internal.TH.Lift’
+instance GHC.Internal.TH.Lift.Lift GHC.Internal.Int.Int32 -- Defined in ‘GHC.Internal.TH.Lift’
+instance GHC.Internal.TH.Lift.Lift GHC.Internal.Int.Int64 -- Defined in ‘GHC.Internal.TH.Lift’
+instance GHC.Internal.TH.Lift.Lift GHC.Internal.Int.Int8 -- Defined in ‘GHC.Internal.TH.Lift’
+instance GHC.Internal.TH.Lift.Lift GHC.Num.Integer.Integer -- Defined in ‘GHC.Internal.TH.Lift’
+instance forall a. GHC.Internal.TH.Lift.Lift a => GHC.Internal.TH.Lift.Lift [a] -- Defined in ‘GHC.Internal.TH.Lift’
+instance forall a. GHC.Internal.TH.Lift.Lift a => GHC.Internal.TH.Lift.Lift (GHC.Internal.Maybe.Maybe a) -- Defined in ‘GHC.Internal.TH.Lift’
+instance GHC.Internal.TH.Lift.Lift GHC.Num.Natural.Natural -- Defined in ‘GHC.Internal.TH.Lift’
+instance forall a. GHC.Internal.TH.Lift.Lift a => GHC.Internal.TH.Lift.Lift (GHC.Internal.Base.NonEmpty a) -- Defined in ‘GHC.Internal.TH.Lift’
+instance forall a. GHC.Internal.Real.Integral a => GHC.Internal.TH.Lift.Lift (GHC.Internal.Real.Ratio a) -- Defined in ‘GHC.Internal.TH.Lift’
+instance forall a b. (GHC.Internal.TH.Lift.Lift a, GHC.Internal.TH.Lift.Lift b) => GHC.Internal.TH.Lift.Lift (a, b) -- Defined in ‘GHC.Internal.TH.Lift’
+instance forall a b c. (GHC.Internal.TH.Lift.Lift a, GHC.Internal.TH.Lift.Lift b, GHC.Internal.TH.Lift.Lift c) => GHC.Internal.TH.Lift.Lift (a, b, c) -- Defined in ‘GHC.Internal.TH.Lift’
+instance forall a b c d. (GHC.Internal.TH.Lift.Lift a, GHC.Internal.TH.Lift.Lift b, GHC.Internal.TH.Lift.Lift c, GHC.Internal.TH.Lift.Lift d) => GHC.Internal.TH.Lift.Lift (a, b, c, d) -- Defined in ‘GHC.Internal.TH.Lift’
+instance forall a b c d e. (GHC.Internal.TH.Lift.Lift a, GHC.Internal.TH.Lift.Lift b, GHC.Internal.TH.Lift.Lift c, GHC.Internal.TH.Lift.Lift d, GHC.Internal.TH.Lift.Lift e) => GHC.Internal.TH.Lift.Lift (a, b, c, d, e) -- Defined in ‘GHC.Internal.TH.Lift’
+instance forall a b c d e f. (GHC.Internal.TH.Lift.Lift a, GHC.Internal.TH.Lift.Lift b, GHC.Internal.TH.Lift.Lift c, GHC.Internal.TH.Lift.Lift d, GHC.Internal.TH.Lift.Lift e, GHC.Internal.TH.Lift.Lift f) => GHC.Internal.TH.Lift.Lift (a, b, c, d, e, f) -- Defined in ‘GHC.Internal.TH.Lift’
+instance forall a b c d e f g. (GHC.Internal.TH.Lift.Lift a, GHC.Internal.TH.Lift.Lift b, GHC.Internal.TH.Lift.Lift c, GHC.Internal.TH.Lift.Lift d, GHC.Internal.TH.Lift.Lift e, GHC.Internal.TH.Lift.Lift f, GHC.Internal.TH.Lift.Lift g) => GHC.Internal.TH.Lift.Lift (a, b, c, d, e, f, g) -- Defined in ‘GHC.Internal.TH.Lift’
+instance GHC.Internal.TH.Lift.Lift () -- Defined in ‘GHC.Internal.TH.Lift’
+instance GHC.Internal.TH.Lift.Lift GHC.Internal.Base.Void -- Defined in ‘GHC.Internal.TH.Lift’
+instance GHC.Internal.TH.Lift.Lift GHC.Types.Word -- Defined in ‘GHC.Internal.TH.Lift’
+instance GHC.Internal.TH.Lift.Lift GHC.Internal.Word.Word16 -- Defined in ‘GHC.Internal.TH.Lift’
+instance GHC.Internal.TH.Lift.Lift GHC.Internal.Word.Word32 -- Defined in ‘GHC.Internal.TH.Lift’
+instance GHC.Internal.TH.Lift.Lift GHC.Internal.Word.Word64 -- Defined in ‘GHC.Internal.TH.Lift’
+instance GHC.Internal.TH.Lift.Lift GHC.Internal.Word.Word8 -- Defined in ‘GHC.Internal.TH.Lift’
+instance forall a b. (GHC.Internal.TH.Lift.Lift a, GHC.Internal.TH.Lift.Lift b) => GHC.Internal.TH.Lift.Lift (# a | b #) -- Defined in ‘GHC.Internal.TH.Lift’
+instance forall a b c. (GHC.Internal.TH.Lift.Lift a, GHC.Internal.TH.Lift.Lift b, GHC.Internal.TH.Lift.Lift c) => GHC.Internal.TH.Lift.Lift (# a | b | c #) -- Defined in ‘GHC.Internal.TH.Lift’
+instance forall a b c d. (GHC.Internal.TH.Lift.Lift a, GHC.Internal.TH.Lift.Lift b, GHC.Internal.TH.Lift.Lift c, GHC.Internal.TH.Lift.Lift d) => GHC.Internal.TH.Lift.Lift (# a | b | c | d #) -- Defined in ‘GHC.Internal.TH.Lift’
+instance forall a b c d e. (GHC.Internal.TH.Lift.Lift a, GHC.Internal.TH.Lift.Lift b, GHC.Internal.TH.Lift.Lift c, GHC.Internal.TH.Lift.Lift d, GHC.Internal.TH.Lift.Lift e) => GHC.Internal.TH.Lift.Lift (# a | b | c | d | e #) -- Defined in ‘GHC.Internal.TH.Lift’
+instance forall a b c d e f. (GHC.Internal.TH.Lift.Lift a, GHC.Internal.TH.Lift.Lift b, GHC.Internal.TH.Lift.Lift c, GHC.Internal.TH.Lift.Lift d, GHC.Internal.TH.Lift.Lift e, GHC.Internal.TH.Lift.Lift f) => GHC.Internal.TH.Lift.Lift (# a | b | c | d | e | f #) -- Defined in ‘GHC.Internal.TH.Lift’
+instance forall a b c d e f g. (GHC.Internal.TH.Lift.Lift a, GHC.Internal.TH.Lift.Lift b, GHC.Internal.TH.Lift.Lift c, GHC.Internal.TH.Lift.Lift d, GHC.Internal.TH.Lift.Lift e, GHC.Internal.TH.Lift.Lift f, GHC.Internal.TH.Lift.Lift g) => GHC.Internal.TH.Lift.Lift (# a | b | c | d | e | f | g #) -- Defined in ‘GHC.Internal.TH.Lift’
+instance forall a. GHC.Internal.TH.Lift.Lift a => GHC.Internal.TH.Lift.Lift (# a #) -- Defined in ‘GHC.Internal.TH.Lift’
+instance forall a b. (GHC.Internal.TH.Lift.Lift a, GHC.Internal.TH.Lift.Lift b) => GHC.Internal.TH.Lift.Lift (# a, b #) -- Defined in ‘GHC.Internal.TH.Lift’
+instance forall a b c. (GHC.Internal.TH.Lift.Lift a, GHC.Internal.TH.Lift.Lift b, GHC.Internal.TH.Lift.Lift c) => GHC.Internal.TH.Lift.Lift (# a, b, c #) -- Defined in ‘GHC.Internal.TH.Lift’
+instance forall a b c d. (GHC.Internal.TH.Lift.Lift a, GHC.Internal.TH.Lift.Lift b, GHC.Internal.TH.Lift.Lift c, GHC.Internal.TH.Lift.Lift d) => GHC.Internal.TH.Lift.Lift (# a, b, c, d #) -- Defined in ‘GHC.Internal.TH.Lift’
+instance forall a b c d e. (GHC.Internal.TH.Lift.Lift a, GHC.Internal.TH.Lift.Lift b, GHC.Internal.TH.Lift.Lift c, GHC.Internal.TH.Lift.Lift d, GHC.Internal.TH.Lift.Lift e) => GHC.Internal.TH.Lift.Lift (# a, b, c, d, e #) -- Defined in ‘GHC.Internal.TH.Lift’
+instance forall a b c d e f. (GHC.Internal.TH.Lift.Lift a, GHC.Internal.TH.Lift.Lift b, GHC.Internal.TH.Lift.Lift c, GHC.Internal.TH.Lift.Lift d, GHC.Internal.TH.Lift.Lift e, GHC.Internal.TH.Lift.Lift f) => GHC.Internal.TH.Lift.Lift (# a, b, c, d, e, f #) -- Defined in ‘GHC.Internal.TH.Lift’
+instance forall a b c d e f g. (GHC.Internal.TH.Lift.Lift a, GHC.Internal.TH.Lift.Lift b, GHC.Internal.TH.Lift.Lift c, GHC.Internal.TH.Lift.Lift d, GHC.Internal.TH.Lift.Lift e, GHC.Internal.TH.Lift.Lift f, GHC.Internal.TH.Lift.Lift g) => GHC.Internal.TH.Lift.Lift (# a, b, c, d, e, f, g #) -- Defined in ‘GHC.Internal.TH.Lift’
+instance GHC.Internal.TH.Lift.Lift (# #) -- Defined in ‘GHC.Internal.TH.Lift’
+instance GHC.Internal.TH.Syntax.Quasi GHC.Types.IO -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.TH.Syntax.Quasi GHC.Internal.TH.Syntax.Q -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.TH.Syntax.Quote GHC.Types.IO -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Internal.TH.Syntax.Quote GHC.Internal.TH.Syntax.Q -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Eq GHC.Internal.TH.Syntax.AnnLookup -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Eq GHC.Internal.TH.Syntax.AnnTarget -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Eq GHC.Internal.TH.Syntax.Bang -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Eq GHC.Internal.TH.Syntax.BndrVis -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Eq GHC.Internal.TH.Syntax.Body -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Eq GHC.Internal.TH.Syntax.Bytes -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Eq GHC.Internal.TH.Syntax.Callconv -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Eq GHC.Internal.TH.Syntax.Clause -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Eq GHC.Internal.TH.Syntax.Con -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Eq GHC.Internal.TH.Syntax.Dec -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Eq GHC.Internal.TH.Syntax.DecidedStrictness -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Eq GHC.Internal.TH.Syntax.DerivClause -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Eq GHC.Internal.TH.Syntax.DerivStrategy -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Eq GHC.Internal.TH.Syntax.DocLoc -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Eq GHC.Internal.TH.Syntax.Exp -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Eq GHC.Internal.TH.Syntax.FamilyResultSig -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Eq GHC.Internal.TH.Syntax.Fixity -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Eq GHC.Internal.TH.Syntax.FixityDirection -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Eq GHC.Internal.TH.Syntax.Foreign -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Eq GHC.Internal.TH.Syntax.FunDep -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Eq GHC.Internal.TH.Syntax.Guard -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Eq GHC.Internal.TH.Syntax.Info -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Eq GHC.Internal.TH.Syntax.InjectivityAnn -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Eq GHC.Internal.TH.Syntax.Inline -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Eq GHC.Internal.TH.Syntax.Lit -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Eq GHC.Internal.TH.Syntax.Loc -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Eq GHC.Internal.TH.Syntax.Match -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Eq GHC.Internal.TH.Syntax.ModName -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Eq GHC.Internal.TH.Syntax.Module -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Eq GHC.Internal.TH.Syntax.ModuleInfo -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Eq GHC.Internal.TH.Syntax.Name -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Eq GHC.Internal.TH.Syntax.NameFlavour -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Eq GHC.Internal.TH.Syntax.NameSpace -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Eq GHC.Internal.TH.Syntax.NamespaceSpecifier -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Eq GHC.Internal.TH.Syntax.OccName -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Eq GHC.Internal.TH.Syntax.Overlap -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Eq GHC.Internal.TH.Syntax.Pat -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Eq GHC.Internal.TH.Syntax.PatSynArgs -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Eq GHC.Internal.TH.Syntax.PatSynDir -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Eq GHC.Internal.TH.Syntax.Phases -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Eq GHC.Internal.TH.Syntax.PkgName -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Eq GHC.Internal.TH.Syntax.Pragma -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Eq GHC.Internal.TH.Syntax.Range -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Eq GHC.Internal.TH.Syntax.Role -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Eq GHC.Internal.TH.Syntax.RuleBndr -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Eq GHC.Internal.TH.Syntax.RuleMatch -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Eq GHC.Internal.TH.Syntax.Safety -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Eq GHC.Internal.TH.Syntax.SourceStrictness -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Eq GHC.Internal.TH.Syntax.SourceUnpackedness -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Eq GHC.Internal.TH.Syntax.Specificity -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Eq GHC.Internal.TH.Syntax.Stmt -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Eq GHC.Internal.TH.Syntax.TyLit -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Eq GHC.Internal.TH.Syntax.TySynEqn -- Defined in ‘GHC.Internal.TH.Syntax’
+instance forall flag. GHC.Classes.Eq flag => GHC.Classes.Eq (GHC.Internal.TH.Syntax.TyVarBndr flag) -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Eq GHC.Internal.TH.Syntax.Type -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Eq GHC.Internal.TH.Syntax.TypeFamilyHead -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Eq GHC.Internal.LanguageExtensions.Extension -- Defined in ‘GHC.Internal.LanguageExtensions’
+instance GHC.Classes.Eq GHC.Internal.ForeignSrcLang.ForeignSrcLang -- Defined in ‘GHC.Internal.ForeignSrcLang’
+instance GHC.Classes.Ord GHC.Internal.TH.Syntax.AnnLookup -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Ord GHC.Internal.TH.Syntax.AnnTarget -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Ord GHC.Internal.TH.Syntax.Bang -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Ord GHC.Internal.TH.Syntax.BndrVis -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Ord GHC.Internal.TH.Syntax.Body -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Ord GHC.Internal.TH.Syntax.Bytes -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Ord GHC.Internal.TH.Syntax.Callconv -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Ord GHC.Internal.TH.Syntax.Clause -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Ord GHC.Internal.TH.Syntax.Con -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Ord GHC.Internal.TH.Syntax.Dec -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Ord GHC.Internal.TH.Syntax.DecidedStrictness -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Ord GHC.Internal.TH.Syntax.DerivClause -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Ord GHC.Internal.TH.Syntax.DerivStrategy -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Ord GHC.Internal.TH.Syntax.DocLoc -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Ord GHC.Internal.TH.Syntax.Exp -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Ord GHC.Internal.TH.Syntax.FamilyResultSig -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Ord GHC.Internal.TH.Syntax.Fixity -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Ord GHC.Internal.TH.Syntax.FixityDirection -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Ord GHC.Internal.TH.Syntax.Foreign -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Ord GHC.Internal.TH.Syntax.FunDep -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Ord GHC.Internal.TH.Syntax.Guard -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Ord GHC.Internal.TH.Syntax.Info -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Ord GHC.Internal.TH.Syntax.InjectivityAnn -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Ord GHC.Internal.TH.Syntax.Inline -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Ord GHC.Internal.TH.Syntax.Lit -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Ord GHC.Internal.TH.Syntax.Loc -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Ord GHC.Internal.TH.Syntax.Match -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Ord GHC.Internal.TH.Syntax.ModName -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Ord GHC.Internal.TH.Syntax.Module -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Ord GHC.Internal.TH.Syntax.ModuleInfo -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Ord GHC.Internal.TH.Syntax.Name -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Ord GHC.Internal.TH.Syntax.NameFlavour -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Ord GHC.Internal.TH.Syntax.NameSpace -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Ord GHC.Internal.TH.Syntax.NamespaceSpecifier -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Ord GHC.Internal.TH.Syntax.OccName -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Ord GHC.Internal.TH.Syntax.Overlap -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Ord GHC.Internal.TH.Syntax.Pat -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Ord GHC.Internal.TH.Syntax.PatSynArgs -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Ord GHC.Internal.TH.Syntax.PatSynDir -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Ord GHC.Internal.TH.Syntax.Phases -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Ord GHC.Internal.TH.Syntax.PkgName -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Ord GHC.Internal.TH.Syntax.Pragma -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Ord GHC.Internal.TH.Syntax.Range -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Ord GHC.Internal.TH.Syntax.Role -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Ord GHC.Internal.TH.Syntax.RuleBndr -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Ord GHC.Internal.TH.Syntax.RuleMatch -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Ord GHC.Internal.TH.Syntax.Safety -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Ord GHC.Internal.TH.Syntax.SourceStrictness -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Ord GHC.Internal.TH.Syntax.SourceUnpackedness -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Ord GHC.Internal.TH.Syntax.Specificity -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Ord GHC.Internal.TH.Syntax.Stmt -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Ord GHC.Internal.TH.Syntax.TyLit -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Ord GHC.Internal.TH.Syntax.TySynEqn -- Defined in ‘GHC.Internal.TH.Syntax’
+instance forall flag. GHC.Classes.Ord flag => GHC.Classes.Ord (GHC.Internal.TH.Syntax.TyVarBndr flag) -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Ord GHC.Internal.TH.Syntax.Type -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Ord GHC.Internal.TH.Syntax.TypeFamilyHead -- Defined in ‘GHC.Internal.TH.Syntax’
+instance GHC.Classes.Ord GHC.Internal.LanguageExtensions.Extension -- Defined in ‘GHC.Internal.LanguageExtensions’
+instance [safe] Language.Haskell.TH.Lib.DefaultBndrFlag GHC.Internal.TH.Syntax.BndrVis -- Defined in ‘Language.Haskell.TH.Lib’
+instance [safe] Language.Haskell.TH.Lib.DefaultBndrFlag GHC.Internal.TH.Syntax.Specificity -- Defined in ‘Language.Haskell.TH.Lib’
instance [safe] Language.Haskell.TH.Lib.DefaultBndrFlag () -- Defined in ‘Language.Haskell.TH.Lib’
-instance Language.Haskell.TH.Lib.Syntax.Lift GHC.Types.Bool -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance Language.Haskell.TH.Lib.Syntax.Lift Data.Array.Byte.ByteArray -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance Language.Haskell.TH.Lib.Syntax.Lift GHC.Types.Char -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance Language.Haskell.TH.Lib.Syntax.Lift GHC.Types.Double -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance forall a b. (Language.Haskell.TH.Lib.Syntax.Lift a, Language.Haskell.TH.Lib.Syntax.Lift b) => Language.Haskell.TH.Lib.Syntax.Lift (GHC.Internal.Data.Either.Either a b) -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance forall k (a :: k). Language.Haskell.TH.Lib.Syntax.Lift (Data.Fixed.Fixed a) -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance Language.Haskell.TH.Lib.Syntax.Lift GHC.Types.Float -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance Language.Haskell.TH.Lib.Syntax.Lift GHC.Types.Int -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance Language.Haskell.TH.Lib.Syntax.Lift GHC.Internal.Int.Int16 -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance Language.Haskell.TH.Lib.Syntax.Lift GHC.Internal.Int.Int32 -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance Language.Haskell.TH.Lib.Syntax.Lift GHC.Internal.Int.Int64 -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance Language.Haskell.TH.Lib.Syntax.Lift GHC.Internal.Int.Int8 -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance Language.Haskell.TH.Lib.Syntax.Lift GHC.Num.Integer.Integer -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance forall a. Language.Haskell.TH.Lib.Syntax.Lift a => Language.Haskell.TH.Lib.Syntax.Lift [a] -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance forall a. Language.Haskell.TH.Lib.Syntax.Lift a => Language.Haskell.TH.Lib.Syntax.Lift (GHC.Internal.Maybe.Maybe a) -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance Language.Haskell.TH.Lib.Syntax.Lift GHC.Num.Natural.Natural -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance forall a. Language.Haskell.TH.Lib.Syntax.Lift a => Language.Haskell.TH.Lib.Syntax.Lift (GHC.Internal.Base.NonEmpty a) -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance forall a. GHC.Internal.Real.Integral a => Language.Haskell.TH.Lib.Syntax.Lift (GHC.Internal.Real.Ratio a) -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance forall a b. (Language.Haskell.TH.Lib.Syntax.Lift a, Language.Haskell.TH.Lib.Syntax.Lift b) => Language.Haskell.TH.Lib.Syntax.Lift (a, b) -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance forall a b c. (Language.Haskell.TH.Lib.Syntax.Lift a, Language.Haskell.TH.Lib.Syntax.Lift b, Language.Haskell.TH.Lib.Syntax.Lift c) => Language.Haskell.TH.Lib.Syntax.Lift (a, b, c) -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance forall a b c d. (Language.Haskell.TH.Lib.Syntax.Lift a, Language.Haskell.TH.Lib.Syntax.Lift b, Language.Haskell.TH.Lib.Syntax.Lift c, Language.Haskell.TH.Lib.Syntax.Lift d) => Language.Haskell.TH.Lib.Syntax.Lift (a, b, c, d) -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance forall a b c d e. (Language.Haskell.TH.Lib.Syntax.Lift a, Language.Haskell.TH.Lib.Syntax.Lift b, Language.Haskell.TH.Lib.Syntax.Lift c, Language.Haskell.TH.Lib.Syntax.Lift d, Language.Haskell.TH.Lib.Syntax.Lift e) => Language.Haskell.TH.Lib.Syntax.Lift (a, b, c, d, e) -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance forall a b c d e f. (Language.Haskell.TH.Lib.Syntax.Lift a, Language.Haskell.TH.Lib.Syntax.Lift b, Language.Haskell.TH.Lib.Syntax.Lift c, Language.Haskell.TH.Lib.Syntax.Lift d, Language.Haskell.TH.Lib.Syntax.Lift e, Language.Haskell.TH.Lib.Syntax.Lift f) => Language.Haskell.TH.Lib.Syntax.Lift (a, b, c, d, e, f) -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance forall a b c d e f g. (Language.Haskell.TH.Lib.Syntax.Lift a, Language.Haskell.TH.Lib.Syntax.Lift b, Language.Haskell.TH.Lib.Syntax.Lift c, Language.Haskell.TH.Lib.Syntax.Lift d, Language.Haskell.TH.Lib.Syntax.Lift e, Language.Haskell.TH.Lib.Syntax.Lift f, Language.Haskell.TH.Lib.Syntax.Lift g) => Language.Haskell.TH.Lib.Syntax.Lift (a, b, c, d, e, f, g) -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance Language.Haskell.TH.Lib.Syntax.Lift () -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance Language.Haskell.TH.Lib.Syntax.Lift GHC.Internal.Base.Void -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance Language.Haskell.TH.Lib.Syntax.Lift GHC.Types.Word -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance Language.Haskell.TH.Lib.Syntax.Lift GHC.Internal.Word.Word16 -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance Language.Haskell.TH.Lib.Syntax.Lift GHC.Internal.Word.Word32 -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance Language.Haskell.TH.Lib.Syntax.Lift GHC.Internal.Word.Word64 -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance Language.Haskell.TH.Lib.Syntax.Lift GHC.Internal.Word.Word8 -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance forall a b. (Language.Haskell.TH.Lib.Syntax.Lift a, Language.Haskell.TH.Lib.Syntax.Lift b) => Language.Haskell.TH.Lib.Syntax.Lift (# a | b #) -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance forall a b c. (Language.Haskell.TH.Lib.Syntax.Lift a, Language.Haskell.TH.Lib.Syntax.Lift b, Language.Haskell.TH.Lib.Syntax.Lift c) => Language.Haskell.TH.Lib.Syntax.Lift (# a | b | c #) -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance forall a b c d. (Language.Haskell.TH.Lib.Syntax.Lift a, Language.Haskell.TH.Lib.Syntax.Lift b, Language.Haskell.TH.Lib.Syntax.Lift c, Language.Haskell.TH.Lib.Syntax.Lift d) => Language.Haskell.TH.Lib.Syntax.Lift (# a | b | c | d #) -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance forall a b c d e. (Language.Haskell.TH.Lib.Syntax.Lift a, Language.Haskell.TH.Lib.Syntax.Lift b, Language.Haskell.TH.Lib.Syntax.Lift c, Language.Haskell.TH.Lib.Syntax.Lift d, Language.Haskell.TH.Lib.Syntax.Lift e) => Language.Haskell.TH.Lib.Syntax.Lift (# a | b | c | d | e #) -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance forall a b c d e f. (Language.Haskell.TH.Lib.Syntax.Lift a, Language.Haskell.TH.Lib.Syntax.Lift b, Language.Haskell.TH.Lib.Syntax.Lift c, Language.Haskell.TH.Lib.Syntax.Lift d, Language.Haskell.TH.Lib.Syntax.Lift e, Language.Haskell.TH.Lib.Syntax.Lift f) => Language.Haskell.TH.Lib.Syntax.Lift (# a | b | c | d | e | f #) -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance forall a b c d e f g. (Language.Haskell.TH.Lib.Syntax.Lift a, Language.Haskell.TH.Lib.Syntax.Lift b, Language.Haskell.TH.Lib.Syntax.Lift c, Language.Haskell.TH.Lib.Syntax.Lift d, Language.Haskell.TH.Lib.Syntax.Lift e, Language.Haskell.TH.Lib.Syntax.Lift f, Language.Haskell.TH.Lib.Syntax.Lift g) => Language.Haskell.TH.Lib.Syntax.Lift (# a | b | c | d | e | f | g #) -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance forall a. Language.Haskell.TH.Lib.Syntax.Lift a => Language.Haskell.TH.Lib.Syntax.Lift (# a #) -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance forall a b. (Language.Haskell.TH.Lib.Syntax.Lift a, Language.Haskell.TH.Lib.Syntax.Lift b) => Language.Haskell.TH.Lib.Syntax.Lift (# a, b #) -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance forall a b c. (Language.Haskell.TH.Lib.Syntax.Lift a, Language.Haskell.TH.Lib.Syntax.Lift b, Language.Haskell.TH.Lib.Syntax.Lift c) => Language.Haskell.TH.Lib.Syntax.Lift (# a, b, c #) -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance forall a b c d. (Language.Haskell.TH.Lib.Syntax.Lift a, Language.Haskell.TH.Lib.Syntax.Lift b, Language.Haskell.TH.Lib.Syntax.Lift c, Language.Haskell.TH.Lib.Syntax.Lift d) => Language.Haskell.TH.Lib.Syntax.Lift (# a, b, c, d #) -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance forall a b c d e. (Language.Haskell.TH.Lib.Syntax.Lift a, Language.Haskell.TH.Lib.Syntax.Lift b, Language.Haskell.TH.Lib.Syntax.Lift c, Language.Haskell.TH.Lib.Syntax.Lift d, Language.Haskell.TH.Lib.Syntax.Lift e) => Language.Haskell.TH.Lib.Syntax.Lift (# a, b, c, d, e #) -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance forall a b c d e f. (Language.Haskell.TH.Lib.Syntax.Lift a, Language.Haskell.TH.Lib.Syntax.Lift b, Language.Haskell.TH.Lib.Syntax.Lift c, Language.Haskell.TH.Lib.Syntax.Lift d, Language.Haskell.TH.Lib.Syntax.Lift e, Language.Haskell.TH.Lib.Syntax.Lift f) => Language.Haskell.TH.Lib.Syntax.Lift (# a, b, c, d, e, f #) -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance forall a b c d e f g. (Language.Haskell.TH.Lib.Syntax.Lift a, Language.Haskell.TH.Lib.Syntax.Lift b, Language.Haskell.TH.Lib.Syntax.Lift c, Language.Haskell.TH.Lib.Syntax.Lift d, Language.Haskell.TH.Lib.Syntax.Lift e, Language.Haskell.TH.Lib.Syntax.Lift f, Language.Haskell.TH.Lib.Syntax.Lift g) => Language.Haskell.TH.Lib.Syntax.Lift (# a, b, c, d, e, f, g #) -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance Language.Haskell.TH.Lib.Syntax.Lift (# #) -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance Language.Haskell.TH.Lib.Syntax.Quasi GHC.Types.IO -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance Language.Haskell.TH.Lib.Syntax.Quasi Language.Haskell.TH.Lib.Syntax.Q -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance Language.Haskell.TH.Lib.Syntax.Quote GHC.Types.IO -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance Language.Haskell.TH.Lib.Syntax.Quote Language.Haskell.TH.Lib.Syntax.Q -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
-instance [safe] Language.Haskell.TH.Ppr.Ppr Language.Haskell.TH.Lib.Syntax.Bang -- Defined in ‘Language.Haskell.TH.Ppr’
-instance [safe] Language.Haskell.TH.Ppr.Ppr Language.Haskell.TH.Lib.Syntax.Clause -- Defined in ‘Language.Haskell.TH.Ppr’
-instance [safe] Language.Haskell.TH.Ppr.Ppr Language.Haskell.TH.Lib.Syntax.Con -- Defined in ‘Language.Haskell.TH.Ppr’
-instance [safe] Language.Haskell.TH.Ppr.Ppr Language.Haskell.TH.Lib.Syntax.Dec -- Defined in ‘Language.Haskell.TH.Ppr’
-instance [safe] Language.Haskell.TH.Ppr.Ppr Language.Haskell.TH.Lib.Syntax.DecidedStrictness -- Defined in ‘Language.Haskell.TH.Ppr’
-instance [safe] Language.Haskell.TH.Ppr.Ppr Language.Haskell.TH.Lib.Syntax.Exp -- Defined in ‘Language.Haskell.TH.Ppr’
-instance [safe] Language.Haskell.TH.Ppr.Ppr Language.Haskell.TH.Lib.Syntax.FamilyResultSig -- Defined in ‘Language.Haskell.TH.Ppr’
-instance [safe] Language.Haskell.TH.Ppr.Ppr Language.Haskell.TH.Lib.Syntax.Foreign -- Defined in ‘Language.Haskell.TH.Ppr’
-instance [safe] Language.Haskell.TH.Ppr.Ppr Language.Haskell.TH.Lib.Syntax.FunDep -- Defined in ‘Language.Haskell.TH.Ppr’
-instance [safe] Language.Haskell.TH.Ppr.Ppr Language.Haskell.TH.Lib.Syntax.Info -- Defined in ‘Language.Haskell.TH.Ppr’
-instance [safe] Language.Haskell.TH.Ppr.Ppr Language.Haskell.TH.Lib.Syntax.InjectivityAnn -- Defined in ‘Language.Haskell.TH.Ppr’
-instance [safe] Language.Haskell.TH.Ppr.Ppr Language.Haskell.TH.Lib.Syntax.Inline -- Defined in ‘Language.Haskell.TH.Ppr’
-instance [safe] forall a. Language.Haskell.TH.Ppr.Ppr a => Language.Haskell.TH.Ppr.Ppr [a] -- Defined in ‘Language.Haskell.TH.Ppr’
-instance [safe] Language.Haskell.TH.Ppr.Ppr Language.Haskell.TH.Lib.Syntax.Lit -- Defined in ‘Language.Haskell.TH.Ppr’
-instance [safe] Language.Haskell.TH.Ppr.Ppr Language.Haskell.TH.Lib.Syntax.Loc -- Defined in ‘Language.Haskell.TH.Ppr’
-instance [safe] Language.Haskell.TH.Ppr.Ppr Language.Haskell.TH.Lib.Syntax.Match -- Defined in ‘Language.Haskell.TH.Ppr’
-instance [safe] Language.Haskell.TH.Ppr.Ppr Language.Haskell.TH.Lib.Syntax.Module -- Defined in ‘Language.Haskell.TH.Ppr’
-instance [safe] Language.Haskell.TH.Ppr.Ppr Language.Haskell.TH.Lib.Syntax.ModuleInfo -- Defined in ‘Language.Haskell.TH.Ppr’
-instance [safe] Language.Haskell.TH.Ppr.Ppr Language.Haskell.TH.Lib.Syntax.Name -- Defined in ‘Language.Haskell.TH.Ppr’
-instance [safe] Language.Haskell.TH.Ppr.Ppr Language.Haskell.TH.Lib.Syntax.Pat -- Defined in ‘Language.Haskell.TH.Ppr’
-instance [safe] Language.Haskell.TH.Ppr.Ppr Language.Haskell.TH.Lib.Syntax.PatSynArgs -- Defined in ‘Language.Haskell.TH.Ppr’
-instance [safe] Language.Haskell.TH.Ppr.Ppr Language.Haskell.TH.Lib.Syntax.PatSynDir -- Defined in ‘Language.Haskell.TH.Ppr’
-instance [safe] Language.Haskell.TH.Ppr.Ppr Language.Haskell.TH.Lib.Syntax.Phases -- Defined in ‘Language.Haskell.TH.Ppr’
-instance [safe] Language.Haskell.TH.Ppr.Ppr Language.Haskell.TH.Lib.Syntax.Pragma -- Defined in ‘Language.Haskell.TH.Ppr’
-instance [safe] Language.Haskell.TH.Ppr.Ppr Language.Haskell.TH.Lib.Syntax.Range -- Defined in ‘Language.Haskell.TH.Ppr’
-instance [safe] Language.Haskell.TH.Ppr.Ppr Language.Haskell.TH.Lib.Syntax.Role -- Defined in ‘Language.Haskell.TH.Ppr’
-instance [safe] Language.Haskell.TH.Ppr.Ppr Language.Haskell.TH.Lib.Syntax.RuleBndr -- Defined in ‘Language.Haskell.TH.Ppr’
-instance [safe] Language.Haskell.TH.Ppr.Ppr Language.Haskell.TH.Lib.Syntax.RuleMatch -- Defined in ‘Language.Haskell.TH.Ppr’
-instance [safe] Language.Haskell.TH.Ppr.Ppr Language.Haskell.TH.Lib.Syntax.SourceStrictness -- Defined in ‘Language.Haskell.TH.Ppr’
-instance [safe] Language.Haskell.TH.Ppr.Ppr Language.Haskell.TH.Lib.Syntax.SourceUnpackedness -- Defined in ‘Language.Haskell.TH.Ppr’
-instance [safe] Language.Haskell.TH.Ppr.Ppr Language.Haskell.TH.Lib.Syntax.Stmt -- Defined in ‘Language.Haskell.TH.Ppr’
-instance [safe] Language.Haskell.TH.Ppr.Ppr Language.Haskell.TH.Lib.Syntax.TyLit -- Defined in ‘Language.Haskell.TH.Ppr’
-instance [safe] forall flag. Language.Haskell.TH.Ppr.PprFlag flag => Language.Haskell.TH.Ppr.Ppr (Language.Haskell.TH.Lib.Syntax.TyVarBndr flag) -- Defined in ‘Language.Haskell.TH.Ppr’
-instance [safe] Language.Haskell.TH.Ppr.Ppr Language.Haskell.TH.Lib.Syntax.Type -- Defined in ‘Language.Haskell.TH.Ppr’
-instance [safe] Language.Haskell.TH.Ppr.Ppr Language.Haskell.TH.Ppr.TypeArg -- Defined in ‘Language.Haskell.TH.Ppr’
-instance [safe] Language.Haskell.TH.Ppr.PprFlag Language.Haskell.TH.Lib.Syntax.BndrVis -- Defined in ‘Language.Haskell.TH.Ppr’
-instance [safe] Language.Haskell.TH.Ppr.PprFlag Language.Haskell.TH.Lib.Syntax.Specificity -- Defined in ‘Language.Haskell.TH.Ppr’
-instance [safe] Language.Haskell.TH.Ppr.PprFlag () -- Defined in ‘Language.Haskell.TH.Ppr’
diff --git a/testsuite/tests/plugins/plugins10.stdout b/testsuite/tests/plugins/plugins10.stdout
index f7baecfb369b959f21cc9a7feb6e2557a162b6f2..d44315ff206424ee7494ccd981647161fd50614c 100644
--- a/testsuite/tests/plugins/plugins10.stdout
+++ b/testsuite/tests/plugins/plugins10.stdout
@@ -5,12 +5,13 @@ interfacePlugin: Language.Haskell.TH.Quote
interfacePlugin: GHC.Internal.Base
interfacePlugin: GHC.Internal.Float
interfacePlugin: GHC.Prim.Ext
-interfacePlugin: Language.Haskell.TH.Lib.Syntax
+interfacePlugin: GHC.Internal.TH.Quote
+interfacePlugin: GHC.Internal.TH.Syntax
typeCheckPlugin (rn)
typeCheckPlugin (tc)
parsePlugin(a)
typeCheckPlugin (rn)
-interfacePlugin: Language.Haskell.TH.Lib.Internal
+interfacePlugin: GHC.Internal.TH.Lib
metaPlugin: (return [])
metaPlugin: quoteExp stringify "x"
interfacePlugin: GHC.CString
diff --git a/testsuite/tests/quotes/TH_localname.stderr b/testsuite/tests/quotes/TH_localname.stderr
index c5a38b4b6d79cd5be119f5acfd5a70e5e7a95abd..35fa83e8f0a0ae94ab0b24176eab87f5ab5f6c69 100644
--- a/testsuite/tests/quotes/TH_localname.stderr
+++ b/testsuite/tests/quotes/TH_localname.stderr
@@ -1,28 +1,28 @@
-
TH_localname.hs:3:11: error: [GHC-39999]
- • Ambiguous type variable ‘t0’ arising from a use of ‘Language.Haskell.TH.Lib.Syntax.lift’
- prevents the constraint ‘(Language.Haskell.TH.Lib.Syntax.Lift
+ • Ambiguous type variable ‘t0’ arising from a use of ‘GHC.Internal.TH.Lift.lift’
+ prevents the constraint ‘(GHC.Internal.TH.Lift.Lift
t0)’ from being solved.
Relevant bindings include
y :: t0 (bound at TH_localname.hs:3:6)
- x :: t0 -> m0 Language.Haskell.TH.Lib.Syntax.Exp
+ x :: t0 -> m0 GHC.Internal.TH.Syntax.Exp
(bound at TH_localname.hs:3:1)
Probable fix: use a type annotation to specify what ‘t0’ should be.
Potentially matching instances:
- instance (Language.Haskell.TH.Lib.Syntax.Lift a,
- Language.Haskell.TH.Lib.Syntax.Lift b) =>
- Language.Haskell.TH.Lib.Syntax.Lift (Either a b)
- -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
- instance Language.Haskell.TH.Lib.Syntax.Lift Integer
- -- Defined in ‘Language.Haskell.TH.Lib.Syntax’
+ instance (GHC.Internal.TH.Lift.Lift a,
+ GHC.Internal.TH.Lift.Lift b) =>
+ GHC.Internal.TH.Lift.Lift (Either a b)
+ -- Defined in ‘GHC.Internal.TH.Lift’
+ instance GHC.Internal.TH.Lift.Lift Integer
+ -- Defined in ‘GHC.Internal.TH.Lift’
...plus 15 others
- ...plus 14 instances involving out-of-scope types
+ ...plus 12 instances involving out-of-scope types
(use -fprint-potential-instances to see them all)
- • In the expression: Language.Haskell.TH.Lib.Syntax.lift y
+ • In the expression: GHC.Internal.TH.Lift.lift y
In the expression:
[| y |]
- pending(rn) [<y, Language.Haskell.TH.Lib.Syntax.lift y>]
+ pending(rn) [<y, GHC.Internal.TH.Lift.lift y>]
In the expression:
\ y
-> [| y |]
- pending(rn) [<y, Language.Haskell.TH.Lib.Syntax.lift y>]
+ pending(rn) [<y, GHC.Internal.TH.Lift.lift y>]
+
diff --git a/testsuite/tests/th/T10796b.stderr b/testsuite/tests/th/T10796b.stderr
index 7c82db6b23dd1375187dd8f23beb6348a90842f5..859aabe43026ea813985ceeee9fbadf46bb6888e 100644
--- a/testsuite/tests/th/T10796b.stderr
+++ b/testsuite/tests/th/T10796b.stderr
@@ -1,9 +1,9 @@
-
T10796b.hs:8:15: error: [GHC-87897]
• Exception when trying to run compile-time code:
Can't construct a pattern from name Data.Set.Internal.fromList
CallStack (from HasCallStack):
- error, called at libraries/template-haskell/Language/Haskell/TH/Lib/Syntax.hs:1539:22 in template-haskell:Language.Haskell.TH.Lib.Syntax
+ error, called at libraries/ghc-internal/src/GHC/Internal/TH/Lift.hs:557:22 in ghc-internal:GHC.Internal.TH.Lift
Code: (dataToPatQ (const Nothing) (fromList "test"))
• In the untyped splice:
$(dataToPatQ (const Nothing) (fromList "test"))
+
diff --git a/testsuite/tests/th/T11452.stderr b/testsuite/tests/th/T11452.stderr
index bb6d196b60499a57f837cee28fa0b72ccd547f75..b2f27a0d411b90aaa8cf5e772085200c942f83d7 100644
--- a/testsuite/tests/th/T11452.stderr
+++ b/testsuite/tests/th/T11452.stderr
@@ -1,4 +1,3 @@
-
T11452.hs:6:12: error: [GHC-94642]
• Illegal polytype: (forall a. a -> a) -> ()
The type of a Typed Template Haskell expression must not have any quantification.
@@ -8,12 +7,13 @@ T11452.hs:6:12: error: [GHC-94642]
T11452.hs:6:14: error: [GHC-91028]
• Couldn't match type ‘p0’ with ‘forall a. a -> a’
- Expected: Language.Haskell.TH.Lib.Syntax.Code
- Language.Haskell.TH.Lib.Syntax.Q ((forall a. a -> a) -> ())
- Actual: Language.Haskell.TH.Lib.Syntax.Code
- Language.Haskell.TH.Lib.Syntax.Q (p0 -> ())
+ Expected: GHC.Internal.TH.Syntax.Code
+ GHC.Internal.TH.Syntax.Q ((forall a. a -> a) -> ())
+ Actual: GHC.Internal.TH.Syntax.Code
+ GHC.Internal.TH.Syntax.Q (p0 -> ())
Cannot instantiate unification variable ‘p0’
with a type involving polytypes: forall a. a -> a
• In the Template Haskell quotation [|| \ _ -> () ||]
In the expression: [|| \ _ -> () ||]
In the Template Haskell splice $$([|| \ _ -> () ||])
+
diff --git a/testsuite/tests/th/T15321.stderr b/testsuite/tests/th/T15321.stderr
index 3ca708ec946caa7aac66c096afc0ee4e5c1e7600..f5688ba6d9e487f7286ed1600721012f8eb82c85 100644
--- a/testsuite/tests/th/T15321.stderr
+++ b/testsuite/tests/th/T15321.stderr
@@ -1,11 +1,10 @@
-
T15321.hs:9:9: error: [GHC-88464]
- • Found hole: _ :: String -> Language.Haskell.TH.Lib.Internal.ExpQ
+ • Found hole: _ :: String -> GHC.Internal.TH.Lib.ExpQ
• In the expression: _ "baz"
In the untyped splice: $(_ "baz")
• Valid hole fits include
fail :: forall (m :: * -> *) a. MonadFail m => String -> m a
- with fail @Language.Haskell.TH.Lib.Syntax.Q
- @Language.Haskell.TH.Lib.Syntax.Exp
+ with fail @GHC.Internal.TH.Syntax.Q @GHC.Internal.TH.Syntax.Exp
(imported from ‘Prelude’ at T15321.hs:3:8-13
(and originally defined in ‘GHC.Internal.Control.Monad.Fail’))
+
diff --git a/testsuite/tests/th/T7276.stderr b/testsuite/tests/th/T7276.stderr
index 111f858eb0c915cd3ef0702326484419db86cdb7..32e04366c54dcd6ed31c771a3043b0e743348873 100644
--- a/testsuite/tests/th/T7276.stderr
+++ b/testsuite/tests/th/T7276.stderr
@@ -1,14 +1,13 @@
-
T7276.hs:6:5: error: [GHC-87897]
• Exception when trying to run compile-time code:
T7276.hs:6:8: error: [GHC-83865]
- • Couldn't match type ‘[Language.Haskell.TH.Lib.Syntax.Dec]’
- with ‘Language.Haskell.TH.Lib.Syntax.Exp’
- Expected: Language.Haskell.TH.Lib.Internal.ExpQ
- Actual: Language.Haskell.TH.Lib.Syntax.Q
- Language.Haskell.TH.Lib.Internal.Decs
+ • Couldn't match type ‘[GHC.Internal.TH.Syntax.Dec]’
+ with ‘GHC.Internal.TH.Syntax.Exp’
+ Expected: GHC.Internal.TH.Lib.ExpQ
+ Actual: GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Lib.Decs
• In the expression: [d| y = 3 |]
In the untyped splice: $([d| y = 3 |])
(deferred type error)
Code: ([d| y = 3 |])
• In the untyped splice: $([d| y = 3 |])
+
diff --git a/testsuite/tests/th/T7276a.stdout b/testsuite/tests/th/T7276a.stdout
index 5140f025794c9216c3b65b137191ee57f8dc3770..c540789c9d0c1903c513cf1f4bf4b2b75e556eed 100644
--- a/testsuite/tests/th/T7276a.stdout
+++ b/testsuite/tests/th/T7276a.stdout
@@ -1,7 +1,7 @@
<interactive>:3:9: warning: [GHC-83865] [-Wdeferred-type-errors (in -Wdefault)]
• Couldn't match type ‘[Dec]’ with ‘Exp’
Expected: Q Exp
- Actual: Q Language.Haskell.TH.Lib.Internal.Decs
+ Actual: Q GHC.Internal.TH.Lib.Decs
• In the expression: [d| a = () |] :: Q Exp
In an equation for ‘x’: x = [d| a = () |] :: Q Exp
@@ -10,7 +10,7 @@
<interactive>:3:9: error: [GHC-83865]
• Couldn't match type ‘[Dec]’ with ‘Exp’
Expected: Q Exp
- Actual: Q Language.Haskell.TH.Lib.Internal.Decs
+ Actual: Q GHC.Internal.TH.Lib.Decs
• In the expression: [d| a = () |] :: Q Exp
In an equation for ‘x’: x = [d| a = () |] :: Q Exp
(deferred type error)
diff --git a/testsuite/tests/th/TH_NestedSplicesFail3.stderr b/testsuite/tests/th/TH_NestedSplicesFail3.stderr
index caf4b5abb6ece3494aaacb763bf3e25cb4d49333..46971d83f2c594d3965d0c939677bdba52603f73 100644
--- a/testsuite/tests/th/TH_NestedSplicesFail3.stderr
+++ b/testsuite/tests/th/TH_NestedSplicesFail3.stderr
@@ -1,9 +1,8 @@
-
TH_NestedSplicesFail3.hs:4:12: error: [GHC-39999]
- • No instance for ‘Language.Haskell.TH.Lib.Syntax.Quote
- (Language.Haskell.TH.Lib.Syntax.Code
- Language.Haskell.TH.Lib.Syntax.Q)’
+ • No instance for ‘GHC.Internal.TH.Syntax.Quote
+ (GHC.Internal.TH.Syntax.Code GHC.Internal.TH.Syntax.Q)’
arising from a quotation bracket
• In the expression: [| 'x' |]
In the Template Haskell splice $$([| 'x' |])
In the expression: $$([| 'x' |])
+
diff --git a/testsuite/tests/th/TH_NestedSplicesFail4.stderr b/testsuite/tests/th/TH_NestedSplicesFail4.stderr
index 1c62b5aec7f355f4a74a4da3e992215aabf477df..990f56c143922c2cc3be7ba92c994bdc5e371520 100644
--- a/testsuite/tests/th/TH_NestedSplicesFail4.stderr
+++ b/testsuite/tests/th/TH_NestedSplicesFail4.stderr
@@ -1,10 +1,9 @@
-
TH_NestedSplicesFail4.hs:4:11: error: [GHC-83865]
- • Couldn't match type: Language.Haskell.TH.Lib.Syntax.Code m0 Char
- with: Language.Haskell.TH.Lib.Syntax.Q
- Language.Haskell.TH.Lib.Syntax.Exp
- Expected: Language.Haskell.TH.Lib.Internal.ExpQ
- Actual: Language.Haskell.TH.Lib.Syntax.Code m0 Char
+ • Couldn't match type: GHC.Internal.TH.Syntax.Code m0 Char
+ with: GHC.Internal.TH.Syntax.Q GHC.Internal.TH.Syntax.Exp
+ Expected: GHC.Internal.TH.Lib.ExpQ
+ Actual: GHC.Internal.TH.Syntax.Code m0 Char
• In the Template Haskell quotation [|| 'y' ||]
In the expression: [|| 'y' ||]
In the untyped splice: $([|| 'y' ||])
+
diff --git a/utils/haddock/html-test/ref/QuasiExpr.html b/utils/haddock/html-test/ref/QuasiExpr.html
index 25f4b0fabaed30125a42058d21db89d6de580b21..5b980d0fa00b7d31324e67231cb276b5977345e1 100644
--- a/utils/haddock/html-test/ref/QuasiExpr.html
+++ b/utils/haddock/html-test/ref/QuasiExpr.html
@@ -335,9 +335,9 @@
>parseExprExp</a
> :: <a href="#" title="Data.String"
>String</a
- > -> <a href="#" title="Language.Haskell.TH"
+ > -> <a href="#" title="Language.Haskell.TH.Syntax"
>Q</a
- > <a href="#" title="Language.Haskell.TH"
+ > <a href="#" title="Language.Haskell.TH.Syntax"
>Exp</a
> <a href="#" class="selflink"
>#</a
diff --git a/utils/haddock/html-test/ref/TH.html b/utils/haddock/html-test/ref/TH.html
index 0695f202ec08875cad7204dcde5ffd17c6590d79..06fcc70facc800fa950bf0f43003327585afdf74 100644
--- a/utils/haddock/html-test/ref/TH.html
+++ b/utils/haddock/html-test/ref/TH.html
@@ -55,9 +55,9 @@
><p class="src"
><a id="v:decl" class="def"
>decl</a
- > :: <a href="#" title="Language.Haskell.TH"
+ > :: <a href="#" title="Language.Haskell.TH.Syntax"
>Q</a
- > [<a href="#" title="Language.Haskell.TH"
+ > [<a href="#" title="Language.Haskell.TH.Syntax"
>Dec</a
>] <a href="#" class="selflink"
>#</a
diff --git a/utils/haddock/html-test/ref/Threaded_TH.html b/utils/haddock/html-test/ref/Threaded_TH.html
index 8c77834686931a8658a37fec63338b6a8371ba80..c515d143f627cdff6e7b9484b20df1da594881cf 100644
--- a/utils/haddock/html-test/ref/Threaded_TH.html
+++ b/utils/haddock/html-test/ref/Threaded_TH.html
@@ -67,9 +67,9 @@
><li class="src short"
><a href="#"
>forkTH</a
- > :: <a href="#" title="Language.Haskell.TH"
+ > :: <a href="#" title="Language.Haskell.TH.Syntax"
>Q</a
- > <a href="#" title="Language.Haskell.TH"
+ > <a href="#" title="Language.Haskell.TH.Syntax"
>Exp</a
></li
></ul
@@ -82,9 +82,9 @@
><p class="src"
><a id="v:forkTH" class="def"
>forkTH</a
- > :: <a href="#" title="Language.Haskell.TH"
+ > :: <a href="#" title="Language.Haskell.TH.Syntax"
>Q</a
- > <a href="#" title="Language.Haskell.TH"
+ > <a href="#" title="Language.Haskell.TH.Syntax"
>Exp</a
> <a href="#" class="selflink"
>#</a