Portability	portable
Stability	experimental
Maintainer	libraries@haskell.org
Safe Haskell	Safe-Infered

Language.Haskell.TH.Syntax

Contents

Names
The algebraic data types
Internal functions

Description

Abstract syntax definitions for Template Haskell.

Synopsis

Documentation

class (Monad m, Applicative m) => Quasi m whereSource

Methods

qNewName Source

Arguments

:: String
-> m Name	Fresh names

qReport Source

Arguments

:: Bool
-> String
-> m ()	Report an error (True) or warning (False) ...but carry on; use `fail` to stop

qRecover Source

Arguments

:: m a	the error handler
-> m a	action which may fail
-> m a	Recover from the monadic `fail`

qLookupName :: Bool -> String -> m (Maybe Name)Source

qReify :: Name -> m Info Source

qReifyInstances :: Name -> [Type] -> m [Dec]Source

qLocation :: m Loc Source

qRunIO :: IO a -> m aSource

Input/output (dangerous)

qAddDependentFile :: FilePath -> m ()Source

Instances

Quasi IO
Quasi Q

class Lift t whereSource

Methods

lift :: t -> Q Exp Source

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 Exp Source

data Q a Source

Instances

Monad Q
Functor Q
Applicative Q
Quasi Q

runQ :: Quasi m => Q a -> m aSource

report :: Bool -> String -> Q ()Source

recover Source

Arguments

:: Q a	recover with this one
-> Q a	failing action
-> Q a

reify :: Name -> Q Info Source

reify looks up information about the Name

lookupTypeName, lookupValueName :: String -> Q (Maybe Name)Source

location :: Q Loc Source

location gives you the Location at which this computation is spliced.

runIO :: IO a -> Q aSource

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.

addDependentFile :: FilePath -> Q ()Source

Record external files that runIO is using (dependent upon). The compiler can then recognize that it should re-compile the file using this TH when the external file changes. Note that ghc -M will still not know about these dependencies - it does not execute TH. Expects an absolute file path.

isInstance :: Name -> [Type] -> Q Bool Source

reifyInstances :: Name -> [Type] -> Q [Dec]Source

classInstances looks up instaces of a class

Names

data Name Source

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

Instances

Eq Name
Data Name
Ord Name
Show Name
Typeable Name
Ppr Name

mkName :: String -> Name Source

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

newName :: String -> Q Name Source

nameBase :: Name -> String Source

Base, unqualified name.

nameModule :: Name -> Maybe String Source

showName :: Name -> String Source

showName' :: NameIs -> Name -> String Source

data NameIs Source

Constructors

Alone
Applied
Infix

The algebraic data types

Note [Unresolved infix] ~~~~~~~~~~~~~~~~~~~~~~~

When implementing antiquotation for quasiquoters, one often wants to parse strings into expressions:

 parse :: String -> Maybe 'Exp'

But how should we parse a + b * c? If we don't know the fixities of + and *, we don't know whether to parse it as a + (b * c) or (a + b) * c.

In cases like this, use UInfixE or UInfixP, which stand for "unresolved infix expression" and "unresolved infix pattern". When the compiler is given a splice containing a tree of UInfixE applications such as

 UInfixE
   (UInfixE e1 op1 e2)
   op2
   (UInfixE e3 op3 e4)

it will look up and the fixities of the relevant operators and reassociate the tree as necessary.

trees will not be reassociated across ParensE or ParensP, which are of use for parsing expressions like

 (a + b * c) + d * e

InfixE and InfixP expressions are never reassociated.
The UInfixE constructor doesn't support sections. Sections such as (a *) have no ambiguity, so InfixE suffices. For longer sections such as (a + b * c -), use an InfixE constructor for the outer-most section, and use UInfixE constructors for all other operators:

 InfixE
   Just (UInfixE ...a + b * c...)
   op
   Nothing

Sections such as (a + b +) and ((a + b) +) should be rendered into Exps differently:

 (+ a + b)   ---> InfixE Nothing + (Just $ UInfixE a + b)
                    -- will result in a fixity error if (+) is left-infix
 (+ (a + b)) ---> InfixE Nothing + (Just $ ParensE $ UInfixE a + b)
                    -- no fixity errors

