Language.Haskell.TH

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.

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

Recover from errors raised by reportError or fail.

The location at which this computation is spliced.

A location within a source file.

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.

reify looks up information about the Name. It will fail with a compile error if the Name is not visible. A Name is visible if it is imported or defined in a prior top-level declaration group. See the documentation for newDeclarationGroup for more details.

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 mod looks up information about module mod. To look up the current module, call this function with the return value of thisModule.

Template Haskell is capable of reifying information about types and terms defined in previous declaration groups. Top-level declaration splices break up declaration groups.

For an example, consider this code block. We define a datatype X and then try to call reify on the datatype.

module Check where

data X = X
    deriving Eq

$(do
    info <- reify ''X
    runIO $ print info
 )

This code fails to compile, noting that X is not available for reification at the site of reify. We can fix this by creating a new declaration group using an empty top-level splice:

data X = X
    deriving Eq

$(pure [])

$(do
    info <- reify ''X
    runIO $ print info
 )

We provide newDeclarationGroup as a means of documenting this behavior and providing a name for the pattern.

Since top level splices infer the presence of the $( ... ) brackets, we can also write:

data X = X
    deriving Eq

newDeclarationGroup

$(do
    info <- reify ''X
    runIO $ print info
 )

Obtained from reify in the Q Monad.

Obtained from reifyModule in the Q Monad.

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

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

In UnboxedSumE and UnboxedSumP, the number associated with a particular data constructor. SumAlts are one-indexed and should never exceed the value of its corresponding SumArity. For example:

