GHC.Internal.TH.Syntax

Internal helper function.

Default fixity: infixl 9

Internal helper function.

Synonym for 'Many, from ghc-internal.

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

Smart constructor for ModName

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 Language.Haskell.TH.Lib.dyn for a useful combinator. The above example could be rewritten using Language.Haskell.TH.Lib.dyn as

f = [| pi + $(dyn "pi") |]

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

Only used internally

Only used internally

Only used internally

Smart constructor for OccName

Smart constructor for PkgName

Accessor for ModName

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

Accessor for OccName

Synonym for 'One, from ghc-internal.

Accessor for PkgName

Internal helper function.

Tuple data constructor

Tuple type constructor

Unboxed sum data constructor

Unboxed sum type constructor

Unboxed tuple data constructor

Unboxed tuple type constructor

Annotation target for reifyAnnotations

The target of an ANN pragma

In PrimTyConI, arity of the type constructor

Strictness information in a data constructor's argument.

A type with a strictness annotation, as in data constructors. See Con.

Visibility of a type variable. See Inferred vs. specified type variables.

A potentially guarded expression, as in function definitions or case alternatives.

Raw bytes embedded into the binary.

Avoid using Bytes constructor directly as it is likely to change in the future. Use helpers such as mkBytes in Language.Haskell.TH.Lib instead.

A calling convention identifier, as in a Foreign declaration.

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.

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 context, as found on the left side of a => in a type.

A single declaration.

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.

A single deriving clause at the end of a datatype declaration.

What the user explicitly requests when deriving an instance with -XDerivingStrategies.

A location at which to attach Haddock documentation. Note that adding documentation to a Name defined oustide of the current module will cause an error.

A Haskell expression.

Type family result signature

A (field name, expression) pair. See RecConE and RecUpdE.

A (field name, pattern) pair. See RecP.

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

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

A foreign declaration.

Functional dependency syntax, as in a class declaration.

A single guard.

Obtained from reify in the Q Monad.

Injectivity annotation as in an injective type family

An inline pragma.

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

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.

A Haskell literal. Note that the numeric types are all in terms of either Integer or Rational, regardless of the type they represent. The extra precision reflects the textual representation in source code.

A location within a source file.

A case-alternative

The name of a module.

Obtained from reifyModule and Language.Haskell.TH.Lib.thisModule.

Obtained from reifyModule in the Q Monad.

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

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

An "Occurence Name".

Varieties of allowed instance overlap.