Language.HERMIT.Kure

KURE

All the required functionality of KURE is exported here, so other modules do not need to import KURE directly.

module Language.KURE

module Language.KURE.BiTranslate

module Language.KURE.Lens

Synonyms

In HERMIT, Translate, Rewrite and Lens always operate on the same context and monad.

type TranslateH a b = Translate HermitC HermitM a b

type RewriteH a = Rewrite HermitC HermitM a

type BiRewriteH a = BiRewrite HermitC HermitM a

type LensH a b = Lens HermitC HermitM a b

Congruence combinators

Modguts

modGutsT :: Monad m => Translate HermitC m CoreProg a -> (ModGuts -> a -> b) -> Translate HermitC m ModGuts b

Translate a module. Slightly different to the other congruence combinators: it passes in all of the original to the reconstruction function.

modGutsR :: Monad m => Rewrite HermitC m CoreProg -> Rewrite HermitC m ModGuts

Rewrite the CoreProg child of a module.

Program

progNilT :: Monad m => b -> Translate HermitC m CoreProg b

Translate an empty list.

progConsT :: Monad m => Translate HermitC m CoreBind a1 -> Translate HermitC m CoreProg a2 -> (a1 -> a2 -> b) -> Translate HermitC m CoreProg b

Translate a program of the form: (CoreBind : CoreProg)

progConsAllR :: Monad m => Rewrite HermitC m CoreBind -> Rewrite HermitC m CoreProg -> Rewrite HermitC m CoreProg

Rewrite all children of a program of the form: (CoreBind : CoreProg)

progConsAnyR :: MonadCatch m => Rewrite HermitC m CoreBind -> Rewrite HermitC m CoreProg -> Rewrite HermitC m CoreProg

Rewrite any children of a program of the form: (CoreBind : CoreProg)

progConsOneR :: MonadCatch m => Rewrite HermitC m CoreBind -> Rewrite HermitC m CoreProg -> Rewrite HermitC m CoreProg

Rewrite one child of a program of the form: (CoreBind : CoreProg)

Binding Groups

nonRecT :: Monad m => Translate HermitC m CoreExpr a -> (Var -> a -> b) -> Translate HermitC m CoreBind b

Translate a binding group of the form: NonRec Var CoreExpr

nonRecR :: Monad m => Rewrite HermitC m CoreExpr -> Rewrite HermitC m CoreBind

Rewrite the CoreExpr child of a binding group of the form: NonRec Var CoreExpr

recT :: Monad m => (Int -> Translate HermitC m CoreDef a) -> ([a] -> b) -> Translate HermitC m CoreBind b

Translate a binding group of the form: Rec [CoreDef]

recAllR :: Monad m => (Int -> Rewrite HermitC m CoreDef) -> Rewrite HermitC m CoreBind

Rewrite all children of a binding group of the form: Rec [CoreDef]

recAnyR :: MonadCatch m => (Int -> Rewrite HermitC m CoreDef) -> Rewrite HermitC m CoreBind

Rewrite any children of a binding group of the form: Rec [CoreDef]

recOneR :: MonadCatch m => (Int -> Rewrite HermitC m CoreDef) -> Rewrite HermitC m CoreBind

Rewrite one child of a binding group of the form: Rec [CoreDef]

Recursive Definitions

defT :: Monad m => Translate HermitC m CoreExpr a -> (Id -> a -> b) -> Translate HermitC m CoreDef b

Translate a recursive definition of the form: Def Id CoreExpr

defR :: Monad m => Rewrite HermitC m CoreExpr -> Rewrite HermitC m CoreDef

Rewrite the CoreExpr child of a recursive definition of the form: Def Id CoreExpr

Case Alternatives

altT :: Monad m => Translate HermitC m CoreExpr a -> (AltCon -> [Var] -> a -> b) -> Translate HermitC m CoreAlt b

Translate a case alternative of the form: (AltCon, [Var], CoreExpr)

altR :: Monad m => Rewrite HermitC m CoreExpr -> Rewrite HermitC m CoreAlt

