Language.HERMIT.Primitive.GHC

GHC-based Transformations

This module contains transformations that are reflections of GHC functions, or derived from GHC functions.

externals :: [External]

Externals that reflect GHC functions, or are derived from GHC functions.

Free Variables

coreExprFreeIds :: CoreExpr -> [Id]

List all free identifiers (value-level free variables) in the expression.

coreExprFreeVars :: CoreExpr -> [Var]

List all free variables (including types) in the expression.

freeIdsT :: TranslateH CoreExpr [Id]

Lifted version of coreExprFreeIds.

freeVarsT :: TranslateH CoreExpr [Var]

Lifted version of coreExprFreeVars.

altFreeVarsT :: TranslateH CoreAlt [Var]

The free variables in a case alternative, which excludes any identifiers bound in the alternative.

altFreeVarsExclWildT :: TranslateH CoreAlt (Id -> [Var])

A variant of altFreeVarsT that returns a function that accepts the case wild-card binder before giving a result. This is so we can use this with congruence combinators, for example:

caseT id (const altFreeVarsT) $ _ wild _ fvs -> [ f wild | f <- fvs ]

Substitution

substR :: Var -> CoreExpr -> RewriteH Core

Substitute all occurrences of a variable with an expression, in either a program or an expression.

substExprR :: Var -> CoreExpr -> RewriteH CoreExpr

Substitute all occurrences of a variable with an expression, in an expression.

letSubstR :: RewriteH CoreExpr

(let x = e1 in e2) ==> (e2[e1/x]), x must not be free in e1.

safeLetSubstR :: RewriteH CoreExpr

This is quite expensive (O(n) for the size of the sub-tree).

safeLetSubstPlusR :: RewriteH CoreExpr

safeLetSubstPlusR tries to inline a stack of bindings, stopping when reaches the end of the stack of lets.

Equality

exprEqual :: CoreExpr -> CoreExpr -> Bool

exprsEqual :: [CoreExpr] -> Bool

coreEqual :: Core -> Core -> Maybe Bool

Utilities

inScope :: HermitC -> Id -> Bool

Determine whether an identifier is in scope.

showVars :: [Var] -> String

Show a human-readable version of a list of Vars.

rule :: String -> RewriteH CoreExpr

Lookup a rule and attempt to construct a corresponding rewrite.

rules :: [String] -> RewriteH CoreExpr

lintExprT :: TranslateH CoreExpr String

Note: this can miss several things that a whole-module core lint will find. For instance, running this on the RHS of a binding, the type of the RHS will not be checked against the type of the binding. Running on the whole let expression will catch that however.

lintProgramT :: TranslateH CoreProg String

lintModuleT :: TranslateH ModGuts String

Run the Core Lint typechecker. Fails on errors, with error messages. Succeeds returning warnings.

equivalent :: (a -> a -> Bool) -> [a] -> Bool