Haskell-无法将类型“（Int，Integer）”与“ Pos”匹配

Question

I am currently learning Haskell and I am currently having an issue.

This is my code:

data Pos = Pos (Int, Int) deriving (Show, Eq)                             
allCoordinates :: [Pos]
allCoordinates = concat [(zip (allHelper x) [0..8]) | x<-[0..8]]

allHelper ::Int -> [Int]
allHelper x = [x | y<-[0..8]]

I have to use that specific data type and I am having a little issue due to this.

This code works perfectly fine if the code is written like this:

type Pos = (Int, Int)
allCoordinates :: [(Int, Int)]
allCoordinates = concat [(zip (allHelper x) [0..8]) | x<-[0..8]]

but I need to edit this bit:

concat [(zip (allHelper x) [0..8]) | x<-[0..8]]

so that it works with:

allCoordinates :: [Pos]

It is probably a simple issue and I having a bit of a mental block however can anyone help?

Thank you

Answer 1

If you write:

type Pos = (Int, Int)

You have not constructed a new type: you have constructed a type alias, so you can interchange Pos with (Int, Int) in the code. So a function with signature f :: [(Int,Int)] is equivalent to f :: [Pos] .

You can clean up the code and write:

allCoordinates :: [Pos]
allCoordinates = [ (x,y) | x <- [0..8], y <- [0..8]]

Or even more clean (but probably somewhat harder to understand):

allCoordinates :: [Pos]
allCoordinates = (,) <$> [0..8] <*> [0..8]

A disadvantage of the fact that you work with a type signature is that there can be a lot of functions defined on that type, and perhaps you want to define functions with the same name (in case of type classes), but with a different implementation. In that case you can define a datatype :

 Pos = Pos (Int,Int)

Now we have defined a new type, with a constructor Pos . Now the above code will no longer work, but we can easily alter it by calling the constructor on the tuples we produce. So:

allCoordinates :: [Pos]
allCoordinates = [  (x,y) | x <- [0..8], y <- [0..8]]

In case you define a type with one constructor and that constructor has one parameter, we can use newtype . Now we have defined a type, but Haskell can optimize it such that internally, it will not wrap and unwrap in a constructor, but simply treat the tuple in another way:

 Pos = Pos (Int,Int)

Answer 2

type defines a Type alias . That is to say, writing:

type Pos = (Int, Int)

means that whenever you write Pos in your code, the compiler sees (Int, Int) . To construct a Pos in this case, you can just write (1, 2) , since an (Int, Int) and a Pos are indistinguishable.

However, data defines a new datatype. Your example is:

data Pos = Pos (Int, Int)

Pos is a type constructed by the function Pos :: (Int, Int) -> Pos . These are not equal ! To construct a Pos in this case, you would write Pos (1, 2) .

To correct your code, write:

data Pos = Pos (Int, Int)
allCoordinates :: [(Int, Int)]
allCoordinates = concat [zipWith (curry Pos) (allHelper x) [0..8] | x<-[0..8]]

Where zipWith :: (a -> b -> c) -> [a] -> [b] -> [c] .

However, unless you want different behaviour in typeclasses, using a type alias would be best, otherwise, you should use a newtype .