Rewrite the CoreExpr child of a case alternative of the form: (AltCon, Id, CoreExpr)

Expressions

varT :: Monad m => (Id -> b) -> Translate HermitC m CoreExpr b

Translate an expression of the form: Var Id

litT :: Monad m => (Literal -> b) -> Translate HermitC m CoreExpr b

Translate an expression of the form: Lit Literal

appT :: Monad m => Translate HermitC m CoreExpr a1 -> Translate HermitC m CoreExpr a2 -> (a1 -> a2 -> b) -> Translate HermitC m CoreExpr b

Translate an expression of the form: App CoreExpr CoreExpr

appAllR :: Monad m => Rewrite HermitC m CoreExpr -> Rewrite HermitC m CoreExpr -> Rewrite HermitC m CoreExpr

Rewrite all children of an expression of the form: App CoreExpr CoreExpr

appAnyR :: MonadCatch m => Rewrite HermitC m CoreExpr -> Rewrite HermitC m CoreExpr -> Rewrite HermitC m CoreExpr

Rewrite any children of an expression of the form: App CoreExpr CoreExpr

appOneR :: MonadCatch m => Rewrite HermitC m CoreExpr -> Rewrite HermitC m CoreExpr -> Rewrite HermitC m CoreExpr

Rewrite one child of an expression of the form: App CoreExpr CoreExpr

lamT :: Monad m => Translate HermitC m CoreExpr a -> (Var -> a -> b) -> Translate HermitC m CoreExpr b

Translate an expression of the form: Lam Var CoreExpr

lamR :: Monad m => Rewrite HermitC m CoreExpr -> Rewrite HermitC m CoreExpr

Rewrite the CoreExpr child of an expression of the form: Lam Var CoreExpr

letT :: Monad m => Translate HermitC m CoreBind a1 -> Translate HermitC m CoreExpr a2 -> (a1 -> a2 -> b) -> Translate HermitC m CoreExpr b

Translate an expression of the form: Let CoreBind CoreExpr

letAllR :: Monad m => Rewrite HermitC m CoreBind -> Rewrite HermitC m CoreExpr -> Rewrite HermitC m CoreExpr

Rewrite all children of an expression of the form: Let CoreBind CoreExpr

letAnyR :: MonadCatch m => Rewrite HermitC m CoreBind -> Rewrite HermitC m CoreExpr -> Rewrite HermitC m CoreExpr

Rewrite any children of an expression of the form: Let CoreBind CoreExpr

letOneR :: MonadCatch m => Rewrite HermitC m CoreBind -> Rewrite HermitC m CoreExpr -> Rewrite HermitC m CoreExpr

Rewrite one child of an expression of the form: Let CoreBind CoreExpr

caseT :: Monad m => Translate HermitC m CoreExpr a1 -> (Int -> Translate HermitC m CoreAlt a2) -> (a1 -> Id -> Type -> [a2] -> b) -> Translate HermitC m CoreExpr b

Translate an expression of the form: Case CoreExpr Id Type [CoreAlt]

caseAllR :: Monad m => Rewrite HermitC m CoreExpr -> (Int -> Rewrite HermitC m CoreAlt) -> Rewrite HermitC m CoreExpr

Rewrite all children of an expression of the form: Case CoreExpr Id Type [CoreAlt]

caseAnyR :: MonadCatch m => Rewrite HermitC m CoreExpr -> (Int -> Rewrite HermitC m CoreAlt) -> Rewrite HermitC m CoreExpr

Rewrite any children of an expression of the form: Case CoreExpr Id Type [CoreAlt]

caseOneR :: MonadCatch m => Rewrite HermitC m CoreExpr -> (Int -> Rewrite HermitC m CoreAlt) -> Rewrite HermitC m CoreExpr

Rewrite one child of an expression of the form: Case CoreExpr Id Type [CoreAlt]

castT :: Monad m => Translate HermitC m CoreExpr a -> (a -> Coercion -> b) -> Translate HermitC m CoreExpr b

Translate an expression of the form: Cast CoreExpr Coercion

