Language.Haskell.TH.Desugar

Desugars full Template Haskell syntax into a smaller core syntax for further processing. The desugared types and constructors are prefixed with a D.

Desugared data types

data DExp

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

Constructors

DVarE Name

DConE Name

DLitE Lit

DAppE DExp DExp

DLamE [Name] DExp

DCaseE DExp [DMatch]

DLetE [DLetDec] DExp

DSigE DExp DType

DStaticE DExp

Instances

Data DExp

Show DExp

Lift DExp

Typeable * DExp

Desugar Exp DExp

data DLetDec

Declarations as used in a let statement.

Constructors

DFunD Name [DClause]

DValD DPat DExp

DSigD Name DType

DInfixD Fixity Name

Instances

Data DLetDec

Show DLetDec

Lift DLetDec

Typeable * DLetDec

data DPat

Corresponds to TH's Pat type.

Constructors

DLitPa Lit

DVarPa Name

DConPa Name [DPat]

DTildePa DPat

DBangPa DPat

DWildPa

Instances

Data DPat

Show DPat

Lift DPat

Typeable * DPat

data DType

Corresponds to TH's Type type.

Constructors

DForallT [DTyVarBndr] DCxt DType

DAppT DType DType

DSigT DType DKind

DVarT Name

DConT Name

DArrowT

DLitT TyLit

Instances

Data DType

Show DType

Lift DType

Typeable * DType

Desugar Type DType

data DKind

Corresponds to TH's Kind type, which is a synonym for Type. DKind, though, only contains constructors that make sense for kinds.

Constructors

DForallK [Name] DKind

DVarK Name

DConK Name [DKind]

DArrowK DKind DKind

DStarK

Instances

Data DKind

Show DKind

Lift DKind

Typeable * DKind

Desugar Kind DKind

type DCxt = [DPred]

Corresponds to TH's Cxt

data DPred

Corresponds to TH's Pred

Constructors

DAppPr DPred DType

DSigPr DPred DKind

DVarPr Name

DConPr Name

Instances

Data DPred

Show DPred

Lift DPred

Typeable * DPred

Desugar Cxt DCxt

data DTyVarBndr

Corresponds to TH's TyVarBndr. Note that PlainTV x and KindedTV x StarT are distinct, so we retain that distinction here.

Constructors

DPlainTV Name

DKindedTV Name DKind

Instances

Data DTyVarBndr

Show DTyVarBndr

Lift DTyVarBndr

Typeable * DTyVarBndr

Desugar TyVarBndr DTyVarBndr

data DMatch

Corresponds to TH's Match type.

Constructors

DMatch DPat DExp

Instances

Data DMatch

Show DMatch

Lift DMatch

Typeable * DMatch

data DClause

Corresponds to TH's Clause type.

Constructors

DClause [DPat] DExp

Instances

Data DClause

Show DClause

Lift DClause

Typeable * DClause

data DDec

Corresponds to TH's Dec type.

Constructors

DLetDec DLetDec

DDataD NewOrData DCxt Name [DTyVarBndr] [DCon] [Name]

DTySynD Name [DTyVarBndr] DType

DClassD DCxt Name [DTyVarBndr] [FunDep] [DDec]

DInstanceD DCxt DType [DDec]

DForeignD DForeign

DPragmaD DPragma

DFamilyD FamFlavour Name [DTyVarBndr] (Maybe DKind)

DDataInstD NewOrData DCxt Name [DType] [DCon] [Name]

DTySynInstD Name DTySynEqn

DClosedTypeFamilyD Name [DTyVarBndr] (Maybe DKind) [DTySynEqn]

DRoleAnnotD Name [Role]

DStandaloneDerivD DCxt DType

DDefaultSigD Name DType

Instances

Data DDec

Show DDec

Lift DDec

Typeable * DDec

Desugar [Dec] [DDec]

data NewOrData

Is it a newtype or a data type?

Constructors

Newtype

Data

Instances

Eq NewOrData

Data NewOrData

Show NewOrData

Lift NewOrData

