template-haskell-2.5.0.0

Language.Haskell.TH

Contents

Description

The public face of Template Haskell

For other documentation, refer to: http://www.haskell.org/haskellwiki/Template_Haskell

Synopsis

The monad and its operations

data Q a Source

Instances

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

recoverSource

Arguments

:: Q a

recover with this one

-> Q a

failing action

-> Q a 

reify :: Name -> Q InfoSource

reify looks up information about the Name

location :: Q LocSource

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.

classInstances :: Name -> [Type] -> Q [Name]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

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

nameBase :: Name -> StringSource

Base, unqualified name.

tupleTypeNameSource

Arguments

:: Int 
-> Name

Type constructor

tupleDataNameSource

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

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?

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

Instances

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

data Type Source

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

Constructors

StarK
*
ArrowK Kind Kind
k1 -> k2

type CxtSource

Arguments

 = [Pred]
(Eq a, Ord b)

data Pred Source

Constructors

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

data Match Source

Constructors

Match Pat Body [Dec]
case e of { pat -> body where decs }

data Clause Source

Constructors

Clause [Pat] Body [Dec]
f { p1 p2 = body where decs }

data Body Source

Constructors

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

data Guard Source

Constructors

NormalG Exp 
PatG [Stmt] 

data Stmt Source

Constructors

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

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

data Pat Source

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 }

Instances

data Info Source

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

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]
 

Library functions

Abbreviations

type DecsQ = Q [Dec]Source

Constructors lifted to Q

Literals

Patterns

Pattern Guards

match :: PatQ -> BodyQ -> [DecQ] -> MatchQSource

Use with caseE

clause :: [PatQ] -> BodyQ -> [DecQ] -> ClauseQSource

Use with funD

Expressions

dyn :: String -> Q ExpSource

Dynamically binding a variable (unhygenic)

lam1E :: PatQ -> ExpQ -> ExpQSource

Single-arg lambda

Ranges

Ranges with more indirection

Statements

Types

Strictness

Class Contexts

Top Level Declarations

Data

valD :: PatQ -> BodyQ -> [DecQ] -> DecQSource

dataD :: CxtQ -> Name -> [TyVarBndr] -> [ConQ] -> [Name] -> DecQSource

Class

classD :: CxtQ -> Name -> [TyVarBndr] -> [FunDep] -> [DecQ] -> DecQSource

Type Family / Data Family

dataInstD :: CxtQ -> Name -> [TypeQ] -> [ConQ] -> [Name] -> DecQSource

Foreign Function Interface (FFI)

Pragmas

Just inline supported so far

Pretty-printer

pprint :: Ppr a => a -> StringSource