| Copyright | (c) The University of Glasgow 2003 |
|---|---|
| License | BSD-style (see the file libraries/base/LICENSE) |
| Maintainer | libraries@haskell.org |
| Stability | experimental |
| Portability | portable |
| Safe Haskell | Trustworthy |
| Language | Haskell2010 |
Language.Haskell.TH.Syntax
Description
Abstract syntax definitions for Template Haskell.
Synopsis
- dataForeign
- dataType
- = ForallT [TyVarBndrSpecificity] CxtType
- | ForallVisT [TyVarBndr ()] Type
- | AppTTypeType
- | AppKindTTypeKind
- | SigTTypeKind
- | VarTName
- | ConTName
- | PromotedTName
- | InfixTTypeNameType
- | UInfixTTypeNameType
- | PromotedInfixTTypeNameType
- | PromotedUInfixTTypeNameType
- | ParensTType
- | TupleTInt
- | UnboxedTupleTInt
- | UnboxedSumTSumArity
- | ArrowT
- | MulArrowT
- | EqualityT
- | ListT
- | PromotedTupleTInt
- | PromotedNilT
- | PromotedConsT
- | StarT
- | ConstraintT
- | LitTTyLit
- | WildCardT
- | ImplicitParamTStringType
- dataModule = ModulePkgNameModName
- typeUnlifted = Bool
- dataDecidedStrictness
- dataSourceStrictness
- dataSourceUnpackedness
- dataFixity = FixityIntFixityDirection
- dataCon
- typeStrict = Bang
- newtypeQ a = Q {}
- classMonad m => Quote m where
- dataLoc = Loc {}
- dataInfo
- dataModuleInfo = ModuleInfo [Module]
- typeInstanceDec = Dec
- typeParentName = Name
- typeSumAlt = Int
- typeSumArity = Int
- typeArity = Int
- dataAnnLookup
- newtypeTExp (a :: TYPE (r :: RuntimeRep)) = TExp {}
- newtypeCode m (a :: TYPE (r :: RuntimeRep)) = Code {
- examineCode :: m (TExp a)
- dataName = NameOccNameNameFlavour
- dataNameSpace
- dataDec
- = FunDName [Clause]
- | ValDPatBody [Dec]
- | DataDCxtName [TyVarBndr ()] (MaybeKind) [Con] [DerivClause]
- | NewtypeDCxtName [TyVarBndr ()] (MaybeKind) Con [DerivClause]
- | TypeDataDName [TyVarBndr ()] (MaybeKind) [Con]
- | TySynDName [TyVarBndr ()] Type
- | ClassDCxtName [TyVarBndr ()] [FunDep] [Dec]
- | InstanceD (MaybeOverlap) CxtType [Dec]
- | SigDNameType
- | KiSigDNameKind
- | ForeignDForeign
- | InfixDFixityName
- | DefaultD [Type]
- | PragmaDPragma
- | DataFamilyDName [TyVarBndr ()] (MaybeKind)
- | DataInstDCxt (Maybe [TyVarBndr ()]) Type (MaybeKind) [Con] [DerivClause]
- | NewtypeInstDCxt (Maybe [TyVarBndr ()]) Type (MaybeKind) Con [DerivClause]
- | TySynInstDTySynEqn
- | OpenTypeFamilyDTypeFamilyHead
- | ClosedTypeFamilyDTypeFamilyHead [TySynEqn]
- | RoleAnnotDName [Role]
- | StandaloneDerivD (MaybeDerivStrategy) CxtType
- | DefaultSigDNameType
- | PatSynDNamePatSynArgsPatSynDirPat
- | PatSynSigDNamePatSynType
- | ImplicitParamBindDStringExp
- dataClause = Clause [Pat] Body [Dec]
- dataBang = BangSourceUnpackednessSourceStrictness
- dataCallconv
- = CCall
- | StdCall
- | CApi
- | Prim
- | JavaScript
- dataSafety
- = Unsafe
- | Safe
- | Interruptible
- dataPragma
- dataInline
- dataRuleMatch
- dataPhases
- dataRuleBndr
- dataAnnTarget
- dataFunDep = FunDep [Name] [Name]
- dataTySynEqn = TySynEqn (Maybe [TyVarBndr ()]) TypeType
- dataTypeFamilyHead = TypeFamilyHeadName [TyVarBndr ()] FamilyResultSig (MaybeInjectivityAnn)
- dataFixityDirection
- dataPatSynDir
- dataPatSynArgs
- dataExp
- = VarEName
- | ConEName
- | LitELit
- | AppEExpExp
- | AppTypeEExpType
- | InfixE (MaybeExp) Exp (MaybeExp)
- | UInfixEExpExpExp
- | ParensEExp
- | LamE [Pat] Exp
- | LamCaseE [Match]
- | LamCasesE [Clause]
- | TupE [MaybeExp]
- | UnboxedTupE [MaybeExp]
- | UnboxedSumEExpSumAltSumArity
- | CondEExpExpExp
- | MultiIfE [(Guard, Exp)]
- | LetE [Dec] Exp
- | CaseEExp [Match]
- | DoE (MaybeModName) [Stmt]
- | MDoE (MaybeModName) [Stmt]
- | CompE [Stmt]
- | ArithSeqERange
- | ListE [Exp]
- | SigEExpType
- | RecConEName [FieldExp]
- | RecUpdEExp [FieldExp]
- | StaticEExp
- | UnboundVarEName
- | LabelEString
- | ImplicitParamVarEString
- | GetFieldEExpString
- | ProjectionE (NonEmptyString)
- dataMatch = MatchPatBody [Dec]
- dataBody
- dataGuard
- dataStmt
- dataRange
- dataLit
- dataPat
- typeFieldExp = (Name, Exp)
- typeFieldPat = (Name, Pat)
- dataTyVarBndr flag
- dataTyLit
- typeKind = Type
- typeCxt = [Pred]
- typePred = Type
- dataRole
- dataSpecificity
- dataFamilyResultSig
- dataInjectivityAnn = InjectivityAnnName [Name]
- typePatSynType = Type
- typeBangType = (Bang, Type)
- typeVarBangType = (Name, Bang, Type)
- dataDocLoc
- dataDerivClause = DerivClause (MaybeDerivStrategy) Cxt
- dataDerivStrategy
- dataOverlap
- typeUniq = Integer
- dataNameFlavour
- dataNameIs
- dataBytes = Bytes {}
- class (MonadIO m, MonadFail m) => Quasi m where
- qNewName :: String -> m Name
- qReport :: Bool -> String -> m ()
- qRecover :: m a -> m a -> m a
- qLookupName :: Bool -> String -> m (MaybeName)
- qReify :: Name -> m Info
- qReifyFixity :: Name -> m (MaybeFixity)
- qReifyType :: Name -> m Type
- qReifyInstances :: Name -> [Type] -> m [Dec]
- qReifyRoles :: Name -> m [Role]
- qReifyAnnotations :: Data a => AnnLookup -> m [a]
- qReifyModule :: Module -> m ModuleInfo
- qReifyConStrictness :: Name -> m [DecidedStrictness]
- qLocation :: m Loc
- qRunIO :: IO a -> m a
- qGetPackageRoot :: m FilePath
- qAddDependentFile :: FilePath -> m ()
- qAddTempFile :: String -> m FilePath
- qAddTopDecls :: [Dec] -> m ()
- qAddForeignFilePath :: ForeignSrcLang -> String -> m ()
- qAddModFinalizer :: Q () -> m ()
- qAddCorePlugin :: String -> m ()
- qGetQ :: Typeable a => m (Maybe a)
- qPutQ :: Typeable a => a -> m ()
- qIsExtEnabled :: Extension -> m Bool
- qExtsEnabled :: m [Extension]
- qPutDoc :: DocLoc -> String -> m ()
- qGetDoc :: DocLoc -> m (MaybeString)
- classLift (t :: TYPE r) where
- newtypeModName = ModNameString
- newtypePkgName = PkgNameString
- newtypeOccName = OccNameString
- typeCharPos = (Int, Int)
- typeStrictType = BangType
- typeVarStrictType = VarBangType
- recover :: Q a -> Q a -> Q a
- reportError :: String -> Q ()
- runIO :: IO a -> Q a
- runQ :: Quasi m => Q a -> m a
- reportWarning :: String -> Q ()
- report :: Bool -> String -> Q ()
- location :: QLoc
- reify :: Name -> QInfo
- reifyModule :: Module -> QModuleInfo
- newDeclarationGroup :: Q [Dec]
- extsEnabled :: Q [Extension]
- isExtEnabled :: Extension -> QBool
- lookupTypeName :: String -> Q (MaybeName)
- lookupValueName :: String -> Q (MaybeName)
- reifyFixity :: Name -> Q (MaybeFixity)
- reifyType :: Name -> QType
- reifyInstances :: Name -> [Type] -> Q [InstanceDec]
- isInstance :: Name -> [Type] -> QBool
- reifyRoles :: Name -> Q [Role]
- reifyAnnotations :: Data a => AnnLookup -> Q [a]
- reifyConStrictness :: Name -> Q [DecidedStrictness]
- unTypeCode :: forall (r :: RuntimeRep) (a :: TYPE r) m. Quote m => Code m a -> m Exp
- unsafeCodeCoerce :: forall (r :: RuntimeRep) (a :: TYPE r) m. Quote m => m Exp -> Code m a
- hoistCode :: forall m n (r :: RuntimeRep) (a :: TYPE r). Monad m => (forall x. m x -> n x) -> Code m a -> Code n a
- bindCode :: forall m a (r :: RuntimeRep) (b :: TYPE r). Monad m => m a -> (a -> Code m b) -> Code m b
- bindCode_ :: forall m a (r :: RuntimeRep) (b :: TYPE r). Monad m => m a -> Code m b -> Code m b
- joinCode :: forall m (r :: RuntimeRep) (a :: TYPE r). Monad m => m (Code m a) -> Code m a
- liftCode :: forall (r :: RuntimeRep) (a :: TYPE r) m. m (TExp a) -> Code m a
- mkName :: String -> Name
- nameBase :: Name -> String
- nameModule :: Name -> MaybeString
- namePackage :: Name -> MaybeString
- nameSpace :: Name -> MaybeNameSpace
- tupleTypeName :: Int -> Name
- tupleDataName :: Int -> Name
- unboxedTupleTypeName :: Int -> Name
- unboxedTupleDataName :: Int -> Name
- unboxedSumTypeName :: SumArity -> Name
- unboxedSumDataName :: SumAlt -> SumArity -> Name
- defaultFixity :: Fixity
- maxPrecedence :: Int
- putDoc :: DocLoc -> String -> Q ()
- getDoc :: DocLoc -> Q (MaybeString)
- showName' :: NameIs -> Name -> String
- 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
- dataToExpQ :: (Quote m, Data a) => (forall b. Data b => b -> Maybe (m Exp)) -> a -> m Exp
- dataToPatQ :: (Quote m, Data a) => (forall b. Data b => b -> Maybe (m Pat)) -> a -> m Pat
- newNameIO :: String -> IOName
- badIO :: String -> IO a
- counter :: IORefUniq
- mkNameU :: String -> Uniq -> Name
- unTypeQ :: forall (r :: RuntimeRep) (a :: TYPE r) m. Quote m => m (TExp a) -> m Exp
- unsafeTExpCoerce :: forall (r :: RuntimeRep) (a :: TYPE r) m. Quote m => m Exp -> m (TExp a)
- lookupName :: Bool -> String -> Q (MaybeName)
- getPackageRoot :: QFilePath
- makeRelativeToProject :: FilePath -> QFilePath
- addDependentFile :: FilePath -> Q ()
- addTempFile :: String -> QFilePath
- addTopDecls :: [Dec] -> Q ()
- addForeignFile :: ForeignSrcLang -> String -> Q ()
- addForeignSource :: ForeignSrcLang -> String -> Q ()
- addForeignFilePath :: ForeignSrcLang -> FilePath -> Q ()
- addModFinalizer :: Q () -> Q ()
- addCorePlugin :: String -> Q ()
- getQ :: Typeable a => Q (Maybe a)
- putQ :: Typeable a => a -> Q ()
- sequenceQ :: forall m. Monad m => forall a. [m a] -> m [a]
- trueName :: Name
- falseName :: Name
- addrToByteArrayName :: Name
- mkNameG_v :: String -> String -> String -> Name
- addrToByteArray :: Int -> Addr# -> ByteArray
- nothingName :: Name
- justName :: Name
- leftName :: Name
- rightName :: Name
- liftString :: Quote m => String -> m Exp
- nonemptyName :: Name
- mkNameG :: NameSpace -> String -> String -> String -> Name
- oneName :: Name
- manyName :: Name
- mkOccName :: String -> OccName
- mkPkgName :: String -> PkgName
- mkModName :: String -> ModName
- mkNameG_d :: String -> String -> String -> Name
- showName :: Name -> String
- liftData :: (Quote m, Data a) => a -> m Exp
- modString :: ModName -> String
- pkgString :: PkgName -> String
- occString :: OccName -> String
- thenCmp :: Ordering -> Ordering -> Ordering
- mkNameL :: String -> Uniq -> Name
- mkNameQ :: String -> String -> Name
- mkNameS :: String -> Name
- mkNameG_tc :: String -> String -> String -> Name
- mk_tup_name :: Int -> NameSpace -> Bool -> Name
- eqBytes :: Bytes -> Bytes -> Bool
- compareBytes :: Bytes -> Bytes -> Ordering
- memcmp :: Ptr a -> Ptr b -> CSize -> IOCInt
- cmpEq :: Ordering -> Bool
- module Language.Haskell.TH.LanguageExtensions
- dataForeignSrcLang
Documentation
Instances
Constructors
| ForallT [TyVarBndrSpecificity] CxtType | forall <vars>. <ctxt> => <type> |
| ForallVisT [TyVarBndr ()] Type | forall <vars> -> <type> |
| AppTTypeType | T a b |
| AppKindTTypeKind | T @k t |
| SigTTypeKind | t :: k |
| VarTName | a |
| ConTName | T |
| PromotedTName | 'T |
| InfixTTypeNameType | T + T |
| UInfixTTypeNameType | T + T |
| PromotedInfixTTypeNameType | T :+: T |
| PromotedUInfixTTypeNameType | T :+: T |
| ParensTType | (T) |
| TupleTInt |
|
| UnboxedTupleTInt |
|
| UnboxedSumTSumArity |
|
| ArrowT | -> |
| MulArrowT | %n -> Generalised arrow type with multiplicity argument |
| EqualityT | ~ |
| ListT | [] |
| PromotedTupleTInt |
|
| PromotedNilT | '[] |
| PromotedConsT | '(:) |
| StarT | * |
| ConstraintT | Constraint |
| LitTTyLit |
|
| WildCardT | _ |
| ImplicitParamTStringType | ?x :: t |
Instances
Obtained from reifyModule and thisModule.
Instances
| DataModuleSource# | |
Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Module -> c ModuleSource# gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ModuleSource# toConstr :: Module -> ConstrSource# dataTypeOf :: Module -> DataTypeSource# dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Module) Source# dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Module) Source# gmapT :: (forall b. Data b => b -> b) -> Module -> ModuleSource# gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Module -> r Source# gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Module -> r Source# gmapQ :: (forall d. Data d => d -> u) -> Module -> [u] Source# gmapQi :: Int -> (forall d. Data d => d -> u) -> Module -> u Source# gmapM :: Monad m => (forall d. Data d => d -> m d) -> Module -> m ModuleSource# gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Module -> m ModuleSource# gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Module -> m ModuleSource# | |
| GenericModuleSource# | |
| ShowModuleSource# | |
| EqModuleSource# | |
| OrdModuleSource# | |
Defined in Language.Haskell.TH.Syntax | |
| PprModuleSource# | |
| typeRepModuleSource# | |
Defined in Language.Haskell.TH.Syntax typeRepModule = D1 ('MetaData "Module" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "Module" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: MaybeSymbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0PkgName) :*:S1 ('MetaSel ('Nothing :: MaybeSymbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0ModName))) | |
In PrimTyConI, is the type constructor unlifted?
Unlike SourceStrictness and SourceUnpackedness, DecidedStrictness refers to the strictness annotations that the compiler chooses for a data constructor field, which may be different from what is written in source code.
Note that non-unpacked strict fields are assigned DecidedLazy when a bang would be inappropriate, such as the field of a newtype constructor and fields that have an unlifted type.
See reifyConStrictness for more information.
Constructors
| DecidedLazy | Field inferred to not have a bang. |
| DecidedStrict | Field inferred to have a bang. |
| DecidedUnpack | Field inferred to be unpacked. |
Instances
SourceStrictness corresponds to strictness annotations found in the source code.
This may not agree with the annotations returned by reifyConStrictness. See reifyConStrictness for more information.
Constructors
| NoSourceStrictness | C a |
| SourceLazy | C {~}a |
| SourceStrict | C {!}a |
Instances
SourceUnpackedness corresponds to unpack annotations found in the source code.
This may not agree with the annotations returned by reifyConStrictness. See reifyConStrictness for more information.
Constructors
| NoSourceUnpackedness | C a |
| SourceNoUnpack | C { {-# NOUNPACK #-} } a |
| SourceUnpack | C { {-# UNPACK #-} } a |
Instances
Constructors
| FixityIntFixityDirection |
Instances
| DataFixitySource# | |
Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Fixity -> c FixitySource# gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c FixitySource# toConstr :: Fixity -> ConstrSource# dataTypeOf :: Fixity -> DataTypeSource# dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Fixity) Source# dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Fixity) Source# gmapT :: (forall b. Data b => b -> b) -> Fixity -> FixitySource# gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Fixity -> r Source# gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Fixity -> r Source# gmapQ :: (forall d. Data d => d -> u) -> Fixity -> [u] Source# gmapQi :: Int -> (forall d. Data d => d -> u) -> Fixity -> u Source# gmapM :: Monad m => (forall d. Data d => d -> m d) -> Fixity -> m FixitySource# gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Fixity -> m FixitySource# gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Fixity -> m FixitySource# | |
| GenericFixitySource# | |
| ShowFixitySource# | |
| EqFixitySource# | |
| OrdFixitySource# | |
Defined in Language.Haskell.TH.Syntax | |
| typeRepFixitySource# | |
Defined in Language.Haskell.TH.Syntax typeRepFixity = D1 ('MetaData "Fixity" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "Fixity" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: MaybeSymbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0Int) :*:S1 ('MetaSel ('Nothing :: MaybeSymbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0FixityDirection))) | |
A single data constructor.
The constructors for Con can roughly be divided up into two categories: those for constructors with "vanilla" syntax (NormalC, RecC, and InfixC), and those for constructors with GADT syntax (GadtC and RecGadtC). The ForallC constructor, which quantifies additional type variables and class contexts, can surround either variety of constructor. However, the type variables that it quantifies are different depending on what constructor syntax is used:
- If a
ForallCsurrounds a constructor with vanilla syntax, then theForallCwill only quantify existential type variables. For example:
data Foo a = forall b. MkFoo a b
In MkFoo, ForallC will quantify b, but not a.
- If a
ForallCsurrounds a constructor with GADT syntax, then theForallCwill quantify all type variables used in the constructor. For example:
data Bar a b where MkBar :: (a ~ b) => c -> MkBar a b
In MkBar, ForallC will quantify a, b, and c.
Multiplicity annotations for data types are currently not supported in Template Haskell (i.e. all fields represented by Template Haskell will be linear).
Constructors
| NormalCName [BangType] | C Int a |
| RecCName [VarBangType] | C { v :: Int, w :: a } |
| InfixCBangTypeNameBangType | Int :+ a |
| ForallC [TyVarBndrSpecificity] CxtCon | forall a. Eq a => C [a] |
| GadtC [Name] [BangType] Type | C :: a -> b -> T b Int |
| RecGadtC [Name] [VarBangType] Type | C :: { v :: Int } -> T b Int |
Instances
Instances
classMonad m => Quote m whereSource#
The Quote class implements the minimal interface which is necessary for desugaring quotations.
- The
Monad msuperclass is needed to stitch together the different AST fragments. newNameis used when desugaring binding structures such as lambdas to generate fresh names.
Therefore the type of an untyped quotation in GHC is `Quote m => m Exp`
For many years the type of a quotation was fixed to be `Q Exp` but by more precisely specifying the minimal interface it enables the Exp to be extracted purely from the quotation without interacting with Q.
Methods
newName :: String -> m NameSource#
Generate a fresh name, which cannot be captured.
For example, this:
f = $(do nm1 <- newName "x" let nm2 =mkName"x" return (LamE[VarPnm1] (LamE [VarP nm2] (VarEnm1))) )
will produce the splice
f = \x0 -> \x -> x0
In particular, the occurrence VarE nm1 refers to the binding VarP nm1, and is not captured by the binding VarP nm2.
Although names generated by newName cannot be captured, they can capture other names. For example, this:
g = $(do nm1 <- newName "x" let nm2 = mkName "x" return (LamE [VarP nm2] (LamE [VarP nm1] (VarE nm2))) )
will produce the splice
g = \x -> \x0 -> x0
since the occurrence VarE nm2 is captured by the innermost binding of x, namely VarP nm1.
Constructors
| Loc | |
Fields
| |
Instances
| DataLocSource# | |
Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Loc -> c LocSource# gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c LocSource# toConstr :: Loc -> ConstrSource# dataTypeOf :: Loc -> DataTypeSource# dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Loc) Source# dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Loc) Source# gmapT :: (forall b. Data b => b -> b) -> Loc -> LocSource# gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Loc -> r Source# gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Loc -> r Source# gmapQ :: (forall d. Data d => d -> u) -> Loc -> [u] Source# gmapQi :: Int -> (forall d. Data d => d -> u) -> Loc -> u Source# gmapM :: Monad m => (forall d. Data d => d -> m d) -> Loc -> m LocSource# gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Loc -> m LocSource# gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Loc -> m LocSource# | |
| GenericLocSource# | |
| ShowLocSource# | |
| EqLocSource# | |
| OrdLocSource# | |
| PprLocSource# | |
| typeRepLocSource# | |
Defined in Language.Haskell.TH.Syntax typeRepLoc = D1 ('MetaData "Loc" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "Loc" 'PrefixI 'True) ((S1 ('MetaSel ('Just "loc_filename") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0String) :*:S1 ('MetaSel ('Just "loc_package") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0String)) :*: (S1 ('MetaSel ('Just "loc_module") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0String) :*: (S1 ('MetaSel ('Just "loc_start") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0CharPos) :*:S1 ('MetaSel ('Just "loc_end") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0CharPos))))) | |
Constructors
| ClassIDec [InstanceDec] | A class, with a list of its visible instances |
| ClassOpINameTypeParentName | A class method |
| TyConIDec | A "plain" type constructor. "Fancier" type constructors are returned using |
| FamilyIDec [InstanceDec] | A type or data family, with a list of its visible instances. A closed type family is returned with 0 instances. |
| PrimTyConINameArityUnlifted | A "primitive" type constructor, which can't be expressed with a |
| DataConINameTypeParentName | A data constructor |
| PatSynINamePatSynType | A pattern synonym |
| VarINameType (MaybeDec) | A "value" variable (as opposed to a type variable, see The |
| TyVarINameType | A type variable. The |
Instances
Obtained from reifyModule in the Q Monad.
Constructors
| ModuleInfo [Module] | Contains the import list of the module. |
Instances
typeInstanceDec = DecSource#
InstanceDec describes a single instance of a class or type function. It is just a Dec, but guaranteed to be one of the following:
InstanceD(with empty[)Dec]DataInstDorNewtypeInstD(with empty derived[)Name]TySynInstD
In UnboxedSumE and UnboxedSumP, the number associated with a particular data constructor. SumAlts are one-indexed and should never exceed the value of its corresponding SumArity. For example:
In UnboxedSumE, UnboxedSumT, and UnboxedSumP, the total number of SumAlts. For example, (#|#) has a SumArity of 2.
In PrimTyConI, arity of the type constructor
Annotation target for reifyAnnotations
Constructors
| AnnLookupModuleModule | |
| AnnLookupNameName |
Instances
newtypeTExp (a :: TYPE (r :: RuntimeRep)) Source#
Represents an expression which has type a. Built on top of Exp, typed expressions allow for type-safe splicing via:
- typed quotes, written as
[|| ... ||]where...is an expression; if that expression has typea, then the quotation has typeQ(TExpa) - typed splices inside of typed quotes, written as
$$(...)where...is an arbitrary expression of typeQ(TExpa)
Traditional expression quotes and splices let us construct ill-typed expressions:
>>>fmap ppr $ runQ [| True == $( [| "foo" |] ) |]GHC.Types.True GHC.Classes.== "foo">>>GHC.Types.True GHC.Classes.== "foo"<interactive> error: • Couldn't match expected type ‘Bool’ with actual type ‘[Char]’ • In the second argument of ‘(==)’, namely ‘"foo"’ In the expression: True == "foo" In an equation for ‘it’: it = True == "foo"
With typed expressions, the type error occurs when constructing the Template Haskell expression:
>>>fmap ppr $ runQ [|| True == $$( [|| "foo" ||] ) ||]<interactive> error: • Couldn't match type ‘[Char]’ with ‘Bool’ Expected type: Q (TExp Bool) Actual type: Q (TExp [Char]) • In the Template Haskell quotation [|| "foo" ||] In the expression: [|| "foo" ||] In the Template Haskell splice $$([|| "foo" ||])
Representation-polymorphic since template-haskell-2.16.0.0.
newtypeCode m (a :: TYPE (r :: RuntimeRep)) Source#
Constructors
| Code | |
Fields
| |
An abstract type representing names in the syntax tree.
Names can be constructed in several ways, which come with different name-capture guarantees (see Language.Haskell.TH.Syntax for an explanation of name capture):
- the built-in syntax
'fand''Tcan be used to construct names, The expression'fgives aNamewhich refers to the valuefcurrently in scope, and''Tgives aNamewhich refers to the typeTcurrently in scope. These names can never be captured. lookupValueNameandlookupTypeNameare similar to'fand''Trespectively, but theNames are looked up at the point where the current splice is being run. These names can never be captured.newNamemonadically generates a new name, which can never be captured.mkNamegenerates a capturable name.
Names constructed using newName and mkName may be used in bindings (such as let x = ... or x -> ...), but names constructed using lookupValueName, lookupTypeName, 'f, ''T may not.
Constructors
| NameOccNameNameFlavour |
Instances
| DataNameSource# | |
Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Name -> c NameSource# gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c NameSource# toConstr :: Name -> ConstrSource# dataTypeOf :: Name -> DataTypeSource# dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Name) Source# dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Name) Source# gmapT :: (forall b. Data b => b -> b) -> Name -> NameSource# gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r Source# gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r Source# gmapQ :: (forall d. Data d => d -> u) -> Name -> [u] Source# gmapQi :: Int -> (forall d. Data d => d -> u) -> Name -> u Source# gmapM :: Monad m => (forall d. Data d => d -> m d) -> Name -> m NameSource# gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Name -> m NameSource# gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Name -> m NameSource# | |
| GenericNameSource# | |
| ShowNameSource# | |
| EqNameSource# | |
| OrdNameSource# | |
| PprNameSource# | |
| typeRepNameSource# | |
Defined in Language.Haskell.TH.Syntax typeRepName = D1 ('MetaData "Name" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "Name" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: MaybeSymbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0OccName) :*:S1 ('MetaSel ('Nothing :: MaybeSymbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0NameFlavour))) | |
Constructors
| VarName | Variables |
| DataName | Data constructors |
| TcClsName | Type constructors and classes; Haskell has them in the same name space for now. |
Instances
| DataNameSpaceSource# | |
Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> NameSpace -> c NameSpaceSource# gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c NameSpaceSource# toConstr :: NameSpace -> ConstrSource# dataTypeOf :: NameSpace -> DataTypeSource# dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c NameSpace) Source# dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NameSpace) Source# gmapT :: (forall b. Data b => b -> b) -> NameSpace -> NameSpaceSource# gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NameSpace -> r Source# gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NameSpace -> r Source# gmapQ :: (forall d. Data d => d -> u) -> NameSpace -> [u] Source# gmapQi :: Int -> (forall d. Data d => d -> u) -> NameSpace -> u Source# gmapM :: Monad m => (forall d. Data d => d -> m d) -> NameSpace -> m NameSpaceSource# gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NameSpace -> m NameSpaceSource# gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NameSpace -> m NameSpaceSource# | |
| GenericNameSpaceSource# | |
| ShowNameSpaceSource# | |
| EqNameSpaceSource# | |
| OrdNameSpaceSource# | |
Defined in Language.Haskell.TH.Syntax | |
| typeRepNameSpaceSource# | |
Defined in Language.Haskell.TH.Syntax typeRepNameSpace = D1 ('MetaData "NameSpace" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "VarName" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "DataName" 'PrefixI 'False) (U1 :: Type -> Type) :+:C1 ('MetaCons "TcClsName" 'PrefixI 'False) (U1 :: Type -> Type))) | |
Constructors
| FunDName [Clause] | { f p1 p2 = b where decs } |
| ValDPatBody [Dec] | { p = b where decs } |
| DataDCxtName [TyVarBndr ()] (MaybeKind) [Con] [DerivClause] | { data Cxt x => T x = A x | B (T x) deriving (Z,W) deriving stock Eq } |
| NewtypeDCxtName [TyVarBndr ()] (MaybeKind) Con [DerivClause] | { newtype Cxt x => T x = A (B x) deriving (Z,W Q) deriving stock Eq } |
| TypeDataDName [TyVarBndr ()] (MaybeKind) [Con] | { type data T x = A x | B (T x) } |
| TySynDName [TyVarBndr ()] Type | { type T x = (x,x) } |
| ClassDCxtName [TyVarBndr ()] [FunDep] [Dec] | { class Eq a => Ord a where ds } |
| InstanceD (MaybeOverlap) CxtType [Dec] | { instance {-# OVERLAPS #-} Show w => Show [w] where ds } |
| SigDNameType | { length :: [a] -> Int } |
| KiSigDNameKind | { type TypeRep :: k -> Type } |
| ForeignDForeign | { foreign import ... } { foreign export ... } |
| InfixDFixityName | { infix 3 foo } |
| DefaultD [Type] | { default (Integer, Double) } |
| PragmaD | pragmas |
Fields
| |
| DataFamilyD | data families (may also appear in [Dec] of |
| DataInstDCxt (Maybe [TyVarBndr ()]) Type (MaybeKind) [Con] [DerivClause] | { data instance Cxt x => T [x] = A x | B (T x) deriving (Z,W) deriving stock Eq } |
| NewtypeInstDCxt (Maybe [TyVarBndr ()]) Type (MaybeKind) Con [DerivClause] | { newtype instance Cxt x => T [x] = A (B x) deriving (Z,W) deriving stock Eq } |
| TySynInstDTySynEqn | { type instance ... } |
| OpenTypeFamilyD | open type families (may also appear in [Dec] of |
Fields
| |
| ClosedTypeFamilyDTypeFamilyHead [TySynEqn] | { type family F a b = (r :: *) | r -> a where ... } |
| RoleAnnotDName [Role] | { type role T nominal representational } |
| StandaloneDerivD (MaybeDerivStrategy) CxtType | { deriving stock instance Ord a => Ord (Foo a) } |
| DefaultSigDNameType | { default size :: Data a => a -> Int } |
| PatSynD | Pattern Synonyms |
Fields
| |
| PatSynSigDNamePatSynType | A pattern synonym's type signature. |
| ImplicitParamBindDStringExp | { ?x = expr }Implicit parameter binding declaration. Can only be used in let and where clauses which consist entirely of implicit bindings. |
Instances
Instances
Constructors
| BangSourceUnpackednessSourceStrictness | C { {-# UNPACK #-} !}a |
Instances
| DataBangSource# | |
Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Bang -> c BangSource# gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c BangSource# toConstr :: Bang -> ConstrSource# dataTypeOf :: Bang -> DataTypeSource# dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Bang) Source# dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Bang) Source# gmapT :: (forall b. Data b => b -> b) -> Bang -> BangSource# gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Bang -> r Source# gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Bang -> r Source# gmapQ :: (forall d. Data d => d -> u) -> Bang -> [u] Source# gmapQi :: Int -> (forall d. Data d => d -> u) -> Bang -> u Source# gmapM :: Monad m => (forall d. Data d => d -> m d) -> Bang -> m BangSource# gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Bang -> m BangSource# gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Bang -> m BangSource# | |
| GenericBangSource# | |
| ShowBangSource# | |
| EqBangSource# | |
| OrdBangSource# | |
| PprBangSource# | |
| typeRepBangSource# | |
Defined in Language.Haskell.TH.Syntax typeRepBang = D1 ('MetaData "Bang" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "Bang" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: MaybeSymbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0SourceUnpackedness) :*:S1 ('MetaSel ('Nothing :: MaybeSymbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0SourceStrictness))) | |
Constructors
| CCall | |
| StdCall | |
| CApi | |
| Prim | |
| JavaScript |
Instances
| DataCallconvSource# | |
Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Callconv -> c CallconvSource# gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c CallconvSource# toConstr :: Callconv -> ConstrSource# dataTypeOf :: Callconv -> DataTypeSource# dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Callconv) Source# dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Callconv) Source# gmapT :: (forall b. Data b => b -> b) -> Callconv -> CallconvSource# gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Callconv -> r Source# gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Callconv -> r Source# gmapQ :: (forall d. Data d => d -> u) -> Callconv -> [u] Source# gmapQi :: Int -> (forall d. Data d => d -> u) -> Callconv -> u Source# gmapM :: Monad m => (forall d. Data d => d -> m d) -> Callconv -> m CallconvSource# gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Callconv -> m CallconvSource# gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Callconv -> m CallconvSource# | |
| GenericCallconvSource# | |
| ShowCallconvSource# | |
| EqCallconvSource# | |
| OrdCallconvSource# | |
Defined in Language.Haskell.TH.Syntax | |
| typeRepCallconvSource# | |
Defined in Language.Haskell.TH.Syntax typeRepCallconv = D1 ('MetaData "Callconv" "Language.Haskell.TH.Syntax" "template-haskell" 'False) ((C1 ('MetaCons "CCall" 'PrefixI 'False) (U1 :: Type -> Type) :+:C1 ('MetaCons "StdCall" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "CApi" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "Prim" 'PrefixI 'False) (U1 :: Type -> Type) :+:C1 ('MetaCons "JavaScript" 'PrefixI 'False) (U1 :: Type -> Type)))) | |
Constructors
| Unsafe | |
| Safe | |
| Interruptible |
Instances
| DataSafetySource# | |
Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Safety -> c SafetySource# gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SafetySource# toConstr :: Safety -> ConstrSource# dataTypeOf :: Safety -> DataTypeSource# dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Safety) Source# dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Safety) Source# gmapT :: (forall b. Data b => b -> b) -> Safety -> SafetySource# gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Safety -> r Source# gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Safety -> r Source# gmapQ :: (forall d. Data d => d -> u) -> Safety -> [u] Source# gmapQi :: Int -> (forall d. Data d => d -> u) -> Safety -> u Source# gmapM :: Monad m => (forall d. Data d => d -> m d) -> Safety -> m SafetySource# gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Safety -> m SafetySource# gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Safety -> m SafetySource# | |
| GenericSafetySource# | |
| ShowSafetySource# | |
| EqSafetySource# | |
| OrdSafetySource# | |
Defined in Language.Haskell.TH.Syntax | |
| typeRepSafetySource# | |
Defined in Language.Haskell.TH.Syntax | |
Constructors
| InlinePNameInlineRuleMatchPhases | |
| OpaquePName | |
| SpecialisePNameType (MaybeInline) Phases | |
| SpecialiseInstPType | |
| RulePString (Maybe [TyVarBndr ()]) [RuleBndr] ExpExpPhases | |
| AnnPAnnTargetExp | |
| LinePIntString | |
| CompleteP [Name] (MaybeName) | { {-# COMPLETE C_1, ..., C_i [ :: T ] #-} } |
Instances
Instances
| DataInlineSource# | |
Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Inline -> c InlineSource# gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c InlineSource# toConstr :: Inline -> ConstrSource# dataTypeOf :: Inline -> DataTypeSource# dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Inline) Source# dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Inline) Source# gmapT :: (forall b. Data b => b -> b) -> Inline -> InlineSource# gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Inline -> r Source# gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Inline -> r Source# gmapQ :: (forall d. Data d => d -> u) -> Inline -> [u] Source# gmapQi :: Int -> (forall d. Data d => d -> u) -> Inline -> u Source# gmapM :: Monad m => (forall d. Data d => d -> m d) -> Inline -> m InlineSource# gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Inline -> m InlineSource# gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Inline -> m InlineSource# | |
| GenericInlineSource# | |
| ShowInlineSource# | |
| EqInlineSource# | |
| OrdInlineSource# | |
Defined in Language.Haskell.TH.Syntax | |
| PprInlineSource# | |
| typeRepInlineSource# | |
Defined in Language.Haskell.TH.Syntax | |
Instances
| DataRuleMatchSource# | |
Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RuleMatch -> c RuleMatchSource# gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c RuleMatchSource# toConstr :: RuleMatch -> ConstrSource# dataTypeOf :: RuleMatch -> DataTypeSource# dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c RuleMatch) Source# dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RuleMatch) Source# gmapT :: (forall b. Data b => b -> b) -> RuleMatch -> RuleMatchSource# gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RuleMatch -> r Source# gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RuleMatch -> r Source# gmapQ :: (forall d. Data d => d -> u) -> RuleMatch -> [u] Source# gmapQi :: Int -> (forall d. Data d => d -> u) -> RuleMatch -> u Source# gmapM :: Monad m => (forall d. Data d => d -> m d) -> RuleMatch -> m RuleMatchSource# gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RuleMatch -> m RuleMatchSource# gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RuleMatch -> m RuleMatchSource# | |
| GenericRuleMatchSource# | |
| ShowRuleMatchSource# | |
| EqRuleMatchSource# | |
| OrdRuleMatchSource# | |
Defined in Language.Haskell.TH.Syntax | |
| PprRuleMatchSource# | |
| typeRepRuleMatchSource# | |
Constructors
| AllPhases | |
| FromPhaseInt | |
| BeforePhaseInt |
Instances
| DataPhasesSource# | |
Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Phases -> c PhasesSource# gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c PhasesSource# toConstr :: Phases -> ConstrSource# dataTypeOf :: Phases -> DataTypeSource# dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Phases) Source# dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Phases) Source# gmapT :: (forall b. Data b => b -> b) -> Phases -> PhasesSource# gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Phases -> r Source# gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Phases -> r Source# gmapQ :: (forall d. Data d => d -> u) -> Phases -> [u] Source# gmapQi :: Int -> (forall d. Data d => d -> u) -> Phases -> u Source# gmapM :: Monad m => (forall d. Data d => d -> m d) -> Phases -> m PhasesSource# gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Phases -> m PhasesSource# gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Phases -> m PhasesSource# | |
| GenericPhasesSource# | |
| ShowPhasesSource# | |
| EqPhasesSource# | |
| OrdPhasesSource# | |
Defined in Language.Haskell.TH.Syntax | |
| PprPhasesSource# | |
| typeRepPhasesSource# | |
Defined in Language.Haskell.TH.Syntax typeRepPhases = D1 ('MetaData "Phases" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "AllPhases" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "FromPhase" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: MaybeSymbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0Int)) :+:C1 ('MetaCons "BeforePhase" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: MaybeSymbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0Int)))) | |
Constructors
| RuleVarName | |
| TypedRuleVarNameType |
Instances
Constructors
| ModuleAnnotation | |
| TypeAnnotationName | |
| ValueAnnotationName |
Instances
Instances
| DataFunDepSource# | |
Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FunDep -> c FunDepSource# gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c FunDepSource# toConstr :: FunDep -> ConstrSource# dataTypeOf :: FunDep -> DataTypeSource# dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c FunDep) Source# dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FunDep) Source# gmapT :: (forall b. Data b => b -> b) -> FunDep -> FunDepSource# gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FunDep -> r Source# gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FunDep -> r Source# gmapQ :: (forall d. Data d => d -> u) -> FunDep -> [u] Source# gmapQi :: Int -> (forall d. Data d => d -> u) -> FunDep -> u Source# gmapM :: Monad m => (forall d. Data d => d -> m d) -> FunDep -> m FunDepSource# gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FunDep -> m FunDepSource# gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FunDep -> m FunDepSource# | |
| GenericFunDepSource# | |
| ShowFunDepSource# | |
| EqFunDepSource# | |
| OrdFunDepSource# | |
Defined in Language.Haskell.TH.Syntax | |
| PprFunDepSource# | |
| typeRepFunDepSource# | |
Defined in Language.Haskell.TH.Syntax typeRepFunDep = D1 ('MetaData "FunDep" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "FunDep" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: MaybeSymbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Name]) :*:S1 ('MetaSel ('Nothing :: MaybeSymbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Name]))) | |
One equation of a type family instance or closed type family. The arguments are the left-hand-side type and the right-hand-side result.
For instance, if you had the following type family:
type family Foo (a :: k) :: k where forall k (a :: k). Foo @k a = a
The Foo @k a = a equation would be represented as follows:
TySynEqn(Just[PlainTVk,KindedTVa (VarTk)]) (AppT(AppKindT(ConT''Foo) (VarTk)) (VarTa)) (VarTa)
Instances
Common elements of OpenTypeFamilyD and ClosedTypeFamilyD. By analogy with "head" for type classes and type class instances as defined in Type classes: an exploration of the design space, the TypeFamilyHead is defined to be the elements of the declaration between type family and where.
Constructors
| TypeFamilyHeadName [TyVarBndr ()] FamilyResultSig (MaybeInjectivityAnn) |
Instances
Instances
A pattern synonym's directionality.
Constructors
| Unidir | pattern P x {<-} p |
| ImplBidir | pattern P x {=} p |
| ExplBidir [Clause] | pattern P x {<-} p where P x = e |
Instances
A pattern synonym's argument type.
Constructors
| PrefixPatSyn [Name] | pattern P {x y z} = p |
| InfixPatSynNameName | pattern {x P y} = p |
| RecordPatSyn [Name] | pattern P { {x,y,z} } = p |
Instances
Constructors
| VarEName | { x } |
| ConEName | data T1 = C1 t1 t2; p = {C1} e1 e2 |
| LitELit | { 5 or 'c'} |
| AppEExpExp | { f x } |
| AppTypeEExpType | { f @Int } |
| InfixE (MaybeExp) Exp (MaybeExp) | {x + y} or {(x+)} or {(+ x)} or {(+)} |
| UInfixEExpExpExp | {x + y} |
| ParensEExp | { (e) } |
| LamE [Pat] Exp | { \ p1 p2 -> e } |
| LamCaseE [Match] | { \case m1; m2 } |
| LamCasesE [Clause] | { \cases m1; m2 } |
| TupE [MaybeExp] | { (e1,e2) }The (1,) translates to TupE [Just (LitE (IntegerL 1)),Nothing] |
| UnboxedTupE [MaybeExp] | { (# e1,e2 #) }The (# 'c', #) translates to UnboxedTupE [Just (LitE (CharL 'c')),Nothing] |
| UnboxedSumEExpSumAltSumArity | { (#|e|#) } |
| CondEExpExpExp | { if e1 then e2 else e3 } |
| MultiIfE [(Guard, Exp)] | { if | g1 -> e1 | g2 -> e2 } |
| LetE [Dec] Exp | { let { x=e1; y=e2 } in e3 } |
| CaseEExp [Match] | { case e of m1; m2 } |
| DoE (MaybeModName) [Stmt] |
|
| MDoE (MaybeModName) [Stmt] |
|
| CompE [Stmt] | { [ (x,y) | x <- xs, y <- ys ] }The result expression of the comprehension is the last of the E.g. translation: [ f x | x <- xs ] CompE [BindS (VarP x) (VarE xs), NoBindS (AppE (VarE f) (VarE x))] |
| ArithSeqERange | { [ 1 ,2 .. 10 ] } |
| ListE [Exp] | { [1,2,3] } |
| SigEExpType | { e :: t } |
| RecConEName [FieldExp] | { T { x = y, z = w } } |
| RecUpdEExp [FieldExp] | { (f x) { z = w } } |
| StaticEExp | { static e } |
| UnboundVarEName | { _x }This is used for holes or unresolved identifiers in AST quotes. Note that it could either have a variable name or constructor name. |
| LabelEString |
|
| ImplicitParamVarEString |
|
| GetFieldEExpString |
|
| ProjectionE (NonEmptyString) |
|
Instances
Instances
Constructors
| GuardedB [(Guard, Exp)] | f p { | e1 = e2 | e3 = e4 } where ds |
| NormalBExp | f p { = e } where ds |
Instances
| DataBodySource# | |
Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Body -> c BodySource# gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c BodySource# toConstr :: Body -> ConstrSource# dataTypeOf :: Body -> DataTypeSource# dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Body) Source# dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Body) Source# gmapT :: (forall b. Data b => b -> b) -> Body -> BodySource# gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Body -> r Source# gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Body -> r Source# gmapQ :: (forall d. Data d => d -> u) -> Body -> [u] Source# gmapQi :: Int -> (forall d. Data d => d -> u) -> Body -> u Source# gmapM :: Monad m => (forall d. Data d => d -> m d) -> Body -> m BodySource# gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Body -> m BodySource# gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Body -> m BodySource# | |
| GenericBodySource# | |
| ShowBodySource# | |
| EqBodySource# | |
| OrdBodySource# | |
| typeRepBodySource# | |
Defined in Language.Haskell.TH.Syntax typeRepBody = D1 ('MetaData "Body" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "GuardedB" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: MaybeSymbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [(Guard, Exp)])) :+:C1 ('MetaCons "NormalB" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: MaybeSymbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0Exp))) | |
Instances
| DataGuardSource# | |
Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Guard -> c GuardSource# gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c GuardSource# toConstr :: Guard -> ConstrSource# dataTypeOf :: Guard -> DataTypeSource# dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Guard) Source# dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Guard) Source# gmapT :: (forall b. Data b => b -> b) -> Guard -> GuardSource# gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Guard -> r Source# gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Guard -> r Source# gmapQ :: (forall d. Data d => d -> u) -> Guard -> [u] Source# gmapQi :: Int -> (forall d. Data d => d -> u) -> Guard -> u Source# gmapM :: Monad m => (forall d. Data d => d -> m d) -> Guard -> m GuardSource# gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Guard -> m GuardSource# gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Guard -> m GuardSource# | |
| GenericGuardSource# | |
| ShowGuardSource# | |
| EqGuardSource# | |
| OrdGuardSource# | |
Defined in Language.Haskell.TH.Syntax | |
| typeRepGuardSource# | |
Defined in Language.Haskell.TH.Syntax typeRepGuard = D1 ('MetaData "Guard" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "NormalG" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: MaybeSymbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0Exp)) :+:C1 ('MetaCons "PatG" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: MaybeSymbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Stmt]))) | |
Constructors
| BindSPatExp | p <- e |
| LetS [Dec] | { let { x=e1; y=e2 } } |
| NoBindSExp | e |
| ParS [[Stmt]] |
|
| RecS [Stmt] | rec { s1; s2 } |
Instances
Instances
Constructors
| CharLChar | |
| StringLString | |
| IntegerLInteger | Used for overloaded and non-overloaded literals. We don't have a good way to represent non-overloaded literals at the moment. Maybe that doesn't matter? |
| RationalLRational | |
| IntPrimLInteger | |
| WordPrimLInteger | |
| FloatPrimLRational | |
| DoublePrimLRational | |
| StringPrimL [Word8] | A primitive C-style string, type |
| BytesPrimLBytes | Some raw bytes, type |
| CharPrimLChar |
Instances
Pattern in Haskell given in {}
Constructors
| LitPLit | { 5 or 'c' } |
| VarPName | { x } |
| TupP [Pat] | { (p1,p2) } |
| UnboxedTupP [Pat] | { (# p1,p2 #) } |
| UnboxedSumPPatSumAltSumArity | { (#|p|#) } |
| ConPName [Type] [Pat] | data T1 = C1 t1 t2; {C1 @ty1 p1 p2} = e |
| InfixPPatNamePat | foo ({x :+ y}) = e |
| UInfixPPatNamePat | foo ({x :+ y}) = e |
| ParensPPat | {(p)} |
| TildePPat | { ~p } |
| BangPPat | { !p } |
| AsPNamePat | { x @ p } |
| WildP | { _ } |
| RecPName [FieldPat] | f (Pt { pointx = x }) = g x |
| ListP [Pat] | { [1,2,3] } |
| SigPPatType | { p :: t } |
| ViewPExpPat | { e -> p } |
Instances
Instances
Instances
To avoid duplication between kinds and types, they are defined to be the same. Naturally, you would never have a type be StarT and you would never have a kind be SigT, but many of the other constructors are shared. Note that the kind Bool is denoted with ConT, not PromotedT. Similarly, tuple kinds are made with TupleT, not PromotedTupleT.
Since the advent of ConstraintKinds, constraints are really just types. Equality constraints use the EqualityT constructor. Constraints may also be tuples of other constraints.
Role annotations
Constructors
| NominalR | nominal |
| RepresentationalR | representational |
| PhantomR | phantom |
| InferR | _ |
Instances
| DataRoleSource# | |
Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Role -> c RoleSource# gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c RoleSource# toConstr :: Role -> ConstrSource# dataTypeOf :: Role -> DataTypeSource# dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Role) Source# dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Role) Source# gmapT :: (forall b. Data b => b -> b) -> Role -> RoleSource# gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Role -> r Source# gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Role -> r Source# gmapQ :: (forall d. Data d => d -> u) -> Role -> [u] Source# gmapQi :: Int -> (forall d. Data d => d -> u) -> Role -> u Source# gmapM :: Monad m => (forall d. Data d => d -> m d) -> Role -> m RoleSource# gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Role -> m RoleSource# gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Role -> m RoleSource# | |
| GenericRoleSource# | |
| ShowRoleSource# | |
| EqRoleSource# | |
| OrdRoleSource# | |
| PprRoleSource# | |
| typeRepRoleSource# | |
Defined in Language.Haskell.TH.Syntax typeRepRole = D1 ('MetaData "Role" "Language.Haskell.TH.Syntax" "template-haskell" 'False) ((C1 ('MetaCons "NominalR" 'PrefixI 'False) (U1 :: Type -> Type) :+:C1 ('MetaCons "RepresentationalR" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "PhantomR" 'PrefixI 'False) (U1 :: Type -> Type) :+:C1 ('MetaCons "InferR" 'PrefixI 'False) (U1 :: Type -> Type))) | |
Constructors
| SpecifiedSpec | a |
| InferredSpec | {a} |
Instances
Type family result signature
Instances
Injectivity annotation
Constructors
| InjectivityAnnName [Name] |
Instances
typePatSynType = TypeSource#
A pattern synonym's type. Note that a pattern synonym's fully specified type has a peculiar shape coming with two forall quantifiers and two constraint contexts. For example, consider the pattern synonym
pattern P x1 x2 ... xn = <some-pattern>
P's complete type is of the following form
pattern P :: forall universals. required constraints => forall existentials. provided constraints => t1 -> t2 -> ... -> tn -> t
consisting of four parts:
- the (possibly empty lists of) universally quantified type variables and required constraints on them.
- the (possibly empty lists of) existentially quantified type variables and the provided constraints on them.
- the types
t1,t2, ..,tnofx1,x2, ..,xn, respectively - the type
tof<some-pattern>, mentioning only universals.
Pattern synonym types interact with TH when (a) reifying a pattern synonym, (b) pretty printing, or (c) specifying a pattern synonym's type signature explicitly:
- Reification always returns a pattern synonym's fully specified type in abstract syntax.
- Pretty printing via
pprPatSynTypeabbreviates a pattern synonym's type unambiguously in concrete syntax: The rule of thumb is to print initial empty universals and the required context as() =>, if existentials and a provided context follow. If only universals and their required context, but no existentials are specified, only the universals and their required context are printed. If both or none are specified, so both (or none) are printed. - When specifying a pattern synonym's type explicitly with
PatSynSigDeither one of the universals, the existentials, or their contexts may be left empty.
See the GHC user's guide for more information on pattern synonyms and their types: https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/glasgow_exts.html#pattern-synonyms.
A location at which to attach Haddock documentation. Note that adding documentation to a Name defined oustide of the current module will cause an error.
Constructors
| ModuleDoc | At the current module's header. |
| DeclDocName | At a declaration, not necessarily top level. |
| ArgDocNameInt | At a specific argument of a function, indexed by its position. |
| InstDocType | At a class or family instance. |
Instances
A single deriving clause at the end of a datatype.
Constructors
| DerivClause (MaybeDerivStrategy) Cxt | { deriving stock (Eq, Ord) } |
Instances
What the user explicitly requests when deriving an instance.
Constructors
| StockStrategy | A "standard" derived instance |
| AnyclassStrategy | -XDeriveAnyClass |
| NewtypeStrategy | -XGeneralizedNewtypeDeriving |
| ViaStrategyType | -XDerivingVia |
Instances
Varieties of allowed instance overlap.
Constructors
| Overlappable | May be overlapped by more specific instances |
| Overlapping | May overlap a more general instance |
| Overlaps | Both |
| Incoherent | Both |
Instances
| DataOverlapSource# | |
Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Overlap -> c OverlapSource# gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c OverlapSource# toConstr :: Overlap -> ConstrSource# dataTypeOf :: Overlap -> DataTypeSource# dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Overlap) Source# dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Overlap) Source# gmapT :: (forall b. Data b => b -> b) -> Overlap -> OverlapSource# gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Overlap -> r Source# gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Overlap -> r Source# gmapQ :: (forall d. Data d => d -> u) -> Overlap -> [u] Source# gmapQi :: Int -> (forall d. Data d => d -> u) -> Overlap -> u Source# gmapM :: Monad m => (forall d. Data d => d -> m d) -> Overlap -> m OverlapSource# gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Overlap -> m OverlapSource# gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Overlap -> m OverlapSource# | |
| GenericOverlapSource# | |
| ShowOverlapSource# | |
| EqOverlapSource# | |
| OrdOverlapSource# | |
| typeRepOverlapSource# | |
Defined in Language.Haskell.TH.Syntax typeRepOverlap = D1 ('MetaData "Overlap" "Language.Haskell.TH.Syntax" "template-haskell" 'False) ((C1 ('MetaCons "Overlappable" 'PrefixI 'False) (U1 :: Type -> Type) :+:C1 ('MetaCons "Overlapping" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "Overlaps" 'PrefixI 'False) (U1 :: Type -> Type) :+:C1 ('MetaCons "Incoherent" 'PrefixI 'False) (U1 :: Type -> Type))) | |
Constructors
| NameS | An unqualified name; dynamically bound |
| NameQModName | A qualified name; dynamically bound |
| NameU !Uniq | A unique local name |
| NameL !Uniq | Local name bound outside of the TH AST |
| NameGNameSpacePkgNameModName | Global name bound outside of the TH AST: An original name (occurrences only, not binders) Need the namespace too to be sure which thing we are naming |
Instances
Raw bytes embedded into the binary.
Avoid using Bytes constructor directly as it is likely to change in the future. Use helpers such as mkBytes in Language.Haskell.TH.Lib instead.
Constructors
| Bytes | |
Fields
| |
Instances
| DataBytesSource# | |
Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Bytes -> c BytesSource# gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c BytesSource# toConstr :: Bytes -> ConstrSource# dataTypeOf :: Bytes -> DataTypeSource# dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Bytes) Source# dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Bytes) Source# gmapT :: (forall b. Data b => b -> b) -> Bytes -> BytesSource# gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Bytes -> r Source# gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Bytes -> r Source# gmapQ :: (forall d. Data d => d -> u) -> Bytes -> [u] Source# gmapQi :: Int -> (forall d. Data d => d -> u) -> Bytes -> u Source# gmapM :: Monad m => (forall d. Data d => d -> m d) -> Bytes -> m BytesSource# gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Bytes -> m BytesSource# gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Bytes -> m BytesSource# | |
| GenericBytesSource# | |
| ShowBytesSource# | |
| EqBytesSource# | |
| OrdBytesSource# | |
Defined in Language.Haskell.TH.Syntax | |
| typeRepBytesSource# | |
Defined in Language.Haskell.TH.Syntax typeRepBytes = D1 ('MetaData "Bytes" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "Bytes" 'PrefixI 'True) (S1 ('MetaSel ('Just "bytesPtr") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (ForeignPtrWord8)) :*: (S1 ('MetaSel ('Just "bytesOffset") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0Word) :*:S1 ('MetaSel ('Just "bytesSize") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0Word)))) | |
class (MonadIO m, MonadFail m) => Quasi m whereSource#
Minimal complete definition
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
Methods
Arguments
| :: Bool | |
| -> String | |
| -> m () | Report an error (True) or warning (False) ...but carry on; use |
Arguments
| :: m a | the error handler |
| -> m a | action which may fail |
| -> m a | Recover from the monadic |
qLookupName :: Bool -> String -> m (MaybeName) Source#
qReify :: Name -> m InfoSource#
qReifyFixity :: Name -> m (MaybeFixity) Source#
qReifyType :: Name -> m TypeSource#
qReifyInstances :: Name -> [Type] -> m [Dec] Source#
qReifyRoles :: Name -> m [Role] Source#
qReifyAnnotations :: Data a => AnnLookup -> m [a] Source#
qReifyModule :: Module -> m ModuleInfoSource#
qReifyConStrictness :: Name -> m [DecidedStrictness] Source#
qGetPackageRoot :: m FilePathSource#
qAddDependentFile :: FilePath -> m () Source#
qAddTempFile :: String -> m FilePathSource#
qAddTopDecls :: [Dec] -> m () Source#
qAddForeignFilePath :: ForeignSrcLang -> String -> m () Source#
qAddModFinalizer :: Q () -> m () Source#
qAddCorePlugin :: String -> m () Source#
qGetQ :: Typeable a => m (Maybe a) Source#
qPutQ :: Typeable a => a -> m () Source#
qIsExtEnabled :: Extension -> m BoolSource#
qExtsEnabled :: m [Extension] Source#
Instances
classLift (t :: TYPE r) whereSource#
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 -> Q (TExp 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 ≡ unTypeQ (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 LiftRepresentation-polymorphic since template-haskell-2.16.0.0.
Minimal complete definition
Methods
lift :: Quote m => t -> m ExpSource#
Turn a value into a Template Haskell expression, suitable for use in a splice.
liftTyped :: Quote m => t -> Code m t Source#
Turn a value into a Template Haskell typed expression, suitable for use in a typed splice.
Since: template-haskell-2.16.0.0
Instances
| LiftAddr#Source# | Produces an Since: template-haskell-2.16.0.0 |
| LiftDouble#Source# | Since: template-haskell-2.16.0.0 |
| LiftFloat#Source# | Since: template-haskell-2.16.0.0 |
| LiftInt#Source# | Since: template-haskell-2.16.0.0 |
| LiftByteArraySource# | Since: template-haskell-2.19.0.0 |
| LiftVoidSource# | Since: template-haskell-2.15.0.0 |
| LiftInt16Source# | |
| LiftInt32Source# | |
| LiftInt64Source# | |
| LiftInt8Source# | |
| LiftWord16Source# | |
| LiftWord32Source# | |
| LiftWord64Source# | |
| LiftWord8Source# | |
| LiftIntegerSource# | |
| LiftNaturalSource# | |
| Lift ()Source# | |
| LiftBoolSource# | |
| LiftCharSource# | |
| LiftDoubleSource# | |
| LiftFloatSource# | |
| LiftIntSource# | |
| LiftWordSource# | |
| LiftChar#Source# | Since: template-haskell-2.16.0.0 |
| LiftWord#Source# | Since: template-haskell-2.16.0.0 |
| Lift (# #)Source# | Since: template-haskell-2.16.0.0 |
| Lift a => Lift (NonEmpty a :: Type)Source# | Since: template-haskell-2.15.0.0 |
| Integral a => Lift (Ratio a :: Type)Source# | |
| Lift a => Lift (Maybe a :: Type)Source# | |
| Lift a => Lift ([a] :: Type)Source# | |
| (Lift a, Lift b) => Lift (Either a b :: Type)Source# | |
| (Lift a, Lift b) => Lift ((a, b) :: Type)Source# | |
| (Lift a, Lift b, Lift c) => Lift ((a, b, c) :: Type)Source# | |
| (Lift a, Lift b, Lift c, Lift d) => Lift ((a, b, c, d) :: Type)Source# | |
| (Lift a, Lift b, Lift c, Lift d, Lift e) => Lift ((a, b, c, d, e) :: Type)Source# | |
| (Lift a, Lift b, Lift c, Lift d, Lift e, Lift f) => Lift ((a, b, c, d, e, f) :: Type)Source# | |
| (Lift a, Lift b, Lift c, Lift d, Lift e, Lift f, Lift g) => Lift ((a, b, c, d, e, f, g) :: Type)Source# | |
| Lift a => Lift ((# a #) :: TYPE ('TupleRep '[LiftedRep]))Source# | Since: template-haskell-2.16.0.0 |
| (Lift a, Lift b) => Lift ((# a | b #) :: TYPE ('SumRep '[LiftedRep, LiftedRep]))Source# | Since: template-haskell-2.16.0.0 |
| (Lift a, Lift b) => Lift ((# a, b #) :: TYPE ('TupleRep '[LiftedRep, LiftedRep]))Source# | Since: template-haskell-2.16.0.0 |
| (Lift a, Lift b, Lift c) => Lift ((# a | b | c #) :: TYPE ('SumRep '[LiftedRep, LiftedRep, LiftedRep]))Source# | Since: template-haskell-2.16.0.0 |
| (Lift a, Lift b, Lift c) => Lift ((# a, b, c #) :: TYPE ('TupleRep '[LiftedRep, LiftedRep, LiftedRep]))Source# | Since: template-haskell-2.16.0.0 |
| (Lift a, Lift b, Lift c, Lift d) => Lift ((# a | b | c | d #) :: TYPE ('SumRep '[LiftedRep, LiftedRep, LiftedRep, LiftedRep]))Source# | Since: template-haskell-2.16.0.0 |
| (Lift a, Lift b, Lift c, Lift d) => Lift ((# a, b, c, d #) :: TYPE ('TupleRep '[LiftedRep, LiftedRep, LiftedRep, LiftedRep]))Source# | Since: template-haskell-2.16.0.0 |
| (Lift a, Lift b, Lift c, Lift d, Lift e) => Lift ((# a | b | c | d | e #) :: TYPE ('SumRep '[LiftedRep, LiftedRep, LiftedRep, LiftedRep, LiftedRep]))Source# | Since: template-haskell-2.16.0.0 |
| (Lift a, Lift b, Lift c, Lift d, Lift e) => Lift ((# a, b, c, d, e #) :: TYPE ('TupleRep '[LiftedRep, LiftedRep, LiftedRep, LiftedRep, LiftedRep]))Source# | Since: template-haskell-2.16.0.0 |
| (Lift a, Lift b, Lift c, Lift d, Lift e, Lift f) => Lift ((# a | b | c | d | e | f #) :: TYPE ('SumRep '[LiftedRep, LiftedRep, LiftedRep, LiftedRep, LiftedRep, LiftedRep]))Source# | Since: template-haskell-2.16.0.0 |
| (Lift a, Lift b, Lift c, Lift d, Lift e, Lift f) => Lift ((# a, b, c, d, e, f #) :: TYPE ('TupleRep '[LiftedRep, LiftedRep, LiftedRep, LiftedRep, LiftedRep, LiftedRep]))Source# | Since: template-haskell-2.16.0.0 |
| (Lift a, Lift b, Lift c, Lift d, Lift e, Lift f, Lift g) => Lift ((# a | b | c | d | e | f | g #) :: TYPE ('SumRep '[LiftedRep, LiftedRep, LiftedRep, LiftedRep, LiftedRep, LiftedRep, LiftedRep]))Source# | Since: template-haskell-2.16.0.0 |
| (Lift a, Lift b, Lift c, Lift d, Lift e, Lift f, Lift g) => Lift ((# a, b, c, d, e, f, g #) :: TYPE ('TupleRep '[LiftedRep, LiftedRep, LiftedRep, LiftedRep, LiftedRep, LiftedRep, LiftedRep]))Source# | Since: template-haskell-2.16.0.0 |
Instances
| DataModNameSource# | |
Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ModName -> c ModNameSource# gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ModNameSource# toConstr :: ModName -> ConstrSource# dataTypeOf :: ModName -> DataTypeSource# dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ModName) Source# dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ModName) Source# gmapT :: (forall b. Data b => b -> b) -> ModName -> ModNameSource# gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ModName -> r Source# gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ModName -> r Source# gmapQ :: (forall d. Data d => d -> u) -> ModName -> [u] Source# gmapQi :: Int -> (forall d. Data d => d -> u) -> ModName -> u Source# gmapM :: Monad m => (forall d. Data d => d -> m d) -> ModName -> m ModNameSource# gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ModName -> m ModNameSource# gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ModName -> m ModNameSource# | |
| GenericModNameSource# | |
| ShowModNameSource# | |
| EqModNameSource# | |
| OrdModNameSource# | |
| typeRepModNameSource# | |
Defined in Language.Haskell.TH.Syntax | |
Instances
| DataPkgNameSource# | |
Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> PkgName -> c PkgNameSource# gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c PkgNameSource# toConstr :: PkgName -> ConstrSource# dataTypeOf :: PkgName -> DataTypeSource# dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c PkgName) Source# dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PkgName) Source# gmapT :: (forall b. Data b => b -> b) -> PkgName -> PkgNameSource# gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PkgName -> r Source# gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PkgName -> r Source# gmapQ :: (forall d. Data d => d -> u) -> PkgName -> [u] Source# gmapQi :: Int -> (forall d. Data d => d -> u) -> PkgName -> u Source# gmapM :: Monad m => (forall d. Data d => d -> m d) -> PkgName -> m PkgNameSource# gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> PkgName -> m PkgNameSource# gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> PkgName -> m PkgNameSource# | |
| GenericPkgNameSource# | |
| ShowPkgNameSource# | |
| EqPkgNameSource# | |
| OrdPkgNameSource# | |
| typeRepPkgNameSource# | |
Defined in Language.Haskell.TH.Syntax | |
Instances
| DataOccNameSource# | |
Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> OccName -> c OccNameSource# gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c OccNameSource# toConstr :: OccName -> ConstrSource# dataTypeOf :: OccName -> DataTypeSource# dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c OccName) Source# dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OccName) Source# gmapT :: (forall b. Data b => b -> b) -> OccName -> OccNameSource# gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> OccName -> r Source# gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> OccName -> r Source# gmapQ :: (forall d. Data d => d -> u) -> OccName -> [u] Source# gmapQi :: Int -> (forall d. Data d => d -> u) -> OccName -> u Source# gmapM :: Monad m => (forall d. Data d => d -> m d) -> OccName -> m OccNameSource# gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> OccName -> m OccNameSource# gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> OccName -> m OccNameSource# | |
| GenericOccNameSource# | |
| ShowOccNameSource# | |
| EqOccNameSource# | |
| OrdOccNameSource# | |
| typeRepOccNameSource# | |
Defined in Language.Haskell.TH.Syntax | |
typeStrictType = BangTypeSource#
As of template-haskell-2.11.0.0, StrictType has been replaced by BangType.
typeVarStrictType = VarBangTypeSource#
As of template-haskell-2.11.0.0, VarStrictType has been replaced by VarBangType.
Recover from errors raised by reportError or fail.
reportError :: String -> Q () Source#
Report an error to the user, but allow the current splice's computation to carry on. To abort the computation, use fail.
The runIO function lets you run an I/O computation in the Q monad. Take care: you are guaranteed the ordering of calls to runIO within a single Q computation, but not about the order in which splices are run.
Note: for various murky reasons, stdout and stderr handles are not necessarily flushed when the compiler finishes running, so you should flush them yourself.
reportWarning :: String -> Q () Source#
Report a warning to the user, and carry on.
report :: Bool -> String -> Q () Source#
Deprecated: Use reportError or reportWarning instead
Report an error (True) or warning (False), but carry on; use fail to stop.
reify looks up information about the Name. It will fail with a compile error if the Name is not visible. A Name is visible if it is imported or defined in a prior top-level declaration group. See the documentation for newDeclarationGroup for more details.
It is sometimes useful to construct the argument name using lookupTypeName or lookupValueName to ensure that we are reifying from the right namespace. For instance, in this context:
data D = D
which D does reify (mkName "D") return information about? (Answer: D-the-type, but don't rely on it.) To ensure we get information about D-the-value, use lookupValueName:
do Just nm <- lookupValueName "D" reify nm
and to get information about D-the-type, use lookupTypeName.
reifyModule :: Module -> QModuleInfoSource#
reifyModule mod looks up information about module mod. To look up the current module, call this function with the return value of thisModule.
newDeclarationGroup :: Q [Dec] Source#
Template Haskell is capable of reifying information about types and terms defined in previous declaration groups. Top-level declaration splices break up declaration groups.
For an example, consider this code block. We define a datatype X and then try to call reify on the datatype.
module Check where data X = X deriving Eq $(do info <- reify ''X runIO $ print info )
This code fails to compile, noting that X is not available for reification at the site of reify. We can fix this by creating a new declaration group using an empty top-level splice:
data X = X deriving Eq $(pure []) $(do info <- reify ''X runIO $ print info )
We provide newDeclarationGroup as a means of documenting this behavior and providing a name for the pattern.
Since top level splices infer the presence of the $( ... ) brackets, we can also write:
data X = X deriving Eq newDeclarationGroup $(do info <- reify ''X runIO $ print info )
extsEnabled :: Q [Extension] Source#
List all enabled language extensions.
isExtEnabled :: Extension -> QBoolSource#
Determine whether the given language extension is enabled in the Q monad.
lookupTypeName :: String -> Q (MaybeName) Source#
Look up the given name in the (type namespace of the) current splice's scope. See Language.Haskell.TH.Syntax for more details.
lookupValueName :: String -> Q (MaybeName) Source#
Look up the given name in the (value namespace of the) current splice's scope. See Language.Haskell.TH.Syntax for more details.
reifyFixity :: Name -> Q (MaybeFixity) Source#
reifyFixity nm attempts to find a fixity declaration for nm. For example, if the function foo has the fixity declaration infixr 7 foo, then reifyFixity 'foo would return Just (Fixity 7 InfixR)bar does not have a fixity declaration, then reifyFixity 'bar returns Nothing, so you may assume bar has defaultFixity.
reifyType :: Name -> QTypeSource#
reifyType nm attempts to find the type or kind of nm. For example, reifyType 'not returns Bool -> Bool, and reifyType ''Bool returns Type. This works even if there's no explicit signature and the type or kind is inferred.
reifyInstances :: Name -> [Type] -> Q [InstanceDec] Source#
reifyInstances nm tys returns a list of all visible instances (see below for "visible") of nm tys. That is, if nm is the name of a type class, then all instances of this class at the types tys are returned. Alternatively, if nm is the name of a data family or type family, all instances of this family at the types tys are returned.
Note that this is a "shallow" test; the declarations returned merely have instance heads which unify with nm tys, they need not actually be satisfiable.
reifyInstances ''Eq [contains theTupleT2 `AppT`ConT''A `AppT`ConT''B ]instance (Eq a, Eq b) => Eq (a, b)regardless of whetherAandBthemselves implementEqreifyInstances ''Show [produces every available instance ofVarT(mkName"a") ]Eq
There is one edge case: reifyInstances ''Typeable tys currently always produces an empty list (no matter what tys are given).
In principle, the *visible* instances are * all instances defined in a prior top-level declaration group (see docs on newDeclarationGroup), or * all instances defined in any module transitively imported by the module being compiled
However, actually searching all modules transitively below the one being compiled is unreasonably expensive, so reifyInstances will report only the instance for modules that GHC has had some cause to visit during this compilation. This is a shortcoming: reifyInstances might fail to report instances for a type that is otherwise unusued, or instances defined in a different component. You can work around this shortcoming by explicitly importing the modules whose instances you want to be visible. GHC issue #20529 has some discussion around this.
isInstance :: Name -> [Type] -> QBoolSource#
Is the list of instances returned by reifyInstances nonempty?
If you're confused by an instance not being visible despite being defined in the same module and above the splice in question, see the docs for newDeclarationGroup for a possible explanation.
reifyRoles :: Name -> Q [Role] Source#
reifyRoles nm returns the list of roles associated with the parameters (both visible and invisible) of the tycon nm. Fails if nm cannot be found or is not a tycon. The returned list should never contain InferR.
An invisible parameter to a tycon is often a kind parameter. For example, if we have
type Proxy :: forall k. k -> Type data Proxy a = MkProxy
and reifyRoles Proxy, we will get [. The NominalR, PhantomR]NominalR is the role of the invisible k parameter. Kind parameters are always nominal.
reifyAnnotations :: Data a => AnnLookup -> Q [a] Source#
reifyAnnotations target returns the list of annotations associated with target. Only the annotations that are appropriately typed is returned. So if you have Int and String annotations for the same target, you have to call this function twice.
reifyConStrictness :: Name -> Q [DecidedStrictness] Source#
reifyConStrictness nm looks up the strictness information for the fields of the constructor with the name nm. Note that the strictness information that reifyConStrictness returns may not correspond to what is written in the source code. For example, in the following data declaration:
data Pair a = Pair a a
reifyConStrictness would return [ under most circumstances, but it would return DecidedLazy, DecidedLazy][ if the DecidedStrict, DecidedStrict]-XStrictData language extension was enabled.
unTypeCode :: forall (r :: RuntimeRep) (a :: TYPE r) m. Quote m => Code m a -> m ExpSource#
Extract the untyped representation from the typed representation
unsafeCodeCoerce :: forall (r :: RuntimeRep) (a :: TYPE r) m. Quote m => m Exp -> Code m a Source#
Unsafely convert an untyped code representation into a typed code representation.
hoistCode :: forall m n (r :: RuntimeRep) (a :: TYPE r). Monad m => (forall x. m x -> n x) -> Code m a -> Code n a Source#
Modify the ambient monad used during code generation. For example, you can use hoistCode to handle a state effect: handleState :: Code (StateT Int Q) a -> Code Q a handleState = hoistCode (flip runState 0)
bindCode :: forall m a (r :: RuntimeRep) (b :: TYPE r). Monad m => m a -> (a -> Code m b) -> Code m b Source#
Variant of (>>=) which allows effectful computations to be injected into code generation.
bindCode_ :: forall m a (r :: RuntimeRep) (b :: TYPE r). Monad m => m a -> Code m b -> Code m b Source#
Variant of (>>) which allows effectful computations to be injected into code generation.
joinCode :: forall m (r :: RuntimeRep) (a :: TYPE r). Monad m => m (Code m a) -> Code m a Source#
A useful combinator for embedding monadic actions into Code myCode :: ... => Code m a myCode = joinCode $ do x <- someSideEffect return (makeCodeWith x)
liftCode :: forall (r :: RuntimeRep) (a :: TYPE r) m. m (TExp a) -> Code m a Source#
Lift a monadic action producing code into the typed Code representation
mkName :: String -> NameSource#
Generate a capturable name. Occurrences of such names will be resolved according to the Haskell scoping rules at the occurrence site.
For example:
f = [| pi + $(varE (mkName "pi")) |] ... g = let pi = 3 in $f
In this case, g is desugared to
g = Prelude.pi + 3
Note that mkName may be used with qualified names:
mkName "Prelude.pi"
See also dyn for a useful combinator. The above example could be rewritten using dyn as
f = [| pi + $(dyn "pi") |]
nameBase :: Name -> StringSource#
The name without its module prefix.
Examples
>>>nameBase ''Data.Either.Either"Either">>>nameBase (mkName "foo")"foo">>>nameBase (mkName "Module.foo")"foo"
nameModule :: Name -> MaybeStringSource#
Module prefix of a name, if it exists.
Examples
>>>nameModule ''Data.Either.EitherJust "Data.Either">>>nameModule (mkName "foo")Nothing>>>nameModule (mkName "Module.foo")Just "Module"
namePackage :: Name -> MaybeStringSource#
A name's package, if it exists.
Examples
>>>namePackage ''Data.Either.EitherJust "base">>>namePackage (mkName "foo")Nothing>>>namePackage (mkName "Module.foo")Nothing
nameSpace :: Name -> MaybeNameSpaceSource#
Returns whether a name represents an occurrence of a top-level variable (VarName), data constructor (DataName), type constructor, or type class (TcClsName). If we can't be sure, it returns Nothing.
Examples
>>>nameSpace 'Prelude.idJust VarName>>>nameSpace (mkName "id")Nothing -- only works for top-level variable names>>>nameSpace 'Data.Maybe.JustJust DataName>>>nameSpace ''Data.Maybe.MaybeJust TcClsName>>>nameSpace ''Data.Ord.OrdJust TcClsName
tupleTypeName :: Int -> NameSource#
Tuple type constructor
tupleDataName :: Int -> NameSource#
Tuple data constructor
unboxedTupleTypeName :: Int -> NameSource#
Unboxed tuple type constructor
unboxedTupleDataName :: Int -> NameSource#
Unboxed tuple data constructor
unboxedSumTypeName :: SumArity -> NameSource#
Unboxed sum type constructor
defaultFixity :: FixitySource#
Default fixity: infixl 9
Highest allowed operator precedence for Fixity constructor (answer: 9)
putDoc :: DocLoc -> String -> Q () Source#
Add Haddock documentation to the specified location. This will overwrite any documentation at the location if it already exists. This will reify the specified name, so it must be in scope when you call it. If you want to add documentation to something that you are currently splicing, you can use addModFinalizer e.g.
do let nm = mkName "x" addModFinalizer $ putDoc (DeclDoc nm) "Hello" [d| $(varP nm) = 42 |]
The helper functions withDecDoc and withDecsDoc will do this for you, as will the funD_doc and other _doc combinators. You most likely want to have the -haddock flag turned on when using this. Adding documentation to anything outside of the current module will cause an error.
getDoc :: DocLoc -> Q (MaybeString) Source#
Retreives the Haddock documentation at the specified location, if one exists. It can be used to read documentation on things defined outside of the current module, provided that those modules were compiled with the -haddock flag.
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 Source#
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.
dataToExpQ :: (Quote m, Data a) => (forall b. Data b => b -> Maybe (m Exp)) -> a -> m ExpSource#
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.
dataToPatQ :: (Quote m, Data a) => (forall b. Data b => b -> Maybe (m Pat)) -> a -> m PatSource#
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.
unTypeQ :: forall (r :: RuntimeRep) (a :: TYPE r) m. Quote m => m (TExp a) -> m ExpSource#
Discard the type annotation and produce a plain Template Haskell expression
Representation-polymorphic since template-haskell-2.16.0.0.
unsafeTExpCoerce :: forall (r :: RuntimeRep) (a :: TYPE r) m. Quote m => m Exp -> m (TExp a) Source#
Annotate the Template Haskell expression with a type
This is unsafe because GHC cannot check for you that the expression really does have the type you claim it has.
Representation-polymorphic since template-haskell-2.16.0.0.
getPackageRoot :: QFilePathSource#
Get the package root for the current package which is being compiled. This can be set explicitly with the -package-root flag but is normally just the current working directory.
The motivation for this flag is to provide a principled means to remove the assumption from splices that they will be executed in the directory where the cabal file resides. Projects such as haskell-language-server can't and don't change directory when compiling files but instead set the -package-root flag appropiately.
makeRelativeToProject :: FilePath -> QFilePathSource#
The input is a filepath, which if relative is offset by the package root.
addDependentFile :: FilePath -> Q () Source#
Record external files that runIO is using (dependent upon). The compiler can then recognize that it should re-compile the Haskell file when an external file changes.
Expects an absolute file path.
Notes:
- ghc -M does not know about these dependencies - it does not execute TH.
- The dependency is based on file content, not a modification time
addTempFile :: String -> QFilePathSource#
Obtain a temporary file path with the given suffix. The compiler will delete this file after compilation.
addTopDecls :: [Dec] -> Q () Source#
Add additional top-level declarations. The added declarations will be type checked along with the current declaration group.
addForeignFile :: ForeignSrcLang -> String -> Q () Source#
Deprecated: Use addForeignSource instead
addForeignSource :: ForeignSrcLang -> String -> Q () Source#
Emit a foreign file which will be compiled and linked to the object for the current module. Currently only languages that can be compiled with the C compiler are supported, and the flags passed as part of -optc will be also applied to the C compiler invocation that will compile them.
Note that for non-C languages (for example C++) extern C directives must be used to get symbols that we can access from Haskell.
To get better errors, it is recommended to use #line pragmas when emitting C files, e.g.
{-# LANGUAGE CPP #-} ... addForeignSource LangC $ unlines [ "#line " ++ show (819 + 1) ++ " " ++ show "libraries/template-haskell/Language/Haskell/TH/Syntax.hs" , ... ]addForeignFilePath :: ForeignSrcLang -> FilePath -> Q () Source#
Same as addForeignSource, but expects to receive a path pointing to the foreign file instead of a String of its contents. Consider using this in conjunction with addTempFile.
This is a good alternative to addForeignSource when you are trying to directly link in an object file.
addModFinalizer :: Q () -> Q () Source#
Add a finalizer that will run in the Q monad after the current module has been type checked. This only makes sense when run within a top-level splice.
The finalizer is given the local type environment at the splice point. Thus reify is able to find the local definitions when executed inside the finalizer.
addCorePlugin :: String -> Q () Source#
Adds a core plugin to the compilation pipeline.
addCorePlugin m has almost the same effect as passing -fplugin=m to ghc in the command line. The major difference is that the plugin module m must not belong to the current package. When TH executes, it is too late to tell the compiler that we needed to compile first a plugin module in the current package.
getQ :: Typeable a => Q (Maybe a) Source#
Get state from the Q monad. Note that the state is local to the Haskell module in which the Template Haskell expression is executed.
putQ :: Typeable a => a -> Q () Source#
Replace the state in the Q monad. Note that the state is local to the Haskell module in which the Template Haskell expression is executed.
mkNameG :: NameSpace -> String -> String -> String -> NameSource#
Used for 'x etc, but not available to the programmer
Language extensions
Foreign formats supported by GHC via TH
Constructors
| LangC | C |
| LangCxx | C++ |
| LangObjc | Objective C |
| LangObjcxx | Objective C++ |
| LangAsm | Assembly language (.s) |
| LangJs | JavaScript |
| RawObject | Object (.o) |
Instances
Notes
Unresolved Infix
When implementing antiquotation for quasiquoters, one often wants to parse strings into expressions:
parse :: String -> Maybe Exp
But how should we parse a + b * c? If we don't know the fixities of + and *, we don't know whether to parse it as a + (b * c) or (a + b) * c.
In cases like this, use UInfixE, UInfixP, UInfixT, or PromotedUInfixT, which stand for "unresolved infix expressionpatterntype/promoted constructor", respectively. When the compiler is given a splice containing a tree of UInfixE applications such as
UInfixE (UInfixE e1 op1 e2) op2 (UInfixE e3 op3 e4)
it will look up and the fixities of the relevant operators and reassociate the tree as necessary.
- trees will not be reassociated across
ParensE,ParensP, orParensT, which are of use for parsing expressions like
(a + b * c) + d * e
InfixE,InfixP,InfixT, andPromotedInfixTexpressions are never reassociated.- The
UInfixEconstructor doesn't support sections. Sections such as(a *)have no ambiguity, soInfixEsuffices. For longer sections such as(a + b * c -), use anInfixEconstructor for the outer-most section, and useUInfixEconstructors for all other operators:
InfixE Just (UInfixE ...a + b * c...) op Nothing
Sections such as (a + b +) and ((a + b) +) should be rendered into Exps differently:
(+ a + b) ---> InfixE Nothing + (Just $ UInfixE a + b) -- will result in a fixity error if (+) is left-infix (+ (a + b)) ---> InfixE Nothing + (Just $ ParensE $ UInfixE a + b) -- no fixity errors
- Quoted expressions such as
[| a * b + c |] :: Q Exp [p| a : b : c |] :: Q Pat [t| T + T |] :: Q Type
will never contain UInfixE, UInfixP, UInfixT, PromotedUInfixT, InfixT, 'PromotedInfixT, ParensE, ParensP, or ParensT constructors.
