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.

isClassInstance :: Name -> [Type] -> Q Bool

classInstances :: Name -> [Type] -> Q [Name]

classInstances looks up instaces of a class

Names

data Name

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 -> Name

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

nameBase :: Name -> String

Base, unqualified name.

nameModule :: Name -> Maybe String

showName :: Name -> String

showName' :: NameIs -> Name -> String

data NameIs

Constructors

Alone
Applied
Infix

The algebraic data types

data Dec

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

data Exp

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?
LamE [Pat] Exp	{ p1 p2 -> e }
TupE [Exp]	{ (e1,e2) }
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 } }

data Con

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]

data Type

Constructors

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

data TyVarBndr

Constructors

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

data Kind

Constructors

StarK	`*`
ArrowK Kind Kind	k1 -> k2

type Cxt

Arguments

= [Pred]

(Eq a, Ord b)

data Pred

Constructors

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

data Match

Constructors

Match Pat Body [Dec]

case e of { pat -> body where decs }

data Clause

Constructors

Clause [Pat] Body [Dec]

f { p1 p2 = body where decs }

data Body

Constructors

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

data Guard

Constructors

NormalG Exp
PatG [Stmt]

data Stmt

Constructors

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

data Range

Constructors

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

data Lit

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#

data Pat

Pattern in Haskell given in {}

Constructors

LitP Lit	{ 5 or `c` }
VarP Name	{ x }
TupP [Pat]	{ (p1,p2) }
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 }

type FieldExp = (Name, Exp)

type FieldPat = (Name, Pat)

data ClassInstance

ClassInstance desribes a single instance of a class

Constructors

ClassInstance
Fields ci_dfun :: Name ci_tvs :: [TyVarBndr] ci_cxt :: Cxt ci_cls :: Name ci_tys :: [Type]

data Strict

Constructors

IsStrict
NotStrict

data Foreign

Constructors

ImportF Callconv Safety String Name Type
ExportF Callconv String Name Type

data Callconv

Constructors

CCall
StdCall

data Safety

Constructors

Unsafe
Safe
Threadsafe

data Pragma

Constructors

InlineP Name InlineSpec
SpecialiseP Name Type (Maybe InlineSpec)

data InlineSpec

Constructors

InlineSpec Bool Bool (Maybe (Bool, Int))

type StrictType = (Strict, Type)

type VarStrictType = (Name, Strict, Type)

data FunDep

Constructors

FunDep [Name] [Name]

data FamFlavour

Constructors

TypeFam
DataFam

data Info

Obtained from reify in the Q Monad.

Constructors

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

data Loc

Constructors

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

type CharPos = (Int, Int)

data Fixity

Constructors

Fixity Int FixityDirection

data FixityDirection

Constructors

InfixL
InfixR
InfixN

defaultFixity :: Fixity

maxPrecedence :: Int

Internal functions

returnQ :: a -> Q a

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

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

data NameFlavour

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