The monad and its operations

data Q a Source

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

Administration: errors, locations and IO

reportError :: String -> Q () Source

Report an error to the user, but allow the current splice's computation to carry on. To abort the computation, use fail.

reportWarning :: String -> Q () Source

Report a warning to the user, and carry on.

report :: Bool -> String -> Q () Source

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

recover Source

Recover from errors raised by reportError or fail.

location :: Q Loc Source

The location at which this computation is spliced.

data Loc Source

runIO :: IO a -> Q a Source

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 necessarily 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.

data ModuleInfo Source

Obtained from reifyModule in the Q Monad.

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

Typed expressions

data TExp a Source

unType :: TExp a -> Exp Source

Names

data Name Source

An abstract type representing names in the syntax tree.

Names can be constructed in several ways, which come with different name-capture guarantees (see Language.Haskell.TH.Syntax 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.

data NameSpace Source

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

{ f p1 p2 = b where decs }

{ p = b where decs }

{ data Cxt x => T x = A x | B (T x)
       deriving (Z,W)}

{ newtype Cxt x => T x = A (B x)
       deriving (Z,W)}

{ type T x = (x,x) }

{ class Eq a => Ord a where ds }

{ instance Show w => Show [w]
       where ds }

{ length :: [a] -> Int }

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

{ infix 3 foo }

{ {--} }

{ type family T a b c :: * }

{ data instance Cxt x => T [x] = A x
                                | B (T x)
       deriving (Z,W)}

{ newtype instance Cxt x => T [x] = A (B x)
       deriving (Z,W)}

{ type instance ... }

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

{ type role T nominal representational }

{ deriving instance Ord a => Ord (Foo a) }

{ default size :: Data a => a -> Int }

data Con Source

C Int a

C { v :: Int, w :: a }

Int :+ a

forall a. Eq a => C [a]

data Clause Source

f { p1 p2 = body where decs }

data Strict Source

data Foreign Source

data Callconv Source

data Safety Source

data Pragma Source

data Inline Source

data RuleMatch Source

data Phases Source

data RuleBndr Source

data AnnTarget Source

data FunDep Source

data FamFlavour Source

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.

data Fixity Source

data FixityDirection Source

defaultFixity :: Fixity Source

Default fixity: infixl 9

maxPrecedence :: Int Source

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

Expressions

data Exp Source

{ x }

data T1 = C1 t1 t2; p = {C1} e1 e2

{ 5 or c}

{ f x }

{x + y} or {(x+)} or {(+ x)} or {(+)}

{x + y}

{ (e) }

{  p1 p2 -> e }

{ case m1; m2 }

{ (e1,e2) }

{ () }

{ if e1 then e2 else e3 }

{ if | g1 -> e1 | g2 -> e2 }

{ let x=e1;   y=e2 in e3 }

{ case e of m1; m2 }

{ do { p <- e1; e2 }  }

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

[ f x | x <- xs ]

CompE [BindS (VarP x) (VarE xs), NoBindS (AppE (VarE f) (VarE x))]

{ [ 1 ,2 .. 10 ] }

{ [1,2,3] }

{ e :: t }

{ T { x = y, z = w } }

{ (f x) { z = w } }

{ static e }

data Match Source

case e of { pat -> body where decs }

data Body Source

f p { | e1 = e2
      | e3 = e4 }
 where ds

f p { = e } where ds

data Guard Source

f x { | odd x } = x

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

data Stmt Source

data Range Source

data Lit Source

Patterns

data Pat Source

Pattern in Haskell given in {}

{ 5 or c }

{ x }

{ (p1,p2) }

{ () }

data T1 = C1 t1 t2; {C1 p1 p1} = e

foo ({x :+ y}) = e

foo ({x :+ y}) = e

{(p)}

{ ~p }

{ !p }

{ x @ p }

{ _ }

f (Pt { pointx = x }) = g x

{ [1,2,3] }

{ p :: t }

{ e -> p }

type FieldExp = (Name, Exp) Source

type FieldPat = (Name, Pat) Source

Types

data Type Source

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

T a b

t :: k

a

T

'T

(,), (,,), etc.

(), (), etc.

->

~

[]

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

'[]

(':)

*

Constraint

0,1,2, etc.

data TyVarBndr Source

a

(a :: k)

data TyLit Source

2

Hello

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.

type Cxt Source

(Eq a, Ord b)

type Pred = Type Source

Since the advent of ConstraintKinds, constraints are really just types. Equality constraints use the EqualityT constructor. Constraints may also be tuples of other constraints.

data Role Source

Role annotations

nominal

representational

phantom

_

Library functions

Abbreviations

type InfoQ = Q Info Source

type ExpQ = Q Exp Source

type DecQ = Q Dec Source

type DecsQ = Q [Dec] Source

type ConQ = Q Con Source

type TypeQ = Q Type Source

type TyLitQ = Q TyLit Source

type CxtQ = Q Cxt Source

type PredQ = Q Pred Source

type MatchQ = Q Match Source

type ClauseQ = Q Clause Source

type BodyQ = Q Body Source

type GuardQ = Q Guard Source

type StmtQ = Q Stmt Source

type RangeQ = Q Range Source

type StrictTypeQ = Q StrictType Source

type VarStrictTypeQ = Q VarStrictType Source

type PatQ = Q Pat Source

type FieldPatQ = Q FieldPat Source

type RuleBndrQ = Q RuleBndr Source

type TySynEqnQ = Q TySynEqn Source

Constructors lifted to Q

Literals

intPrimL :: Integer -> Lit Source

wordPrimL :: Integer -> Lit Source

floatPrimL :: Rational -> Lit Source

doublePrimL :: Rational -> Lit Source

integerL :: Integer -> Lit Source

rationalL :: Rational -> Lit Source

charL :: Char -> Lit Source

stringL :: String -> Lit Source

stringPrimL :: [Word8] -> Lit Source

Patterns

litP :: Lit -> PatQ Source

varP :: Name -> PatQ Source

tupP :: [PatQ] -> PatQ Source

conP :: Name -> [PatQ] -> PatQ Source

uInfixP :: PatQ -> Name -> PatQ -> PatQ Source

parensP :: PatQ -> PatQ Source

infixP :: PatQ -> Name -> PatQ -> PatQ Source

tildeP :: PatQ -> PatQ Source

bangP :: PatQ -> PatQ Source

asP :: Name -> PatQ -> PatQ Source

wildP :: PatQ Source

recP :: Name -> [FieldPatQ] -> PatQ Source

listP :: [PatQ] -> PatQ Source

sigP :: PatQ -> TypeQ -> PatQ Source

viewP :: ExpQ -> PatQ -> PatQ Source

fieldPat :: Name -> PatQ -> FieldPatQ Source

Pattern Guards

normalB :: ExpQ -> BodyQ Source

guardedB :: [Q (Guard, Exp)] -> BodyQ Source

normalG :: ExpQ -> GuardQ Source

normalGE :: ExpQ -> ExpQ -> Q (Guard, Exp) Source

patG :: [StmtQ] -> GuardQ Source

patGE :: [StmtQ] -> ExpQ -> Q (Guard, Exp) Source

match :: PatQ -> BodyQ -> [DecQ] -> MatchQ Source

Use with caseE

clause :: [PatQ] -> BodyQ -> [DecQ] -> ClauseQ Source

Use with funD

Expressions

dyn :: String -> ExpQ Source

Dynamically binding a variable (unhygenic)

global :: Name -> ExpQ Source

varE :: Name -> ExpQ Source

conE :: Name -> ExpQ Source

litE :: Lit -> ExpQ Source

appE :: ExpQ -> ExpQ -> ExpQ Source

uInfixE :: ExpQ -> ExpQ -> ExpQ -> ExpQ Source

parensE :: ExpQ -> ExpQ Source

staticE :: ExpQ -> ExpQ Source

staticE x = [| static x |]

infixE :: Maybe ExpQ -> ExpQ -> Maybe ExpQ -> ExpQ Source

infixApp :: ExpQ -> ExpQ -> ExpQ -> ExpQ Source

sectionL :: ExpQ -> ExpQ -> ExpQ Source

sectionR :: ExpQ -> ExpQ -> ExpQ Source

lamE :: [PatQ] -> ExpQ -> ExpQ Source

lam1E :: PatQ -> ExpQ -> ExpQ Source

Single-arg lambda

lamCaseE :: [MatchQ] -> ExpQ Source

tupE :: [ExpQ] -> ExpQ Source

condE :: ExpQ -> ExpQ -> ExpQ -> ExpQ Source

multiIfE :: [Q (Guard, Exp)] -> ExpQ Source

letE :: [DecQ] -> ExpQ -> ExpQ Source

caseE :: ExpQ -> [MatchQ] -> ExpQ Source

appsE :: [ExpQ] -> ExpQ Source

listE :: [ExpQ] -> ExpQ Source

sigE :: ExpQ -> TypeQ -> ExpQ Source

recConE :: Name -> [Q (Name, Exp)] -> ExpQ Source

recUpdE :: ExpQ -> [Q (Name, Exp)] -> ExpQ Source

stringE :: String -> ExpQ Source

fieldExp :: Name -> ExpQ -> Q (Name, Exp) Source

Ranges

fromE :: ExpQ -> ExpQ Source

fromThenE :: ExpQ -> ExpQ -> ExpQ Source

fromToE :: ExpQ -> ExpQ -> ExpQ Source

fromThenToE :: ExpQ -> ExpQ -> ExpQ -> ExpQ Source

Ranges with more indirection

arithSeqE :: RangeQ -> ExpQ Source

fromR :: ExpQ -> RangeQ Source

fromThenR :: ExpQ -> ExpQ -> RangeQ Source

fromToR :: ExpQ -> ExpQ -> RangeQ Source

fromThenToR :: ExpQ -> ExpQ -> ExpQ -> RangeQ Source

Statements

doE :: [StmtQ] -> ExpQ Source

compE :: [StmtQ] -> ExpQ Source

bindS :: PatQ -> ExpQ -> StmtQ Source

letS :: [DecQ] -> StmtQ Source

noBindS :: ExpQ -> StmtQ Source

parS :: [[StmtQ]] -> StmtQ Source

Types

forallT :: [TyVarBndr] -> CxtQ -> TypeQ -> TypeQ Source

varT :: Name -> TypeQ Source

conT :: Name -> TypeQ Source

appT :: TypeQ -> TypeQ -> TypeQ Source

arrowT :: TypeQ Source

equalityT :: TypeQ Source

listT :: TypeQ Source

tupleT :: Int -> TypeQ Source

sigT :: TypeQ -> Kind -> TypeQ Source

litT :: TyLitQ -> TypeQ Source

promotedT :: Name -> TypeQ Source

promotedTupleT :: Int -> TypeQ Source

promotedNilT :: TypeQ Source

promotedConsT :: TypeQ Source

Type literals

numTyLit :: Integer -> TyLitQ Source

strTyLit :: String -> TyLitQ Source

Strictness

isStrict :: Q Strict Source

notStrict :: Q Strict Source

strictType :: Q Strict -> TypeQ -> StrictTypeQ Source

varStrictType :: Name -> StrictTypeQ -> VarStrictTypeQ Source

Class Contexts

cxt :: [PredQ] -> CxtQ Source

classP :: Name -> [Q Type] -> Q Pred Source

equalP :: TypeQ -> TypeQ -> PredQ Source

normalC :: Name -> [StrictTypeQ] -> ConQ Source

recC :: Name -> [VarStrictTypeQ] -> ConQ Source

infixC :: Q (Strict, Type) -> Name -> Q (Strict, Type) -> ConQ Source

forallC :: [TyVarBndr] -> CxtQ -> ConQ -> ConQ Source

Kinds

varK :: Name -> Kind Source

conK :: Name -> Kind Source

tupleK :: Int -> Kind Source

arrowK :: Kind Source

listK :: Kind Source

appK :: Kind -> Kind -> Kind Source

starK :: Kind Source

constraintK :: Kind Source

Roles

nominalR :: Role Source

representationalR :: Role Source

phantomR :: Role Source

inferR :: Role Source

Top Level Declarations

Data

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

funD :: Name -> [ClauseQ] -> DecQ Source

tySynD :: Name -> [TyVarBndr] -> TypeQ -> DecQ Source

dataD :: CxtQ -> Name -> [TyVarBndr] -> [ConQ] -> [Name] -> DecQ Source

newtypeD :: CxtQ -> Name -> [TyVarBndr] -> ConQ -> [Name] -> DecQ Source

Class

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

instanceD :: CxtQ -> TypeQ -> [DecQ] -> DecQ Source

sigD :: Name -> TypeQ -> DecQ Source

standaloneDerivD :: CxtQ -> TypeQ -> DecQ Source

defaultSigD :: Name -> TypeQ -> DecQ Source

Role annotations

roleAnnotD :: Name -> [Role] -> DecQ Source

Type Family / Data Family

familyNoKindD :: FamFlavour -> Name -> [TyVarBndr] -> DecQ Source

familyKindD :: FamFlavour -> Name -> [TyVarBndr] -> Kind -> DecQ Source

dataInstD :: CxtQ -> Name -> [TypeQ] -> [ConQ] -> [Name] -> DecQ Source

closedTypeFamilyNoKindD :: Name -> [TyVarBndr] -> [TySynEqnQ] -> DecQ Source

closedTypeFamilyKindD :: Name -> [TyVarBndr] -> Kind -> [TySynEqnQ] -> DecQ Source

newtypeInstD :: CxtQ -> Name -> [TypeQ] -> ConQ -> [Name] -> DecQ Source

tySynInstD :: Name -> TySynEqnQ -> DecQ Source

typeFam :: FamFlavour Source

dataFam :: FamFlavour Source

tySynEqn :: [TypeQ] -> TypeQ -> TySynEqnQ Source

Foreign Function Interface (FFI)

cCall :: Callconv Source

stdCall :: Callconv Source

cApi :: Callconv Source

prim :: Callconv Source

javaScript :: Callconv Source

unsafe :: Safety Source

safe :: Safety Source

forImpD :: Callconv -> Safety -> String -> Name -> TypeQ -> DecQ Source

Pragmas

ruleVar :: Name -> RuleBndrQ Source

typedRuleVar :: Name -> TypeQ -> RuleBndrQ Source

pragInlD :: Name -> Inline -> RuleMatch -> Phases -> DecQ Source

pragSpecD :: Name -> TypeQ -> Phases -> DecQ Source

pragSpecInlD :: Name -> TypeQ -> Inline -> Phases -> DecQ Source

pragSpecInstD :: TypeQ -> DecQ Source

pragRuleD :: String -> [RuleBndrQ] -> ExpQ -> ExpQ -> Phases -> DecQ Source

pragAnnD :: AnnTarget -> ExpQ -> DecQ Source

pragLineD :: Int -> String -> DecQ Source

Pretty-printer

class Ppr a where Source

pprint :: Ppr a => a -> String Source

pprExp :: Precedence -> Exp -> Doc Source

pprLit :: Precedence -> Lit -> Doc Source

pprPat :: Precedence -> Pat -> Doc Source

pprParendType :: Type -> Doc Source