REPL

Repl.hs
{-# LANGUAGE BlockArguments #-} Allows writing e.g. functionOf do ... instead of functionOf $ do.


module Repl where

import Chess
import Control.Monad
import Control.Monad.Except
import Control.Monad.State
import Data.Text (Text)
import Data.Text qualified as T
import Evaluator
import Parser
import Text.Megaparsec hiding (parse) hiding is convenient for avoiding namespace conflicts.

import Witch (into)


main :: IO ()
main = do
    runReplWithBoard $
      displayLine "Welcome!\n\n" >> forever do forever takes a value of type m X (where m has a Monad constraint on it) and loops it: forever mX = mX >> forever mX. It's a clean way to write a for-loop.


        line <- requestLine "> " Get a line from the user.

        let instruction = parse line Parse the user's input, using parse from the Parser module.

        board <- get Get the current state of the board.

        result <-
          case instruction of
            Left (ParseError err) -> pure err pure is like return, but only requires the Applicative typeclass. It can be used almost everywhere that return is used, but is strictly more general, because a Monad constraint implies an Applicative constraint.

            Left (ReplError err) -> pure err
            Right instr -> evaluate instr
              `catchError` ( \case catchError, here used in infix form, stops an error percolating to the top level. This is useful here, because an uncaught error would halt main, and so exit the repl.

                              ReplError txt -> pure txt
                              err -> throwError err catchError chooses what to do with the error it catches, and one option is to throw it again. It does this for errors including Exit, in order to exit the repl on ":q".

                          )

        displayLine result Neither return nor pure is a keyword, and a block of do-notation does not need to end with it. All that is needed at the end of the "do-block" is a value of type m a (for the monad m in question), and displayLine result has that type.

    pure ()

  where

    runReplWithBoard :: StateT Board (ExceptT e IO) a -> IO (Either e a) runReplWithBoard is the function responsible for "unpacking" the monadic value into something simpler. This is sometimes referred to as "running the side effects" of a program.

    runReplWithBoard = runExceptT . flip evalStateT initBoard flip is a useful function that takes a function of type X -> Y -> Z and flips the argument order to give a function of type Y -> X -> Z. It is often useful when writing in pointfree style.


    displayLine :: Text -> StateT Board (ExceptT ChessError IO) ()
    displayLine = liftIO . putStrLn . into @String It is often useful to lift the type IO X to the more abstract MonadIO m => m X, which is what liftIO does.


    requestLine :: Text -> StateT Board (ExceptT ChessError IO) Text
    requestLine prompt = do
      displayLine prompt
      line <- liftIO getLine
      pure $ into @Text line

Analysis¶

This module is responsible for producing the actual runnable program (of type IO ()) that wraps up the whole system.

`main`¶

original

```haskell

main :: IO () main = void $ runReplWithBoard $ displayLine "Welcome!\n\n" >> forever do

            line <- requestLine "> "
            let instruction = parse line
            board <- get
            result <-
            case instruction of
                Left (ParseError err) -> pure err
                Left (ReplError err) -> pure err
                Right instr -> evaluate instr
                `catchError` ( \case
                                ReplError txt -> pure txt
                                err -> throwError err 
                            )

            displayLine result 
```

without forever

```haskell

main :: IO () main = runReplWithBoard $ displayLine "Welcome!\n\n" >> loop where

        loop = do

        line <- requestLine "> "
        let instruction = parse line
        board <- get
        result <-
            case instruction of
            Left (ParseError err) -> pure err
            Left (ReplError err) -> pure err
            Right instr -> evaluate instr
                `catchError` ( \case
                                ReplError txt -> pure txt
                                err -> throwError err 
                            )

        displayLine result 
        loop
```

without void

```haskell

main :: IO () main = do runReplWithBoard $ displayLine "Welcome!\n\n" >> forever do

            line <- requestLine "> "
            let instruction = parse line
            board <- get
            result <-
            case instruction of
                Left (ParseError err) -> pure err
                Left (ReplError err) -> pure err
                Right instr -> evaluate instr
                `catchError` ( \case
                                ReplError txt -> pure txt
                                err -> throwError err 
                            )

            displayLine result 
    pure ()
```

Last update: February 9, 2023
Created: January 8, 2023

REPL

Analysis¶

main¶

`main`¶