Vision:
Build a stackless CPS engine written in Haskell that:
Key separation:
GHC plugin / custom backend
EngineCore IR
CPS runtime
Meta layer
A GHC plugin that captures Core after optimization:
module Plugin (plugin) where
import GhcPlugins
plugin :: Plugin
plugin = defaultPlugin { installCoreToDos = install }
install :: [CommandLineOption] -> [CoreToDo] -> CoreM [CoreToDo]
install _ todos = do
modGuts <- getModGuts
let binds = mg_binds modGuts
liftIO $ writeFile "program.core" (show binds)
-- Option A: stop compilation here
pure []
Later iteration: instead of writing to a file, directly call into the engine or serialize a structured format.
Define a Core-like IR:
type Name = String
data EngineExpr
= EVar Name
| ELam Name EngineExpr
| EApp EngineExpr EngineExpr
| ELet Name EngineExpr EngineExpr
| EInt Int
| ECase EngineExpr [Alt]
| EConstr Name [EngineExpr]
deriving (Show)
data Alt = Alt ConName [Name] EngineExpr
type ConName = String
Translator skeleton:
ghcCoreToEngine :: GHC.CoreExpr -> EngineExpr
ghcCoreToEngine = go
where
go (Var v) = EVar (occNameString (getOccName v))
go (Lit (MachInt n)) = EInt (fromIntegral n)
go (Lam b e) = ELam (occNameString (getOccName b)) (go e)
go (App f a) = EApp (go f) (go a)
go (Let (NonRec b rhs) body) =
ELet (occNameString (getOccName b)) (go rhs) (go body)
go (Case scrut b _ alts) =
ECase (go scrut) (map goAlt alts)
go _ = error "unsupported Core form (first pass)"
goAlt (DataAlt dc, bs, rhs) =
Alt (occNameString (getOccName dc))
(map (occNameString . getOccName) bs)
(go rhs)
goAlt _ = error "unsupported alt"
data Value
= VInt Int
| VClosure Name EngineExpr Env
| VConstr ConName [Value]
deriving (Show)
type Env = [(Name, Value)]
data Frame
= FAppFun EngineExpr Env
| FAppArg Value
| FLet Name EngineExpr Env
| FCase [Alt] Env
deriving (Show)
type Cont = [Frame] -- head = next frame
data VersionId = VersionId String
data TraceId = TraceId String
data MetaState = MetaState
{ msVersion :: VersionId
, msTrace :: TraceId
-- hooks for logging, lore, etc.
}
data MachineState = MachineState
{ msExpr :: EngineExpr
, msEnv :: Env
, msCont :: Cont
, msMeta :: MetaState
}
Exactly one semantic frame is active: (msExpr, msEnv).
All other “future work” is in msCont on the heap.
newtype Engine a = Engine { runEngine :: IO a }
deriving (Functor, Applicative, Monad, MonadIO)
step :: MachineState -> Engine MachineState
step st@MachineState{ msExpr = expr, msEnv = env, msCont = cont } =
case expr of
EVar x ->
case lookup x env of
Just v -> continueValue v cont (msMeta st)
Nothing -> error ("unbound variable: " ++ x)
ELam x body ->
continueValue (VClosure x body env) cont (msMeta st)
EApp f a ->
pure st { msExpr = f
, msCont = FAppFun a env : cont
}
ELet x e body ->
pure st { msExpr = e
, msCont = FLet x body env : cont
}
EInt n ->
continueValue (VInt n) cont (msMeta st)
EConstr c es ->
-- naive: evaluate args left-to-right
case es of
[] -> continueValue (VConstr c []) cont (msMeta st)
(e0:rest) ->
pure st { msExpr = e0
, msCont = FAppFun (EConstr c rest) env : cont
}
ECase scrut alts ->
pure st { msExpr = scrut
, msCont = FCase alts env : cont
}
continueValue :: Value -> Cont -> MetaState -> Engine MachineState
continueValue v [] meta =
pure $ MachineState (EInt 0) [] [] meta -- “done” marker
continueValue v (frame:rest) meta =
case frame of
FAppFun arg env ->
pure $ MachineState arg env (FAppArg v : rest) meta
FAppArg funVal ->
case funVal of
VClosure x body cloEnv ->
let env' = (x, v) : cloEnv
in pure $ MachineState body env' rest meta
_ ->
error "attempt to call non-function"
FLet x body env ->
let env' = (x, v) : env
in pure $ MachineState body env' rest meta
FCase alts env ->
matchCase v alts env rest meta
matchCase :: Value -> [Alt] -> Env -> Cont -> MetaState -> Engine MachineState
matchCase v alts env cont meta =
case v of
VConstr c vs ->
case findAlt c alts of
Just (Alt _ names body) ->
let env' = zip names vs ++ env
in pure $ MachineState body env' cont meta
Nothing ->
error "no matching constructor"
_ ->
error "case on non-constructor"
findAlt :: ConName -> [Alt] -> Maybe Alt
findAlt c = find (\(Alt c' _ _) -> c' == c)
runMachine :: MachineState -> Engine Value
runMachine st0 = loop st0
where
loop st = do
st' <- step st
case msCont st' of
[] -> extractResult st'
_ -> loop st'
extractResult :: MachineState -> Engine Value
extractResult MachineState{ msExpr = expr, msEnv = env } =
case expr of
EInt n -> pure (VInt n)
_ -> error "non-value at termination"
Because continuations and machine states are heap data, we can:
VersionId in MetaState.step, consult a version router to decide:Hook point: inside step or continueValue, before executing a function body.
MachineState (deep copy of msExpr, msEnv, msCont, msMeta).stA under version A,stB under version B.Shadow execution is “fork the future,” not “clone a stack.”
MachineState (or log deltas).msCont and:Because frames are just data, you can patch history.
Phase 1: Minimal engine
EngineExpr, Value, Env, Frame, Cont, MachineState.step, continueValue, runMachine.EngineExpr programs and run them.Phase 2: GHC integration
ghcCoreToEngine for a small subset (ints, lambdas, apps, lets).Phase 3: Extend Core coverage
Phase 4: Meta and effects
MetaState with versioning and tracing.Effect layer (IO-like operations via explicit effect nodes).Phase 5: Advanced semantics
Phase 6: Tooling and ergonomics
main.This gives you a full, end-to-end story:
These are the features that make your hot‑swap / replay / shadow‑execution / version‑routing runtime easy instead of a nightmare of hacks.
Not just syntactic closures — but closures that:
This is the foundation of your entire model.
You don’t need religious purity.
You need semantic purity:
This is what makes:
…possible without black magic.
Your runtime is fundamentally:
You don’t need full call/cc, but you do need:
This is why your “no real stack, only semantic frames” idea is so powerful.
Your runtime wants:
This is what makes:
…tractable.
This doesn’t have to be Haskell‑level purity.
It can be:
But you need some way to know:
This is essential for:
These aren’t strictly required, but they make your life dramatically easier.
Because:
Because your runtime manipulates:
…and ADTs make this clean.
Not for performance —
but because your runtime is fundamentally CPS‑shaped.
Languages like Java, Go, and Python hide:
This makes your runtime harder to implement.
Languages like:
…give you more control.
If closures were the only requirement, you could port the runtime anywhere.
But closures are only 1 of the 5 essential features.
The full set is:
These five together make your runtime natural instead of forced.