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

Instances

Data DExp

Show DExp

Typeable DExp

data DLetDec

Declarations as used in a let statement. Other Decs are not desugared.

Constructors

DFunD Name [DClause]

DValD DPat DExp

DSigD Name DType

DInfixD Fixity Name

Instances

Data DLetDec

Show 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

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

Typeable 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

Typeable 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

Typeable DPred

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

Typeable DTyVarBndr

data DMatch

Corresponds to TH's Match type.

Constructors

DMatch DPat DExp

Instances

Data DMatch

Show DMatch

Typeable DMatch

data DClause

Corresponds to TH's Clause type.

Constructors

DClause [DPat] DExp

Instances

Data DClause

Show DClause

Typeable DClause

Main desugaring functions

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

Desugar an expression

dsPatOverExp :: Quasi 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 :: Quasi q => [Pat] -> DExp -> q ([DPat], DExp)

Desugar multiple patterns. Like dsPatOverExp.

dsPatX :: Quasi 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 :: Quasi q => [Dec] -> q [DLetDec]

Desugar Decs that can appear in a let expression

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

Desugar a type

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

Desugar a kind

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

Desugar a TyVarBndr

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

Desugar a Pred, flattening any internal tuples

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.

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

Desugar a pattern.

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

Desugar a single Dec, perhaps producing multiple DLetDecs

dsMatches

Arguments

:: Quasi 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

:: Quasi 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

:: Quasi q

=> [(Guard, Exp)]

Guarded expressions

-> DExp

What to do if none of the guards match

-> q DExp

Desugar guarded expressions

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

Desugar the Stmts in a do expression

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

Desugar the Stmts in a list or monad comprehension

dsClauses

Arguments

:: Quasi q

=> Name

Name of the function

-> [Clause]

Clauses to desugar

-> q [DClause]

Desugar clauses to a function definition

Utility functions

dPatToDExp :: DPat -> DExp

Convert a DPat to a DExp. Fails on DWildP.

removeWilds :: Quasi q => DPat -> q DPat

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

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.

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

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

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

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

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