Language.Haskell.TH.Desugar

Corresponds to TH's Exp type. Note that DLamE takes names, not patterns.

Declarations as used in a let statement.

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

Corresponds to TH's Pat type.

Corresponds to TH's Type type, used to represent types and kinds.

The type variable binders in a forall.

Kinds are types. Corresponds to TH's Kind

Corresponds to TH's Cxt

Predicates are types. Corresponds to TH's Pred

Corresponds to TH's TyVarBndr

Corresponds to TH's TyVarBndrSpec

Corresponds to TH's TyVarBndrUnit

Corresponds to TH's TyVarBndrVis

Corresponds to TH's Match type.

Corresponds to TH's Clause type.

Corresponds to TH's Dec type.

Corresponds to TH's DerivClause type.

Corresponds to TH's DerivStrategy type.

Corresponds to TH's PatSynDir type

Corresponds to TH's PatSynType type

Varieties of allowed instance overlap.

A pattern synonym's argument type.

Is a data type or data instance declaration a newtype declaration, a data declaration, or a type data declaration?

Corresponds to TH's TypeFamilyHead type

Corresponds to TH's FamilyResultSig type

Injectivity annotation

Corresponds to TH's Con type. Unlike Con, all DCons reflect GADT syntax. This is beneficial for th-desugar's since it means that all data type declarations can support explicit return kinds, so one does not need to represent them with something like Maybe DKind, since Haskell98-style data declaration syntax isn't used. Accordingly, there are some differences between DCon and Con to keep in mind:

• Unlike ForallC, where the meaning of the TyVarBndrs changes depending on whether it's followed by GadtC/RecGadtC or not, the meaning of the DTyVarBndrs in a DCon is always the same: it is the list of universally and existentially quantified type variables. Note that it is not guaranteed that one set of type variables will appear before the other.

• A DCon always has an explicit return type.

A list of fields either for a standard data constructor or a record data constructor.

True if a constructor is declared infix. For normal ADTs, this means that is was written in infix style. For example, both of the constructors below are declared infix.

data Infix = Int Infix Int | Int :*: Int

Whereas neither of these constructors are declared infix:

data Prefix = Prefix Int Int | (:+:) Int Int

For GADTs, detecting whether a constructor is declared infix is a bit trickier, as one cannot write a GADT constructor "infix-style" like one can for normal ADT constructors. GHC considers a GADT constructor to be declared infix if it meets the following three criteria:

1. Its name uses operator syntax (e.g., (:*:)).

2. It has exactly two fields (without record syntax).

3. It has a programmer-specified fixity declaration.

For example, in the following GADT:

infixl 5 :**:, :&&:, :^^:, ActuallyPrefix
data InfixGADT a where
  (:**:) :: Int -> b -> InfixGADT (Maybe b) -- Only this one is infix
  ActuallyPrefix :: Char -> Bool -> InfixGADT Double
  (:&&:) :: { infixGADT1 :: b, infixGADT2 :: Int } -> InfixGADT b :: Int -> Int -> Int -> InfixGADT Int
  (:!!:) :: Char -> Char -> InfixGADT Char

Only the (:**:) constructor is declared infix. The other constructors are not declared infix, because:

• ActuallyPrefix does not use operator syntax (criterion 1).

• (:&&:) uses record syntax (criterion 2).

• (:^^:) does not have exactly two fields (criterion 2).

• (:!!:) does not have a programmer-specified fixity declaration (criterion 3).

Corresponds to TH's BangType type.

Corresponds to TH's VarBangType type.

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.

Corresponds to TH's Foreign type.

Corresponds to TH's Pragma type.

Corresponds to TH's RuleBndr type.

Corresponds to TH's TySynEqn type (to store type family equations).

Corresponds to TH's Info type.

Role annotations

This class relates a TH type with its th-desugar type and allows conversions back and forth. The functional dependency goes only one way because we define the following instances on old versions of GHC:

instance Desugar TyVarBndrSpec DTyVarBndrSpec
instance Desugar TyVarBndrUnit DTyVarBndrUnit

Prior to GHC 9.0, TyVarBndrSpec and TyVarBndrUnit are simply type synonyms for TyVarBndr, so making the functional dependencies bidirectional would cause these instances to be rejected.

Desugar an expression

Desugar arbitrary Decs

Desugar a type

Desugar Info

Desugar a pattern, along with processing a (desugared) expression that is the entire scope of the variables bound in the pattern.

