| Portability | portable |
|---|---|
| Stability | experimental |
| Maintainer | libraries@haskell.org |
| Safe Haskell | Safe-Infered |
Language.Haskell.TH.Syntax
Description
Abstract syntax definitions for Template Haskell.
- class (Monad m, Functor m) => Quasi m where
- class Lift t where
- liftString :: String -> Q Exp
- data Q a
- runQ :: Quasi m => Q a -> m a
- report :: Bool -> String -> Q ()
- recover :: Q a -> Q a -> Q a
- reify :: Name -> Q Info
- location :: Q Loc
- runIO :: IO a -> Q a
- isClassInstance :: Name -> [Type] -> Q Bool
- classInstances :: Name -> [Type] -> Q [ClassInstance]
- data Name = Name OccName NameFlavour
- mkName :: String -> Name
- newName :: String -> Q Name
- nameBase :: Name -> String
- nameModule :: Name -> Maybe String
- showName :: Name -> String
- showName' :: NameIs -> Name -> String
- data NameIs
- data Dec
- = FunD Name [Clause]
- | ValD Pat Body [Dec]
- | DataD Cxt Name [TyVarBndr] [Con] [Name]
- | NewtypeD Cxt Name [TyVarBndr] Con [Name]
- | TySynD Name [TyVarBndr] Type
- | ClassD Cxt Name [TyVarBndr] [FunDep] [Dec]
- | InstanceD Cxt Type [Dec]
- | SigD Name Type
- | ForeignD Foreign
- | PragmaD Pragma
- | FamilyD FamFlavour Name [TyVarBndr] (Maybe Kind)
- | DataInstD Cxt Name [Type] [Con] [Name]
- | NewtypeInstD Cxt Name [Type] Con [Name]
- | TySynInstD Name [Type] Type
- data Exp
- = VarE Name
- | ConE Name
- | LitE Lit
- | AppE Exp Exp
- | InfixE (Maybe Exp) Exp (Maybe Exp)
- | LamE [Pat] Exp
- | TupE [Exp]
- | UnboxedTupE [Exp]
- | CondE Exp Exp Exp
- | LetE [Dec] Exp
- | CaseE Exp [Match]
- | DoE [Stmt]
- | CompE [Stmt]
- | ArithSeqE Range
- | ListE [Exp]
- | SigE Exp Type
- | RecConE Name [FieldExp]
- | RecUpdE Exp [FieldExp]
- data Con
- = NormalC Name [StrictType]
- | RecC Name [VarStrictType]
- | InfixC StrictType Name StrictType
- | ForallC [TyVarBndr] Cxt Con
- data Type
- data TyVarBndr
- data Kind
- type Cxt = [Pred]
- data Pred
- data Match = Match Pat Body [Dec]
- data Clause = Clause [Pat] Body [Dec]
- data Body
- data Guard
- data Stmt
- data Range
- data Lit
- data Pat
- type FieldExp = (Name, Exp)
- type FieldPat = (Name, Pat)
- data ClassInstance = ClassInstance {}
- data Strict
- data Foreign
- data Callconv
- data Safety
- = Unsafe
- | Safe
- | Interruptible
- data Pragma
- data InlineSpec = InlineSpec Bool Bool (Maybe (Bool, Int))
- type StrictType = (Strict, Type)
- type VarStrictType = (Name, Strict, Type)
- data FunDep = FunDep [Name] [Name]
- data FamFlavour
- data Info
- data Loc = Loc {}
- type CharPos = (Int, Int)
- data Fixity = Fixity Int FixityDirection
- data FixityDirection
- defaultFixity :: Fixity
- maxPrecedence :: Int
- returnQ :: a -> Q a
- bindQ :: Q a -> (a -> Q b) -> Q b
- sequenceQ :: [Q a] -> Q [a]
- data NameFlavour
- data NameSpace
- mkNameG_v, mkNameG_d, mkNameG_tc :: String -> String -> String -> Name
- type Uniq = Int
- mkNameL :: String -> Uniq -> Name
- mkNameU :: String -> Uniq -> Name
- tupleTypeName :: Int -> Name
- tupleDataName :: Int -> Name
- unboxedTupleTypeName :: Int -> Name
- unboxedTupleDataName :: Int -> Name
- data OccName
- mkOccName :: String -> OccName
- occString :: OccName -> String
- data ModName
- mkModName :: String -> ModName
- modString :: ModName -> String
- data PkgName
- mkPkgName :: String -> PkgName
- pkgString :: PkgName -> String
Documentation
class (Monad m, Functor m) => Quasi m whereSource
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 |
qReify :: Name -> m InfoSource
qClassInstances :: Name -> [Type] -> m [ClassInstance]Source
Input/output (dangerous)
Instances
| Lift Bool | |
| Lift Char | |
| Lift Int | |
| Lift Integer | |
| Lift a => Lift [a] | |
| Lift a => Lift (Maybe a) | |
| (Lift a, Lift b) => Lift (Either a b) | |
| (Lift a, Lift b) => Lift (a, b) | |
| (Lift a, Lift b, Lift c) => Lift (a, b, c) | |
| (Lift a, Lift b, Lift c, Lift d) => Lift (a, b, c, d) | |
| (Lift a, Lift b, Lift c, Lift d, Lift e) => Lift (a, b, c, d, e) | |
| (Lift a, Lift b, Lift c, Lift d, Lift e, Lift f) => Lift (a, b, c, d, e, f) | |
| (Lift a, Lift b, Lift c, Lift d, Lift e, Lift f, Lift g) => Lift (a, b, c, d, e, f, g) |
liftString :: String -> Q ExpSource
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 necesarily flushed when the compiler finishes running, so you should flush them yourself.
classInstances :: Name -> [Type] -> Q [ClassInstance]Source
classInstances looks up instaces of a class
Names
For global names (NameG) we need a totally unique name,
so we must include the name-space of the thing
For unique-numbered things (NameU), we've got a unique reference
anyway, so no need for name space
For dynamically bound thing (NameS) we probably want them to
in a context-dependent way, so again we don't want the name
space. For example:
let v = mkName "T" in [| data $v = $v |]
Here we use the same Name for both type constructor and data constructor
NameL and NameG are bound *outside* the TH syntax tree either globally (NameG) or locally (NameL). Ex:
f x = $(h [| (map, x) |])
The map will be a NameG, and x wil be a NameL
These Names should never appear in a binding position in a TH syntax tree
Constructors
| Name OccName NameFlavour |
mkName :: String -> NameSource
The string can have a ., thus Foo.baz,
giving a dynamically-bound qualified name,
in which case we want to generate a NameQ
Parse the string to see if it has a . in it so we know whether to generate a qualified or unqualified name It's a bit tricky because we need to parse
Foo.Baz.x as Qual Foo.Baz x
So we parse it from back to front
nameModule :: Name -> Maybe StringSource
The algebraic data types
Constructors
| FunD Name [Clause] | { f p1 p2 = b where decs } |
| ValD Pat Body [Dec] | { p = b where decs } |
| DataD Cxt Name [TyVarBndr] [Con] [Name] | { data Cxt x => T x = A x | B (T x)
deriving (Z,W)} |
| NewtypeD Cxt Name [TyVarBndr] Con [Name] | { newtype Cxt x => T x = A (B x)
deriving (Z,W)} |
| TySynD Name [TyVarBndr] Type | { type T x = (x,x) } |
| ClassD Cxt Name [TyVarBndr] [FunDep] [Dec] | { class Eq a => Ord a where ds } |
| InstanceD Cxt Type [Dec] | { instance Show w => Show [w]
where ds } |
| SigD Name Type | { length :: [a] -> Int } |
| ForeignD Foreign | |
| PragmaD Pragma | { {--} } |
| FamilyD FamFlavour Name [TyVarBndr] (Maybe Kind) | { type family T a b c :: * } |
| DataInstD Cxt Name [Type] [Con] [Name] | { data instance Cxt x => T [x] = A x
| B (T x)
deriving (Z,W)} |
| NewtypeInstD Cxt Name [Type] Con [Name] | { newtype instance Cxt x => T [x] = A (B x)
deriving (Z,W)} |
| TySynInstD Name [Type] Type | { type instance T (Maybe x) = (x,x) } |
The CompE constructor represents a list comprehension, and
takes a [Stmt]. The result expression of the comprehension is
the *last* of these, and should be a NoBindS.
E.g. translation:
[ f x | x <- xs ]
CompE [BindS (VarP x) (VarE xs), NoBindS (AppE (VarE f) (VarE x))]
Constructors
| VarE Name | { x } |
| ConE Name | data T1 = C1 t1 t2; p = {C1} e1 e2 |
| LitE Lit | { 5 or |
| AppE Exp Exp | { f x } |
| InfixE (Maybe Exp) Exp (Maybe Exp) | {x + y} or {(x+)} or {(+ x)} or {(+)}It's a bit gruesome to use an Exp as the operator, but how else can we distinguish constructors from non-constructors? Maybe there should be a var-or-con type? Or maybe we should leave it to the String itself? |
| LamE [Pat] Exp | { p1 p2 -> e } |
| TupE [Exp] | { (e1,e2) } |
| UnboxedTupE [Exp] | { () } |
| CondE Exp Exp Exp | { if e1 then e2 else e3 } |
| LetE [Dec] Exp | { let x=e1; y=e2 in e3 } |
| CaseE Exp [Match] | { case e of m1; m2 } |
| DoE [Stmt] | { do { p <- e1; e2 } } |
| CompE [Stmt] | { [ (x,y) | x <- xs, y <- ys ] } |
| 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 } } |
Constructors
| NormalC Name [StrictType] | C Int a |
| RecC Name [VarStrictType] | C { v :: Int, w :: a } |
| InfixC StrictType Name StrictType | Int :+ a |
| ForallC [TyVarBndr] Cxt Con | forall a. Eq a => C [a] |
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 String | A primitive C-style string, type Addr# |
Pattern in Haskell given in {}
Constructors
| LitP Lit | { 5 or |
| VarP Name | { x } |
| TupP [Pat] | { (p1,p2) } |
| UnboxedTupP [Pat] | { () } |
| ConP Name [Pat] | data T1 = C1 t1 t2; {C1 p1 p1} = e |
| InfixP Pat Name Pat | foo ({x :+ y}) = e |
| 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 } |
data ClassInstance Source
ClassInstance desribes a single instance of a class
Constructors
| ClassInstance | |
Constructors
| Unsafe | |
| Safe | |
| Interruptible |
Constructors
| InlineP Name InlineSpec | |
| SpecialiseP Name Type (Maybe InlineSpec) |
data InlineSpec Source
Instances
type StrictType = (Strict, Type)Source
type VarStrictType = (Name, Strict, Type)Source
data FamFlavour Source
Instances
Constructors
| Loc | |
Fields
| |
Constructors
| Fixity Int FixityDirection |
data FixityDirection Source
Internal functions
data NameFlavour Source
Constructors
| NameS | An unqualified name; dynamically bound |
| NameQ ModName | A qualified name; dynamically bound |
| NameU Int# | A unique local name |
| NameL Int# | 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
| Eq NameFlavour | |
| Data NameFlavour | Although the NameFlavour type is abstract, the Data instance is not. The reason for this is that currently we use Data to serialize values in annotations, and in order for that to work for Template Haskell names introduced via the 'x syntax we need gunfold on NameFlavour to work. Bleh! The long term solution to this is to use the binary package for annotation serialization and then remove this instance. However, to do _that_ we need to wait on binary to become stable, since boot libraries cannot be upgraded seperately from GHC itself. This instance cannot be derived automatically due to bug #2701 |
| Ord NameFlavour | |
| Typeable NameFlavour |