| Safe Haskell | None |
|---|---|
| Language | Haskell2010 |
Language.Haskell.TH
Contents
Description
The public face of Template Haskell
For other documentation, refer to: http://www.haskell.org/haskellwiki/Template_Haskell
- data Q a
- runQ :: Quasi m => Q a -> m a
- reportError :: String -> Q ()
- reportWarning :: String -> Q ()
- report :: Bool -> String -> Q ()
- recover :: Q a -> Q a -> Q a
- location :: Q Loc
- data Loc = Loc {}
- runIO :: IO a -> Q a
- reify :: Name -> Q Info
- reifyModule :: Module -> Q ModuleInfo
- thisModule :: Q Module
- data Info
- data ModuleInfo = ModuleInfo [Module]
- type InstanceDec = Dec
- type ParentName = Name
- type Arity = Int
- type Unlifted = Bool
- data Extension :: *
- = Cpp
- | OverlappingInstances
- | UndecidableInstances
- | IncoherentInstances
- | UndecidableSuperClasses
- | MonomorphismRestriction
- | MonoPatBinds
- | MonoLocalBinds
- | RelaxedPolyRec
- | ExtendedDefaultRules
- | ForeignFunctionInterface
- | UnliftedFFITypes
- | InterruptibleFFI
- | CApiFFI
- | GHCForeignImportPrim
- | JavaScriptFFI
- | ParallelArrays
- | Arrows
- | TemplateHaskell
- | TemplateHaskellQuotes
- | QuasiQuotes
- | ImplicitParams
- | ImplicitPrelude
- | ScopedTypeVariables
- | AllowAmbiguousTypes
- | UnboxedTuples
- | BangPatterns
- | TypeFamilies
- | TypeFamilyDependencies
- | TypeInType
- | OverloadedStrings
- | OverloadedLists
- | NumDecimals
- | DisambiguateRecordFields
- | RecordWildCards
- | RecordPuns
- | ViewPatterns
- | GADTs
- | GADTSyntax
- | NPlusKPatterns
- | DoAndIfThenElse
- | RebindableSyntax
- | ConstraintKinds
- | PolyKinds
- | DataKinds
- | InstanceSigs
- | ApplicativeDo
- | StandaloneDeriving
- | DeriveDataTypeable
- | AutoDeriveTypeable
- | DeriveFunctor
- | DeriveTraversable
- | DeriveFoldable
- | DeriveGeneric
- | DefaultSignatures
- | DeriveAnyClass
- | DeriveLift
- | 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
- | DuplicateRecordFields
- | OverloadedLabels
- | EmptyCase
- | PatternSynonyms
- | PartialTypeSignatures
- | NamedWildCards
- | StaticPointers
- | TypeApplications
- | Strict
- | StrictData
- | MonadFailDesugaring
- extsEnabled :: Q [Extension]
- isExtEnabled :: Extension -> Q Bool
- lookupTypeName :: String -> Q (Maybe Name)
- lookupValueName :: String -> Q (Maybe Name)
- reifyFixity :: Name -> Q (Maybe Fixity)
- reifyInstances :: Name -> [Type] -> Q [InstanceDec]
- isInstance :: Name -> [Type] -> Q Bool
- reifyRoles :: Name -> Q [Role]
- reifyAnnotations :: Data a => AnnLookup -> Q [a]
- data AnnLookup
- reifyConStrictness :: Name -> Q [DecidedStrictness]
- data TExp a
- unType :: TExp a -> Exp
- data Name
- data NameSpace
- mkName :: String -> Name
- newName :: String -> Q Name
- nameBase :: Name -> String
- nameModule :: Name -> Maybe String
- namePackage :: Name -> Maybe String
- nameSpace :: Name -> Maybe NameSpace
- tupleTypeName :: Int -> Name
- tupleDataName :: Int -> Name
- unboxedTupleTypeName :: Int -> Name
- unboxedTupleDataName :: Int -> Name
- data Dec
- = FunD Name [Clause]
- | ValD Pat Body [Dec]
- | DataD Cxt Name [TyVarBndr] (Maybe Kind) [Con] Cxt
- | NewtypeD Cxt Name [TyVarBndr] (Maybe Kind) Con Cxt
- | TySynD Name [TyVarBndr] Type
- | ClassD Cxt Name [TyVarBndr] [FunDep] [Dec]
- | InstanceD (Maybe Overlap) Cxt Type [Dec]
- | SigD Name Type
- | ForeignD Foreign
- | InfixD Fixity Name
- | PragmaD Pragma
- | DataFamilyD Name [TyVarBndr] (Maybe Kind)
- | DataInstD Cxt Name [Type] (Maybe Kind) [Con] Cxt
- | NewtypeInstD Cxt Name [Type] (Maybe Kind) Con Cxt
- | TySynInstD Name TySynEqn
- | OpenTypeFamilyD TypeFamilyHead
- | ClosedTypeFamilyD TypeFamilyHead [TySynEqn]
- | RoleAnnotD Name [Role]
- | StandaloneDerivD Cxt Type
- | DefaultSigD Name Type
- data Con
- data Clause = Clause [Pat] Body [Dec]
- data SourceUnpackedness
- data SourceStrictness
- data DecidedStrictness
- data Bang = Bang SourceUnpackedness SourceStrictness
- type Strict = Bang
- data Foreign
- data Callconv
- = CCall
- | StdCall
- | CApi
- | Prim
- | JavaScript
- data Safety
- = Unsafe
- | Safe
- | Interruptible
- data Pragma
- data Inline
- data RuleMatch
- data Phases
- data RuleBndr
- data AnnTarget
- data FunDep = FunDep [Name] [Name]
- data FamFlavour
- data TySynEqn = TySynEqn [Type] Type
- data TypeFamilyHead = TypeFamilyHead Name [TyVarBndr] FamilyResultSig (Maybe InjectivityAnn)
- data Fixity = Fixity Int FixityDirection
- data FixityDirection
- defaultFixity :: Fixity
- maxPrecedence :: Int
- data Exp
- = VarE Name
- | ConE Name
- | LitE Lit
- | AppE Exp Exp
- | InfixE (Maybe Exp) Exp (Maybe Exp)
- | UInfixE Exp Exp Exp
- | ParensE Exp
- | LamE [Pat] Exp
- | LamCaseE [Match]
- | TupE [Exp]
- | UnboxedTupE [Exp]
- | CondE Exp Exp Exp
- | MultiIfE [(Guard, Exp)]
- | LetE [Dec] Exp
- | CaseE Exp [Match]
- | DoE [Stmt]
- | CompE [Stmt]
- | ArithSeqE Range
- | ListE [Exp]
- | SigE Exp Type
- | RecConE Name [FieldExp]
- | RecUpdE Exp [FieldExp]
- | StaticE Exp
- | UnboundVarE Name
- data Match = Match Pat Body [Dec]
- data Body
- data Guard
- data Stmt
- data Range
- data Lit
- data Pat
- type FieldExp = (Name, Exp)
- type FieldPat = (Name, Pat)
- data Type
- = ForallT [TyVarBndr] Cxt Type
- | AppT Type Type
- | SigT Type Kind
- | VarT Name
- | ConT Name
- | PromotedT Name
- | InfixT Type Name Type
- | UInfixT Type Name Type
- | ParensT Type
- | TupleT Int
- | UnboxedTupleT Int
- | ArrowT
- | EqualityT
- | ListT
- | PromotedTupleT Int
- | PromotedNilT
- | PromotedConsT
- | StarT
- | ConstraintT
- | LitT TyLit
- | WildCardT
- data TyVarBndr
- data TyLit
- type Kind = Type
- type Cxt = [Pred]
- type Pred = Type
- data Role
- data FamilyResultSig
- data InjectivityAnn = InjectivityAnn Name [Name]
- type InfoQ = Q Info
- type ExpQ = Q Exp
- type DecQ = Q Dec
- type DecsQ = Q [Dec]
- type ConQ = Q Con
- type TypeQ = Q Type
- type TyLitQ = Q TyLit
- type CxtQ = Q Cxt
- type PredQ = Q Pred
- 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 BangTypeQ = Q BangType
- type VarBangTypeQ = Q VarBangType
- type StrictTypeQ = Q StrictType
- type VarStrictTypeQ = Q VarStrictType
- type PatQ = Q Pat
- type FieldPatQ = Q FieldPat
- type RuleBndrQ = Q RuleBndr
- type TySynEqnQ = Q TySynEqn
- intPrimL :: Integer -> Lit
- wordPrimL :: Integer -> Lit
- floatPrimL :: Rational -> Lit
- doublePrimL :: Rational -> Lit
- integerL :: Integer -> Lit
- rationalL :: Rational -> Lit
- charL :: Char -> Lit
- stringL :: String -> Lit
- stringPrimL :: [Word8] -> Lit
- charPrimL :: Char -> Lit
- litP :: Lit -> PatQ
- varP :: Name -> PatQ
- tupP :: [PatQ] -> PatQ
- conP :: Name -> [PatQ] -> PatQ
- uInfixP :: PatQ -> Name -> PatQ -> PatQ
- parensP :: PatQ -> PatQ
- infixP :: PatQ -> Name -> PatQ -> PatQ
- tildeP :: PatQ -> PatQ
- bangP :: PatQ -> PatQ
- asP :: Name -> PatQ -> PatQ
- wildP :: PatQ
- recP :: Name -> [FieldPatQ] -> PatQ
- listP :: [PatQ] -> PatQ
- sigP :: PatQ -> TypeQ -> PatQ
- viewP :: ExpQ -> PatQ -> PatQ
- fieldPat :: Name -> PatQ -> FieldPatQ
- normalB :: ExpQ -> BodyQ
- guardedB :: [Q (Guard, Exp)] -> BodyQ
- normalG :: ExpQ -> GuardQ
- normalGE :: ExpQ -> ExpQ -> Q (Guard, Exp)
- patG :: [StmtQ] -> GuardQ
- patGE :: [StmtQ] -> ExpQ -> Q (Guard, Exp)
- match :: PatQ -> BodyQ -> [DecQ] -> MatchQ
- clause :: [PatQ] -> BodyQ -> [DecQ] -> ClauseQ
- dyn :: String -> ExpQ
- varE :: Name -> ExpQ
- conE :: Name -> ExpQ
- litE :: Lit -> ExpQ
- appE :: ExpQ -> ExpQ -> ExpQ
- uInfixE :: ExpQ -> ExpQ -> ExpQ -> ExpQ
- parensE :: ExpQ -> ExpQ
- staticE :: ExpQ -> ExpQ
- infixE :: Maybe ExpQ -> ExpQ -> Maybe ExpQ -> ExpQ
- infixApp :: ExpQ -> ExpQ -> ExpQ -> ExpQ
- sectionL :: ExpQ -> ExpQ -> ExpQ
- sectionR :: ExpQ -> ExpQ -> ExpQ
- lamE :: [PatQ] -> ExpQ -> ExpQ
- lam1E :: PatQ -> ExpQ -> ExpQ
- lamCaseE :: [MatchQ] -> ExpQ
- tupE :: [ExpQ] -> ExpQ
- condE :: ExpQ -> ExpQ -> ExpQ -> ExpQ
- multiIfE :: [Q (Guard, Exp)] -> ExpQ
- letE :: [DecQ] -> ExpQ -> ExpQ
- caseE :: ExpQ -> [MatchQ] -> ExpQ
- appsE :: [ExpQ] -> ExpQ
- listE :: [ExpQ] -> ExpQ
- sigE :: ExpQ -> TypeQ -> ExpQ
- recConE :: Name -> [Q (Name, Exp)] -> ExpQ
- recUpdE :: ExpQ -> [Q (Name, Exp)] -> ExpQ
- stringE :: String -> ExpQ
- fieldExp :: Name -> ExpQ -> Q (Name, Exp)
- fromE :: ExpQ -> ExpQ
- fromThenE :: ExpQ -> ExpQ -> ExpQ
- fromToE :: ExpQ -> ExpQ -> ExpQ
- fromThenToE :: ExpQ -> ExpQ -> ExpQ -> ExpQ
- arithSeqE :: RangeQ -> ExpQ
- fromR :: ExpQ -> RangeQ
- fromThenR :: ExpQ -> ExpQ -> RangeQ
- fromToR :: ExpQ -> ExpQ -> RangeQ
- fromThenToR :: ExpQ -> ExpQ -> ExpQ -> RangeQ
- doE :: [StmtQ] -> ExpQ
- compE :: [StmtQ] -> ExpQ
- bindS :: PatQ -> ExpQ -> StmtQ
- letS :: [DecQ] -> StmtQ
- noBindS :: ExpQ -> StmtQ
- parS :: [[StmtQ]] -> StmtQ
- forallT :: [TyVarBndr] -> CxtQ -> TypeQ -> TypeQ
- varT :: Name -> TypeQ
- conT :: Name -> TypeQ
- appT :: TypeQ -> TypeQ -> TypeQ
- arrowT :: TypeQ
- infixT :: TypeQ -> Name -> TypeQ -> TypeQ
- uInfixT :: TypeQ -> Name -> TypeQ -> TypeQ
- parensT :: TypeQ -> TypeQ
- equalityT :: TypeQ
- listT :: TypeQ
- tupleT :: Int -> TypeQ
- sigT :: TypeQ -> Kind -> TypeQ
- litT :: TyLitQ -> TypeQ
- promotedT :: Name -> TypeQ
- promotedTupleT :: Int -> TypeQ
- promotedNilT :: TypeQ
- promotedConsT :: TypeQ
- numTyLit :: Integer -> TyLitQ
- strTyLit :: String -> TyLitQ
- noSourceUnpackedness :: SourceUnpackednessQ
- sourceNoUnpack :: SourceUnpackednessQ
- sourceUnpack :: SourceUnpackednessQ
- noSourceStrictness :: SourceStrictnessQ
- sourceLazy :: SourceStrictnessQ
- sourceStrict :: SourceStrictnessQ
- isStrict :: Q Strict
- notStrict :: Q Strict
- unpacked :: Q Strict
- bang :: SourceUnpackednessQ -> SourceStrictnessQ -> BangQ
- bangType :: BangQ -> TypeQ -> BangTypeQ
- varBangType :: Name -> BangTypeQ -> VarBangTypeQ
- strictType :: Q Strict -> TypeQ -> StrictTypeQ
- varStrictType :: Name -> StrictTypeQ -> VarStrictTypeQ
- cxt :: [PredQ] -> CxtQ
- classP :: Name -> [Q Type] -> Q Pred
- equalP :: TypeQ -> TypeQ -> PredQ
- normalC :: Name -> [BangTypeQ] -> ConQ
- recC :: Name -> [VarBangTypeQ] -> ConQ
- infixC :: Q (Bang, Type) -> Name -> Q (Bang, Type) -> ConQ
- forallC :: [TyVarBndr] -> CxtQ -> ConQ -> ConQ
- gadtC :: [Name] -> [StrictTypeQ] -> TypeQ -> ConQ
- recGadtC :: [Name] -> [VarStrictTypeQ] -> TypeQ -> ConQ
- varK :: Name -> Kind
- conK :: Name -> Kind
- tupleK :: Int -> Kind
- arrowK :: Kind
- listK :: Kind
- appK :: Kind -> Kind -> Kind
- starK :: Kind
- constraintK :: Kind
- nominalR :: Role
- representationalR :: Role
- phantomR :: Role
- inferR :: Role
- valD :: PatQ -> BodyQ -> [DecQ] -> DecQ
- funD :: Name -> [ClauseQ] -> DecQ
- tySynD :: Name -> [TyVarBndr] -> TypeQ -> DecQ
- dataD :: CxtQ -> Name -> [TyVarBndr] -> Maybe Kind -> [ConQ] -> CxtQ -> DecQ
- newtypeD :: CxtQ -> Name -> [TyVarBndr] -> Maybe Kind -> ConQ -> CxtQ -> DecQ
- classD :: CxtQ -> Name -> [TyVarBndr] -> [FunDep] -> [DecQ] -> DecQ
- instanceD :: CxtQ -> TypeQ -> [DecQ] -> DecQ
- instanceWithOverlapD :: Maybe Overlap -> CxtQ -> TypeQ -> [DecQ] -> DecQ
- data Overlap
- sigD :: Name -> TypeQ -> DecQ
- standaloneDerivD :: CxtQ -> TypeQ -> DecQ
- defaultSigD :: Name -> TypeQ -> DecQ
- roleAnnotD :: Name -> [Role] -> DecQ
- dataFamilyD :: Name -> [TyVarBndr] -> Maybe Kind -> DecQ
- openTypeFamilyD :: Name -> [TyVarBndr] -> FamilyResultSig -> Maybe InjectivityAnn -> DecQ
- closedTypeFamilyD :: Name -> [TyVarBndr] -> FamilyResultSig -> Maybe InjectivityAnn -> [TySynEqnQ] -> DecQ
- dataInstD :: CxtQ -> Name -> [TypeQ] -> Maybe Kind -> [ConQ] -> CxtQ -> DecQ
- familyNoKindD :: FamFlavour -> Name -> [TyVarBndr] -> DecQ
- familyKindD :: FamFlavour -> Name -> [TyVarBndr] -> Kind -> DecQ
- closedTypeFamilyNoKindD :: Name -> [TyVarBndr] -> [TySynEqnQ] -> DecQ
- closedTypeFamilyKindD :: Name -> [TyVarBndr] -> Kind -> [TySynEqnQ] -> DecQ
- newtypeInstD :: CxtQ -> Name -> [TypeQ] -> Maybe Kind -> ConQ -> CxtQ -> DecQ
- tySynInstD :: Name -> TySynEqnQ -> DecQ
- typeFam :: FamFlavour
- dataFam :: FamFlavour
- tySynEqn :: [TypeQ] -> TypeQ -> TySynEqnQ
- injectivityAnn :: Name -> [Name] -> InjectivityAnn
- noSig :: FamilyResultSig
- kindSig :: Kind -> FamilyResultSig
- tyVarSig :: TyVarBndr -> FamilyResultSig
- cCall :: Callconv
- stdCall :: Callconv
- cApi :: Callconv
- prim :: Callconv
- javaScript :: Callconv
- unsafe :: Safety
- safe :: Safety
- forImpD :: Callconv -> Safety -> String -> Name -> TypeQ -> DecQ
- ruleVar :: Name -> RuleBndrQ
- typedRuleVar :: Name -> TypeQ -> RuleBndrQ
- pragInlD :: Name -> Inline -> RuleMatch -> Phases -> DecQ
- pragSpecD :: Name -> TypeQ -> Phases -> DecQ
- pragSpecInlD :: Name -> TypeQ -> Inline -> Phases -> DecQ
- pragSpecInstD :: TypeQ -> DecQ
- pragRuleD :: String -> [RuleBndrQ] -> ExpQ -> ExpQ -> Phases -> DecQ
- pragAnnD :: AnnTarget -> ExpQ -> DecQ
- pragLineD :: Int -> String -> DecQ
- class Ppr a where
- pprint :: Ppr a => a -> String
- pprExp :: Precedence -> Exp -> Doc
- pprLit :: Precedence -> Lit -> Doc
- pprPat :: Precedence -> Pat -> Doc
- pprParendType :: Type -> Doc
The monad and its operations
Administration: errors, locations and IO
reportError :: String -> Q () #
Report an error to the user, but allow the current splice's computation to carry on. To abort the computation, use fail.
reportWarning :: String -> Q () #
Report a warning to the user, and carry on.
report :: Bool -> String -> Q () #
Deprecated: Use reportError or reportWarning instead
Report an error (True) or warning (False),
but carry on; use fail to stop.
Recover from errors raised by reportError or fail.
Constructors
| Loc | |
Fields
| |
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.
Querying the compiler
Reify
reify looks up information about the Name.
It is sometimes useful to construct the argument name using lookupTypeName or lookupValueName
to ensure that we are reifying from the right namespace. For instance, in this context:
data D = D
which D does reify (mkName "D") return information about? (Answer: D-the-type, but don't rely on it.)
To ensure we get information about D-the-value, use lookupValueName:
do Just nm <- lookupValueName "D" reify nm
and to get information about D-the-type, use lookupTypeName.
reifyModule :: Module -> Q ModuleInfo #
reifyModule mod looks up information about module mod. To
look up the current module, call this function with the return
value of thisModule.
thisModule :: Q Module #
Return the Module at the place of splicing. Can be used as an
input for reifyModule.
Constructors
| ClassI Dec [InstanceDec] | A class, with a list of its visible instances |
| ClassOpI Name Type ParentName | A class method |
| TyConI Dec | A "plain" type constructor. "Fancier" type constructors are returned using |
| FamilyI Dec [InstanceDec] | A type or data family, with a list of its visible instances. A closed type family is returned with 0 instances. |
| PrimTyConI Name Arity Unlifted | A "primitive" type constructor, which can't be expressed with a |
| DataConI Name Type ParentName | A data constructor |
| VarI Name Type (Maybe Dec) | A "value" variable (as opposed to a type variable, see The |
| TyVarI Name Type | A type variable. The |
data ModuleInfo #
Obtained from reifyModule in the Q Monad.
Constructors
| ModuleInfo [Module] | Contains the import list of the module. |
Instances
type InstanceDec = Dec #
InstanceDec desribes a single instance of a class or type function.
It is just a Dec, but guaranteed to be one of the following:
InstanceD(with empty[)Dec]DataInstDorNewtypeInstD(with empty derived[)Name]TySynInstD
type ParentName = Name #
In PrimTyConI, arity of the type constructor
In PrimTyConI, is the type constructor unlifted?
Language extension lookup
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.
Constructors
extsEnabled :: Q [Extension] #
List all enabled language extensions.
isExtEnabled :: Extension -> Q Bool #
Determine whether the given language extension is enabled in the Q monad.
Name lookup
lookupTypeName :: String -> Q (Maybe Name) #
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 (Maybe Name) #
Look up the given name in the (value namespace of the) current splice's scope. See Language.Haskell.TH.Syntax for more details.
Fixity lookup
reifyFixity :: Name -> Q (Maybe Fixity) #
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.
Instance lookup
reifyInstances :: Name -> [Type] -> Q [InstanceDec] #
reifyInstances nm tys returns a list of visible instances of nm tys. That is,
if nm is the name of a type class, then all instances of this class at the types tys
are returned. Alternatively, if nm is the name of a data family or type family,
all instances of this family at the types tys are returned.
isInstance :: Name -> [Type] -> Q Bool #
Is the list of instances returned by reifyInstances nonempty?
Roles lookup
reifyRoles :: Name -> Q [Role] #
reifyRoles nm returns the list of roles associated with the parameters of
the tycon nm. Fails if nm cannot be found or is not a tycon.
The returned list should never contain InferR.
Annotation lookup
reifyAnnotations :: Data a => AnnLookup -> Q [a] #
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.
Annotation target for reifyAnnotations
Constructors
| AnnLookupModule Module | |
| AnnLookupName Name |
Constructor strictness lookup
reifyConStrictness :: Name -> Q [DecidedStrictness] #
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.
Typed expressions
Names
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.
Constructing names
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") |]
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.
Deconstructing names
The name without its module prefix.
Examples
>>>nameBase ''Data.Either.Either"Either">>>nameBase (mkName "foo")"foo">>>nameBase (mkName "Module.foo")"foo"
nameModule :: Name -> Maybe String #
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 -> Maybe String #
A name's package, if it exists.
Examples
>>>namePackage ''Data.Either.EitherJust "base">>>namePackage (mkName "foo")Nothing>>>namePackage (mkName "Module.foo")Nothing
nameSpace :: Name -> Maybe NameSpace #
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
Built-in names
tupleTypeName :: Int -> Name #
Tuple type constructor
tupleDataName :: Int -> Name #
Tuple data constructor
unboxedTupleTypeName :: Int -> Name #
Unboxed tuple type constructor
unboxedTupleDataName :: Int -> Name #
Unboxed tuple data constructor
The algebraic data types
The lowercase versions (syntax operators) of these constructors are
preferred to these constructors, since they compose better with
quotations ([| |]) and splices ($( ... ))
Declarations
Constructors
| FunD Name [Clause] | { f p1 p2 = b where decs } |
| ValD Pat Body [Dec] | { p = b where decs } |
| DataD Cxt Name [TyVarBndr] (Maybe Kind) [Con] Cxt | { data Cxt x => T x = A x | B (T x)
deriving (Z,W)} |
| NewtypeD Cxt Name [TyVarBndr] (Maybe Kind) Con Cxt | { newtype Cxt x => T x = A (B x)
deriving (Z,W Q)} |
| TySynD Name [TyVarBndr] Type | { type T x = (x,x) } |
| ClassD Cxt Name [TyVarBndr] [FunDep] [Dec] | { class Eq a => Ord a where ds } |
| InstanceD (Maybe Overlap) Cxt Type [Dec] | { instance {-# OVERLAPS #-}
Show w => Show [w] where ds } |
| SigD Name Type | { length :: [a] -> Int } |
| ForeignD Foreign | { foreign import ... }
{ foreign export ... } |
| InfixD Fixity Name | { infix 3 foo } |
| PragmaD Pragma | { {-# INLINE [1] foo #-} } |
| DataFamilyD Name [TyVarBndr] (Maybe Kind) | { data family T a b c :: * } |
| DataInstD Cxt Name [Type] (Maybe Kind) [Con] Cxt | { data instance Cxt x => T [x]
= A x | B (T x) deriving (Z,W)} |
| NewtypeInstD Cxt Name [Type] (Maybe Kind) Con Cxt | { newtype instance Cxt x => T [x]
= A (B x) deriving (Z,W)} |
| TySynInstD Name TySynEqn | { type instance ... } |
| OpenTypeFamilyD TypeFamilyHead | { type family T a b c = (r :: *) | r -> a b } |
| ClosedTypeFamilyD TypeFamilyHead [TySynEqn] | { type family F a b = (r :: *) | r -> a where ... } |
| RoleAnnotD Name [Role] | { type role T nominal representational } |
| StandaloneDerivD Cxt Type | { deriving instance Ord a => Ord (Foo a) } |
| DefaultSigD Name Type | { default size :: Data a => a -> Int } |
data SourceUnpackedness #
Constructors
| NoSourceUnpackedness | C a |
| SourceNoUnpack | C { {-# NOUNPACK #-} } a |
| SourceUnpack | C { {-# UNPACK #-} } a |
data SourceStrictness #
Constructors
| NoSourceStrictness | C a |
| SourceLazy | C {~}a |
| SourceStrict | C {!}a |
data DecidedStrictness #
Unlike SourceStrictness and SourceUnpackedness, DecidedStrictness
refers to the strictness that the compiler chooses for a data constructor
field, which may be different from what is written in source code. See
reifyConStrictness for more information.
Constructors
| DecidedLazy | |
| DecidedStrict | |
| DecidedUnpack |
Constructors
| Bang SourceUnpackedness SourceStrictness | C { {-# UNPACK #-} !}a |
Constructors
| CCall | |
| StdCall | |
| CApi | |
| Prim | |
| JavaScript |
Constructors
| Unsafe | |
| Safe | |
| Interruptible |
Constructors
| AllPhases | |
| FromPhase Int | |
| BeforePhase Int |
Constructors
| RuleVar Name | |
| TypedRuleVar Name Type |
Constructors
| ModuleAnnotation | |
| TypeAnnotation Name | |
| ValueAnnotation Name |
data FamFlavour #
Instances
One equation of a type family instance or closed type family. The arguments are the left-hand-side type patterns and the right-hand-side result.
data TypeFamilyHead #
Common elements of OpenTypeFamilyD and ClosedTypeFamilyD.
By analogy with 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
| TypeFamilyHead Name [TyVarBndr] FamilyResultSig (Maybe InjectivityAnn) |
Instances
Constructors
| Fixity Int FixityDirection |
data FixityDirection #
Instances
defaultFixity :: Fixity #
Default fixity: infixl 9
maxPrecedence :: Int #
Highest allowed operator precedence for Fixity constructor (answer: 9)
Expressions
Constructors
| VarE Name | { x } |
| ConE Name | data T1 = C1 t1 t2; p = {C1} e1 e2 |
| LitE Lit | { 5 or 'c'} |
| AppE Exp Exp | { f x } |
| InfixE (Maybe Exp) Exp (Maybe Exp) | {x + y} or {(x+)} or {(+ x)} or {(+)} |
| UInfixE Exp Exp Exp | {x + y} |
| ParensE Exp | { (e) } |
| LamE [Pat] Exp | { \ p1 p2 -> e } |
| LamCaseE [Match] | { \case m1; m2 } |
| TupE [Exp] | { (e1,e2) } |
| UnboxedTupE [Exp] | { (# e1,e2 #) } |
| CondE Exp Exp Exp | { if e1 then e2 else e3 } |
| MultiIfE [(Guard, Exp)] | { if | g1 -> e1 | g2 -> e2 } |
| LetE [Dec] Exp | { let x=e1; y=e2 in e3 } |
| CaseE Exp [Match] | { case e of m1; m2 } |
| DoE [Stmt] | { do { p <- e1; e2 } } |
| 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))] |
| ArithSeqE Range | { [ 1 ,2 .. 10 ] } |
| ListE [Exp] | { [1,2,3] } |
| SigE Exp Type | { e :: t } |
| RecConE Name [FieldExp] | { T { x = y, z = w } } |
| RecUpdE Exp [FieldExp] | { (f x) { z = w } } |
| StaticE Exp | { static e } |
| UnboundVarE Name |
|
Constructors
| CharL Char | |
| StringL String | |
| IntegerL Integer | Used for overloaded and non-overloaded literals. We don't have a good way to represent non-overloaded literals at the moment. Maybe that doesn't matter? |
| RationalL Rational | |
| IntPrimL Integer | |
| WordPrimL Integer | |
| FloatPrimL Rational | |
| DoublePrimL Rational | |
| StringPrimL [Word8] | A primitive C-style string, type Addr# |
| CharPrimL Char |
Patterns
Pattern in Haskell given in {}
Constructors
| LitP Lit | { 5 or 'c' } |
| VarP Name | { x } |
| TupP [Pat] | { (p1,p2) } |
| UnboxedTupP [Pat] | { (# p1,p2 #) } |
| ConP Name [Pat] | data T1 = C1 t1 t2; {C1 p1 p1} = e |
| InfixP Pat Name Pat | foo ({x :+ y}) = e |
| UInfixP Pat Name Pat | foo ({x :+ y}) = e |
| ParensP Pat | {(p)} |
| TildeP Pat | { ~p } |
| BangP Pat | { !p } |
| AsP Name Pat | { x @ p } |
| WildP | { _ } |
| RecP Name [FieldPat] | f (Pt { pointx = x }) = g x |
| ListP [Pat] | { [1,2,3] } |
| SigP Pat Type | { p :: t } |
| ViewP Exp Pat | { e -> p } |
Types
Constructors
| ForallT [TyVarBndr] Cxt Type | forall <vars>. <ctxt> -> <type> |
| AppT Type Type | T a b |
| SigT Type Kind | t :: k |
| VarT Name | a |
| ConT Name | T |
| PromotedT Name | 'T |
| InfixT Type Name Type | T + T |
| UInfixT Type Name Type | T + T |
| ParensT Type | (T) |
| TupleT Int | (,), (,,), etc. |
| UnboxedTupleT Int | (#,#), (#,,#), etc. |
| ArrowT | -> |
| EqualityT | ~ |
| ListT | [] |
| PromotedTupleT Int | '(), '(,), '(,,), etc. |
| PromotedNilT | '[] |
| PromotedConsT | (':) |
| StarT | * |
| ConstraintT | Constraint |
| LitT TyLit | 0,1,2, etc. |
| WildCardT | @_, |
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 | _ |
Library functions
Abbreviations
type SourceStrictnessQ = Q SourceStrictness #
type SourceUnpackednessQ = Q SourceUnpackedness #
type VarBangTypeQ = Q VarBangType #
type StrictTypeQ = Q StrictType #
type VarStrictTypeQ = Q VarStrictType #
Constructors lifted to Q
Literals
floatPrimL :: Rational -> Lit #
doublePrimL :: Rational -> Lit #
stringPrimL :: [Word8] -> Lit #
Patterns
Pattern Guards
Expressions
Ranges
Ranges with more indirection
Statements
Types
promotedTupleT :: Int -> TypeQ #
promotedNilT :: TypeQ #
promotedConsT :: TypeQ #
Type literals
Strictness
Deprecated: Use bang. See https://ghc.haskell.org/trac/ghc/wiki/Migration/8.0. Example usage: 'bang noSourceUnpackedness sourceStrict'
Deprecated: Use bang. See https://ghc.haskell.org/trac/ghc/wiki/Migration/8.0. Example usage: 'bang noSourceUnpackedness noSourceStrictness'
Deprecated: Use bang. See https://ghc.haskell.org/trac/ghc/wiki/Migration/8.0. Example usage: 'bang sourceUnpack sourceStrict'
bang :: SourceUnpackednessQ -> SourceStrictnessQ -> BangQ #
varBangType :: Name -> BangTypeQ -> VarBangTypeQ #
strictType :: Q Strict -> TypeQ -> StrictTypeQ #
Deprecated: As of template-haskell-2.11.0.0, StrictType has been replaced by BangType. Please use bangType instead.
varStrictType :: Name -> StrictTypeQ -> VarStrictTypeQ #
Deprecated: As of template-haskell-2.11.0.0, VarStrictType has been replaced by VarBangType. Please use varBangType instead.
Class Contexts
equalP :: TypeQ -> TypeQ -> PredQ #
Deprecated: As of template-haskell-2.10, constraint predicates (Pred) are just types (Type), in keeping with ConstraintKinds. Please see equalityT.
Constructors
recC :: Name -> [VarBangTypeQ] -> ConQ #
Kinds
constraintK :: Kind #
Roles
Top Level Declarations
Data
Class
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 |
standaloneDerivD :: CxtQ -> TypeQ -> DecQ #
defaultSigD :: Name -> TypeQ -> DecQ #
Role annotations
roleAnnotD :: Name -> [Role] -> DecQ #
Type Family / Data Family
openTypeFamilyD :: Name -> [TyVarBndr] -> FamilyResultSig -> Maybe InjectivityAnn -> DecQ #
closedTypeFamilyD :: Name -> [TyVarBndr] -> FamilyResultSig -> Maybe InjectivityAnn -> [TySynEqnQ] -> DecQ #
familyNoKindD :: FamFlavour -> Name -> [TyVarBndr] -> DecQ #
Deprecated: This function will be removed in the next stable release. Use openTypeFamilyD/dataFamilyD instead.
familyKindD :: FamFlavour -> Name -> [TyVarBndr] -> Kind -> DecQ #
Deprecated: This function will be removed in the next stable release. Use openTypeFamilyD/dataFamilyD instead.
closedTypeFamilyNoKindD :: Name -> [TyVarBndr] -> [TySynEqnQ] -> DecQ #
Deprecated: This function will be removed in the next stable release. Use closedTypeFamilyD instead.
closedTypeFamilyKindD :: Name -> [TyVarBndr] -> Kind -> [TySynEqnQ] -> DecQ #
Deprecated: This function will be removed in the next stable release. Use closedTypeFamilyD instead.
tySynInstD :: Name -> TySynEqnQ -> DecQ #
typeFam :: FamFlavour #
dataFam :: FamFlavour #
injectivityAnn :: Name -> [Name] -> InjectivityAnn #
kindSig :: Kind -> FamilyResultSig #
tyVarSig :: TyVarBndr -> FamilyResultSig #
Foreign Function Interface (FFI)
javaScript :: Callconv #
Pragmas
typedRuleVar :: Name -> TypeQ -> RuleBndrQ #
pragSpecInstD :: TypeQ -> DecQ #
Pretty-printer
Minimal complete definition
Instances
| Ppr Exp # | |
| Ppr Match # | |
| Ppr Clause # | |
| Ppr Pat # | |
| Ppr Type # | |
| Ppr Dec # | |
| Ppr Name # | |
| Ppr FunDep # | |
| Ppr TyVarBndr # | |
| Ppr InjectivityAnn # | |
| Ppr Role # | |
| Ppr TyLit # | |
| Ppr FamilyResultSig # | |
| Ppr Bang # | |
| Ppr Con # | |
| Ppr DecidedStrictness # | |
| Ppr SourceStrictness # | |
| Ppr SourceUnpackedness # | |
| Ppr RuleBndr # | |
| Ppr Phases # | |
| Ppr RuleMatch # | |
| Ppr Inline # | |
| Ppr Pragma # | |
| Ppr Foreign # | |
| Ppr FamFlavour # | |
| Ppr Range # | |
| Ppr Stmt # | |
| Ppr Lit # | |
| Ppr ModuleInfo # | |
| Ppr Info # | |
| Ppr Loc # | |
| Ppr Module # | |
| Ppr a => Ppr [a] # | |
pprExp :: Precedence -> Exp -> Doc #
pprLit :: Precedence -> Lit -> Doc #
pprPat :: Precedence -> Pat -> Doc #
pprParendType :: Type -> Doc #