Desugar multiple patterns. Like dsPatOverExp.

Desugar a pattern, returning a list of (Name, DExp) pairs of extra variables that must be bound within the scope of the pattern

Desugar Decs that can appear in a let expression. See the documentation for dsLetDec for an explanation of what the return type represents.

Desugar a TyVarBndr.

Desugar a TyVarBndrSpec.

Desugar a TyVarBndrUnit.

Desugar a TyVarBndrVis.

Desugar a Cxt

Desugar a single Con.

Because we always desugar Cons to GADT syntax (see the documentation for DCon), it is not always possible to desugar with just a Con alone. For instance, we must desugar:

data Foo a = forall b. MkFoo b

To this:

data Foo a :: Type where
  MkFoo :: forall a b. b -> Foo a

If our only argument was forall b. MkFoo b, it would be somewhat awkward to figure out (1) what the set of universally quantified type variables ([a]) was, and (2) what the return type (Foo a) was. For this reason, we require passing these as arguments. (If we desugar an actual GADT constructor, these arguments are ignored.)

Desugar a Foreign.

Desugar a Pragma.

Desugar a RuleBndr.

Expand all type synonyms and type families in the desugared abstract syntax tree provided, where type family simplification is on a "best effort" basis. Normally, the first parameter should have a type like DExp or DLetDec.

Expands all type synonyms in a desugared type. Also expands open type family applications. (In GHCs before 7.10, this part does not work if there are any variables.) Attempts to expand closed type family applications, but aborts the moment it spots anything strange, like a nested type family application or type variable.

Reify a declaration, warning the user about splices if the reify fails. The warning says that reification can fail if you try to reify a type in the same splice as it is declared.

Remove all nested pattern-matches within this expression. This also removes all DTildePas and DBangPas. After this is run, every pattern is guaranteed to be either a DConPa with bare variables as arguments, a DLitPa, or a DWildPa.

Like scExp, but for a DLetDec.

Compute the free variables of a DType.

Extract the term variables bound by a DPat.

This does not extract any type variables bound by pattern signatures, constructor patterns, or type patterns.

Apply one DExp to a list of arguments

Convert a DPat to a DExp. Fails on DWildP and DInvisP.

Remove all wildcards from a pattern, replacing any wildcard with a fresh variable

Extract the DataFlavor, TyVarBndrs and constructors given the Name of a type.

From the name of a data constructor, retrive the datatype definition it is a part of.

From the name of a data constructor, retrieve its definition as a Con

Check if a name occurs anywhere within a TH tree.

Extract all Names mentioned in a TH tree.

If the declaration passed in is a DValD, creates new, equivalent declarations such that the DPat in all DValDs is just a plain DVarPa. Other declarations are passed through unchanged. Note that the declarations that come out of this function are rather less efficient than those that come in: they have many more pattern matches.

Produces DLetDecs representing the record selector functions from the provided DCons.

Note that if the same record selector appears in multiple constructors, getRecordSelectors will return only one binding for that selector. For example, if you had:

data X = X1 {y :: Symbol} | X2 {y :: Symbol}

Then calling getRecordSelectors on [X1, X2] will return:

[ DSigD y (DAppT (DAppT DArrowT (DConT X)) (DConT Symbol))
, DFunD y [ DClause [DConP X1 [DVarP field]] (DVarE field)
          , DClause [DConP X2 [DVarP field]] (DVarE field) ] ]

instead of returning one binding for X1 and another binding for X2.

getRecordSelectors does not attempt to filter out "naughty" record selectors—that is, records whose field types mention existentially quantified type variables that do not appear in the constructor's return type. Here is an example of a naughty record selector:

data Some :: (Type -> Type) -> Type where
  MkSome :: { getSome :: f a } -> Some f

GHC itself will not allow the use of getSome as a top-level function due to its type f a mentioning the existential variable a, but getRecordSelectors will return it nonetheless. Ultimately, this design choice is a practical one, as detecting which type variables are existential in Template Haskell is difficult in the general case.

Like TH's lookupTypeName, but if this name is not bound, then we assume it is declared in the current module.

Like TH's lookupDataName, but if this name is not bound, then we assume it is declared in the current module.

Like newName, but even more unique (unique across different splices), and with unique nameBases. Precondition: the string is a valid Haskell alphanumeric identifier (could be upper- or lower-case).