Write You a Haskell Stephen Diehl

Embedding IO
As mentioned before, effects are first class values in Haskell.
In Haskell we don’t read from a file directly, but create a value that represents reading from a file. is
allows us to very cleanly model an interpreter for our language inside of Haskell by establishing a mapping
between the base operations of our language and existing function implementations of the standard
operations in Haskell, and using monadic operations to build up a pure effectful computation as a result
of interpretation. After evaluation, we finally lift the resulting IO value into Haskell and execute the
results. is fits in nicely with the PHOAS model and allows us to efficiently implement a fully-fledged
interpreter for our language with remarkably little code, simply by exploiting Haskell’s implementation.
To embed IO actions inside of our interpreter we create a distinct VEffect value that will build up a
sequenced IO computation during evaluation. is value will be passed off to Haskell and reified into
real world effects.
data ExprP a
= VarP a
| GlobalP Name
| AppP (ExprP a) (ExprP a)
| LamP (a -> ExprP a)
| LitP Char
| EffectP a
data Value
= VChar Char
| VFun (Value -> Value)
| VEffect (IO Value)
| VUnit
fromVEff :: Value -> (IO Value)
fromVEff val = case val of
VEffect f -> f
_
-> error ”not an effect”
eval :: Expr -> Value
eval e = ev (unExpr e) where
ev (LamP f) = VFun(ev . f)
ev (AppP e1 e2) = fromVFun (ev e1) (ev e2)
ev (LitP n) = VChar n
ev (EffectP v) = v
ev (VarP v) = v
ev (GlobalP op) = prim op
-- Lift an effect from our language into Haskell IO.
run :: Expr -> IO ()
run f = void (fromVEff (eval f))
76