Write You a Haskell Stephen Diehl

cannot proceed because the reduction simply isn’t well-defined. e rules for evaluation are a single step
by which an expression takes a single small step from one form to another by a given rule.
eval’ x = case x of
IsZero Zero
-> Just Tr
IsZero (Succ t) | isNum t -> Just Fl
IsZero t -> IsZero (eval’ t)
Succ t -> Succ (eval’ t)
Pred Zero
-> Just Zero
Pred (Succ t) | isNum t -> Just t
Pred t -> Pred (eval’ t)
If Tr c _ -> Just c
If Fl _ a
-> Just a
If t c a
-> (\t’ -> If t’ c a) eval’ t
_
-> Nothing
At the toplevel we simply apply eval’ repeatedly until either a value is reached or we’re left with an expression
that has no well-defined way to proceed. e term is “stuck” and the program is in an undefined
state.
nf x = fromMaybe x (nf eval’ x)
eval :: Expr -> Maybe Expr
eval t = case nf t of
nft | isVal nft -> Just nft
| otherwise -> Nothing -- term is ”stuck”
REPL
e driver for our simple language simply invokes all of the parser and evaluation logic in a loop feeding
the resulting state to the next iteration. We will use the haskeline library to give us readline interactions
for the small REPL. Behind the scenes haskeline is using readline or another platform-specific system
library to manage the terminal input. To start out we just create the simplest loop, which only parses
and evaluates expressions and prints them to the screen. We’ll build on this pattern in each chapter,
eventually ending up with a more full-featured REPL.
e two functions of note are the operations for the InputT monad transformer.
runInputT :: Settings IO -> InputT IO a -> IO a
getInputLine :: String -> InputT IO (Maybe String)
When the user enters an EOF or sends a SIGQUIT to input, getInputLine will yield Nothing and can
handle the exit logic.
41