Typeable * NewOrData

data DCon

Corresponds to TH's Con type.

Constructors

DCon [DTyVarBndr] DCxt Name DConFields

Instances

Data DCon

Show DCon

Lift DCon

Typeable * DCon

Desugar Con DCon

data DConFields

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

Constructors

DNormalC [DStrictType]

DRecC [DVarStrictType]

Instances

Data DConFields

Show DConFields

Lift DConFields

Typeable * DConFields

type DStrictType = (Strict, DType)

Corresponds to TH's StrictType type.

type DVarStrictType = (Name, Strict, DType)

Corresponds to TH's VarStrictType type.

data DForeign

Corresponds to TH's Foreign type.

Constructors

DImportF Callconv Safety String Name DType

DExportF Callconv String Name DType

Instances

Data DForeign

Show DForeign

Lift DForeign

Typeable * DForeign

data DPragma

Corresponds to TH's Pragma type.

Constructors

DInlineP Name Inline RuleMatch Phases

DSpecialiseP Name DType (Maybe Inline) Phases

DSpecialiseInstP DType

DRuleP String [DRuleBndr] DExp DExp Phases

DAnnP AnnTarget DExp

DLineP Int String

Instances

Data DPragma

Show DPragma

Lift DPragma

Typeable * DPragma

data DRuleBndr

Corresponds to TH's RuleBndr type.

Constructors

DRuleVar Name

DTypedRuleVar Name DType

Instances

Data DRuleBndr

Show DRuleBndr

Lift DRuleBndr

Typeable * DRuleBndr

data DTySynEqn

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

Constructors

DTySynEqn [DType] DType

Instances

Data DTySynEqn

Show DTySynEqn

Lift DTySynEqn

Typeable * DTySynEqn

data DInfo

Corresponds to TH's Info type.

Constructors

DTyConI DDec (Maybe [DInstanceDec])

DVarI Name DType (Maybe Name) Fixity

The Maybe Name stores the name of the enclosing definition (datatype, for a data constructor; class, for a method), if any

DTyVarI Name DKind

DPrimTyConI Name Int Bool

The Int is the arity; the Bool is whether this tycon is unlifted.

Instances

Data DInfo

Show DInfo

Typeable * DInfo

type DInstanceDec

Arguments

 = DDec

Guaranteed to be an instance declaration

data Role :: *

Role annotations

Constructors

NominalR

nominal

RepresentationalR

representational

PhantomR

phantom

InferR

_

Instances

Eq Role

Data Role

Ord Role

Show Role

Generic Role

Ppr Role

Lift Role

Typeable * Role

type Rep Role = D1 D1Role ((:+:) ((:+:) (C1 C1_0Role U1) (C1 C1_1Role U1)) ((:+:) (C1 C1_2Role U1) (C1 C1_3Role U1)))

data AnnTarget :: *

Constructors

ModuleAnnotation

TypeAnnotation Name

ValueAnnotation Name

Instances

Eq AnnTarget

Data AnnTarget

Ord AnnTarget

Show AnnTarget

Generic AnnTarget

Lift AnnTarget

Typeable * AnnTarget

type Rep AnnTarget = D1 D1AnnTarget ((:+:) (C1 C1_0AnnTarget U1) ((:+:) (C1 C1_1AnnTarget (S1 NoSelector (Rec0 Name))) (C1 C1_2AnnTarget (S1 NoSelector (Rec0 Name)))))

The Desugar class

class Desugar th ds | ds -> th where

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 Type and Kind are type synonyms, but they desugar to different types.

Methods

desugar :: DsMonad q => th -> q ds

sweeten :: ds -> th

Instances

Desugar Exp DExp

Desugar Type DType

Desugar TyVarBndr DTyVarBndr

Desugar Cxt DCxt

Desugar Con DCon

Desugar Kind DKind

Desugar [Dec] [DDec]

Main desugaring functions

dsExp :: DsMonad q => Exp -> q DExp

Desugar an expression

dsDecs :: DsMonad q => [Dec] -> q [DDec]

