Skip to content

Evaluator

Evaluator.hs
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
module Evaluator where


import Chess ( display, Board(..), SquareState(HasPiece) )
import Control.Monad.Except ( MonadError(throwError) )
import Control.Monad.State ( MonadState(put, get), gets, modify ) 
import Data.Text ( Text ) 
import Parser ( Instruction(..), ChessError(ReplError, Exit) )

evaluate :: (MonadError ChessError m, MonadState Board m) => 
  Instruction -> m Text
evaluate instr = case instr of
  ReplInstruction "quit" -> throwError Exit 
  ReplInstruction "display" -> gets display 
  Set file rank piece -> do
    (Board boardFunc) <- get 
    let newBoard =
          Board 
            ( \f r ->
                if f == file && r == rank
                  then HasPiece piece
                  else boardFunc f r
            )
    put newBoard 
    return $ display newBoard
  ReplInstruction _ -> throwError $ ReplError "no such instruction"

Analysis

MonadError and MonadState are typeclasses for types with the ability to throw errors and mutate local state respectively. See the monad transformer library (mtl) for more.

With that in mind, read the type signature of evaluate as follows: evaluate is a function that takes an Instruction and returns Text, but with the possibility of throwing an error of type ChessError, and of changing the state (of type Board).

We can think of evaluate as taking a synactic description of an Instruction and evaluating it into a result. For example ReplInstruction "quit" is a description of an instruction, but throwError Exit is the actually "program" that will quit the repl.

evaluate

evaluate :: (MonadError ChessError m, MonadState Board m) => 
    Instruction -> m Text
evaluate instr = case instr of
    ReplInstruction "quit" -> throwError Exit
    ReplInstruction "display" -> gets display
    Set file rank piece -> do
        (Board boardFunc) <- get
        let newBoard =
            Board
                ( \f r ->
                    if f == file && r == rank
                    then HasPiece piece
                    else boardFunc f r
                )
        put newBoard
        return $ display newBoard
    ReplInstruction _ -> throwError $ ReplError "no such instruction"

evaluate' :: (MonadError ChessError m, MonadState Board m) => 
    Instruction -> m Text
evaluate' = \case
    ReplInstruction "quit" -> throwError Exit
    ReplInstruction "display" -> gets display
    Set file rank piece -> do
        (Board boardFunc) <- get
        let newBoard =
            Board
                ( \f r ->
                    if f == file && r == rank
                    then HasPiece piece
                    else boardFunc f r
                )
        put newBoard
        return $ display newBoard
    ReplInstruction _ -> throwError $ ReplError "no such instruction"

evaluate :: (MonadError ChessError m, MonadState Board m) => 
    Instruction -> m Text
evaluate instr = case instr of
    ReplInstruction "quit" -> throwError Exit
    ReplInstruction "display" -> gets display
    Set file rank piece -> do
        let updateBoard (Board boardFunc) = Board ( \f r ->
            if f == file && r == rank
                then HasPiece piece
                else boardFunc f r)
        modify updateBoard
        gets display
    ReplInstruction _ -> throwError $ ReplError "no such instruction"
Last update: February 14, 2023
Created: August 18, 2022

Comments