Quoted expressions such as

 [| a * b + c |] :: Q Exp
 [p| a : b : c |] :: Q Pat

will never contain UInfixE, UInfixP, ParensE, or ParensP constructors.

data Dec Source

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) }

Instances

Eq Dec
Data Dec
Show Dec
Typeable Dec
Ppr Dec

data Exp Source

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 `c`}
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?
UInfixE Exp Exp Exp	{x + y} See Note [Unresolved infix] at Language.Haskell.TH.Syntax
ParensE Exp	{ (e) } See Note [Unresolved infix] at Language.Haskell.TH.Syntax
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 } }

Instances

Eq Exp
Data Exp
Show Exp
Typeable Exp
Ppr Exp

data Con Source

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]

Instances

Eq Con
Data Con
Show Con
Typeable Con
Ppr Con

data Type Source

Constructors

ForallT [TyVarBndr] Cxt Type	forall vars. ctxt -> type
VarT Name	a
ConT Name	T
TupleT Int	(,), (,,), etc.
UnboxedTupleT Int	(), (), etc.
ArrowT	->
ListT	[]
AppT Type Type	T a b
SigT Type Kind	t :: k

Instances

Eq Type
Data Type
Show Type
Typeable Type
Ppr Type

data TyVarBndr Source

Constructors

PlainTV Name	a
KindedTV Name Kind	(a :: k)

Instances

Eq TyVarBndr
Data TyVarBndr
Show TyVarBndr
Typeable TyVarBndr
Ppr TyVarBndr

data Kind Source

Constructors

StarK	`*`
ArrowK Kind Kind	k1 -> k2

Instances

Eq Kind
Data Kind
Show Kind
Typeable Kind
Ppr Kind

type Cxt Source

Arguments

= [Pred]

(Eq a, Ord b)

data Pred Source

Constructors

ClassP Name [Type]	Eq (Int, a)
EqualP Type Type	F a ~ Bool

Instances

Eq Pred
Data Pred
Show Pred
Typeable Pred
Ppr Pred

data Match Source

Constructors

Match Pat Body [Dec]

case e of { pat -> body where decs }

Instances

Eq Match
Data Match
Show Match
Typeable Match
Ppr Match

data Clause Source

Constructors

Clause [Pat] Body [Dec]

f { p1 p2 = body where decs }

Instances

Eq Clause
Data Clause
Show Clause
Typeable Clause
Ppr Clause

data Body Source

Constructors

GuardedB [(Guard, Exp)]	f p { \| e1 = e2 \| e3 = e4 } where ds
NormalB Exp	f p { = e } where ds

Instances

Eq Body
Data Body
Show Body
Typeable Body

data Guard Source

Constructors

NormalG Exp
PatG [Stmt]

Instances

Eq Guard
Data Guard
Show Guard
Typeable Guard

data Stmt Source

Constructors

BindS Pat Exp
LetS [Dec]
NoBindS Exp
ParS [[Stmt]]

Instances

Eq Stmt
Data Stmt
Show Stmt
Typeable Stmt
Ppr Stmt

data Range Source

Constructors

FromR Exp
FromThenR Exp Exp
FromToR Exp Exp
FromThenToR Exp Exp Exp

Instances

Eq Range
Data Range
Show Range
Typeable Range
Ppr Range

data Lit Source

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#

Instances

Eq Lit
Data Lit
Show Lit
Typeable Lit

data Pat Source

Pattern in Haskell given in {}

Constructors

LitP Lit	{ 5 or `c` }
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
UInfixP Pat Name Pat	foo ({x :+ y}) = e See Note [Unresolved infix] at Language.Haskell.TH.Syntax
ParensP Pat	{(p)} See Note [Unresolved infix] at Language.Haskell.TH.Syntax
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

Eq Pat
Data Pat
Show Pat
Typeable Pat
Ppr Pat

type FieldExp = (Name, Exp)Source

type FieldPat = (Name, Pat)Source

