Chess Logic

module Chess where -- (3)!

import Data.Char (toUpper)
import Data.List (intercalate, intersperse)
import Data.Text qualified as T
import Witch (into)


data PieceType = Bishop | Rook | Knight | Pawn | King | Queen -- (1)!
  deriving (Eq, Show) -- (4)!

data Color = Black | White
  deriving (Eq, Show)

data Piece = Piece PieceType Color -- (2)!
  deriving (Eq, Show)

data File = A | B | C | D | E | F | G | H
  deriving (Eq, Ord, Show, Enum) -- (5)!

data Rank = One | Two | Three | Four | Five | Six | Seven | Eight
  deriving (Eq, Ord, Show, Enum)

data SquareState where -- (7)!
  Empty :: SquareState
  HasPiece :: Piece -> SquareState

-- (15)!
newtype Board where -- (14)!
  Board :: (File -> Rank -> SquareState) -> Board

initBoard :: Board -- (6)!
initBoard = Board $ \f r -> Empty

display :: Board -> T.Text
display (Board boardFunc) =
  into @T.Text $ -- (9)!
    intercalate "\n" $
      map (intersperse '|') $
        group 8 flatBoard
  where

    -- (10)!
    flatBoard =
      [ showSquare (boardFunc file rank)
        | file <- [A .. H],
          rank <- [One .. Eight] -- (8)!
      ]

    showPiece (Piece pieceType color) = letterCase color $ case pieceType of
      Bishop -> 'b'
      King -> 'k'
      Knight -> 'n'
      Queen -> 'q'
      Rook -> 'r'
      Pawn -> 'p'

    showSquare = \case
      -- (11)!
      Empty -> '_'
      HasPiece p -> showPiece p

    letterCase = \case
      Black -> toUpper -- (12)!
      White -> id -- (13)!

-- helper function: split list into chunks of size n
group :: Int -> [a] -> [[a]]
group _ [] = []
group n l = (take n l) : (group n (drop n l))

1. A sum type.
2. A product type.
3. Module should have same name as file.
4. Automatically derive Eq and Show typeclasses
5. Enum allows for writing e.g. [A .. H]
6. Alternative approaches include
7. Another syntax for custom datatypes, know as GADT
8. A list comprehension, as in Python.
9. into is from the witch package, for type coercions. @Text indicates the type to coerce to.
10. No need to write type signatures (although it's good practice) - Haskell will infer them for you.
11. \case requires the LambdaCase extension which has been globally enabled in the project's .cabal file.
12. If Black, return function to uppercase the character.
13. If White, don't change the letter case. id can be useful.
14. newtype is like the data keyword. See more about newtype here
15. Alternative approaches to the Board type include.

Analysis

Because custom types are so easily made and expressive, it is typical in Haskell to create types that model your problem domain (here various chess-related types).

The central type is Board, which represents the state of a chessboard. We have chosen to directly represent the board's state as a function from a square (specified by file and rank) to the square's state.

A good example of type-based refactoring in Haskell is to change Board to an alternative representation and then fix the series of type errors that Haskell will show you in order to make the new Board type work across your project.

Alternative approaches

initBoard

original

```haskell

initBoard :: Board initBoard = Board $ \f r -> Empty ```

wildcards

```haskell

initBoard :: Board initBoard = Board $ _ _ -> Empty ```

with curry and const

```haskell

initBoard :: Board initBoard = Board $ curry $ const Empty ```

!!! Tip 
    To understand how this works, lookup the types of `const` and `curry` on [Hoogle](/gettingstarted/overview/#step-4-hoogle) (both are common and useful functions).

    Then ascertain the type of `const Empty` with VSCode, namely:

    - `#!hs (const Empty) :: (File, Rank) -> SquareState`

    Convince yourself that this is an appropriate input type for `curry`, and an appropriate output type for `const`.

Board

original

```haskell

data SquareState where Empty :: SquareState HasPiece :: Piece -> SquareState

newtype Board where
    Board :: (File -> Rank -> SquareState) -> Board
```

with dictionary

import qualified Data.Map as M
type Board = M.Map (File, Rank) Piece

---

Last update: February 9, 2023
Created: August 18, 2022

Comments