Desugar arbitrary Decs

dsType :: DsMonad q => Type -> q DType

Desugar a type

dsKind :: DsMonad q => Kind -> q DKind

Desugar a kind

dsInfo :: DsMonad q => Info -> q DInfo

Desugar Info

dsPatOverExp :: DsMonad q => Pat -> DExp -> q (DPat, DExp)

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

dsPatsOverExp :: DsMonad q => [Pat] -> DExp -> q ([DPat], DExp)

Desugar multiple patterns. Like dsPatOverExp.

dsPatX :: DsMonad q => Pat -> q (DPat, [(Name, DExp)])

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

dsLetDecs :: DsMonad q => [Dec] -> q [DLetDec]

Desugar Decs that can appear in a let expression

dsTvb :: DsMonad q => TyVarBndr -> q DTyVarBndr

Desugar a TyVarBndr

dsCxt :: DsMonad q => Cxt -> q DCxt

Desugar a Cxt

dsCon :: DsMonad q => Con -> q DCon

Desugar a single Con.

dsForeign :: DsMonad q => Foreign -> q DForeign

Desugar a Foreign.

dsPragma :: DsMonad q => Pragma -> q DPragma

Desugar a Pragma.

dsRuleBndr :: DsMonad q => RuleBndr -> q DRuleBndr

Desugar a RuleBndr.

Secondary desugaring functions

type PatM q = WriterT [(Name, DExp)] q

Desugaring a pattern also returns the list of variables bound in as-patterns and the values they should be bound to. This variables must be brought into scope in the "body" of the pattern.

dsPred :: DsMonad q => Pred -> q DCxt

Desugar a Pred, flattening any internal tuples

dsPat :: DsMonad q => Pat -> PatM q DPat

Desugar a pattern.

dsDec :: DsMonad q => Dec -> q [DDec]

Desugar a single Dec, perhaps producing multiple DDecs

dsLetDec :: DsMonad q => Dec -> q [DLetDec]

Desugar a single Dec, perhaps producing multiple DLetDecs

dsMatches

Arguments

:: DsMonad q

=> Name

Name of the scrutinee, which must be a bare var

-> [Match]

Matches of the case statement

-> q [DMatch]

Desugar a list of matches for a case statement

dsBody

Arguments

:: DsMonad q

=> Body

body to desugar

-> [Dec]

"where" declarations

-> DExp

what to do if the guards don't match

-> q DExp

Desugar a Body

dsGuards

Arguments

:: DsMonad q

=> [(Guard, Exp)]

Guarded expressions

-> DExp

What to do if none of the guards match

-> q DExp

Desugar guarded expressions

dsDoStmts :: DsMonad q => [Stmt] -> q DExp

Desugar the Stmts in a do expression

dsComp :: DsMonad q => [Stmt] -> q DExp

Desugar the Stmts in a list or monad comprehension

dsClauses

Arguments

:: DsMonad q

=> Name

Name of the function

-> [Clause]

Clauses to desugar

-> q [DClause]

Desugar clauses to a function definition

Converting desugared AST back to TH AST

module Language.Haskell.TH.Desugar.Sweeten

Expanding type synonyms

expand :: (DsMonad q, Data a) => a -> q a

Expand all type synonyms and open type families in the desugared abstract syntax tree provided. Normally, the first parameter should have a type like DExp or DLetDec.

expandType :: DsMonad q => DType -> q DType

Expands all type synonyms in a desugared type. Also expands open type family applications, as long as the arguments have no free 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.

Reification

reifyWithWarning :: Quasi q => Name -> q Info

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.

The following definitions allow you to register a list of Decs to be used in reification queries.

withLocalDeclarations :: DsMonad q => [Dec] -> DsM q a -> q a

Add a list of declarations to be considered when reifying local declarations.

dsReify :: DsMonad q => Name -> q (Maybe DInfo)

Like reify, but safer and desugared. Uses local declarations where available.

reifyWithLocals_maybe :: DsMonad q => Name -> q (Maybe Info)