castR :: Monad m => Rewrite HermitC m CoreExpr -> Rewrite HermitC m CoreExpr

Rewrite the CoreExpr child of an expression of the form: Cast CoreExpr Coercion

tickT :: Monad m => Translate HermitC m CoreExpr a -> (CoreTickish -> a -> b) -> Translate HermitC m CoreExpr b

Translate an expression of the form: Tick CoreTickish CoreExpr

tickR :: Monad m => Rewrite HermitC m CoreExpr -> Rewrite HermitC m CoreExpr

Rewrite the CoreExpr child of an expression of the form: Tick CoreTickish CoreExpr

typeT :: Monad m => (Type -> b) -> Translate HermitC m CoreExpr b

Translate an expression of the form: Type Type

coercionT :: Monad m => (Coercion -> b) -> Translate HermitC m CoreExpr b

Translate an expression of the form: Coercion Coercion

Composite Congruence Combinators

recDefT :: Monad m => (Int -> Translate HermitC m CoreExpr a1) -> ([(Id, a1)] -> b) -> Translate HermitC m CoreBind b

Translate a binding group of the form: Rec [(Id, CoreExpr)]

recDefAllR :: Monad m => (Int -> Rewrite HermitC m CoreExpr) -> Rewrite HermitC m CoreBind

Rewrite all children of a binding group of the form: Rec [(Id, CoreExpr)]

recDefAnyR :: MonadCatch m => (Int -> Rewrite HermitC m CoreExpr) -> Rewrite HermitC m CoreBind

Rewrite any children of a binding group of the form: Rec [(Id, CoreExpr)]

recDefOneR :: MonadCatch m => (Int -> Rewrite HermitC m CoreExpr) -> Rewrite HermitC m CoreBind

Rewrite one child of a binding group of the form: Rec [(Id, CoreExpr)]

letNonRecT :: Monad m => Translate HermitC m CoreExpr a1 -> Translate HermitC m CoreExpr a2 -> (Var -> a1 -> a2 -> b) -> Translate HermitC m CoreExpr b

Translate an expression of the form: Let (NonRec Var CoreExpr) CoreExpr

letNonRecAllR :: Monad m => Rewrite HermitC m CoreExpr -> Rewrite HermitC m CoreExpr -> Rewrite HermitC m CoreExpr

Rewrite all children of an expression of the form: Let (NonRec Var CoreExpr) CoreExpr

letNonRecAnyR :: MonadCatch m => Rewrite HermitC m CoreExpr -> Rewrite HermitC m CoreExpr -> Rewrite HermitC m CoreExpr

Rewrite any children of an expression of the form: Let (NonRec Var CoreExpr) CoreExpr

letNonRecOneR :: MonadCatch m => Rewrite HermitC m CoreExpr -> Rewrite HermitC m CoreExpr -> Rewrite HermitC m CoreExpr

Rewrite one child of an expression of the form: Let (NonRec Var CoreExpr) CoreExpr

letRecT :: Monad m => (Int -> Translate HermitC m CoreDef a1) -> Translate HermitC m CoreExpr a2 -> ([a1] -> a2 -> b) -> Translate HermitC m CoreExpr b

Translate an expression of the form: Let (Rec [CoreDef]) CoreExpr

letRecAllR :: Monad m => (Int -> Rewrite HermitC m CoreDef) -> Rewrite HermitC m CoreExpr -> Rewrite HermitC m CoreExpr

Rewrite all children of an expression of the form: Let (Rec [CoreDef]) CoreExpr

letRecAnyR :: MonadCatch m => (Int -> Rewrite HermitC m CoreDef) -> Rewrite HermitC m CoreExpr -> Rewrite HermitC m CoreExpr

Rewrite any children of an expression of the form: Let (Rec [CoreDef]) CoreExpr

letRecOneR :: MonadCatch m => (Int -> Rewrite HermitC m CoreDef) -> Rewrite HermitC m CoreExpr -> Rewrite HermitC m CoreExpr

Rewrite one child of an expression of the form: Let (Rec [CoreDef]) CoreExpr

