Safe Haskell | Safe |
---|---|
Language | Haskell2010 |
The public face of Template Haskell
For other documentation, refer to: http://www.haskell.org/haskellwiki/Template_Haskell
Synopsis
- data Q a
- runQ :: Quasi m => Q a -> m a
- class Monad m => Quote m where
- 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
- data Info
- data ModuleInfo = ModuleInfo [Module]
- type InstanceDec = Dec
- type ParentName = Name
- type SumAlt = Int
- type SumArity = Int
- 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
- | QualifiedDo
- | QuasiQuotes
- | ImplicitParams
- | ImplicitPrelude
- | ScopedTypeVariables
- | AllowAmbiguousTypes
- | UnboxedTuples
- | UnboxedSums
- | UnliftedNewtypes
- | BangPatterns
- | TypeFamilies
- | TypeFamilyDependencies
- | TypeInType
- | OverloadedStrings
- | OverloadedLists
- | NumDecimals
- | DisambiguateRecordFields
- | RecordWildCards
- | RecordPuns
- | ViewPatterns
- | GADTs
- | GADTSyntax
- | NPlusKPatterns
- | DoAndIfThenElse
- | BlockArguments
- | RebindableSyntax
- | ConstraintKinds
- | PolyKinds
- | DataKinds
- | InstanceSigs
- | ApplicativeDo
- | LinearTypes
- | StandaloneDeriving
- | DeriveDataTypeable
- | AutoDeriveTypeable
- | DeriveFunctor
- | DeriveTraversable
- | DeriveFoldable
- | DeriveGeneric
- | DefaultSignatures
- | DeriveAnyClass
- | DeriveLift
- | DerivingStrategies
- | DerivingVia
- | TypeSynonymInstances
- | FlexibleContexts
- | FlexibleInstances
- | ConstrainedClassMethods
- | MultiParamTypeClasses
- | NullaryTypeClasses
- | FunctionalDependencies
- | UnicodeSyntax
- | ExistentialQuantification
- | MagicHash
- | EmptyDataDecls
- | KindSignatures
- | RoleAnnotations
- | ParallelListComp
- | TransformListComp
- | MonadComprehensions
- | GeneralizedNewtypeDeriving
- | RecursiveDo
- | PostfixOperators
- | TupleSections
- | PatternGuards
- | LiberalTypeSynonyms
- | RankNTypes
- | ImpredicativeTypes
- | TypeOperators
- | ExplicitNamespaces
- | PackageImports
- | ExplicitForAll
- | AlternativeLayoutRule
- | AlternativeLayoutRuleTransitional
- | DatatypeContexts
- | NondecreasingIndentation
- | RelaxedLayout
- | TraditionalRecordSyntax
- | LambdaCase
- | MultiWayIf
- | BinaryLiterals
- | NegativeLiterals
- | HexFloatLiterals
- | DuplicateRecordFields
- | OverloadedLabels
- | EmptyCase
- | PatternSynonyms
- | PartialTypeSignatures
- | NamedWildCards
- | StaticPointers
- | TypeApplications
- | Strict
- | StrictData
- | MonadFailDesugaring
- | EmptyDataDeriving
- | NumericUnderscores
- | QuantifiedConstraints
- | StarIsType
- | ImportQualifiedPost
- | CUSKs
- | StandaloneKindSignatures
- | LexicalNegation
- extsEnabled :: Q [Extension]
- isExtEnabled :: Extension -> Q Bool
- lookupTypeName :: String -> Q (Maybe Name)
- lookupValueName :: String -> Q (Maybe Name)
- reifyFixity :: Name -> Q (Maybe Fixity)
- reifyType :: Name -> Q Type
- 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 :: TYPE (r :: RuntimeRep))
- unType :: TExp a -> Exp
- newtype Code m (a :: TYPE (r :: RuntimeRep)) = Code {
- examineCode :: m (TExp a)
- 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
- data Name
- data NameSpace
- mkName :: String -> 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
- unboxedSumTypeName :: SumArity -> Name
- unboxedSumDataName :: SumAlt -> SumArity -> Name
- data Dec
- = FunD Name [Clause]
- | ValD Pat Body [Dec]
- | DataD Cxt Name [TyVarBndr ()] (Maybe Kind) [Con] [DerivClause]
- | NewtypeD Cxt Name [TyVarBndr ()] (Maybe Kind) Con [DerivClause]
- | TySynD Name [TyVarBndr ()] Type
- | ClassD Cxt Name [TyVarBndr ()] [FunDep] [Dec]
- | InstanceD (Maybe Overlap) Cxt Type [Dec]
- | SigD Name Type
- | KiSigD Name Kind
- | ForeignD Foreign
- | InfixD Fixity Name
- | PragmaD Pragma
- | DataFamilyD Name [TyVarBndr ()] (Maybe Kind)
- | DataInstD Cxt (Maybe [TyVarBndr ()]) Type (Maybe Kind) [Con] [DerivClause]
- | NewtypeInstD Cxt (Maybe [TyVarBndr ()]) Type (Maybe Kind) Con [DerivClause]
- | TySynInstD TySynEqn
- | OpenTypeFamilyD TypeFamilyHead
- | ClosedTypeFamilyD TypeFamilyHead [TySynEqn]
- | RoleAnnotD Name [Role]
- | StandaloneDerivD (Maybe DerivStrategy) Cxt Type
- | DefaultSigD Name Type
- | PatSynD Name PatSynArgs PatSynDir Pat
- | PatSynSigD Name PatSynType
- | ImplicitParamBindD String Exp
- 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 TySynEqn = TySynEqn (Maybe [TyVarBndr ()]) Type Type
- data TypeFamilyHead = TypeFamilyHead Name [TyVarBndr ()] FamilyResultSig (Maybe InjectivityAnn)
- data Fixity = Fixity Int FixityDirection
- data FixityDirection
- defaultFixity :: Fixity
- maxPrecedence :: Int
- data PatSynDir
- data PatSynArgs
- = PrefixPatSyn [Name]
- | InfixPatSyn Name Name
- | RecordPatSyn [Name]
- data Exp
- = VarE Name
- | ConE Name
- | LitE Lit
- | AppE Exp Exp
- | AppTypeE Exp Type
- | InfixE (Maybe Exp) Exp (Maybe Exp)
- | UInfixE Exp Exp Exp
- | ParensE Exp
- | LamE [Pat] Exp
- | LamCaseE [Match]
- | TupE [Maybe Exp]
- | UnboxedTupE [Maybe Exp]
- | UnboxedSumE Exp SumAlt SumArity
- | CondE Exp Exp Exp
- | MultiIfE [(Guard, Exp)]
- | LetE [Dec] Exp
- | CaseE Exp [Match]
- | DoE (Maybe ModName) [Stmt]
- | MDoE (Maybe ModName) [Stmt]
- | CompE [Stmt]
- | ArithSeqE Range
- | ListE [Exp]
- | SigE Exp Type
- | RecConE Name [FieldExp]
- | RecUpdE Exp [FieldExp]
- | StaticE Exp
- | UnboundVarE Name
- | LabelE String
- | ImplicitParamVarE String
- 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 Specificity] Cxt Type
- | ForallVisT [TyVarBndr ()] Type
- | AppT Type Type
- | AppKindT Type Kind
- | SigT Type Kind
- | VarT Name
- | ConT Name
- | PromotedT Name
- | InfixT Type Name Type
- | UInfixT Type Name Type
- | ParensT Type
- | TupleT Int
- | UnboxedTupleT Int
- | UnboxedSumT SumArity
- | ArrowT
- | MulArrowT
- | EqualityT
- | ListT
- | PromotedTupleT Int
- | PromotedNilT
- | PromotedConsT
- | StarT
- | ConstraintT
- | LitT TyLit
- | WildCardT
- | ImplicitParamT String Type
- data TyVarBndr flag
- data TyLit
- type Kind = Type
- type Cxt = [Pred]
- type Pred = Type
- data Role
- data Specificity
- data FamilyResultSig
- data InjectivityAnn = InjectivityAnn Name [Name]
- type PatSynType = Type
- type BangType = (Bang, Type)
- type VarBangType = (Name, Bang, Type)
- module Language.Haskell.TH.Lib
- 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
Instances
class Monad m => Quote m where Source #
The Quote
class implements the minimal interface which is necessary for
desugaring quotations.
- The
Monad m
superclass is needed to stitch together the different AST fragments. newName
is 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
.
newName :: String -> m Name Source #
Generate a fresh name, which cannot be captured.
For example, this:
f = $(do nm1 <- newName "x" let nm2 =mkName
"x" return (LamE
[VarP
nm1] (LamE [VarP nm2] (VarE
nm1))) )
will produce the splice
f = \x0 -> \x -> x0
In particular, the occurrence VarE nm1
refers to the binding VarP nm1
,
and is not captured by the binding VarP nm2
.
Although names generated by newName
cannot be captured, they can
capture other names. For example, this:
g = $(do nm1 <- newName "x" let nm2 = mkName "x" return (LamE [VarP nm2] (LamE [VarP nm1] (VarE nm2))) )
will produce the splice
g = \x -> \x0 -> x0
since the occurrence VarE nm2
is captured by the innermost binding
of x
, namely VarP nm1
.
Administration: errors, locations and IO
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
.
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.
Recover from errors raised by reportError
or fail
.
Loc | |
|
Instances
Eq Loc # | |
Data Loc # | |
Defined in Language.Haskell.TH.Syntax gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Loc -> c Loc Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Loc Source # toConstr :: Loc -> Constr Source # dataTypeOf :: Loc -> DataType Source # 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 -> Loc Source # 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 Loc Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Loc -> m Loc Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Loc -> m Loc Source # | |
Ord Loc # | |
Show Loc # | |
Generic Loc # | |
Ppr Loc # | |
type Rep Loc # | |
Defined in Language.Haskell.TH.Syntax type Rep Loc = D1 ('MetaData "Loc" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "Loc" 'PrefixI 'True) ((S1 ('MetaSel ('Just "loc_filename") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String) :*: S1 ('MetaSel ('Just "loc_package") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String)) :*: (S1 ('MetaSel ('Just "loc_module") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String) :*: (S1 ('MetaSel ('Just "loc_start") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 CharPos) :*: S1 ('MetaSel ('Just "loc_end") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 CharPos))))) |
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 :: Name -> Q Info Source #
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 Source #
reifyModule mod
looks up information about module mod
. To
look up the current module, call this function with the return
value of thisModule
.
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 |
PatSynI Name PatSynType | A pattern synonym |
VarI Name Type (Maybe Dec) | A "value" variable (as opposed to a type variable, see The |
TyVarI Name Type | A type variable. The |
Instances
data ModuleInfo Source #
Obtained from reifyModule
in the Q
Monad.
ModuleInfo [Module] | Contains the import list of the module. |
Instances
type InstanceDec = Dec Source #
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
]DataInstD
orNewtypeInstD
(with empty derived[
)Name
]TySynInstD
In UnboxedSumE
and UnboxedSumP
, the number associated with a
particular data constructor. SumAlt
s are one-indexed and should never
exceed the value of its corresponding SumArity
. For example:
In UnboxedSumE
, UnboxedSumT
, and UnboxedSumP
, the total number of
SumAlt
s. For example, (#|#)
has a SumArity
of 2.
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.
Instances
Bounded Extension | |
Enum Extension | |
Defined in GHC.LanguageExtensions.Type succ :: Extension -> Extension Source # pred :: Extension -> Extension Source # toEnum :: Int -> Extension Source # fromEnum :: Extension -> Int Source # enumFrom :: Extension -> [Extension] Source # enumFromThen :: Extension -> Extension -> [Extension] Source # enumFromTo :: Extension -> Extension -> [Extension] Source # enumFromThenTo :: Extension -> Extension -> Extension -> [Extension] Source # | |
Eq Extension | |
Ord Extension | |
Defined in GHC.LanguageExtensions.Type | |
Show Extension | |
Generic Extension | |
type Rep Extension | |
Defined in GHC.LanguageExtensions.Type type Rep Extension = D1 ('MetaData "Extension" "GHC.LanguageExtensions.Type" "ghc-boot-th-9.0.1" 'False) ((((((C1 ('MetaCons "Cpp" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "OverlappingInstances" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "UndecidableInstances" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "IncoherentInstances" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "UndecidableSuperClasses" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "MonomorphismRestriction" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "MonoPatBinds" 'PrefixI 'False) (U1 :: Type -> Type)))) :+: (((C1 ('MetaCons "MonoLocalBinds" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "RelaxedPolyRec" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "ExtendedDefaultRules" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "ForeignFunctionInterface" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "UnliftedFFITypes" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "InterruptibleFFI" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "CApiFFI" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "GHCForeignImportPrim" 'PrefixI 'False) (U1 :: Type -> Type))))) :+: (((C1 ('MetaCons "JavaScriptFFI" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "ParallelArrays" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Arrows" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "TemplateHaskell" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "TemplateHaskellQuotes" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "QualifiedDo" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "QuasiQuotes" 'PrefixI 'False) (U1 :: Type -> Type)))) :+: (((C1 ('MetaCons "ImplicitParams" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "ImplicitPrelude" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "ScopedTypeVariables" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "AllowAmbiguousTypes" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "UnboxedTuples" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "UnboxedSums" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "UnliftedNewtypes" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "BangPatterns" 'PrefixI 'False) (U1 :: Type -> Type)))))) :+: ((((C1 ('MetaCons "TypeFamilies" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "TypeFamilyDependencies" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "TypeInType" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "OverloadedStrings" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "OverloadedLists" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "NumDecimals" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "DisambiguateRecordFields" 'PrefixI 'False) (U1 :: Type -> Type)))) :+: (((C1 ('MetaCons "RecordWildCards" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "RecordPuns" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "ViewPatterns" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "GADTs" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "GADTSyntax" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "NPlusKPatterns" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "DoAndIfThenElse" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "BlockArguments" 'PrefixI 'False) (U1 :: Type -> Type))))) :+: ((((C1 ('MetaCons "RebindableSyntax" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "ConstraintKinds" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "PolyKinds" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "DataKinds" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "InstanceSigs" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "ApplicativeDo" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "LinearTypes" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "StandaloneDeriving" 'PrefixI 'False) (U1 :: Type -> Type)))) :+: (((C1 ('MetaCons "DeriveDataTypeable" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "AutoDeriveTypeable" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "DeriveFunctor" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "DeriveTraversable" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "DeriveFoldable" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "DeriveGeneric" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "DefaultSignatures" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "DeriveAnyClass" 'PrefixI 'False) (U1 :: Type -> Type))))))) :+: (((((C1 ('MetaCons "DeriveLift" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "DerivingStrategies" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "DerivingVia" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "TypeSynonymInstances" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "FlexibleContexts" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "FlexibleInstances" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "ConstrainedClassMethods" 'PrefixI 'False) (U1 :: Type -> Type)))) :+: (((C1 ('MetaCons "MultiParamTypeClasses" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "NullaryTypeClasses" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "FunctionalDependencies" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "UnicodeSyntax" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "ExistentialQuantification" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "MagicHash" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "EmptyDataDecls" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "KindSignatures" 'PrefixI 'False) (U1 :: Type -> Type))))) :+: (((C1 ('MetaCons "RoleAnnotations" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "ParallelListComp" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "TransformListComp" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "MonadComprehensions" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "GeneralizedNewtypeDeriving" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "RecursiveDo" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "PostfixOperators" 'PrefixI 'False) (U1 :: Type -> Type)))) :+: (((C1 ('MetaCons "TupleSections" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "PatternGuards" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "LiberalTypeSynonyms" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "RankNTypes" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "ImpredicativeTypes" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "TypeOperators" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "ExplicitNamespaces" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "PackageImports" 'PrefixI 'False) (U1 :: Type -> Type)))))) :+: ((((C1 ('MetaCons "ExplicitForAll" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "AlternativeLayoutRule" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "AlternativeLayoutRuleTransitional" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "DatatypeContexts" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "NondecreasingIndentation" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "RelaxedLayout" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "TraditionalRecordSyntax" 'PrefixI 'False) (U1 :: Type -> Type)))) :+: (((C1 ('MetaCons "LambdaCase" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "MultiWayIf" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "BinaryLiterals" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "NegativeLiterals" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "HexFloatLiterals" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "DuplicateRecordFields" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "OverloadedLabels" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "EmptyCase" 'PrefixI 'False) (U1 :: Type -> Type))))) :+: ((((C1 ('MetaCons "PatternSynonyms" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "PartialTypeSignatures" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "NamedWildCards" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "StaticPointers" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "TypeApplications" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Strict" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "StrictData" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "MonadFailDesugaring" 'PrefixI 'False) (U1 :: Type -> Type)))) :+: (((C1 ('MetaCons "EmptyDataDeriving" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "NumericUnderscores" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "QuantifiedConstraints" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "StarIsType" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "ImportQualifiedPost" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "CUSKs" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "StandaloneKindSignatures" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "LexicalNegation" 'PrefixI 'False) (U1 :: Type -> Type)))))))) |
extsEnabled :: Q [Extension] Source #
List all enabled language extensions.
isExtEnabled :: Extension -> Q Bool Source #
Determine whether the given language extension is enabled in the Q
monad.
Name lookup
lookupTypeName :: String -> Q (Maybe Name) 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 (Maybe Name) Source #
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) 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
. If the function
Just
(Fixity
7 InfixR
)bar
does not have a fixity declaration, then reifyFixity 'bar
returns
Nothing
, so you may assume bar
has defaultFixity
.
Type lookup
reifyType :: Name -> Q Type Source #
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.
Instance lookup
reifyInstances :: Name -> [Type] -> Q [InstanceDec] Source #
reifyInstances nm tys
returns a list of visible instances of nm tys
. That is,
if nm
is the name of a type class, then all instances of this class at the types tys
are returned. Alternatively, if nm
is the name of a data family or type family,
all instances of this family at the types tys
are returned.
Note that this is a "shallow" test; the declarations returned merely have
instance heads which unify with nm tys
, they need not actually be satisfiable.
reifyInstances ''Eq [
contains theTupleT
2 `AppT
`ConT
''A `AppT
`ConT
''B ]instance (Eq a, Eq b) => Eq (a, b)
regardless of whetherA
andB
themselves implementEq
reifyInstances ''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).
isInstance :: Name -> [Type] -> Q Bool Source #
Is the list of instances returned by reifyInstances
nonempty?
Roles lookup
reifyRoles :: Name -> Q [Role] Source #
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] 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.
Annotation target for reifyAnnotations
Instances
Eq AnnLookup # | |
Data AnnLookup # | |
Defined in Language.Haskell.TH.Syntax gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AnnLookup -> c AnnLookup Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c AnnLookup Source # toConstr :: AnnLookup -> Constr Source # dataTypeOf :: AnnLookup -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c AnnLookup) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AnnLookup) Source # gmapT :: (forall b. Data b => b -> b) -> AnnLookup -> AnnLookup Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AnnLookup -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AnnLookup -> r Source # gmapQ :: (forall d. Data d => d -> u) -> AnnLookup -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> AnnLookup -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> AnnLookup -> m AnnLookup Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnLookup -> m AnnLookup Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnLookup -> m AnnLookup Source # | |
Ord AnnLookup # | |
Defined in Language.Haskell.TH.Syntax | |
Show AnnLookup # | |
Generic AnnLookup # | |
type Rep AnnLookup # | |
Defined in Language.Haskell.TH.Syntax type Rep AnnLookup = D1 ('MetaData "AnnLookup" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "AnnLookupModule" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Module)) :+: C1 ('MetaCons "AnnLookupName" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name))) |
Constructor strictness lookup
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.
Typed expressions
data TExp (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
(TExp
a) - typed splices inside of typed quotes, written as
$$(...)
where...
is an arbitrary expression of typeQ
(TExp
a)
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" ||])
Levity-polymorphic since template-haskell-2.16.0.0.
newtype Code m (a :: TYPE (r :: RuntimeRep)) Source #
Code | |
|
unTypeCode :: forall (r :: RuntimeRep) (a :: TYPE r) m. Quote m => Code m a -> m Exp Source #
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
Names
An abstract type representing names in the syntax tree.
Name
s can be constructed in several ways, which come with different
name-capture guarantees (see Language.Haskell.TH.Syntax for
an explanation of name capture):
- the built-in syntax
'f
and''T
can be used to construct names, The expression'f
gives aName
which refers to the valuef
currently in scope, and''T
gives aName
which refers to the typeT
currently in scope. These names can never be captured. lookupValueName
andlookupTypeName
are similar to'f
and''T
respectively, but theName
s are looked up at the point where the current splice is being run. These names can never be captured.newName
monadically generates a new name, which can never be captured.mkName
generates a capturable name.
Names constructed using newName
and mkName
may be used in bindings
(such as let x = ...
or x -> ...
), but names constructed using
lookupValueName
, lookupTypeName
, 'f
, ''T
may not.
Instances
Eq Name # | |
Data Name # | |
Defined in Language.Haskell.TH.Syntax gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Name -> c Name Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Name Source # toConstr :: Name -> Constr Source # dataTypeOf :: Name -> DataType Source # 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 -> Name Source # 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 Name Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Name -> m Name Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Name -> m Name Source # | |
Ord Name # | |
Defined in Language.Haskell.TH.Syntax | |
Show Name # | |
Generic Name # | |
Ppr Name # | |
type Rep Name # | |
Defined in Language.Haskell.TH.Syntax type Rep Name = D1 ('MetaData "Name" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "Name" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 OccName) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 NameFlavour))) |
Instances
Eq NameSpace # | |
Data NameSpace # | |
Defined in Language.Haskell.TH.Syntax gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> NameSpace -> c NameSpace Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c NameSpace Source # toConstr :: NameSpace -> Constr Source # dataTypeOf :: NameSpace -> DataType Source # 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 -> NameSpace Source # 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 NameSpace Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NameSpace -> m NameSpace Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NameSpace -> m NameSpace Source # | |
Ord NameSpace # | |
Defined in Language.Haskell.TH.Syntax | |
Show NameSpace # | |
Generic NameSpace # | |
type Rep NameSpace # | |
Defined in Language.Haskell.TH.Syntax type Rep NameSpace = 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))) |
Constructing names
mkName :: String -> Name Source #
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") |]
Deconstructing names
nameBase :: Name -> String Source #
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 Source #
Module prefix of a name, if it exists.
Examples
>>>
nameModule ''Data.Either.Either
Just "Data.Either">>>
nameModule (mkName "foo")
Nothing>>>
nameModule (mkName "Module.foo")
Just "Module"
namePackage :: Name -> Maybe String Source #
A name's package, if it exists.
Examples
>>>
namePackage ''Data.Either.Either
Just "base">>>
namePackage (mkName "foo")
Nothing>>>
namePackage (mkName "Module.foo")
Nothing
nameSpace :: Name -> Maybe NameSpace Source #
Returns whether a name represents an occurrence of a top-level variable
(VarName
), data constructor (DataName
), type constructor, or type class
(TcClsName
). If we can't be sure, it returns Nothing
.
Examples
>>>
nameSpace 'Prelude.id
Just VarName>>>
nameSpace (mkName "id")
Nothing -- only works for top-level variable names>>>
nameSpace 'Data.Maybe.Just
Just DataName>>>
nameSpace ''Data.Maybe.Maybe
Just TcClsName>>>
nameSpace ''Data.Ord.Ord
Just TcClsName
Built-in names
tupleTypeName :: Int -> Name Source #
Tuple type constructor
tupleDataName :: Int -> Name Source #
Tuple data constructor
unboxedTupleTypeName :: Int -> Name Source #
Unboxed tuple type constructor
unboxedTupleDataName :: Int -> Name Source #
Unboxed tuple data constructor
unboxedSumTypeName :: SumArity -> Name Source #
Unboxed sum type 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
FunD Name [Clause] | { f p1 p2 = b where decs } |
ValD Pat Body [Dec] | { p = b where decs } |
DataD Cxt Name [TyVarBndr ()] (Maybe Kind) [Con] [DerivClause] | { data Cxt x => T x = A x | B (T x) deriving (Z,W) deriving stock Eq } |
NewtypeD Cxt Name [TyVarBndr ()] (Maybe Kind) Con [DerivClause] | { newtype Cxt x => T x = A (B x) deriving (Z,W Q) deriving stock Eq } |
TySynD Name [TyVarBndr ()] Type | { type T x = (x,x) } |
ClassD Cxt Name [TyVarBndr ()] [FunDep] [Dec] | { class Eq a => Ord a where ds } |
InstanceD (Maybe Overlap) Cxt Type [Dec] | { instance {-# OVERLAPS #-} Show w => Show [w] where ds } |
SigD Name Type | { length :: [a] -> Int } |
KiSigD Name Kind | { type TypeRep :: k -> Type } |
ForeignD Foreign | { foreign import ... } { foreign export ... } |
InfixD Fixity Name | { infix 3 foo } |
PragmaD | pragmas |
| |
DataFamilyD | data families (may also appear in [Dec] of |
DataInstD Cxt (Maybe [TyVarBndr ()]) Type (Maybe Kind) [Con] [DerivClause] | { data instance Cxt x => T [x] = A x | B (T x) deriving (Z,W) deriving stock Eq } |
NewtypeInstD Cxt (Maybe [TyVarBndr ()]) Type (Maybe Kind) Con [DerivClause] | { newtype instance Cxt x => T [x] = A (B x) deriving (Z,W) deriving stock Eq } |
TySynInstD TySynEqn | { type instance ... } |
OpenTypeFamilyD | open type families (may also appear in [Dec] of |
| |
ClosedTypeFamilyD TypeFamilyHead [TySynEqn] | { type family F a b = (r :: *) | r -> a where ... } |
RoleAnnotD Name [Role] | { type role T nominal representational } |
StandaloneDerivD (Maybe DerivStrategy) Cxt Type | { deriving stock instance Ord a => Ord (Foo a) } |
DefaultSigD Name Type | { default size :: Data a => a -> Int } |
PatSynD | Pattern Synonyms |
| |
PatSynSigD Name PatSynType | A pattern synonym's type signature. |
ImplicitParamBindD String Exp | { ?x = expr } Implicit parameter binding declaration. Can only be used in let and where clauses which consist entirely of implicit bindings. |
Instances
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
ForallC
surrounds a constructor with vanilla syntax, then theForallC
will 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
ForallC
surrounds a constructor with GADT syntax, then theForallC
will 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
.
NormalC Name [BangType] | C Int a |
RecC Name [VarBangType] | C { v :: Int, w :: a } |
InfixC BangType Name BangType | Int :+ a |
ForallC [TyVarBndr Specificity] Cxt Con | 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
Eq Clause # | |
Data Clause # | |
Defined in Language.Haskell.TH.Syntax gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Clause -> c Clause Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Clause Source # toConstr :: Clause -> Constr Source # dataTypeOf :: Clause -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Clause) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Clause) Source # gmapT :: (forall b. Data b => b -> b) -> Clause -> Clause Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Clause -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Clause -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Clause -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Clause -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Clause -> m Clause Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Clause -> m Clause Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Clause -> m Clause Source # | |
Ord Clause # | |
Defined in Language.Haskell.TH.Syntax | |
Show Clause # | |
Generic Clause # | |
Ppr Clause # | |
type Rep Clause # | |
Defined in Language.Haskell.TH.Syntax type Rep Clause = D1 ('MetaData "Clause" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "Clause" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Pat]) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Body) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Dec])))) |
data SourceUnpackedness Source #
NoSourceUnpackedness | C a |
SourceNoUnpack | C { {-# NOUNPACK #-} } a |
SourceUnpack | C { {-# UNPACK #-} } a |
Instances
data SourceStrictness Source #
NoSourceStrictness | C a |
SourceLazy | C {~}a |
SourceStrict | C {!}a |
Instances
data DecidedStrictness Source #
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.
Instances
Bang SourceUnpackedness SourceStrictness | C { {-# UNPACK #-} !}a |
Instances
Eq Bang # | |
Data Bang # | |
Defined in Language.Haskell.TH.Syntax gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Bang -> c Bang Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Bang Source # toConstr :: Bang -> Constr Source # dataTypeOf :: Bang -> DataType Source # 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 -> Bang Source # 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 Bang Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Bang -> m Bang Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Bang -> m Bang Source # | |
Ord Bang # | |
Defined in Language.Haskell.TH.Syntax | |
Show Bang # | |
Generic Bang # | |
Ppr Bang # | |
type Rep Bang # | |
Defined in Language.Haskell.TH.Syntax type Rep Bang = D1 ('MetaData "Bang" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "Bang" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 SourceUnpackedness) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 SourceStrictness))) |
Instances
Instances
Eq Callconv # | |
Data Callconv # | |
Defined in Language.Haskell.TH.Syntax gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Callconv -> c Callconv Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Callconv Source # toConstr :: Callconv -> Constr Source # dataTypeOf :: Callconv -> DataType Source # 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 -> Callconv Source # 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 Callconv Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Callconv -> m Callconv Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Callconv -> m Callconv Source # | |
Ord Callconv # | |
Defined in Language.Haskell.TH.Syntax | |
Show Callconv # | |
Generic Callconv # | |
type Rep Callconv # | |
Defined in Language.Haskell.TH.Syntax type Rep Callconv = 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)))) |
Instances
Eq Safety # | |
Data Safety # | |
Defined in Language.Haskell.TH.Syntax gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Safety -> c Safety Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Safety Source # toConstr :: Safety -> Constr Source # dataTypeOf :: Safety -> DataType Source # 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 -> Safety Source # 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 Safety Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Safety -> m Safety Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Safety -> m Safety Source # | |
Ord Safety # | |
Defined in Language.Haskell.TH.Syntax | |
Show Safety # | |
Generic Safety # | |
type Rep Safety # | |
Defined in Language.Haskell.TH.Syntax |
InlineP Name Inline RuleMatch Phases | |
SpecialiseP Name Type (Maybe Inline) Phases | |
SpecialiseInstP Type | |
RuleP String (Maybe [TyVarBndr ()]) [RuleBndr] Exp Exp Phases | |
AnnP AnnTarget Exp | |
LineP Int String | |
CompleteP [Name] (Maybe Name) | { {-# COMPLETE C_1, ..., C_i [ :: T ] #-} } |
Instances
Instances
Eq Inline # | |
Data Inline # | |
Defined in Language.Haskell.TH.Syntax gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Inline -> c Inline Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Inline Source # toConstr :: Inline -> Constr Source # dataTypeOf :: Inline -> DataType Source # 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 -> Inline Source # 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 Inline Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Inline -> m Inline Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Inline -> m Inline Source # | |
Ord Inline # | |
Defined in Language.Haskell.TH.Syntax | |
Show Inline # | |
Generic Inline # | |
Ppr Inline # | |
type Rep Inline # | |
Defined in Language.Haskell.TH.Syntax |
Instances
Eq RuleMatch # | |
Data RuleMatch # | |
Defined in Language.Haskell.TH.Syntax gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RuleMatch -> c RuleMatch Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c RuleMatch Source # toConstr :: RuleMatch -> Constr Source # dataTypeOf :: RuleMatch -> DataType Source # 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 -> RuleMatch Source # 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 RuleMatch Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RuleMatch -> m RuleMatch Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RuleMatch -> m RuleMatch Source # | |
Ord RuleMatch # | |
Defined in Language.Haskell.TH.Syntax | |
Show RuleMatch # | |
Generic RuleMatch # | |
Ppr RuleMatch # | |
type Rep RuleMatch # | |
Instances
Eq Phases # | |
Data Phases # | |
Defined in Language.Haskell.TH.Syntax gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Phases -> c Phases Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Phases Source # toConstr :: Phases -> Constr Source # dataTypeOf :: Phases -> DataType Source # 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 -> Phases Source # 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 Phases Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Phases -> m Phases Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Phases -> m Phases Source # | |
Ord Phases # | |
Defined in Language.Haskell.TH.Syntax | |
Show Phases # | |
Generic Phases # | |
Ppr Phases # | |
type Rep Phases # | |
Defined in Language.Haskell.TH.Syntax type Rep Phases = 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 :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Int)) :+: C1 ('MetaCons "BeforePhase" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Int)))) |
Instances
Instances
Eq AnnTarget # | |
Data AnnTarget # | |
Defined in Language.Haskell.TH.Syntax gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AnnTarget -> c AnnTarget Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c AnnTarget Source # toConstr :: AnnTarget -> Constr Source # dataTypeOf :: AnnTarget -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c AnnTarget) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AnnTarget) Source # gmapT :: (forall b. Data b => b -> b) -> AnnTarget -> AnnTarget Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AnnTarget -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AnnTarget -> r Source # gmapQ :: (forall d. Data d => d -> u) -> AnnTarget -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> AnnTarget -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> AnnTarget -> m AnnTarget Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnTarget -> m AnnTarget Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnTarget -> m AnnTarget Source # | |
Ord AnnTarget # | |
Defined in Language.Haskell.TH.Syntax | |
Show AnnTarget # | |
Generic AnnTarget # | |
type Rep AnnTarget # | |
Defined in Language.Haskell.TH.Syntax type Rep AnnTarget = D1 ('MetaData "AnnTarget" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "ModuleAnnotation" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "TypeAnnotation" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name)) :+: C1 ('MetaCons "ValueAnnotation" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name)))) |
Instances
Eq FunDep # | |
Data FunDep # | |
Defined in Language.Haskell.TH.Syntax gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FunDep -> c FunDep Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c FunDep Source # toConstr :: FunDep -> Constr Source # dataTypeOf :: FunDep -> DataType Source # 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 -> FunDep Source # 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 FunDep Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FunDep -> m FunDep Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FunDep -> m FunDep Source # | |
Ord FunDep # | |
Defined in Language.Haskell.TH.Syntax | |
Show FunDep # | |
Generic FunDep # | |
Ppr FunDep # | |
type Rep FunDep # | |
Defined in Language.Haskell.TH.Syntax type Rep FunDep = D1 ('MetaData "FunDep" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "FunDep" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Name]) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) '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
[PlainTV
k,KindedTV
a (VarT
k)]) (AppT
(AppKindT
(ConT
''Foo) (VarT
k)) (VarT
a)) (VarT
a)
Instances
data TypeFamilyHead Source #
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
.
Instances
Instances
Eq Fixity # | |
Data Fixity # | |
Defined in Language.Haskell.TH.Syntax gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Fixity -> c Fixity Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Fixity Source # toConstr :: Fixity -> Constr Source # dataTypeOf :: Fixity -> DataType Source # 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 -> Fixity Source # 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 Fixity Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Fixity -> m Fixity Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Fixity -> m Fixity Source # | |
Ord Fixity # | |
Defined in Language.Haskell.TH.Syntax | |
Show Fixity # | |
Generic Fixity # | |
type Rep Fixity # | |
Defined in Language.Haskell.TH.Syntax type Rep Fixity = D1 ('MetaData "Fixity" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "Fixity" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Int) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 FixityDirection))) |
data FixityDirection Source #
Instances
defaultFixity :: Fixity Source #
Default fixity: infixl 9
maxPrecedence :: Int Source #
Highest allowed operator precedence for Fixity
constructor (answer: 9)
A pattern synonym's directionality.
Unidir | pattern P x {<-} p |
ImplBidir | pattern P x {=} p |
ExplBidir [Clause] | pattern P x {<-} p where P x = e |
Instances
Eq PatSynDir # | |
Data PatSynDir # | |
Defined in Language.Haskell.TH.Syntax gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> PatSynDir -> c PatSynDir Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c PatSynDir Source # toConstr :: PatSynDir -> Constr Source # dataTypeOf :: PatSynDir -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c PatSynDir) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PatSynDir) Source # gmapT :: (forall b. Data b => b -> b) -> PatSynDir -> PatSynDir Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PatSynDir -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PatSynDir -> r Source # gmapQ :: (forall d. Data d => d -> u) -> PatSynDir -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> PatSynDir -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> PatSynDir -> m PatSynDir Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> PatSynDir -> m PatSynDir Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> PatSynDir -> m PatSynDir Source # | |
Ord PatSynDir # | |
Defined in Language.Haskell.TH.Syntax | |
Show PatSynDir # | |
Generic PatSynDir # | |
Ppr PatSynDir # | |
type Rep PatSynDir # | |
Defined in Language.Haskell.TH.Syntax type Rep PatSynDir = D1 ('MetaData "PatSynDir" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "Unidir" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "ImplBidir" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "ExplBidir" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Clause])))) |
data PatSynArgs Source #
A pattern synonym's argument type.
PrefixPatSyn [Name] | pattern P {x y z} = p |
InfixPatSyn Name Name | pattern {x P y} = p |
RecordPatSyn [Name] | pattern P { {x,y,z} } = p |
Instances
Expressions
VarE Name | { x } |
ConE Name | data T1 = C1 t1 t2; p = {C1} e1 e2 |
LitE Lit | { 5 or 'c'} |
AppE Exp Exp | { f x } |
AppTypeE Exp Type | { f @Int } |
InfixE (Maybe Exp) Exp (Maybe Exp) | {x + y} or {(x+)} or {(+ x)} or {(+)} |
UInfixE Exp Exp Exp | {x + y} |
ParensE Exp | { (e) } |
LamE [Pat] Exp | { \ p1 p2 -> e } |
LamCaseE [Match] | { \case m1; m2 } |
TupE [Maybe Exp] | { (e1,e2) } The (1,) translates to TupE [Just (LitE (IntegerL 1)),Nothing] |
UnboxedTupE [Maybe Exp] | { (# e1,e2 #) } The (# 'c', #) translates to UnboxedTupE [Just (LitE (CharL 'c')),Nothing] |
UnboxedSumE Exp SumAlt SumArity | { (#|e|#) } |
CondE Exp Exp Exp | { if e1 then e2 else e3 } |
MultiIfE [(Guard, Exp)] | { if | g1 -> e1 | g2 -> e2 } |
LetE [Dec] Exp | { let { x=e1; y=e2 } in e3 } |
CaseE Exp [Match] | { case e of m1; m2 } |
DoE (Maybe ModName) [Stmt] |
|
MDoE (Maybe ModName) [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))] |
ArithSeqE Range | { [ 1 ,2 .. 10 ] } |
ListE [Exp] | { [1,2,3] } |
SigE Exp Type | { e :: t } |
RecConE Name [FieldExp] | { T { x = y, z = w } } |
RecUpdE Exp [FieldExp] | { (f x) { z = w } } |
StaticE Exp | { static e } |
UnboundVarE Name | { _x } This is used for holes or unresolved identifiers in AST quotes. Note that it could either have a variable name or constructor name. |
LabelE String |
|
ImplicitParamVarE String |
|
Instances
Instances
Eq Match # | |
Data Match # | |
Defined in Language.Haskell.TH.Syntax gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Match -> c Match Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Match Source # toConstr :: Match -> Constr Source # dataTypeOf :: Match -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Match) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Match) Source # gmapT :: (forall b. Data b => b -> b) -> Match -> Match Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Match -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Match -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Match -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Match -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Match -> m Match Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Match -> m Match Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Match -> m Match Source # | |
Ord Match # | |
Defined in Language.Haskell.TH.Syntax | |
Show Match # | |
Generic Match # | |
Ppr Match # | |
type Rep Match # | |
Defined in Language.Haskell.TH.Syntax type Rep Match = D1 ('MetaData "Match" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "Match" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Pat) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Body) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Dec])))) |
Instances
Eq Body # | |
Data Body # | |
Defined in Language.Haskell.TH.Syntax gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Body -> c Body Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Body Source # toConstr :: Body -> Constr Source # dataTypeOf :: Body -> DataType Source # 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 -> Body Source # 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 Body Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Body -> m Body Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Body -> m Body Source # | |
Ord Body # | |
Defined in Language.Haskell.TH.Syntax | |
Show Body # | |
Generic Body # | |
type Rep Body # | |
Defined in Language.Haskell.TH.Syntax type Rep Body = D1 ('MetaData "Body" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "GuardedB" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [(Guard, Exp)])) :+: C1 ('MetaCons "NormalB" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Exp))) |
Instances
Eq Guard # | |
Data Guard # | |
Defined in Language.Haskell.TH.Syntax gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Guard -> c Guard Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Guard Source # toConstr :: Guard -> Constr Source # dataTypeOf :: Guard -> DataType Source # 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 -> Guard Source # 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 Guard Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Guard -> m Guard Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Guard -> m Guard Source # | |
Ord Guard # | |
Defined in Language.Haskell.TH.Syntax | |
Show Guard # | |
Generic Guard # | |
type Rep Guard # | |
Defined in Language.Haskell.TH.Syntax type Rep Guard = D1 ('MetaData "Guard" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "NormalG" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Exp)) :+: C1 ('MetaCons "PatG" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Stmt]))) |
BindS Pat Exp | p <- e |
LetS [Dec] | { let { x=e1; y=e2 } } |
NoBindS Exp | e |
ParS [[Stmt]] |
|
RecS [Stmt] | rec { s1; s2 } |
Instances
Instances
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 |
BytesPrimL Bytes | Some raw bytes, type |
CharPrimL Char |
Instances
Patterns
Pattern in Haskell given in {}
LitP Lit | { 5 or 'c' } |
VarP Name | { x } |
TupP [Pat] | { (p1,p2) } |
UnboxedTupP [Pat] | { (# p1,p2 #) } |
UnboxedSumP Pat SumAlt SumArity | { (#|p|#) } |
ConP Name [Pat] | data T1 = C1 t1 t2; {C1 p1 p1} = e |
InfixP Pat Name Pat | foo ({x :+ y}) = e |
UInfixP Pat Name Pat | foo ({x :+ y}) = e |
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 } |
Instances
Types
ForallT [TyVarBndr Specificity] Cxt Type | forall <vars>. <ctxt> => <type> |
ForallVisT [TyVarBndr ()] Type | forall <vars> -> <type> |
AppT Type Type | T a b |
AppKindT Type Kind | T @k t |
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. |
UnboxedSumT SumArity | (#|#), (#||#), etc. |
ArrowT | -> |
MulArrowT | FUN |
EqualityT | ~ |
ListT | [] |
PromotedTupleT Int | '(), '(,), '(,,), etc. |
PromotedNilT | '[] |
PromotedConsT | (':) |
StarT | * |
ConstraintT | Constraint |
LitT TyLit | 0,1,2, etc. |
WildCardT | _ |
ImplicitParamT String Type | ?x :: t |
Instances
Instances
Instances
Eq TyLit # | |
Data TyLit # | |
Defined in Language.Haskell.TH.Syntax gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TyLit -> c TyLit Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TyLit Source # toConstr :: TyLit -> Constr Source # dataTypeOf :: TyLit -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c TyLit) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TyLit) Source # gmapT :: (forall b. Data b => b -> b) -> TyLit -> TyLit Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TyLit -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TyLit -> r Source # gmapQ :: (forall d. Data d => d -> u) -> TyLit -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> TyLit -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> TyLit -> m TyLit Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TyLit -> m TyLit Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TyLit -> m TyLit Source # | |
Ord TyLit # | |
Defined in Language.Haskell.TH.Syntax | |
Show TyLit # | |
Generic TyLit # | |
Ppr TyLit # | |
type Rep TyLit # | |
Defined in Language.Haskell.TH.Syntax type Rep TyLit = D1 ('MetaData "TyLit" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "NumTyLit" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Integer)) :+: C1 ('MetaCons "StrTyLit" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String))) |
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
NominalR | nominal |
RepresentationalR | representational |
PhantomR | phantom |
InferR | _ |
Instances
Eq Role # | |
Data Role # | |
Defined in Language.Haskell.TH.Syntax gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Role -> c Role Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Role Source # toConstr :: Role -> Constr Source # dataTypeOf :: Role -> DataType Source # 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 -> Role Source # 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 Role Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Role -> m Role Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Role -> m Role Source # | |
Ord Role # | |
Defined in Language.Haskell.TH.Syntax | |
Show Role # | |
Generic Role # | |
Ppr Role # | |
type Rep Role # | |
Defined in Language.Haskell.TH.Syntax type Rep Role = 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))) |
data Specificity Source #
Instances
data FamilyResultSig Source #
Type family result signature
Instances
data InjectivityAnn Source #
Injectivity annotation
Instances
type PatSynType = Type Source #
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
, ..,tn
ofx1
,x2
, ..,xn
, respectively - the type
t
of<some-pattern>
, mentioning only universals.
Pattern synonym types interact with TH when (a) reifying a pattern synonym, (b) pretty printing, or (c) specifying a pattern synonym's type signature explicitly:
- Reification always returns a pattern synonym's fully specified type in abstract syntax.
- Pretty printing via
pprPatSynType
abbreviates a pattern synonym's type unambiguously in concrete syntax: The rule of thumb is to print initial empty universals and the required context as() =>
, if existentials and a provided context follow. If only universals and their required context, but no existentials are specified, only the universals and their required context are printed. If both or none are specified, so both (or none) are printed. - When specifying a pattern synonym's type explicitly with
PatSynSigD
either one of the universals, the existentials, or their contexts may be left empty.
See the GHC user's guide for more information on pattern synonyms and their types: https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/glasgow_exts.html#pattern-synonyms.
Library functions
module Language.Haskell.TH.Lib
Pretty-printer
Instances
pprParendType :: Type -> Doc Source #