Like reify from Template Haskell, but looks also in any not-yet-typechecked declarations. To establish this list of not-yet-typechecked declarations, use withLocalDeclarations. Returns Nothing if reification fails. Note that no inferred type information is available from local declarations; bottoms may be used if necessary.

reifyWithLocals :: DsMonad q => Name -> q Info

Like reifyWithLocals_maybe, but throws an exception upon failure, warning the user about separating splices.

class Quasi m => DsMonad m where

A DsMonad stores some list of declarations that should be considered in scope. DsM is the prototypical inhabitant of DsMonad.

Methods

localDeclarations :: m [Dec]

Produce a list of local declarations.

Instances

DsMonad IO

DsMonad Q

Quasi q => DsMonad (DsM q)

data DsM q a

A convenient implementation of the DsMonad class. Use by calling withLocalDeclarations.

Instances

MonadTrans DsM

Monad q => Monad (DsM q)

Functor q => Functor (DsM q)

Applicative q => Applicative (DsM q)

Quasi q => Quasi (DsM q)

Quasi q => DsMonad (DsM q)

Nested pattern flattening

scExp :: DsMonad q => DExp -> q DExp

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.

scLetDec :: DsMonad q => DLetDec -> q DLetDec

Like scExp, but for a DLetDec.

Utility functions

applyDExp :: DExp -> [DExp] -> DExp

Apply one DExp to a list of arguments

applyDType :: DType -> [DType] -> DType

Apply one DType to a list of arguments

dPatToDExp :: DPat -> DExp

Convert a DPat to a DExp. Fails on DWildP.

removeWilds :: DsMonad q => DPat -> q DPat

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

getDataD

Arguments

:: Quasi q

=> String

Print this out on failure

-> Name

Name of the datatype (data or newtype) of interest

-> q ([TyVarBndr], [Con])

Extract the TyVarBndrs and constructors given the Name of a type

dataConNameToDataName :: Quasi q => Name -> q Name

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

dataConNameToCon :: Quasi q => Name -> q Con

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

nameOccursIn :: Data a => Name -> a -> Bool

Check if a name occurs anywhere within a TH tree.

allNamesIn :: Data a => a -> [Name]

Extract all Names mentioned in a TH tree.

flattenDValD :: Quasi q => DLetDec -> q [DLetDec]

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.

getRecordSelectors

Arguments

:: Quasi q

=> DType

the type of the argument

-> DCon

-> q [DLetDec]

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

mkTypeName :: Quasi q => String -> q Name

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

mkDataName :: Quasi q => String -> q Name

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

newUniqueName :: Quasi q => String -> q Name

Like newName, but even more unique (unique across different splices), and with unique nameBases.

mkTupleDExp :: [DExp] -> DExp

Make a tuple DExp from a list of DExps. Avoids using a 1-tuple.

mkTupleDPat :: [DPat] -> DPat

Make a tuple DPat from a list of DPats. Avoids using a 1-tuple.

maybeDLetE :: [DLetDec] -> DExp -> DExp

If decs is non-empty, delcare them in a let:

maybeDCaseE :: String -> DExp -> [DMatch] -> DExp

If matches is non-empty, make a case statement; otherwise make an error statement

substTy :: DsMonad q => Map Name DType -> DType -> q DType

Capture-avoiding substitution on types

tupleDegree_maybe :: String -> Maybe Int

Extract the degree of a tuple

tupleNameDegree_maybe :: Name -> Maybe Int

Extract the degree of a tuple name

unboxedTupleDegree_maybe :: String -> Maybe Int

Extract the degree of an unboxed tuple

unboxedTupleNameDegree_maybe :: Name -> Maybe Int

Extract the degree of a tuple name

Extracting bound names

extractBoundNamesStmt :: Stmt -> Set Name

Extract the names bound in a Stmt

extractBoundNamesDec :: Dec -> Set Name

Extract the names bound in a Dec that could appear in a let expression.

extractBoundNamesPat :: Pat -> Set Name

Extract the names bound in a Pat