HERMIT.Dictionary.Local

Local Structural Manipulations

externals :: [External]

Externals for local structural manipulations. (Many taken from Chapter 3 of Andre Santos' dissertation.)

Binding Groups

module HERMIT.Dictionary.Local.Bind

Case Expressions

module HERMIT.Dictionary.Local.Case

Cast Expressions

module HERMIT.Dictionary.Local.Cast

Let Expressions

module HERMIT.Dictionary.Local.Let

Miscellaneous

abstractR :: (ReadBindings c, MonadCatch m, MonadUnique m) => (Var -> Bool) -> Rewrite c m CoreExpr

Abstract over a variable using a lambda. e ==> ( x. e) x

pushR

Arguments

:: (ExtendPath c Crumb, ReadPath c Crumb, AddBindings c, ReadBindings c)

=> Maybe (Rewrite c HermitM CoreExpr)

a proof that the function (after being applied to its type arguments) is strict

-> (Id -> Bool)

a predicate to identify the function

-> Rewrite c HermitM CoreExpr

Push a function through a Case or Let expression. Unsafe if the function is not strict.

betaReduceR :: MonadCatch m => Rewrite c m CoreExpr

((\ v -> e1) e2) ==> (let v = e2 in e1) This form of beta-reduction is safe if e2 is an arbitrary expression (won't duplicate work).

betaExpandR :: MonadCatch m => Rewrite c m CoreExpr

(let v = e1 in e2) ==> (\ v -> e2) e1

etaReduceR :: MonadCatch m => Rewrite c m CoreExpr

(\ v -> f v) ==> f

etaExpandR :: String -> Rewrite c HermitM CoreExpr

e1 ==> (\ v -> e1 v)

multiEtaExpandR :: (ExtendPath c Crumb, ReadPath c Crumb, AddBindings c) => [String] -> Rewrite c HermitM CoreExpr

Perform multiple eta-expansions.

flattenModuleR :: (ExtendPath c Crumb, HasEmptyContext c, Monad m) => Rewrite c m ModGuts

Flatten all the top-level binding groups in the module to a single recursive binding group.

flattenProgramR :: Monad m => Rewrite c m CoreProg

Flatten all the top-level binding groups in a program to a program containing a single recursive binding group.

flattenProgramT :: Monad m => Transform c m CoreProg CoreBind

Flatten all the top-level binding groups in a program to a single recursive binding group.