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.

Querying the compiler

Reify

reify :: Name -> Q Info Source

reify looks up information about the Name .

It is sometimes useful to construct the argument name using lookupTypeName or lookupValueName to ensure that we are reifying from the right namespace. For instance, in this context:

data D = D

which D does reify (mkName "D") return information about? (Answer: D-the-type, but don't rely on it.) To ensure we get information about D-the-value, use lookupValueName :

do
 Just nm <- lookupValueName "D"
 reify nm

and to get information about D-the-type, use lookupTypeName .

reifyModule :: Module -> Q ModuleInfo Source

reifyModule mod looks up information about module mod. To look up the current module, call this function with the return value of thisModule.

thisModule :: Q Module Source

Return the Module at the place of splicing. Can be used as an input for reifyModule .

data Info Source

Obtained from reify in the Q Monad.

Constructors

ClassI Dec [InstanceDec]

A class, with a list of its visible instances

ClassOpI Name Type ParentName Fixity

A class method

TyConI Dec

A "plain" type constructor. "Fancier" type constructors are returned using PrimTyConI or FamilyI as appropriate

FamilyI Dec [InstanceDec]

A type or data family, with a list of its visible instances. A closed type family is returned with 0 instances.

PrimTyConI Name Arity Unlifted

A "primitive" type constructor, which can't be expressed with a Dec . Examples: (->), Int#.

DataConI Name Type ParentName Fixity

A data constructor

VarI Name Type (Maybe Dec) Fixity

A "value" variable (as opposed to a type variable, see TyVarI ).

The Maybe Dec field contains Just the declaration which defined the variable -- including the RHS of the declaration -- or else Nothing, in the case where the RHS is unavailable to the compiler. At present, this value is _always_ Nothing: returning the RHS has not yet been implemented because of lack of interest.

TyVarI Name Type

A type variable.

The Type field contains the type which underlies the variable. At present, this is always VarT theName, but future changes may permit refinement of this.

Instances

Data Info

Show Info

Ppr Info

Typeable * Info

data ModuleInfo Source

Obtained from reifyModule in the Q Monad.

Constructors

ModuleInfo [Module]

Contains the import list of the module.

Instances

Data ModuleInfo

Show ModuleInfo

Ppr ModuleInfo

Typeable * ModuleInfo

type InstanceDec = Dec Source

InstanceDec desribes a single instance of a class or type function. It is just a Dec , but guaranteed to be one of the following:

InstanceD (with empty [Dec ])
DataInstD or NewtypeInstD (with empty derived [Name ])
TySynInstD

type ParentName = Name Source

In ClassOpI and DataConI , name of the parent class or type

type Arity = Int Source

In PrimTyConI , arity of the type constructor

type Unlifted = Bool Source

In PrimTyConI , is the type constructor unlifted?

Name lookup

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

Look up the given name in the (type namespace of the) current splice's scope. See "Language.Haskell.TH.Syntax#namelookup" for more details.

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

Look up the given name in the (value namespace of the) current splice's scope. See "Language.Haskell.TH.Syntax#namelookup" for more details.

Instance lookup

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

reifyInstances nm tys returns a list of visible instances of nm tys. That is, if nm is the name of a type class, then all instances of this class at the types tys are returned. Alternatively, if nm is the name of a data family or type family, all instances of this family at the types tys are returned.

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

Is the list of instances returned by reifyInstances nonempty?

Roles lookup

reifyRoles :: Name -> Q [Role] Source

reifyRoles nm returns the list of roles associated with the parameters of the tycon nm. Fails if nm cannot be found or is not a tycon. The returned list should never contain InferR .

Annotation lookup

reifyAnnotations :: Data a => AnnLookup -> Q [a] Source

reifyAnnotations target returns the list of annotations associated with target. Only the annotations that are appropriately typed is returned. So if you have Int and String annotations for the same target, you have to call this function twice.

data AnnLookup Source

Annotation target for reifyAnnotations

Constructors

AnnLookupModule Module

AnnLookupName Name

Instances

Eq AnnLookup

Data AnnLookup

Show AnnLookup

Typeable * AnnLookup

Typed expressions

data TExp a Source

unType :: TExp a -> Exp Source

Names

data Name Source

An abstract type representing names in the syntax tree.

Name s can be constructed in several ways, which come with different name-capture guarantees (see "Language.Haskell.TH.Syntax#namecapture" for an explanation of name capture):

the built-in syntax '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.

Instances

Eq Name

Data Name

Ord Name

Show Name

Ppr Name

Typeable * Name

data NameSpace Source

Instances

Eq NameSpace

Data NameSpace

Ord NameSpace

Typeable * NameSpace

Constructing names

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") |]

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.

Deconstructing names

nameBase :: Name -> String Source

The name without its module prefix

nameModule :: Name -> Maybe String Source

Module prefix of a name, if it exists

Built-in names

tupleTypeName :: Int -> Name Source

Tuple type constructor

tupleDataName :: Int -> Name Source

Tuple data constructor

unboxedTupleTypeName :: Int -> Name Source

Unboxed tuple type constructor

unboxedTupleDataName :: Int -> Name Source

Unboxed tuple 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 ($( ... ))

Declarations

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

{ foreign import ... }
{ foreign export ... }

InfixD Fixity Name

{ infix 3 foo }

PragmaD Pragma

{ {-# INLINE [1] foo #-} }

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 TySynEqn

{ type instance ... }

ClosedTypeFamilyD Name [TyVarBndr] (Maybe Kind) [TySynEqn]

{ type family F a b :: * where ... }

RoleAnnotD Name [Role]

{ type role T nominal representational }

Instances

Eq Dec

Data Dec

Show Dec

Ppr Dec

Typeable * Dec

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

Ppr Con

Typeable * Con

data Clause Source

Constructors

Clause [Pat] Body [Dec]

f { p1 p2 = body where decs }

Instances

Eq Clause

Data Clause

Show Clause

Ppr Clause

Typeable * Clause

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

Ppr Foreign

Typeable * 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 Inline RuleMatch Phases

SpecialiseP Name Type (Maybe Inline) Phases

SpecialiseInstP Type

RuleP String [RuleBndr] Exp Exp Phases

AnnP AnnTarget Exp

Instances

Eq Pragma

Data Pragma

Show Pragma

Ppr Pragma

Typeable * Pragma

data Inline Source

Constructors

NoInline

Inline

Inlinable

Instances

Eq Inline

Data Inline

Show Inline

Ppr Inline

Typeable * Inline

data RuleMatch Source

Constructors

ConLike

FunLike

Instances

Eq RuleMatch

Data RuleMatch

Show RuleMatch

Ppr RuleMatch

Typeable * RuleMatch

data Phases Source

Constructors

AllPhases

FromPhase Int

BeforePhase Int

Instances

Eq Phases

Data Phases

Show Phases

Ppr Phases

Typeable * Phases

data RuleBndr Source

Constructors

RuleVar Name

TypedRuleVar Name Type

Instances

Eq RuleBndr

Data RuleBndr

Show RuleBndr

Ppr RuleBndr

Typeable * RuleBndr

data AnnTarget Source

Constructors

ModuleAnnotation

TypeAnnotation Name

ValueAnnotation Name

Instances

Eq AnnTarget

Data AnnTarget

Show AnnTarget

Typeable * AnnTarget

data FunDep Source

Constructors

FunDep [Name] [Name]

Instances

Eq FunDep

Data FunDep

Show FunDep

Ppr FunDep

Typeable * FunDep

data FamFlavour Source

Constructors

TypeFam

DataFam

Instances

Typeable * FamFlavour

data TySynEqn Source

One equation of a type family instance or closed type family. The arguments are the left-hand-side type patterns and the right-hand-side result.

Constructors

TySynEqn [Type] Type

Instances

Eq TySynEqn

Data TySynEqn

Show TySynEqn

Typeable * TySynEqn

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

Default fixity: infixl 9

maxPrecedence :: Int Source

Highest allowed operator precedence for Fixity constructor (answer: 9)

Expressions

data Exp Source

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 {(+)}

UInfixE Exp Exp Exp

{x + y}

See "Language.Haskell.TH.Syntax#infix"

ParensE Exp

{ (e) }

See "Language.Haskell.TH.Syntax#infix"

LamE [Pat] Exp

{ p1 p2 -> e }

LamCaseE [Match]

{ case m1; m2 }

TupE [Exp]

{ (e1,e2) }

UnboxedTupE [Exp]

{ (# e1,e2 #) }

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

CompE [Stmt]

{ [ (x,y) | x <- xs, y <- ys ] }

The result expression of the comprehension is the last of the Stmt s, and should be a NoBindS .

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

Instances

Eq Exp

Data Exp

Show Exp

Ppr Exp

Typeable * Exp

data Match Source

Constructors

Match Pat Body [Dec]

case e of { pat -> body where decs }

Instances

Eq Match

Data Match

Show Match

Ppr Match

Typeable * Match

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

f x { | odd x } = x

PatG [Stmt]

f x { | Just y <- x, Just z <- y } = z

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

Ppr Stmt

Typeable * Stmt

data Range Source

Constructors

FromR Exp

FromThenR Exp Exp

FromToR Exp Exp

FromThenToR Exp Exp Exp

Instances

Eq Range

Data Range

Show Range

Ppr Range

Typeable * 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?

StringPrimL [Word8]

A primitive C-style string, type Addr#

Instances

Eq Lit

Data Lit

Show Lit

Typeable * Lit

Patterns

data Pat Source

Pattern in Haskell given in {}

Constructors

LitP Lit

{ 5 or c }

VarP Name

{ x }

TupP [Pat]

{ (p1,p2) }

UnboxedTupP [Pat]

{ (# p1,p2 #) }

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 "Language.Haskell.TH.Syntax#infix"

ParensP Pat

{(p)}

See "Language.Haskell.TH.Syntax#infix"

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

Ppr Pat

Typeable * Pat

type FieldExp = (Name, Exp) Source

type FieldPat = (Name, Pat) Source

Types

data Type Source

Constructors

ForallT [TyVarBndr] Cxt Type

forall <vars>. <ctxt> -> <type>

AppT Type Type

T a b

SigT Type Kind

t :: k

VarT Name

ConT Name

PromotedT Name

'T

TupleT Int

(,), (,,), etc.

UnboxedTupleT Int

(#,#), (#,,#), etc.

ArrowT

->

ListT

[]

PromotedTupleT Int

'(), '(,), '(,,), etc.

PromotedNilT

'[]

PromotedConsT

(':)

StarT

ConstraintT

Constraint

LitT TyLit

0,1,2, etc.

Instances

Eq Type

Data Type

Show Type

Ppr Type

Typeable * Type

data TyVarBndr Source

Constructors

PlainTV Name

KindedTV Name Kind

(a :: k)

Instances

Eq TyVarBndr

Data TyVarBndr

Show TyVarBndr

Ppr TyVarBndr

Typeable * TyVarBndr

data TyLit Source

Constructors

NumTyLit Integer

StrTyLit String

Hello

Instances

Eq TyLit

Data TyLit

Show TyLit

Ppr TyLit

Typeable * TyLit

type Kind = Type Source

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 .