另一个类型错误

Question

Why doesn't this compile?

append :: [a] -> [a] -> [a]
append xs ys = foldr (:) ys xs

traverse :: a -> [[a]] -> [[a]]
traverse x [[]] = [[x]]
traverse x [(y:ys)] = append [(x:y:ys)] (map (y:) (traverse x [ys]))

comb :: [a] -> [[a]]
comb [] = [[]]
comb (x:[]) = [[x]]
comb (x:y:[]) = [[x,y],[y,x]] 
comb (x:xs) = map (traverse x) (comb xs)

It fails with this error:

 Couldn't match type `a' with `[a]'
  `a' is a rigid type variable bound by
      the type signature for comb :: [a] -> [[a]] at pr27.hs:10:1
Expected type: [[a]]
  Actual type: [a]
In the first argument of `comb', namely `xs'
In the second argument of `map', namely `(comb xs)'

xs is a tail of list and so it is a valid argument for comb?? Thanks , David Kramf

Answer 1

Your method comb xs returns a type [[a]] . When passed into map (traverse x) , this calls traverse x with each element of [[a]] , ie elements of type [a] . However, traverse x has the type [[a]] -> [[a]] , so the mismatch here is traverse is expecting a [[a]] but you're giving it a [a] .

Answer 2

Some pointers:

• educational though it may be, you don't need your own append function -- you can use ++
• you probably have more cases than necessary for comb -- do you really need more than comb [] and comb (x:xs) ?
• as written, traverse will not match a second argument containing more than one list

I have not run this through Haskell myself, but I think that last point may be your main problem.

---

Edit: @Kevin Ballard's answer is of course correct with respect to why you get the particular type error. But, I believe the larger problem is that, at some point, you will need to concat -enate (ie, flatten) a list of lists of combinations (actually permutations, if I understand your existing code), and I don't see that here.

As the flip side of this coin, perhaps the type signature of traverse should be a -> [a] -> [[a]] ?

Answer 3

My advice would be to stay concrete. The type variable a can match Int, [ Int ], [[ Int ]] and so on, which can lead to confusion at the early stages of development. Once the program works for concrete types, it is often not very difficult to generalize over arbitrary types.

Here is the conrete version of your previous (buggy) program:

append :: [a] -> [a] -> [a]
append xs ys = foldr (:) ys xs

traverse :: Int -> [Int] -> [[Int]]
traverse x [] = [[x]]
traverse x (y:ys) = append [(x:y:ys)] (map (y:) (traverse x ys))

comb :: [Int] -> [[Int]]
comb [] = [[]]
comb (x:[]) = [[x]]
comb (x:y:[]) = [[x,y],[y,x]] 
comb (x:xs) = map (traverse x) (comb xs)

ghci would complain about the last line:

Couldn't match expected type `Int' with actual type `[Int]'
Expected type: [Int] -> [Int]
  Actual type: [Int] -> [[Int]]
In the return type of a call of `traverse'
In the first argument of `map', namely `(traverse x)'

which looks more understandable than the one you encountered. Whereas [a] can mean anything from [ Int ], [[ Int ]], etc., [ Int ] can mean .. well, [ Int ].
As you said in your last question, the traverse function is fine:

Main> map (traverse 3) [[1,2],[2,1]]
[[[3,1,2],[1,3,2],[1,2,3]],[[3,2,1],[2,3,1],[2,1,3]]]

with type:

Main> :type map (traverse 3) [[1,2],[2,1]]
map (traverse 3) [[1,2],[2,1]] :: [[[Int]]]

Now, recall the type of comb function:

comb :: [Int] -> [[Int]]

The reason of the type error should be clear enough. All you need to do is to "combine" the results of map in the last line, like so:

comb (x:xs) = concat $ map (traverse x) (comb xs)

Here is the output of the (fixed) program:

Main>  comb [1,2,3]
[[1,2,3],[2,1,3],[2,3,1],[1,3,2],[3,1,2],[3,2,1]] 

Now you can try generalizing to arbitrary types.