Question

I am not a Haskell pro. Today I had a somewhat bizarre experience with the type system today. The second line of this will cause a type error. The problem is the maxdiag (as:bs:cs:ds) bit of the second line:

maxdiag ((a:as):(b:bs):(c:cs):(d:ds):xs) len =
  maximum [a*(bs !! 0)*(cs !! 1)*(ds !! 2), maxdiag (as:bs:cs:ds) (len-1)]

It fails with the following error:

Occurs check: cannot construct the infinite type: a0 = [a0]
Expected type: [[a0]]
  Actual type: [a0]
In the second argument of `(:)', namely `ds'
In the second argument of `(:)', namely `cs : ds'

When I change the offending part of the second line to maxdiag (as:bs:cs:ds:xs), so that it reads

maxdiag ((a:as):(b:bs):(c:cs):(d:ds):xs) len =
  maximum [a*(bs !! 0)*(cs !! 1)*(ds !! 2), maxdiag (as:bs:cs:ds:xs) (len-1)]

… then there is no error. Similarly, if I replace it with maxdiag (as:bs:cs:(ds:xs)) it succeeds. My questions are

1. What does this error mean?
2. Why has it occurred?
3. Why do these two seemingly different things fix it?

Answer 1

The thing to remember is that (:) has the type a -> [a] -> [a], so its first argument is an element, while the second argument is a list with that element type. If the elements are themselves lists, this becomes [a] -> [[a]] -> [[a]].

In your example, as, bs, cs and ds all have type [a], while xs has type [[a]], so cs:ds is an error while ds:xs is well-typed.

The reason for that particular error message is that when you try to use (:) on two things of the same type b, the only way that would work is if b was the same type as [b], but that would be an infinite type which is not allowed.

For the other question, the (:) operator is right-associative, so as:bs:cs:ds:xs is the same as as:(bs:(cs:(ds:xs))) and also as:bs:cs:(ds:xs).