data Strict Source

Constructors

IsStrict
NotStrict
Unpacked

Instances

Eq Strict
Data Strict
Show Strict
Typeable Strict

data Foreign Source

Constructors

ImportF Callconv Safety String Name Type
ExportF Callconv String Name Type

Instances

Eq Foreign
Data Foreign
Show Foreign
Typeable Foreign
Ppr Foreign

data Callconv Source

Constructors

CCall
StdCall

Instances

Eq Callconv
Data Callconv
Show Callconv
Typeable Callconv

data Safety Source

Constructors

Unsafe
Safe
Interruptible

Instances

Eq Safety
Data Safety
Show Safety
Typeable Safety

data Pragma Source

Constructors

InlineP Name InlineSpec
SpecialiseP Name Type (Maybe InlineSpec)

Instances

Eq Pragma
Data Pragma
Show Pragma
Typeable Pragma
Ppr Pragma

data InlineSpec Source

Constructors

InlineSpec Bool Bool (Maybe (Bool, Int))

Instances

Eq InlineSpec
Data InlineSpec
Show InlineSpec
Typeable InlineSpec

type StrictType = (Strict, Type)Source

type VarStrictType = (Name, Strict, Type)Source

data FunDep Source

Constructors

FunDep [Name] [Name]

Instances

Eq FunDep
Data FunDep
Show FunDep
Typeable FunDep
Ppr FunDep

data FamFlavour Source

Constructors

TypeFam
DataFam

Instances

Eq FamFlavour
Data FamFlavour
Show FamFlavour
Typeable FamFlavour
Ppr FamFlavour

data Info Source

Obtained from reify in the Q Monad.

Constructors

ClassI Dec [InstanceDec]	A class is reified to its declaration and a list of its instances
ClassOpI Name Type Name Fixity
TyConI Dec
FamilyI Dec [InstanceDec]
PrimTyConI Name Int Bool
DataConI Name Type Name Fixity
VarI Name Type (Maybe Dec) Fixity
TyVarI Name Type

Instances

Data Info
Show Info
Typeable Info
Ppr Info

data Loc Source

Constructors

Loc
Fields loc_filename :: String loc_package :: String loc_module :: String loc_start :: CharPos loc_end :: CharPos

type CharPos = (Int, Int)Source

data Fixity Source

Constructors

Fixity Int FixityDirection

Instances

Eq Fixity
Data Fixity
Show Fixity
Typeable Fixity

data FixityDirection Source

Constructors

InfixL
InfixR
InfixN

Instances

Eq FixityDirection
Data FixityDirection
Show FixityDirection
Typeable FixityDirection

defaultFixity :: Fixity Source

maxPrecedence :: Int Source

Internal functions

returnQ :: a -> Q aSource

bindQ :: Q a -> (a -> Q b) -> Q bSource

sequenceQ :: [Q a] -> Q [a]Source

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

data NameSpace Source

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
Ord NameSpace
Typeable NameSpace

mkNameG_v, mkNameG_d, mkNameG_tc :: String -> String -> String -> Name Source

type Uniq = Int Source

mkNameL :: String -> Uniq -> Name Source

Only used internally

mkNameU :: String -> Uniq -> Name Source

Only used internally

tupleTypeName Source

Arguments

:: Int
-> Name	Type constructor

tupleDataName Source

Arguments

:: Int
-> Name	Data constructor

unboxedTupleTypeName Source

Arguments

:: Int
-> Name	Type constructor

unboxedTupleDataName Source

Arguments

:: Int
-> Name	Data constructor

data OccName Source

Instances

Eq OccName
Data OccName
Ord OccName
Typeable OccName

mkOccName :: String -> OccName Source

occString :: OccName -> String Source

data ModName Source

Instances

Eq ModName
Data ModName
Ord ModName
Typeable ModName

mkModName :: String -> ModName Source

modString :: ModName -> String Source

data PkgName Source

Instances

Eq PkgName
Data PkgName
Ord PkgName
Typeable PkgName

mkPkgName :: String -> PkgName Source

pkgString :: PkgName -> String Source