letRecDefT :: Monad m => (Int -> Translate HermitC m CoreExpr a1) -> Translate HermitC m CoreExpr a2 -> ([(Id, a1)] -> a2 -> b) -> Translate HermitC m CoreExpr b

Translate an expression of the form: Let (Rec [(Id, CoreExpr)]) CoreExpr

letRecDefAllR :: Monad m => (Int -> Rewrite HermitC m CoreExpr) -> Rewrite HermitC m CoreExpr -> Rewrite HermitC m CoreExpr

Rewrite all children of an expression of the form: Let (Rec [(Id, CoreExpr)]) CoreExpr

letRecDefAnyR :: MonadCatch m => (Int -> Rewrite HermitC m CoreExpr) -> Rewrite HermitC m CoreExpr -> Rewrite HermitC m CoreExpr

Rewrite any children of an expression of the form: Let (Rec [(Id, CoreExpr)]) CoreExpr

letRecDefOneR :: MonadCatch m => (Int -> Rewrite HermitC m CoreExpr) -> Rewrite HermitC m CoreExpr -> Rewrite HermitC m CoreExpr

Rewrite one child of an expression of the form: Let (Rec [(Id, CoreExpr)]) CoreExpr

consNonRecT :: Monad m => Translate HermitC m CoreExpr a1 -> Translate HermitC m CoreProg a2 -> (Var -> a1 -> a2 -> b) -> Translate HermitC m CoreProg b

Translate a program of the form: (NonRec Var CoreExpr) : CoreProg

consNonRecAllR :: Monad m => Rewrite HermitC m CoreExpr -> Rewrite HermitC m CoreProg -> Rewrite HermitC m CoreProg

Rewrite all children of an expression of the form: (NonRec Var CoreExpr) : CoreProg

consNonRecAnyR :: MonadCatch m => Rewrite HermitC m CoreExpr -> Rewrite HermitC m CoreProg -> Rewrite HermitC m CoreProg

Rewrite any children of an expression of the form: (NonRec Var CoreExpr) : CoreProg

consNonRecOneR :: MonadCatch m => Rewrite HermitC m CoreExpr -> Rewrite HermitC m CoreProg -> Rewrite HermitC m CoreProg

Rewrite one child of an expression of the form: (NonRec Var CoreExpr) : CoreProg

consRecT :: Monad m => (Int -> Translate HermitC m CoreDef a1) -> Translate HermitC m CoreProg a2 -> ([a1] -> a2 -> b) -> Translate HermitC m CoreProg b

Translate an expression of the form: (Rec [CoreDef]) : CoreProg

consRecAllR :: Monad m => (Int -> Rewrite HermitC m CoreDef) -> Rewrite HermitC m CoreProg -> Rewrite HermitC m CoreProg

Rewrite all children of an expression of the form: (Rec [CoreDef]) : CoreProg

consRecAnyR :: MonadCatch m => (Int -> Rewrite HermitC m CoreDef) -> Rewrite HermitC m CoreProg -> Rewrite HermitC m CoreProg

Rewrite any children of an expression of the form: (Rec [CoreDef]) : CoreProg

consRecOneR :: MonadCatch m => (Int -> Rewrite HermitC m CoreDef) -> Rewrite HermitC m CoreProg -> Rewrite HermitC m CoreProg

Rewrite one child of an expression of the form: (Rec [CoreDef]) : CoreProg

consRecDefT :: Monad m => (Int -> Translate HermitC m CoreExpr a1) -> Translate HermitC m CoreProg a2 -> ([(Id, a1)] -> a2 -> b) -> Translate HermitC m CoreProg b

Translate an expression of the form: (Rec [(Id, CoreExpr)]) : CoreProg

consRecDefAllR :: Monad m => (Int -> Rewrite HermitC m CoreExpr) -> Rewrite HermitC m CoreProg -> Rewrite HermitC m CoreProg

Rewrite all children of an expression of the form: (Rec [(Id, CoreExpr)]) : CoreProg

consRecDefAnyR :: MonadCatch m => (Int -> Rewrite HermitC m CoreExpr) -> Rewrite HermitC m CoreProg -> Rewrite HermitC m CoreProg