• (#_|#) has SumAlt 1 (out of a total SumArity of 2)

• (#|_#) has SumAlt 2 (out of a total SumArity of 2)

In UnboxedSumE, UnboxedSumT, and UnboxedSumP, the total number of SumAlts. For example, (#|#) has a SumArity of 2.

In PrimTyConI, arity of the type constructor

In PrimTyConI, is the type constructor unlifted?

The language extensions known to GHC.

Note that there is an orphan Binary instance for this type supplied by the GHC.LanguageExtensions module provided by ghc-boot. We can't provide here as this would require adding transitive dependencies to the template-haskell package, which must have a minimal dependency set.

List all enabled language extensions.

Determine whether the given language extension is enabled in the Q monad.

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

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

reifyFixity nm attempts to find a fixity declaration for nm. For example, if the function foo has the fixity declaration infixr 7 foo, then reifyFixity 'foo would return Just (Fixity 7 InfixR). If the function bar does not have a fixity declaration, then reifyFixity 'bar returns Nothing, so you may assume bar has defaultFixity.

reifyType nm attempts to find the type or kind of nm. For example, reifyType 'not returns Bool -> Bool, and reifyType ''Bool returns Type. This works even if there's no explicit signature and the type or kind is inferred.

reifyInstances nm tys returns a list of all visible instances (see below for "visible") 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.

Note that this is a "shallow" test; the declarations returned merely have instance heads which unify with nm tys, they need not actually be satisfiable.

• reifyInstances ''Eq [ TupleT 2 `AppT` ConT ''A `AppT` ConT ''B ] contains the instance (Eq a, Eq b) => Eq (a, b) regardless of whether A and B themselves implement Eq

• reifyInstances ''Show [ VarT (mkName "a") ] produces every available instance of Show

There is one edge case: reifyInstances ''Typeable tys currently always produces an empty list (no matter what tys are given).

In principle, the *visible* instances are * all instances defined in a prior top-level declaration group (see docs on newDeclarationGroup), or * all instances defined in any module transitively imported by the module being compiled

However, actually searching all modules transitively below the one being compiled is unreasonably expensive, so reifyInstances will report only the instance for modules that GHC has had some cause to visit during this compilation. This is a shortcoming: reifyInstances might fail to report instances for a type that is otherwise unusued, or instances defined in a different component. You can work around this shortcoming by explicitly importing the modules whose instances you want to be visible. GHC issue #20529 has some discussion around this.

Is the list of instances returned by reifyInstances nonempty?

If you're confused by an instance not being visible despite being defined in the same module and above the splice in question, see the docs for newDeclarationGroup for a possible explanation.

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

An invisible parameter to a tycon is often a kind parameter. For example, if we have

type Proxy :: forall k. k -> Type
data Proxy a = MkProxy

and reifyRoles Proxy, we will get [NominalR, PhantomR]. The NominalR is the role of the invisible k parameter. Kind parameters are always nominal.

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.

Annotation target for reifyAnnotations

reifyConStrictness nm looks up the strictness information for the fields of the constructor with the name nm. Note that the strictness information that reifyConStrictness returns may not correspond to what is written in the source code. For example, in the following data declaration:

data Pair a = Pair a a

reifyConStrictness would return [DecidedLazy, DecidedLazy] under most circumstances, but it would return [DecidedStrict, DecidedStrict] if the -XStrictData language extension was enabled.

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

The name without its module prefix.

Examples

>>> nameBase ''Data.Either.Either"Either">>> nameBase (mkName "foo")"foo">>> nameBase (mkName "Module.foo")"foo"

Module prefix of a name, if it exists.

Examples

>>> nameModule ''Data.Either.EitherJust "Data.Either">>> nameModule (mkName "foo")Nothing>>> nameModule (mkName "Module.foo")Just "Module"

A name's package, if it exists.

Examples

>>> namePackage ''Data.Either.EitherJust "base">>> namePackage (mkName "foo")Nothing>>> namePackage (mkName "Module.foo")Nothing

Returns whether a name represents an occurrence of a top-level variable (VarName), data constructor (DataName), type constructor, or type class (TcClsName). If we can't be sure, it returns Nothing.

Examples

>>> nameSpace 'Prelude.idJust VarName>>> nameSpace (mkName "id")Nothing -- only works for top-level variable names>>> nameSpace 'Data.Maybe.JustJust DataName>>> nameSpace ''Data.Maybe.MaybeJust TcClsName>>> nameSpace ''Data.Ord.OrdJust TcClsName

Tuple type constructor

Tuple data constructor

Unboxed tuple type constructor

Unboxed tuple data constructor

Unboxed sum type constructor

Unboxed sum data constructor

A single declaration.

A data constructor.

The constructors for Con can roughly be divided up into two categories: those for constructors with "vanilla" syntax (NormalC, RecC, and InfixC), and those for constructors with GADT syntax (GadtC and RecGadtC). The ForallC constructor, which quantifies additional type variables and class contexts, can surround either variety of constructor. However, the type variables that it quantifies are different depending on what constructor syntax is used:

• If a ForallC surrounds a constructor with vanilla syntax, then the ForallC will only quantify existential type variables. For example:

  data Foo a = forall b. MkFoo a b
  

In MkFoo, ForallC will quantify b, but not a.

• If a ForallC surrounds a constructor with GADT syntax, then the ForallC will quantify all type variables used in the constructor. For example:

  data Bar a b where
    MkBar :: (a ~ b) => c -> MkBar a b
  

In MkBar, ForallC will quantify a, b, and c.

Multiplicity annotations for data types are currently not supported in Template Haskell (i.e. all fields represented by Template Haskell will be linear).

A clause consists of patterns, guards, a body expression, and a list of declarations under a where. Clauses are seen in equations for function definitions, case-experssions, explicitly-bidirectional pattern synonyms, etc.

SourceUnpackedness corresponds to unpack annotations found in the source code.

This may not agree with the annotations returned by reifyConStrictness. See reifyConStrictness for more information.

SourceStrictness corresponds to strictness annotations found in the source code.

This may not agree with the annotations returned by reifyConStrictness. See reifyConStrictness for more information.

Unlike SourceStrictness and SourceUnpackedness, DecidedStrictness refers to the strictness annotations that the compiler chooses for a data constructor field, which may be different from what is written in source code.

Note that non-unpacked strict fields are assigned DecidedLazy when a bang would be inappropriate, such as the field of a newtype constructor and fields that have an unlifted type.

See reifyConStrictness for more information.

Strictness information in a data constructor's argument.

As of template-haskell-2.11.0.0, Strict has been replaced by Bang.

A foreign declaration.

A calling convention identifier, as in a Foreign declaration.

A safety level, as in a Foreign declaration.

Old-form specialise pragma { {-# SPECIALISE [INLINE] [phases] (var :: ty) #-} }.

Subsumed by the more general SpecialiseEP constructor.

An inline pragma.

A CONLIKE modifier, as in one of the various inline pragmas, or lack thereof (FunLike).

Phase control syntax.

A binder found in the forall of a RULES pragma.

The target of an ANN pragma

Functional dependency syntax, as in a class declaration.

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

For instance, if you had the following type family:

type family Foo (a :: k) :: k where
  forall k (a :: k). Foo @k a = a

The Foo @k a = a equation would be represented as follows:

TySynEqn (Just [PlainTV k, KindedTV a (VarT k)])
           (AppT (AppKindT (ConT ''Foo) (VarT k)) (VarT a))
           (VarT a)

Common elements of OpenTypeFamilyD and ClosedTypeFamilyD. By analogy with "head" for type classes and type class instances as defined in Type classes: an exploration of the design space, the TypeFamilyHead is defined to be the elements of the declaration between type family and where.

Fixity, as specified in a infix[lr] n declaration.

The associativity of an operator, as in an infix declaration.

A way to specify a namespace to look in when GHC needs to find a name's source

Default fixity: infixl 9

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

A pattern synonym's directionality.