Haskell Chesshs and Array Error How To Define `board :: Array (Int, Int) (Maybe Piece)`

I am trying to build a Board in the library chesshs.

-- from chesshs source code:

data Board = Board { turn :: Color
                   , castlingAvail :: String
                   , enpassant :: Maybe (Int, Int)
                   , board :: Array (Int, Int) (Maybe Piece)
                   } deriving (Eq)

so I am trying to create a Board with the following:

*MyLib Data.Array Chess> Board {
  turn = White
, castlingAvail = ""
, enpassant = Nothing
, board = Array (0,0) (Just (Piece White Pawn))
}

but I get the following error, as if Array doesn't exist, Strange because is what it appears as type signature in the board parameter as per chesshs source code:

<interactive>:103:71: error:
    • Data constructor not in scope:
        Array :: (a0, b0) -> Maybe Piece -> Array (Int, Int) (Maybe Piece)
    • Perhaps you meant variable ‘array’ (imported from Data.Array)

so I try substituting Array for array (not quite sure why Array doesn't work and if array is just the way to create an Array)

*MyLib Data.Array Chess Chess.PGN> Board {
  turn = White
, castlingAvail = ""
, enpassant = Nothing
, board = array (0,0) (Just (Piece White Pawn))
}

but it doesn't work and I receive this error message:

<interactive>:104:84: error:
    • Couldn't match expected type ‘[((Int, Int), Maybe Piece)]’
                  with actual type ‘Maybe Piece’
    • In the second argument of ‘array’, namely
        ‘(Just (Piece White Pawn))’
      In the ‘board’ field of a record
      In the expression:
        Board
          {turn = White, castlingAvail = "", enpassant = Nothing,
           board = array (0, 0) (Just (Piece White Pawn))}

Which make sense because checking the array type

array :: Ix i => (i, i) -> [(i, e)] -> Array i e

so I try the following:

*MyLib Data.Array Chess> Board {
  turn = White
, castlingAvail = ""
, enpassant = Nothing
, board = array (0,0) [((0,0), (Just (Piece White Pawn)))]
}

which gives me this error:

<interactive>:108:78: error:
    • No instance for (Num (Int, Int)) arising from the literal ‘0’
    • In the expression: 0
      In the first argument of ‘array’, namely ‘(0, 0)’
      In the ‘board’ field of a record

Which leaves me very confused.. not quite sure why ghci interaction drives me to use a type different from what it appears in the source code of chesshs Board and why it anyway drives me to an error that I don't understand.

Array i e is a type. It's defined in a module which does not export its data constructors, so we don't get access to those. This is unlike the Maybe a type for which we get access to the Nothing and Just constructors.

Hence, to create an array value we need to rely on the functions exported by the module. There is indeed a function for that, named array. This function is sometimes referred to as a "smart" constructor, since unlike a (regular) constructor it performs some sanity checks before constructing the value.

Anyway, it is meant to be used like this:

array (startPos, endPos)
      [ (startPos, value0), (nextPos, value1), ..., (endPos, valueLast) ]

We provide a pair with the first and last valid array indices/positions. We then provide a list of pairs. associating each valid index/position to its value.

In your case, if you board only contains position (0,0) (should it be so?) then it should be created as

array ((0,0),(0,0)) [ ((0,0), Just (Piece White Pawn)) ]

If instead you need to create a 8x8 board, you will need a longer list for that.

array ((0,0),(7,7)) [ ((0,0), Just (Piece White Pawn)) , ....
-- add all other positions, possibly with Nothing values

If you need to place only a few pieces in a large board, it might be more convenient to simply create an empty board and then update it with the few pieces. E.g.

let emptyB = array ((0,0),(7,7)) [ ((x,y), Nothing) | x<-[0..7], y<-[0..7] ]
    myB = emptyB // [ ((5,5), Just (Piece White Pawn)) ]
in ...

Here I used the // operator to create a new board with the same pieces as emptyB, except for those positions and values in the list.