Capstone B: the REPL

A loop over getLine

The REPL reads one line, evaluates it and prints the value or the error, and it stops on :quit with a count of the errors. The parser and the evaluator are the ones of the previous lessons; the new part is the recursion in IO that keeps the loop alive.

The loop is a function of the error count: it reads a line, matches it against :quit, the empty line and an expression, and calls itself with the new count. The accumulator errors is an ordinary argument of the loop and not a cell, so the count is a fold over the lines the session read. A bad line does not end the session, which is the point of a REPL.

The program

module Main (main) where import Data.Char (isDigit) data Token = TNum Int | TPlus | TMinus | TStar | TSlash | TLParen | TRParen deriving (Show, Eq) data Expr = Num Int | Add Expr Expr | Sub Expr Expr | Mul Expr Expr | Div Expr Expr deriving (Show, Eq) lexer :: String -> [Token] lexer [] = [] lexer (c : cs) | c == ' ' = lexer cs | c `elem` "+-*/()" = symbol c : lexer cs | isDigit c = let (digits, rest) = span isDigit (c : cs) in TNum (read digits) : lexer rest | otherwise = error ("bad character: " ++ [c]) where symbol '+' = TPlus symbol '-' = TMinus symbol '*' = TStar symbol '/' = TSlash symbol '(' = TLParen symbol ')' = TRParen symbol other = error ("bad symbol: " ++ [other]) parseExpr :: [Token] -> Either String (Expr, [Token]) parseExpr tokens = do (left, rest) <- parseTerm tokens restExpr left rest where restExpr left (TPlus : rest) = do (right, rest') <- parseTerm rest restExpr (Add left right) rest' restExpr left (TMinus : rest) = do (right, rest') <- parseTerm rest restExpr (Sub left right) rest' restExpr left rest = Right (left, rest) parseTerm :: [Token] -> Either String (Expr, [Token]) parseTerm tokens = do (left, rest) <- parseFactor tokens restTerm left rest where restTerm left (TStar : rest) = do (right, rest') <- parseFactor rest restTerm (Mul left right) rest' restTerm left (TSlash : rest) = do (right, rest') <- parseFactor rest restTerm (Div left right) rest' restTerm left rest = Right (left, rest) parseFactor :: [Token] -> Either String (Expr, [Token]) parseFactor (TNum n : rest) = Right (Num n, rest) parseFactor (TLParen : rest) = do (expr, rest') <- parseExpr rest case rest' of TRParen : rest'' -> Right (expr, rest'') _ -> Left "expected )" parseFactor [] = Left "unexpected end of input" parseFactor (token : _) = Left ("unexpected token " ++ show token) parseAll :: String -> Either String Expr parseAll input = do (expr, rest) <- parseExpr (lexer input) case rest of [] -> Right expr _ -> Left "unexpected input after the expression" eval :: Expr -> Either String Int eval (Num n) = Right n eval (Add a b) = (+) <$> eval a <*> eval b eval (Sub a b) = (-) <$> eval a <*> eval b eval (Mul a b) = (*) <$> eval a <*> eval b eval (Div a b) = do x <- eval a y <- eval b if y == 0 then Left "division by zero" else Right (x `div` y) main :: IO () main = loop (0 :: Int) where loop errors = do line <- getLine case line of ":quit" -> putStrLn ("bye, " ++ show errors ++ " errors") "" -> loop errors _ -> case parseAll line >>= eval of Left message -> do putStrLn ("error: " ++ message) loop (errors + 1) Right value -> do print value loop errors

ghc -Wall -O1 -threaded -o repl repl.hs
printf '1+2\n2*3\n1/0\n:quit\n' | ./repl

3
6
error: division by zero
bye, 1 errors

Reading the session

The next lesson tests the whole pipeline, parser and evaluator together, with a table of expressions and the values they must give.

Questions

A new set of questions in a new order every time. Choose one answer for each, then check.

  1. What happens on a bad line in the REPL?

    Answer

    It prints the error, counts it and continues

    A REPL stays alive after an error, which is why the error is a value.

  2. How is the error count kept?

    Answer

    As an argument of the loop

    The loop passes the number to its next call.

  3. What ends the session?

    Answer

    :quit

    The literal :quit is the command and prints the count.

  4. What does this program print? module Main (main) where main :: IO () main = print (2 + 2 :: Int)

    Answer

    4

    The sum is printed without quotes.

  5. Why does an empty line do nothing?

    Answer

    The loop matches it and starts again without evaluating

    The empty string is a case of its own in the loop.

  6. What does this program print? module Main (main) where main :: IO () main = print (1 / 0)

    Answer

    Infinity

    The literal defaults to Double and 1/0 in Double is Infinity; the evaluator uses div, which fails instead.

  7. What is printed at the end of the session?

    Answer

    bye and the number of errors

    The :quit branch prints the count it carried.

  8. What does this program print? module Main (main) where main :: IO () main = print (length ["a", "b"])

    Answer

    2

    The list has two elements.

  9. Why is the loop recursive in IO?

    Answer

    Each line is an effect and the next line needs the loop again

    The session is a sequence of actions, one per line.

  10. What does this program print? module Main (main) where main :: IO () main = putStrLn (show (3 * 3 :: Int))

    Answer

    9

    putStrLn prints the shown product without quotes.

The code on this page was built with GHC 9.10.3 and run on Alpine Linux 3.24.3 (x86_64) in a Docker container.

Article author: Arthur Isaev

Banner image