Haskell에서 다형성 방식으로 여러 유형에 대한 여러 함수 정의를 작성하려면 어떻게해야합니까?

내 유형 정의가 주어지면 :

data Tile = Revealed | Covered deriving (Eq, Show)
data MinePit = Clean | Unsafe deriving (Eq, Show)
data Flag = Flagged | Unflagged deriving (Eq, Show)
type Square = (Tile, MinePit, Flag)
type Board = [[Square]]

두 가지 기능을 만들었습니다.

1. createBoard 는 값의 튜플 또는 'Board' 의 2D 목록을 생성합니다 . 동일한 값의 차원 n * m 목록을 초기화합니다.

createBoard :: Int -> Int -> Board
createBoard 0 _ = [[]]
createBoard _ 0 = [[]]
createBoard 1 1 = [[(Covered, Clean, Unflagged)]]
createBoard n m = take n (repeat (take m (repeat (Covered, Clean, Unflagged))))

예 :

λ> createBoard 2 3
[[(Covered,Clean,Unflagged),(Covered,Clean,Unflagged),(Covered,Clean,Unflagged)],[(Covered,Clean,Unflagged),(Covered,Clean,Unflagged),(Covered,Clean,Unflagged)]]

2. 함수 defineIndices 는 createBoard에 의해 생성 된 보드에 대한 인덱스의 순서 목록을 목적으로 정의되었습니다.

defineIndices :: Int -> Int -> [[(Int,Int)]]
defineIndices n m = [[(i,j) | j <- [1..m]] | i <- [1..n]]

다음과 같이 작동합니다.

λ> defineIndices 2 3
[[(1,1),(1,2),(1,3)],[(2,1),(2,2),(2,3)]]

여기에서 특정 Square의 값을 인덱스를 통해 조회 할 수있는 MapBoard 를 만드는 함수를 만들었 습니다.

type MapBoard = Map (Int, Int) Square

createMapBoard :: [[(Int,Int)]] -> [[Square]] -> MapBoard
createMapBoard indices squares = M.fromList $ zip (concat indices) (concat squares)

그러나 Int (s) 쌍에서 직접 MapBoard를 생성하여 이전 기능을 구현할 수있는 메서드도 작성해야한다는 것이 합리적이었습니다. 다음과 같이 보일 수 있습니다.

createMapBoard2 :: Int -> Int -> MapBoard
createMapBoard2 n m = createMapBoard indices squares where
  indices = defineIndices n m
  squares = createBoard n m

그러나 createMapBoard를 사용하여이 상황에서 다형성을 달성 할 수 있는지 여부를 조사하고 createMapBoard2를 대신 createMapBoard로 설정했습니다. 나는 이것이 Ad-Hoc Polymorphism이라고 불리는 것을 온라인 에서 발견했습니다.

class Square a where
    square :: a -> a
    
instance Square Int where
    square x = x * x

instance Square Float where
    square x = x * x 

비슷한 것을 직접 작성하려고 시도했을 때 제가 생각 해낼 수있는 최선의 방법은 다음과 같습니다.

class MyClass a b MapBoard where
  createMapBoard :: a -> b -> MapBoard

instance createMapBoard [[(Int,Int)]] -> [[Square]] -> MapBoard where
  createMapBoard indices squares = M.fromList $ zip (concat indices) (concat squares)

instance createMapBoard Int -> Int -> MapBoard where
  createMapBoard n m = createMapBoard indices squares where
  indices = defineIndices n m
  squares = createBoard n m

이를 컴파일하려고하면 컴파일 오류가 발생합니다.

src/minesweeper.hs:35:19-26: error: …
    Unexpected type ‘MapBoard’
    In the class declaration for ‘MyClass’
    A class declaration should have form
      class MyClass a b c where ...
   |
Compilation failed.
λ> 

클래스 정의에서 MapBoard와 같은 비 대수 유형을 사용할 수없는 이유가 혼란 스럽습니다.

class MyClass a b MapBoard where

MapBoard를 다른 대수 유형 c로 대체하면 또 다른 컴파일 오류가 발생하여 손실됩니다.

src/minesweeper.hs:37:10-63: error: …
    Illegal class instance: ‘createMapBoard [[(Int, Int)]]
                             -> [[Square]] -> MapBoard’
      Class instances must be of the form
        context => C ty_1 ... ty_n
      where ‘C’ is a class
   |
src/minesweeper.hs:39:10-46: error: …
    Illegal class instance: ‘createMapBoard Int -> Int -> MapBoard’
      Class instances must be of the form
        context => C ty_1 ... ty_n
      where ‘C’ is a class
   |
Compilation failed.

createMapBoard의 임시 다형성을 얻을 수 있습니까? 반환 유형이 모든 인스턴스에 대해 MapBoard 여야한다는 엄격한 제약이있는 클래스 정의를 만들 수 있습니까?

편집하다:

구문 오류를 수정 한 후 내 코드는 다음과 같습니다.

class MyClass a b where
  createMapBoard :: a -> b
instance createMapBoard [[(Int,Int)]] [[Square]] where
  createMapBoard indices squares = M.fromList $ zip (concat indices) (concat squares)
instance createMapBoard Int Int where
  createMapBoard n m = createMapBoard indices squares where
  indices = defineIndices n m
  squares = createBoard n m

이로 인해 또 다른 컴파일 오류가 발생합니다.

src/minesweeper.hs:37:10-23: error: …
    Not in scope: type variable ‘createMapBoard’
   |
src/minesweeper.hs:39:10-23: error: …
    Not in scope: type variable ‘createMapBoard’
   |
Compilation failed.

나는 수업에 대한 나의 이해에 여전히 오류가 있다고 믿는 경향이 있습니다.