template-haskell-2.6.0.0

Portabilityportable
Stabilityexperimental
Maintainerlibraries@haskell.org
Safe HaskellNone

Language.Haskell.TH.Syntax

Contents

Description

Abstract syntax definitions for Template Haskell.

Synopsis

Documentation

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

Methods

qNewNameSource

Arguments

:: String 
-> m Name

Fresh names

qReportSource

Arguments

:: Bool 
-> String 
-> m ()

Report an error (True) or warning (False) ...but carry on; use fail to stop

qRecoverSource

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 InfoSource

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

qLocation :: m LocSource

qRunIO :: IO a -> m aSource

Input/output (dangerous)

qAddDependentFile :: FilePath -> m ()Source

Instances

class Lift t whereSource

Methods

lift :: t -> Q ExpSource

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) 

data Q a Source

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.

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.

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 

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.

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 
InfixD Fixity Name
{ infix 3 foo }
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?

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

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
AppT Type Type
T a b
SigT Type Kind
t :: k
VarT Name
a
ConT Name
T
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.

type Kind = TypeSource

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.

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 [Word8]

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

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 

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.

mkNameL :: String -> Uniq -> NameSource

Only used internally

mkNameU :: String -> Uniq -> NameSource

Only used internally

tupleTypeNameSource

Arguments

:: Int 
-> Name

Type constructor

tupleDataNameSource

Arguments

:: Int 
-> Name

Data constructor

unboxedTupleTypeNameSource

Arguments

:: Int 
-> Name

Type constructor

unboxedTupleDataNameSource

Arguments

:: Int 
-> Name

Data constructor