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.

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

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

Instances

Eq Name

Data Name

Ord Name

Show Name

Typeable Name

Ppr Name

data NameSpace Source

Instances

Eq NameSpace

Data NameSpace

Ord NameSpace

Typeable NameSpace

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

tupleTypeName Source

Arguments

:: Int

-> Name

Type constructor

tupleDataName Source

Arguments

:: Int

-> Name

Data constructor

The algebraic data types

The lowercase versions (syntax operators) of these constructors are preferred to these constructors, since they compose better with quotations ([| |]) and splices ($( ... ))

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

ConT Name

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

KindedTV Name Kind

(a :: k)

Instances

Eq 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?

A primitive C-style string, type Addr#

Instances

Eq Lit

Data Lit

Show Lit

Typeable Lit