Rewrite any children of an expression of the form: (Rec [(Id, CoreExpr)]) : CoreProg

consRecDefOneR :: MonadCatch m => (Int -> Rewrite HermitC m CoreExpr) -> Rewrite HermitC m CoreProg -> Rewrite HermitC m CoreProg

Rewrite one child of an expression of the form: (Rec [(Id, CoreExpr)]) : CoreProg

caseAltT :: Monad m => Translate HermitC m CoreExpr a1 -> (Int -> Translate HermitC m CoreExpr a2) -> (a1 -> Id -> Type -> [(AltCon, [Var], a2)] -> b) -> Translate HermitC m CoreExpr b

Translate an expression of the form: Case CoreExpr Id Type [(AltCon, [Var], CoreExpr)]

caseAltAllR :: Monad m => Rewrite HermitC m CoreExpr -> (Int -> Rewrite HermitC m CoreExpr) -> Rewrite HermitC m CoreExpr

Rewrite all children of an expression of the form: Case CoreExpr Id Type [(AltCon, [Var], CoreExpr)]

caseAltAnyR :: MonadCatch m => Rewrite HermitC m CoreExpr -> (Int -> Rewrite HermitC m CoreExpr) -> Rewrite HermitC m CoreExpr

Rewrite any children of an expression of the form: Case CoreExpr Id Type [(AltCon, [Var], CoreExpr)]

caseAltOneR :: MonadCatch m => Rewrite HermitC m CoreExpr -> (Int -> Rewrite HermitC m CoreExpr) -> Rewrite HermitC m CoreExpr

Rewrite one child of an expression of the form: Case CoreExpr Id Type [(AltCon, [Var], CoreExpr)]

Promotion Combinators

Rewrite Promotions

promoteModGutsR :: Monad m => Rewrite HermitC m ModGuts -> Rewrite HermitC m Core

Promote a rewrite on ModGuts to a rewrite on Core.

promoteProgR :: Monad m => Rewrite HermitC m CoreProg -> Rewrite HermitC m Core

Promote a rewrite on CoreProg to a rewrite on Core.

promoteBindR :: Monad m => Rewrite HermitC m CoreBind -> Rewrite HermitC m Core

Promote a rewrite on CoreBind to a rewrite on Core.

promoteDefR :: Monad m => Rewrite HermitC m CoreDef -> Rewrite HermitC m Core

Promote a rewrite on CoreDef to a rewrite on Core.

promoteExprR :: Monad m => Rewrite HermitC m CoreExpr -> Rewrite HermitC m Core

Promote a rewrite on CoreExpr to a rewrite on Core.

promoteAltR :: Monad m => Rewrite HermitC m CoreAlt -> Rewrite HermitC m Core

Promote a rewrite on CoreAlt to a rewrite on Core.

BiRewrite Promotions

promoteExprBiR :: Monad m => BiRewrite HermitC m CoreExpr -> BiRewrite HermitC m Core

Promote a bidirectional rewrite on CoreExpr to a bidirectional rewrite on Core.

Translate Promotions

promoteModGutsT :: Monad m => Translate HermitC m ModGuts b -> Translate HermitC m Core b

Promote a translate on ModGuts to a translate on Core.

promoteProgT :: Monad m => Translate HermitC m CoreProg b -> Translate HermitC m Core b

Promote a translate on CoreProg to a translate on Core.

promoteBindT :: Monad m => Translate HermitC m CoreBind b -> Translate HermitC m Core b

Promote a translate on CoreBind to a translate on Core.

promoteDefT :: Monad m => Translate HermitC m CoreDef b -> Translate HermitC m Core b

Promote a translate on CoreDef to a translate on Core.

promoteExprT :: Monad m => Translate HermitC m CoreExpr b -> Translate HermitC m Core b

Promote a translate on CoreExpr to a translate on Core.

promoteAltT :: Monad m => Translate HermitC m CoreAlt b -> Translate HermitC m Core b

Promote a translate on CoreAlt to a translate on Core.