Language.Haskell.TH.Syntax
| Copyright | (c) The University of Glasgow 2003 |
|---|---|
| License | BSD-style (see the file libraries/base/LICENSE) |
| Maintainer | [email protected] |
| Stability | experimental |
| Portability | portable |
| Safe Haskell | Trustworthy |
| Language | Haskell2010 |
Contents
Description
Abstract syntax definitions for Template Haskell.
bindQ :: Q a -> (a -> Q b) -> Q b Source
sequenceQ :: [Q a] -> Q [a] Source
newName :: String -> Q 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.
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") |]
mkNameG_v :: String -> String -> String -> Name Source
mkNameG_d :: String -> String -> String -> Name Source
mkNameG_tc :: String -> String -> String -> Name Source
mkNameL :: String -> Uniq -> Name Source
Only used internally
mkNameS :: String -> Name Source
unTypeQ :: forall (r :: RuntimeRep) (a :: TYPE r). Q (TExp a) -> Q Exp Source
Discard the type annotation and produce a plain Template Haskell expression
Levity-polymorphic since template-haskell-2.16.0.0.
unsafeTExpCoerce :: forall (r :: RuntimeRep) (a :: TYPE r). Q Exp -> Q (TExp a) Source
Annotate the Template Haskell expression with a type
This is unsafe because GHC cannot check for you that the expression really does have the type you claim it has.
Levity-polymorphic since template-haskell-2.16.0.0.
liftString :: String -> Q Exp Source
class Lift (t :: TYPE r) where Source
A Lift instance can have any of its values turned into a Template Haskell expression. This is needed when a value used within a Template Haskell quotation is bound outside the Oxford brackets ([| ... |] or [|| ... ||]) but not at the top level. As an example:
add1 :: Int -> Q (TExp Int) add1 x = [|| x + 1 ||]
Template Haskell has no way of knowing what value x will take on at splice-time, so it requires the type of x to be an instance of Lift.
A Lift instance must satisfy $(lift x) ≡ x and $$(liftTyped x) ≡ x for all x, where $(...) and $$(...) are Template Haskell splices. It is additionally expected that lift x ≡ unTypeQ (liftTyped x).
Lift instances can be derived automatically by use of the -XDeriveLift GHC language extension:
{-# LANGUAGE DeriveLift #-}
module Foo where
import Language.Haskell.TH.Syntax
data Bar a = Bar1 a (Bar a) | Bar2 String
deriving Lift
Levity-polymorphic since template-haskell-2.16.0.0.
Minimal complete definition
Methods
Turn a value into a Template Haskell expression, suitable for use in a splice.
liftTyped :: t -> Q (TExp t) Source
Turn a value into a Template Haskell typed expression, suitable for use in a typed splice.
Since: template-haskell-2.16.0.0
Instances
| Lift Bool | |
| Lift Char | |
| Lift Double | |
| Lift Float | |
| Lift Int | |
| Lift Int8 | |
| Lift Int16 | |
| Lift Int32 | |
| Lift Int64 | |
| Lift Integer | |
| Lift Natural | |
| Lift Word | |
| Lift Word8 | |
| Lift Word16 | |
| Lift Word32 | |
| Lift Word64 | |
| Lift () | |
| Lift Void | Since: template-haskell-2.15.0.0 |
| Lift Int# | Since: template-haskell-2.16.0.0 |
| Lift Char# | Since: template-haskell-2.16.0.0 |
| Lift Word# | Since: template-haskell-2.16.0.0 |
| Lift Addr# |
Produces an Since: template-haskell-2.16.0.0 |
| Lift Float# | Since: template-haskell-2.16.0.0 |
| Lift Double# | Since: template-haskell-2.16.0.0 |
| Lift a => Lift ([a] :: Type) | |
| Lift a => Lift (Maybe a :: Type) | |
| Integral a => Lift (Ratio a :: Type) | |
| Lift a => Lift (NonEmpty a :: Type) | Since: template-haskell-2.15.0.0 |
| (Lift a, Lift b) => Lift (Either a b :: Type) | |
| (Lift a, Lift b) => Lift ((a, b) :: Type) | |
| (Lift a, Lift b, Lift c) => Lift ((a, b, c) :: Type) | |
| (Lift a, Lift b, Lift c, Lift d) => Lift ((a, b, c, d) :: Type) | |
| (Lift a, Lift b, Lift c, Lift d, Lift e) => Lift ((a, b, c, d, e) :: Type) | |
| (Lift a, Lift b, Lift c, Lift d, Lift e, Lift f) => Lift ((a, b, c, d, e, f) :: Type) | |
| (Lift a, Lift b, Lift c, Lift d, Lift e, Lift f, Lift g) => Lift ((a, b, c, d, e, f, g) :: Type) | |
| Lift (# #) | Since: template-haskell-2.16.0.0 |
| Lift a => Lift ((# a #) :: TYPE ('TupleRep '['LiftedRep])) | Since: template-haskell-2.16.0.0 |
| (Lift a, Lift b) => Lift ((# a, b #) :: TYPE ('TupleRep '['LiftedRep, 'LiftedRep])) | Since: template-haskell-2.16.0.0 |
| (Lift a, Lift b) => Lift ((# a | b #) :: TYPE ('SumRep '['LiftedRep, 'LiftedRep])) | Since: template-haskell-2.16.0.0 |
| (Lift a, Lift b, Lift c) => Lift ((# a, b, c #) :: TYPE ('TupleRep '['LiftedRep, 'LiftedRep, 'LiftedRep])) | Since: template-haskell-2.16.0.0 |
| (Lift a, Lift b, Lift c) => Lift ((# a | b | c #) :: TYPE ('SumRep '['LiftedRep, 'LiftedRep, 'LiftedRep])) | Since: template-haskell-2.16.0.0 |
| (Lift a, Lift b, Lift c, Lift d) => Lift ((# a, b, c, d #) :: TYPE ('TupleRep '['LiftedRep, 'LiftedRep, 'LiftedRep, 'LiftedRep])) | Since: template-haskell-2.16.0.0 |
| (Lift a, Lift b, Lift c, Lift d) => Lift ((# a | b | c | d #) :: TYPE ('SumRep '['LiftedRep, 'LiftedRep, 'LiftedRep, 'LiftedRep])) | Since: template-haskell-2.16.0.0 |
| (Lift a, Lift b, Lift c, Lift d, Lift e) => Lift ((# a, b, c, d, e #) :: TYPE ('TupleRep '['LiftedRep, 'LiftedRep, 'LiftedRep, 'LiftedRep, 'LiftedRep])) | Since: template-haskell-2.16.0.0 |
| (Lift a, Lift b, Lift c, Lift d, Lift e) => Lift ((# a | b | c | d | e #) :: TYPE ('SumRep '['LiftedRep, 'LiftedRep, 'LiftedRep, 'LiftedRep, 'LiftedRep])) | Since: template-haskell-2.16.0.0 |
| (Lift a, Lift b, Lift c, Lift d, Lift e, Lift f) => Lift ((# a, b, c, d, e, f #) :: TYPE ('TupleRep '['LiftedRep, 'LiftedRep, 'LiftedRep, 'LiftedRep, 'LiftedRep, 'LiftedRep])) | Since: template-haskell-2.16.0.0 |
| (Lift a, Lift b, Lift c, Lift d, Lift e, Lift f) => Lift ((# a | b | c | d | e | f #) :: TYPE ('SumRep '['LiftedRep, 'LiftedRep, 'LiftedRep, 'LiftedRep, 'LiftedRep, 'LiftedRep])) | Since: template-haskell-2.16.0.0 |
| (Lift a, Lift b, Lift c, Lift d, Lift e, Lift f, Lift g) => Lift ((# a, b, c, d, e, f, g #) :: TYPE ('TupleRep '['LiftedRep, 'LiftedRep, 'LiftedRep, 'LiftedRep, 'LiftedRep, 'LiftedRep, 'LiftedRep])) | Since: template-haskell-2.16.0.0 |
| (Lift a, Lift b, Lift c, Lift d, Lift e, Lift f, Lift g) => Lift ((# a | b | c | d | e | f | g #) :: TYPE ('SumRep '['LiftedRep, 'LiftedRep, 'LiftedRep, 'LiftedRep, 'LiftedRep, 'LiftedRep, 'LiftedRep])) | Since: template-haskell-2.16.0.0 |
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 } |
| 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 [Stmt] | { do { p <- e1; e2 } } |
| MDoE [Stmt] | { mdo { x <- e1 y; y <- e2 x; } } |
| CompE [Stmt] |
{ [ (x,y) | x <- xs, y <- ys ] }
The result expression of the comprehension is the last of the 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 Methodsgfoldl :: (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 Clause | |
| Data Clause | |
Defined in Language.Haskell.TH.Syntax Methodsgfoldl :: (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])))) | |
Instances
Pattern in Haskell given in {}
Constructors
| 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
Constructors
| ForallT [TyVarBndr] 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 | -> |
| EqualityT | ~ |
| ListT | [] |
| PromotedTupleT Int | '(), '(,), '(,,), etc. |
| PromotedNilT | '[] |
| PromotedConsT | (':) |
| StarT | * |
| ConstraintT | Constraint |
| LitT TyLit | 0,1,2, etc. |
| WildCardT | _ |
| ImplicitParamT String Type | ?x :: t |
Instances
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] [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 Pragma | { {-# INLINE [1] foo #-} } |
| DataFamilyD Name [TyVarBndr] (Maybe Kind) | { data family T a b c :: * } |
| 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 TypeFamilyHead | { type family T a b c = (r :: *) | r -> a b } |
| ClosedTypeFamilyD TypeFamilyHead [TySynEqn] | { type family F a b = (r :: *) | r -> a where ... } |
| RoleAnnotD Name [Role] | { type role T nominal representational } |
| StandaloneDerivD (Maybe DerivStrategy) Cxt Type | { deriving stock instance Ord a => Ord (Foo a) } |
| DefaultSigD Name Type | { default size :: Data a => a -> Int } |
| PatSynD Name PatSynArgs PatSynDir Pat |
also, besides prefix pattern synonyms, both infix and record pattern synonyms are supported. See |
| 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
type FieldExp = (Name, Exp) Source
type FieldPat = (Name, Pat) Source
An abstract type representing names in the syntax tree.
Names can be constructed in several ways, which come with different name-capture guarantees (see Language.Haskell.TH.Syntax for an explanation of name capture):
- the built-in syntax
'fand''Tcan be used to construct names, The expression'fgives aNamewhich refers to the valuefcurrently in scope, and''Tgives aNamewhich refers to the typeTcurrently in scope. These names can never be captured. -
lookupValueNameandlookupTypeNameare similar to'fand''Trespectively, but theNames are looked up at the point where the current splice is being run. These names can never be captured. -
newNamemonadically generates a new name, which can never be captured. -
mkNamegenerates a capturable name.
Names constructed using newName and mkName may be used in bindings (such as let x = ... or x -> ...), but names constructed using lookupValueName, lookupTypeName, 'f, ''T may not.
Constructors
| Name OccName NameFlavour |
Instances
| Eq Name | |
| Data Name | |
Defined in Language.Haskell.TH.Syntax Methodsgfoldl :: (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 FunDep | |
| Data FunDep | |
Defined in Language.Haskell.TH.Syntax Methodsgfoldl :: (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]))) | |
Since the advent of ConstraintKinds, constraints are really just types. Equality constraints use the EqualityT constructor. Constraints may also be tuples of other constraints.
newtype 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" ||])
data InjectivityAnn Source
Injectivity annotation
Constructors
| InjectivityAnn Name [Name] |
Instances
Varieties of allowed instance overlap.
Constructors
| Overlappable | May be overlapped by more specific instances |
| Overlapping | May overlap a more general instance |
| Overlaps | Both |
| Incoherent | Both |
Instances
| Eq Overlap | |
| Data Overlap | |
Defined in Language.Haskell.TH.Syntax Methodsgfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Overlap -> c Overlap Source gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Overlap Source toConstr :: Overlap -> Constr Source dataTypeOf :: Overlap -> DataType Source dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Overlap) Source dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Overlap) Source gmapT :: (forall b. Data b => b -> b) -> Overlap -> Overlap Source gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Overlap -> r Source gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Overlap -> r Source gmapQ :: (forall d. Data d => d -> u) -> Overlap -> [u] Source gmapQi :: Int -> (forall d. Data d => d -> u) -> Overlap -> u Source gmapM :: Monad m => (forall d. Data d => d -> m d) -> Overlap -> m Overlap Source gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Overlap -> m Overlap Source gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Overlap -> m Overlap Source | |
| Ord Overlap | |
Defined in Language.Haskell.TH.Syntax | |
| Show Overlap | |
| Generic Overlap | |
| type Rep Overlap | |
Defined in Language.Haskell.TH.Syntax type Rep Overlap = D1 ('MetaData "Overlap" "Language.Haskell.TH.Syntax" "template-haskell" 'False) ((C1 ('MetaCons "Overlappable" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Overlapping" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "Overlaps" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Incoherent" 'PrefixI 'False) (U1 :: Type -> Type))) | |
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.
Annotation target for reifyAnnotations
Constructors
| AnnLookupModule Module | |
| AnnLookupName Name |
Instances
| Eq AnnLookup | |
| Data AnnLookup | |
Defined in Language.Haskell.TH.Syntax Methodsgfoldl :: (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))) | |
Role annotations
Constructors
| NominalR | nominal |
| RepresentationalR | representational |
| PhantomR | phantom |
| InferR | _ |
Instances
| Eq Role | |
| Data Role | |
Defined in Language.Haskell.TH.Syntax Methodsgfoldl :: (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))) | |
Instances
| Eq TyLit | |
| Data TyLit | |
Defined in Language.Haskell.TH.Syntax Methodsgfoldl :: (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))) | |
data FamilyResultSig Source
Type family result signature
Instances
Instances
data PatSynArgs Source
A pattern synonym's argument type.
Constructors
| 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
A pattern synonym's directionality.
Constructors
| Unidir | pattern P x {<-} p |
| ImplBidir | pattern P x {=} p |
| ExplBidir [Clause] | pattern P x {<-} p where P x = e |
Instances
| Eq PatSynDir | |
| Data PatSynDir | |
Defined in Language.Haskell.TH.Syntax Methodsgfoldl :: (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])))) | |
type VarStrictType = VarBangType Source
As of template-haskell-2.11.0.0, VarStrictType has been replaced by VarBangType.
type StrictType = BangType Source
As of template-haskell-2.11.0.0, StrictType has been replaced by BangType.
As of template-haskell-2.11.0.0, Strict has been replaced by Bang.
type VarBangType = (Name, Bang, Type) Source
type BangType = (Bang, Type) Source
Constructors
| Bang SourceUnpackedness SourceStrictness | C { {-# UNPACK #-} !}a |
Instances
| Eq Bang | |
| Data Bang | |
Defined in Language.Haskell.TH.Syntax Methodsgfoldl :: (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))) | |
A single data constructor.
The constructors for Con can roughly be divided up into two categories: those for constructors with "vanilla" syntax (NormalC, RecC, and InfixC), and those for constructors with GADT syntax (GadtC and RecGadtC). The ForallC constructor, which quantifies additional type variables and class contexts, can surround either variety of constructor. However, the type variables that it quantifies are different depending on what constructor syntax is used:
- If a
ForallCsurrounds a constructor with vanilla syntax, then theForallCwill only quantify existential type variables. For example:
data Foo a = forall b. MkFoo a b
In MkFoo, ForallC will quantify b, but not a.
- If a
ForallCsurrounds a constructor with GADT syntax, then theForallCwill quantify all type variables used in the constructor. For example:
data Bar a b where
MkBar :: (a ~ b) => c -> MkBar a b
In MkBar, ForallC will quantify a, b, and c.
Constructors
| NormalC Name [BangType] | C Int a |
| RecC Name [VarBangType] | C { v :: Int, w :: a } |
| InfixC BangType Name BangType | Int :+ a |
| ForallC [TyVarBndr] 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
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.
Constructors
| DecidedLazy | |
| DecidedStrict | |
| DecidedUnpack |
Instances
data SourceStrictness Source
Constructors
| NoSourceStrictness | C a |
| SourceLazy | C {~}a |
| SourceStrict | C {!}a |
Instances
data SourceUnpackedness Source
Constructors
| NoSourceUnpackedness | C a |
| SourceNoUnpack | C { {-# NOUNPACK #-} } a |
| SourceUnpack | C { {-# UNPACK #-} } a |
Instances
Arguments
| = [Pred] | (Eq a, Ord b) |
Constructors
| ModuleAnnotation | |
| TypeAnnotation Name | |
| ValueAnnotation Name |
Instances
| Eq AnnTarget | |
| Data AnnTarget | |
Defined in Language.Haskell.TH.Syntax Methodsgfoldl :: (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)))) | |
Constructors
| RuleVar Name | |
| TypedRuleVar Name Type |
Instances
| Eq RuleBndr | |
| Data RuleBndr | |
Defined in Language.Haskell.TH.Syntax Methodsgfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RuleBndr -> c RuleBndr Source gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c RuleBndr Source toConstr :: RuleBndr -> Constr Source dataTypeOf :: RuleBndr -> DataType Source dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c RuleBndr) Source dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RuleBndr) Source gmapT :: (forall b. Data b => b -> b) -> RuleBndr -> RuleBndr Source gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RuleBndr -> r Source gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RuleBndr -> r Source gmapQ :: (forall d. Data d => d -> u) -> RuleBndr -> [u] Source gmapQi :: Int -> (forall d. Data d => d -> u) -> RuleBndr -> u Source gmapM :: Monad m => (forall d. Data d => d -> m d) -> RuleBndr -> m RuleBndr Source gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RuleBndr -> m RuleBndr Source gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RuleBndr -> m RuleBndr Source | |
| Ord RuleBndr | |
Defined in Language.Haskell.TH.Syntax | |
| Show RuleBndr | |
| Generic RuleBndr | |
| Ppr RuleBndr | |
| type Rep RuleBndr | |
Defined in Language.Haskell.TH.Syntax type Rep RuleBndr = D1 ('MetaData "RuleBndr" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "RuleVar" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name)) :+: C1 ('MetaCons "TypedRuleVar" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type))) | |
Constructors
| AllPhases | |
| FromPhase Int | |
| BeforePhase Int |
Instances
| Eq Phases | |
| Data Phases | |
Defined in Language.Haskell.TH.Syntax Methodsgfoldl :: (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
| Eq RuleMatch | |
| Data RuleMatch | |
Defined in Language.Haskell.TH.Syntax Methodsgfoldl :: (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 Inline | |
| Data Inline | |
Defined in Language.Haskell.TH.Syntax Methodsgfoldl :: (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 | |
Constructors
| 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
Constructors
| Unsafe | |
| Safe | |
| Interruptible |
Instances
| Eq Safety | |
| Data Safety | |
Defined in Language.Haskell.TH.Syntax Methodsgfoldl :: (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 | |
Constructors
| CCall | |
| StdCall | |
| CApi | |
| Prim | |
| JavaScript |
Instances
| Eq Callconv | |
| Data Callconv | |
Defined in Language.Haskell.TH.Syntax Methodsgfoldl :: (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
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
| Eq TySynEqn | |
| Data TySynEqn | |
Defined in Language.Haskell.TH.Syntax Methodsgfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TySynEqn -> c TySynEqn Source gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TySynEqn Source toConstr :: TySynEqn -> Constr Source dataTypeOf :: TySynEqn -> DataType Source dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c TySynEqn) Source dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TySynEqn) Source gmapT :: (forall b. Data b => b -> b) -> TySynEqn -> TySynEqn Source gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TySynEqn -> r Source gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TySynEqn -> r Source gmapQ :: (forall d. Data d => d -> u) -> TySynEqn -> [u] Source gmapQi :: Int -> (forall d. Data d => d -> u) -> TySynEqn -> u Source gmapM :: Monad m => (forall d. Data d => d -> m d) -> TySynEqn -> m TySynEqn Source gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TySynEqn -> m TySynEqn Source gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TySynEqn -> m TySynEqn Source | |
| Ord TySynEqn | |
Defined in Language.Haskell.TH.Syntax | |
| Show TySynEqn | |
| Generic TySynEqn | |
| type Rep TySynEqn | |
Defined in Language.Haskell.TH.Syntax type Rep TySynEqn = D1 ('MetaData "TySynEqn" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "TySynEqn" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe [TyVarBndr])) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Type)))) | |
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.
Constructors
| TypeFamilyHead Name [TyVarBndr] FamilyResultSig (Maybe InjectivityAnn) |
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, ..,tnofx1,x2, ..,xn, respectively - the type
tof<some-pattern>, mentioning only universals.
Pattern synonym types interact with TH when (a) reifying a pattern synonym, (b) pretty printing, or (c) specifying a pattern synonym's type signature explicitly:
- Reification always returns a pattern synonym's fully specified type in abstract syntax.
- Pretty printing via
pprPatSynTypeabbreviates a pattern synonym's type unambiguously in concrete syntax: The rule of thumb is to print initial empty universals and the required context as() =>, if existentials and a provided context follow. If only universals and their required context, but no existentials are specified, only the universals and their required context are printed. If both or none are specified, so both (or none) are printed. - When specifying a pattern synonym's type explicitly with
PatSynSigDeither one of the universals, the existentials, or their contexts may be left empty.
See the GHC user's guide for more information on pattern synonyms and their types: https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/glasgow_exts.html#pattern-synonyms.
data DerivStrategy Source
What the user explicitly requests when deriving an instance.
Constructors
| StockStrategy | A "standard" derived instance |
| AnyclassStrategy | -XDeriveAnyClass |
| NewtypeStrategy | -XGeneralizedNewtypeDeriving |
| ViaStrategy Type | -XDerivingVia |
Instances
data DerivClause Source
A single deriving clause at the end of a datatype.
Constructors
| DerivClause (Maybe DerivStrategy) Cxt | { deriving stock (Eq, Ord) } |
Instances
Instances
Constructors
| BindS Pat Exp | p <- e |
| LetS [Dec] | { let { x=e1; y=e2 } } |
| NoBindS Exp | e |
| ParS [[Stmt]] |
|
| RecS [Stmt] | rec { s1; s2 } |
Instances
Instances
| Eq Guard | |
| Data Guard | |
Defined in Language.Haskell.TH.Syntax Methodsgfoldl :: (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]))) | |
Constructors
| GuardedB [(Guard, Exp)] | f p { | e1 = e2
| e3 = e4 }
where ds |
| NormalB Exp | f p { = e } where ds |
Instances
| Eq Body | |
| Data Body | |
Defined in Language.Haskell.TH.Syntax Methodsgfoldl :: (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))) | |
Raw bytes embedded into the binary.
Avoid using Bytes constructor directly as it is likely to change in the future. Use helpers such as mkBytes in Language.Haskell.TH.Lib instead.
Constructors
| Bytes | |
Fields
| |
Instances
| Eq Bytes | |
| Data Bytes | |
Defined in Language.Haskell.TH.Syntax Methodsgfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Bytes -> c Bytes Source gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Bytes Source toConstr :: Bytes -> Constr Source dataTypeOf :: Bytes -> DataType Source dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Bytes) Source dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Bytes) Source gmapT :: (forall b. Data b => b -> b) -> Bytes -> Bytes Source gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Bytes -> r Source gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Bytes -> r Source gmapQ :: (forall d. Data d => d -> u) -> Bytes -> [u] Source gmapQi :: Int -> (forall d. Data d => d -> u) -> Bytes -> u Source gmapM :: Monad m => (forall d. Data d => d -> m d) -> Bytes -> m Bytes Source gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Bytes -> m Bytes Source gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Bytes -> m Bytes Source | |
| Ord Bytes | |
Defined in Language.Haskell.TH.Syntax | |
| Show Bytes | |
| Generic Bytes | |
| type Rep Bytes | |
Defined in Language.Haskell.TH.Syntax type Rep Bytes = D1 ('MetaData "Bytes" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "Bytes" 'PrefixI 'True) (S1 ('MetaSel ('Just "bytesPtr") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (ForeignPtr Word8)) :*: (S1 ('MetaSel ('Just "bytesOffset") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Word) :*: S1 ('MetaSel ('Just "bytesSize") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Word)))) | |
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 |
| BytesPrimL Bytes | Some raw bytes, type |
| CharPrimL Char |
Instances
data FixityDirection Source
Instances
Constructors
| Fixity Int FixityDirection |
Instances
| Eq Fixity | |
| Data Fixity | |
Defined in Language.Haskell.TH.Syntax Methodsgfoldl :: (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))) | |
type InstanceDec = Dec Source
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
In PrimTyConI, is the type constructor unlifted?
In PrimTyConI, arity of the type constructor
In UnboxedSumE, UnboxedSumT, and UnboxedSumP, the total number of SumAlts. For example, (#|#) has a SumArity of 2.
In UnboxedSumE and UnboxedSumP, the number associated with a particular data constructor. SumAlts are one-indexed and should never exceed the value of its corresponding SumArity. For example:
-
(#_|#)hasSumAlt1 (out of a totalSumArityof 2) -
(#|_#)hasSumAlt2 (out of a totalSumArityof 2)
type ParentName = Name Source
In ClassOpI and DataConI, name of the parent class or type
data ModuleInfo Source
Obtained from reifyModule in the Q Monad.
Constructors
| ModuleInfo [Module] | Contains the import list of the module. |
Instances
Obtained from reify in the Q Monad.
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 |
| 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
Constructors
| Loc | |
Fields
| |
Instances
| Eq Loc | |
| Data Loc | |
Defined in Language.Haskell.TH.Syntax Methodsgfoldl :: (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))))) | |
Uniq is used by GHC to distinguish names from each other.
Constructors
| VarName | Variables |
| DataName | Data constructors |
| TcClsName | Type constructors and classes; Haskell has them in the same name space for now. |
Instances
| Eq NameSpace | |
| Data NameSpace | |
Defined in Language.Haskell.TH.Syntax Methodsgfoldl :: (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))) | |
data NameFlavour Source
Constructors
| NameS | An unqualified name; dynamically bound |
| NameQ ModName | A qualified name; dynamically bound |
| NameU !Uniq | A unique local name |
| NameL !Uniq | Local name bound outside of the TH AST |
| NameG NameSpace PkgName ModName | Global name bound outside of the TH AST: An original name (occurrences only, not binders) Need the namespace too to be sure which thing we are naming |
Instances
Instances
| Eq OccName | |
| Data OccName | |
Defined in Language.Haskell.TH.Syntax Methodsgfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> OccName -> c OccName Source gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c OccName Source toConstr :: OccName -> Constr Source dataTypeOf :: OccName -> DataType Source dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c OccName) Source dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OccName) Source gmapT :: (forall b. Data b => b -> b) -> OccName -> OccName Source gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> OccName -> r Source gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> OccName -> r Source gmapQ :: (forall d. Data d => d -> u) -> OccName -> [u] Source gmapQi :: Int -> (forall d. Data d => d -> u) -> OccName -> u Source gmapM :: Monad m => (forall d. Data d => d -> m d) -> OccName -> m OccName Source gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> OccName -> m OccName Source gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> OccName -> m OccName Source | |
| Ord OccName | |
Defined in Language.Haskell.TH.Syntax | |
| Show OccName | |
| Generic OccName | |
| type Rep OccName | |
Defined in Language.Haskell.TH.Syntax | |
Obtained from reifyModule and thisModule.
Instances
| Eq Module | |
| Data Module | |
Defined in Language.Haskell.TH.Syntax Methodsgfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Module -> c Module Source gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Module Source toConstr :: Module -> Constr Source dataTypeOf :: Module -> DataType Source dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Module) Source dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Module) Source gmapT :: (forall b. Data b => b -> b) -> Module -> Module Source gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Module -> r Source gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Module -> r Source gmapQ :: (forall d. Data d => d -> u) -> Module -> [u] Source gmapQi :: Int -> (forall d. Data d => d -> u) -> Module -> u Source gmapM :: Monad m => (forall d. Data d => d -> m d) -> Module -> m Module Source gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Module -> m Module Source gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Module -> m Module Source | |
| Ord Module | |
Defined in Language.Haskell.TH.Syntax | |
| Show Module | |
| Generic Module | |
| Ppr Module | |
| type Rep Module | |
Defined in Language.Haskell.TH.Syntax type Rep Module = D1 ('MetaData "Module" "Language.Haskell.TH.Syntax" "template-haskell" 'False) (C1 ('MetaCons "Module" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 PkgName) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ModName))) | |
Instances
| Eq PkgName | |
| Data PkgName | |
Defined in Language.Haskell.TH.Syntax Methodsgfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> PkgName -> c PkgName Source gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c PkgName Source toConstr :: PkgName -> Constr Source dataTypeOf :: PkgName -> DataType Source dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c PkgName) Source dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PkgName) Source gmapT :: (forall b. Data b => b -> b) -> PkgName -> PkgName Source gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PkgName -> r Source gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PkgName -> r Source gmapQ :: (forall d. Data d => d -> u) -> PkgName -> [u] Source gmapQi :: Int -> (forall d. Data d => d -> u) -> PkgName -> u Source gmapM :: Monad m => (forall d. Data d => d -> m d) -> PkgName -> m PkgName Source gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> PkgName -> m PkgName Source gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> PkgName -> m PkgName Source | |
| Ord PkgName | |
Defined in Language.Haskell.TH.Syntax | |
| Show PkgName | |
| Generic PkgName | |
| type Rep PkgName | |
Defined in Language.Haskell.TH.Syntax | |
Instances
| Eq ModName | |
| Data ModName | |
Defined in Language.Haskell.TH.Syntax Methodsgfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ModName -> c ModName Source gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ModName Source toConstr :: ModName -> Constr Source dataTypeOf :: ModName -> DataType Source dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ModName) Source dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ModName) Source gmapT :: (forall b. Data b => b -> b) -> ModName -> ModName Source gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ModName -> r Source gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ModName -> r Source gmapQ :: (forall d. Data d => d -> u) -> ModName -> [u] Source gmapQi :: Int -> (forall d. Data d => d -> u) -> ModName -> u Source gmapM :: Monad m => (forall d. Data d => d -> m d) -> ModName -> m ModName Source gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ModName -> m ModName Source gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ModName -> m ModName Source | |
| Ord ModName | |
Defined in Language.Haskell.TH.Syntax | |
| Show ModName | |
| Generic ModName | |
| type Rep ModName | |
Defined in Language.Haskell.TH.Syntax | |
class (MonadIO m, MonadFail m) => Quasi m where Source
Minimal complete definition
qNewName, qReport, qRecover, qLookupName, qReify, qReifyFixity, qReifyType, qReifyInstances, qReifyRoles, qReifyAnnotations, qReifyModule, qReifyConStrictness, qLocation, qAddDependentFile, qAddTempFile, qAddTopDecls, qAddForeignFilePath, qAddModFinalizer, qAddCorePlugin, qGetQ, qPutQ, qIsExtEnabled, qExtsEnabled
Methods
Arguments
| :: Bool | |
| -> String | |
| -> m () | Report an error (True) or warning (False) ...but carry on; use |
Arguments
| :: m a | the error handler |
| -> m a | action which may fail |
| -> m a | Recover from the monadic |
qLookupName :: Bool -> String -> m (Maybe Name) Source
qReify :: Name -> m Info Source
qReifyFixity :: Name -> m (Maybe Fixity) Source
qReifyType :: Name -> m Type Source
qReifyInstances :: Name -> [Type] -> m [Dec] Source
qReifyRoles :: Name -> m [Role] Source
qReifyAnnotations :: Data a => AnnLookup -> m [a] Source
qReifyModule :: Module -> m ModuleInfo Source
qReifyConStrictness :: Name -> m [DecidedStrictness] Source
qAddDependentFile :: FilePath -> m () Source
qAddTempFile :: String -> m FilePath Source
qAddTopDecls :: [Dec] -> m () Source
qAddForeignFilePath :: ForeignSrcLang -> String -> m () Source
qAddModFinalizer :: Q () -> m () Source
qAddCorePlugin :: String -> m () Source
qGetQ :: Typeable a => m (Maybe a) Source
qPutQ :: Typeable a => a -> m () Source
qIsExtEnabled :: Extension -> m Bool Source
qExtsEnabled :: m [Extension] Source
Instances
badIO :: String -> IO a Source
runQ :: Quasi m => Q a -> m a Source
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.
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.
Recover from errors raised by reportError or fail.
lookupName :: Bool -> String -> Q (Maybe Name) Source
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.
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.
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 Just (Fixity 7 InfixR). If the function bar does not have a fixity declaration, then reifyFixity 'bar returns Nothing, so you may assume bar has defaultFixity.
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.
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 [ TupleT 2 `AppT` ConT ''A `AppT` ConT ''B ]contains theinstance (Eq a, Eq b) => Eq (a, b)regardless of whetherAandBthemselves implementEq -
reifyInstances ''Show [ VarT (mkName "a") ]produces every available instance ofEq
There is one edge case: reifyInstances ''Typeable tys currently always produces an empty list (no matter what tys are given).
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.
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.
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.
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 [DecidedLazy, DecidedLazy] under most circumstances, but it would return [DecidedStrict, DecidedStrict] if the -XStrictData language extension was enabled.
isInstance :: Name -> [Type] -> Q Bool Source
Is the list of instances returned by reifyInstances nonempty?
The location at which this computation is spliced.
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.
addDependentFile :: FilePath -> Q () Source
Record external files that runIO is using (dependent upon). The compiler can then recognize that it should re-compile the Haskell file when an external file changes.
Expects an absolute file path.
Notes:
- ghc -M does not know about these dependencies - it does not execute TH.
- The dependency is based on file content, not a modification time
addTempFile :: String -> Q FilePath Source
Obtain a temporary file path with the given suffix. The compiler will delete this file after compilation.
addTopDecls :: [Dec] -> Q () Source
Add additional top-level declarations. The added declarations will be type checked along with the current declaration group.
addForeignFile :: ForeignSrcLang -> String -> Q () Source
Deprecated: Use addForeignSource instead
addForeignSource :: ForeignSrcLang -> String -> Q () Source
Emit a foreign file which will be compiled and linked to the object for the current module. Currently only languages that can be compiled with the C compiler are supported, and the flags passed as part of -optc will be also applied to the C compiler invocation that will compile them.
Note that for non-C languages (for example C++) extern C directives must be used to get symbols that we can access from Haskell.
To get better errors, it is recommended to use #line pragmas when emitting C files, e.g.
{-# LANGUAGE CPP #-}
...
addForeignSource LangC $ unlines
[ "#line " ++ show (562 + 1) ++ " " ++ show "libraries/template-haskell/./Language/Haskell/TH/Syntax.hs"
, ...
]
addForeignFilePath :: ForeignSrcLang -> FilePath -> Q () Source
Same as addForeignSource, but expects to receive a path pointing to the foreign file instead of a String of its contents. Consider using this in conjunction with addTempFile.
This is a good alternative to addForeignSource when you are trying to directly link in an object file.
addModFinalizer :: Q () -> Q () Source
Add a finalizer that will run in the Q monad after the current module has been type checked. This only makes sense when run within a top-level splice.
The finalizer is given the local type environment at the splice point. Thus reify is able to find the local definitions when executed inside the finalizer.
addCorePlugin :: String -> Q () Source
Adds a core plugin to the compilation pipeline.
addCorePlugin m has almost the same effect as passing -fplugin=m to ghc in the command line. The major difference is that the plugin module m must not belong to the current package. When TH executes, it is too late to tell the compiler that we needed to compile first a plugin module in the current package.
getQ :: Typeable a => Q (Maybe a) Source
Get state from the Q monad. Note that the state is local to the Haskell module in which the Template Haskell expression is executed.
putQ :: Typeable a => a -> Q () Source
Replace the state in the Q monad. Note that the state is local to the Haskell module in which the Template Haskell expression is executed.
isExtEnabled :: Extension -> Q Bool Source
Determine whether the given language extension is enabled in the Q monad.
extsEnabled :: Q [Extension] Source
List all enabled language extensions.
dataToQa :: forall a k q. Data a => (Name -> k) -> (Lit -> Q q) -> (k -> [Q q] -> Q q) -> (forall b. Data b => b -> Maybe (Q q)) -> a -> Q q Source
dataToQa is an internal utility function for constructing generic conversion functions from types with Data instances to various quasi-quoting representations. See the source of dataToExpQ and dataToPatQ for two example usages: mkCon, mkLit and appQ are overloadable to account for different syntax for expressions and patterns; antiQ allows you to override type-specific cases, a common usage is just const Nothing, which results in no overloading.
dataToExpQ :: Data a => (forall b. Data b => b -> Maybe (Q Exp)) -> a -> Q Exp Source
dataToExpQ converts a value to a 'Q Exp' representation of the same value, in the SYB style. It is generalized to take a function override type-specific cases; see liftData for a more commonly used variant.
liftData :: Data a => a -> Q Exp Source
liftData is a variant of lift in the Lift type class which works for any type with a Data instance.
dataToPatQ :: Data a => (forall b. Data b => b -> Maybe (Q Pat)) -> a -> Q Pat Source
dataToPatQ converts a value to a 'Q Pat' representation of the same value, in the SYB style. It takes a function to handle type-specific cases, alternatively, pass const Nothing to get default behavior.
mkModName :: String -> ModName Source
modString :: ModName -> String Source
mkPkgName :: String -> PkgName Source
pkgString :: PkgName -> String Source
mkOccName :: String -> OccName Source
occString :: OccName -> String Source
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
mkNameU :: String -> Uniq -> Name Source
Only used internally
mkNameG :: NameSpace -> String -> String -> String -> Name Source
Used for 'x etc, but not available to the programmer
showName :: Name -> String Source
showName' :: NameIs -> Name -> String Source
tupleDataName :: Int -> Name Source
Tuple data constructor
tupleTypeName :: Int -> Name Source
Tuple type constructor
unboxedTupleDataName :: Int -> Name Source
Unboxed tuple data constructor
unboxedTupleTypeName :: Int -> Name Source
Unboxed tuple type constructor
mk_tup_name :: Int -> NameSpace -> Bool -> Name Source
unboxedSumDataName :: SumAlt -> SumArity -> Name Source
Unboxed sum data constructor
unboxedSumTypeName :: SumArity -> Name Source
Unboxed sum type constructor
Highest allowed operator precedence for Fixity constructor (answer: 9)
defaultFixity :: Fixity Source
Default fixity: infixl 9
cmpEq :: Ordering -> Bool Source
thenCmp :: Ordering -> Ordering -> Ordering Source
Language extensions
module Language.Haskell.TH.LanguageExtensions
data ForeignSrcLang Source
Foreign formats supported by GHC via TH
Constructors
| LangC | C |
| LangCxx | C++ |
| LangObjc | Objective C |
| LangObjcxx | Objective C++ |
| LangAsm | Assembly language (.s) |
| RawObject | Object (.o) |
Instances
© The University of Glasgow and others
Licensed under a BSD-style license (see top of the page).
https://downloads.haskell.org/~ghc/8.10.2/docs/html/libraries/template-haskell-2.16.0.0/Language-Haskell-TH-Syntax.html