| 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 |
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 :: Q (TExp a) -> Q Exp Source
unsafeTExpCoerce :: Q Exp -> Q (TExp a) Source
liftString :: String -> Q Exp 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 ([| ... |]) but not at the top level. As an example:
add1 :: Int -> Q Exp 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 for all x, where $(...) is a Template Haskell splice.
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
Nothing
Turn a value into a Template Haskell expression, suitable for use in a splice.
| 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 [Exp] | { (e1,e2) } |
| UnboxedTupE [Exp] | { (# e1,e2 #) } |
| 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 |
|
| 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 | |
| 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])))) | |
| 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 | |
| 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])))) | |
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 } |
| ForallT [TyVarBndr] Cxt Type | forall <vars>. <ctxt> => <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 |
| 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 } |
| 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. |
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):
'f and ''T can be used to construct names, The expression 'f gives a Name which refers to the value f currently in scope, and ''T gives a Name which refers to the type T currently in scope. These names can never be captured.lookupValueName and lookupTypeName are similar to 'f and ''T respectively, but the Names 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.
| Name OccName NameFlavour |
| 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 | |
| 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))) | |
| 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 | |
| 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.
data InjectivityAnn Source
Injectivity annotation
| InjectivityAnn Name [Name] |
Varieties of allowed instance overlap.
| Overlappable | May be overlapped by more specific instances |
| Overlapping | May overlap a more general instance |
| Overlaps | Both |
| Incoherent | Both |
| 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 | |
| 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
| AnnLookupModule Module | |
| AnnLookupName Name |
| 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
| NominalR | nominal |
| RepresentationalR | representational |
| PhantomR | phantom |
| InferR | _ |
| 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 | |
| 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))) | |
| 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 | |
| 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
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 |
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 |
| 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
| Bang SourceUnpackedness SourceStrictness | C { {-# UNPACK #-} !}a |
| 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 | |
| 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:
ForallC surrounds a constructor with vanilla syntax, then the ForallC 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.
ForallC surrounds a constructor with GADT syntax, then the ForallC 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] 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 |
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.
| DecidedLazy | |
| DecidedStrict | |
| DecidedUnpack |
data SourceStrictness Source
| NoSourceStrictness | C a |
| SourceLazy | C {~}a |
| SourceStrict | C {!}a |
data SourceUnpackedness Source
| NoSourceUnpackedness | C a |
| SourceNoUnpack | C { {-# NOUNPACK #-} } a |
| SourceUnpack | C { {-# UNPACK #-} } a |
| = [Pred] | (Eq a, Ord b) |
| ModuleAnnotation | |
| TypeAnnotation Name | |
| ValueAnnotation Name |
| 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)))) | |
| RuleVar Name | |
| TypedRuleVar Name Type |
| 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))) | |
| AllPhases | |
| FromPhase Int | |
| BeforePhase Int |
| 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 | |
| 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)))) | |
| 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 | |
| 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 | |
| Show Inline | |
| Generic Inline | |
| Ppr Inline | |
| type Rep Inline | |
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 ] #-} } |
| Unsafe | |
| Safe | |
| Interruptible |
| 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 | |
| Show Safety | |
| Generic Safety | |
| type Rep Safety | |
Defined in Language.Haskell.TH.Syntax | |
| CCall | |
| StdCall | |
| CApi | |
| Prim | |
| JavaScript |
| 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)))) | |
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)
| 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.
| TypeFamilyHead Name [TyVarBndr] FamilyResultSig (Maybe InjectivityAnn) |
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:
t1, t2, .., tn of x1, x2, .., xn, respectivelyt 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:
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.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.
data DerivStrategy Source
What the user explicitly requests when deriving an instance.
| StockStrategy | A "standard" derived instance |
| AnyclassStrategy | -XDeriveAnyClass |
| NewtypeStrategy | -XGeneralizedNewtypeDeriving |
| ViaStrategy Type | -XDerivingVia |
| Eq DerivStrategy | |
Defined in Language.Haskell.TH.Syntax Methods(==) :: DerivStrategy -> DerivStrategy -> Bool (/=) :: DerivStrategy -> DerivStrategy -> Bool | |
| Data DerivStrategy | |
Defined in Language.Haskell.TH.Syntax Methodsgfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DerivStrategy -> c DerivStrategy Source gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DerivStrategy Source toConstr :: DerivStrategy -> Constr Source dataTypeOf :: DerivStrategy -> DataType Source dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c DerivStrategy) Source dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DerivStrategy) Source gmapT :: (forall b. Data b => b -> b) -> DerivStrategy -> DerivStrategy Source gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DerivStrategy -> r Source gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DerivStrategy -> r Source gmapQ :: (forall d. Data d => d -> u) -> DerivStrategy -> [u] Source gmapQi :: Int -> (forall d. Data d => d -> u) -> DerivStrategy -> u Source gmapM :: Monad m => (forall d. Data d => d -> m d) -> DerivStrategy -> m DerivStrategy Source gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DerivStrategy -> m DerivStrategy Source gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DerivStrategy -> m DerivStrategy Source | |
| Ord DerivStrategy | |
Defined in Language.Haskell.TH.Syntax | |