Documentation

Methods

qNewName Source

qReport Source

qRecover Source

qLookupName :: Bool -> String -> m (Maybe Name)Source

qReify :: Name -> m Info Source

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

qLocation :: m Loc Source

qRunIO :: IO a -> m aSource

qAddDependentFile :: FilePath -> m () Source

Instances

Constructors

Instances

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.

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

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

Report a warning to the user, and carry on.

Arguments

Recover from errors raised by reportError or fail .

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

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

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 .

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.

Is the list of instances returned by reifyInstances nonempty?

The location at which this computation is spliced.

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.

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.

Methods

lift :: t -> Q Exp Source

Instances

Constructors

Instances

Constructors

Instances

Constructors

Instances

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

Constructors

Instances

Constructors

Instances

Constructors

Instances

The name without its module prefix

Module prefix of a name, if it exists

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

Only used internally

Only used internally

Used for 'x etc, but not available to the programmer

Constructors

Tuple data constructor

Tuple type constructor

Unboxed tuple data constructor

Unboxed tuple type constructor

Constructors

Arguments

Obtained from reify in the Q Monad.

Constructors

Instances

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

In PrimTyConI , arity of the type constructor

In PrimTyConI , is the type constructor unlifted?

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

Constructors

Instances

Constructors

Instances

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

Default fixity: infixl 9

Constructors

Instances

Pattern in Haskell given in {}

Constructors

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

Instances

Constructors

case e of { pat -> body where decs }

Instances

Constructors

f { p1 p2 = body where decs }

Instances

Constructors

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

Instances

Constructors

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

f p { = e } where ds

Instances

Constructors

f x { | odd x } = x

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

Instances

Constructors

Instances

Constructors

Instances

Constructors

{ 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 T (Maybe x) = (x,x) }

Instances

Constructors

Instances

Constructors

Instances

Constructors

Instances

Constructors

Instances

Constructors

Instances

Constructors

Instances

Constructors

Instances

Constructors

Instances

Constructors

Instances

Constructors

Instances

Arguments

(Eq a, Ord b)

Constructors

Eq (Int, a)

F a ~ Bool

Instances

Constructors

Instances

Constructors

C Int a

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

Int :+ a

forall a. Eq a => C [a]

Instances

Constructors

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

T a b

t :: k

a

T

'T

(,), (,,), etc.

(), (), etc.

->

[]

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

'[]

(':)

*

Constraint

0,1,2, etc.

Instances

Constructors

a

(a :: k)

Instances

Constructors

2

Hello 

Instances

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 .