Why does this Haskell code produce the “infinite type” error?

86
votes

I am new to Haskell and facing a "cannot construct infinite type" error that I cannot make sense of.

In fact, beyond that, I have not been able to find a good explanation of what this error even means, so if you could go beyond my basic question and explain the "infinite type" error, I'd really appreciate it.

Here's the code: 

intersperse :: a -> [[a]] -> [a]

-- intersperse '*' ["foo","bar","baz","quux"] 
--  should produce the following:
--  "foo*bar*baz*quux"

-- intersperse -99 [ [1,2,3],[4,5,6],[7,8,9]]
--  should produce the following:
--  [1,2,3,-99,4,5,6,-99,7,8,9]

intersperse _ [] = []
intersperse _ [x] = x
intersperse s (x:y:xs) = x:s:y:intersperse s xs

And here's the error trying to load it into the interpreter: 

Prelude> :load ./chapter.3.ending.real.world.haskell.exercises.hs
[1 of 1] Compiling Main (chapter.3.ending.real.world.haskell.exercises.hs, interpreted )

chapter.3.ending.real.world.haskell.exercises.hs:147:0:
Occurs check: cannot construct the infinite type: a = [a]
When generalising the type(s) for `intersperse'
Failed, modules loaded: none.

Thanks.

--

Here is some corrected the code and a general guideline for dealing with the "infinite type" error in Haskell:

Corrected code

intersperse _ [] = []
intersperse _ [x] = x
intersperse s (x:xs) =  x ++ s:intersperse s xs

What the problem was:

My type signature states that the second parameter to intersperse is a list of lists. Therefore, when I pattern matched against "s (x:y:xs)", x and y became lists. And yet I was treating x and y as elements, not lists.

Guideline for dealing with the "infinite type" error:

Most of the time, when you get this error, you have forgotten the types of the various variables you're dealing with, and you have attempted to use a variable as if it were some other type than what it is. Look carefully at what type everything is versus how you're using it, and this will usually uncover the problem.

4
haskelltypestype-inference
Another good tip: declare the types explicitly. This gives the compiler something to check against. – Paul Johnson
So this solves the problem, but why does the compiler say "Cannot construct infinite type?". What does that mean? If the problem is you are trying to perform operations on types that do not support those operations, why doesn't the compiler say something like that? – freedrull
+1 for the structure of the question (question - corrected - problem was - guideline) – Dacav
@freedrull: the error is worded that way because I told the compiler that the type parameter "a" should be "filled" with a "list of a's". That's like saying my coffee cup contains a bunch of copies of my coffee cup. It truly is a recursive definition that makes no sense (or at least, is defined as invalid in Haskell). So it tells me, "Cannot construct infinite type". The thing is, I could do other things with that type parameter that are based on a. For ex, I could fill that type parameter with "Maybe a". So the kind of thing I was doing is ok, but the specific thing I did is not ok. – Charlie Flowers
@freedrull: The compiler has noticed the code does a bunch of things with values related to a, any of which would be fine in isolation. So it can't point to any one of them and say "that's an unsupported operation for this type". But together they add up to a requirement for a type satisfying a = [a]. The compiler knows that is impossible, so it tells you that. It doesn't know which parts of the code that led to that requirement are the wrong parts; that depends on what you intended the code to mean. – Ben

4 Answers

38
votes

The problem is in the last clause, where you treat x and y as elements, while they are lists. This will work:

intersperse _ [] = []
intersperse _ [x] = x 
intersperse s (x:y:xs) = x ++ [s] ++ y ++ intersperse s xs

The infinite type error occurs because the : operator has type a -> [a] -> [a], while you treat it as [a] -> a -> [a], which means that [a] must be identified with a, which would mean that a is an infinitely nested list. That is not allowed (and not what you mean, anyway).

Edit: there is also another bug in the above code. It should be:

intersperse _ [] = []
intersperse _ [x] = x
intersperse s (x:xs) = x ++ [s] ++ intersperse s xs
6
votes

Often adding an explicit type definition can make the compiler's type error message make more sense. But in this case, the explicit typing makes the compiler's error message worse.

Look what happens when I let ghc guess the type of intersperse:

Occurs check: cannot construct the infinite type: a = [a]
  Expected type: [a] -> [[a]] -> [[a]]
  Inferred type: [a] -> [[a]] -> [a]
In the second argument of `(:)', namely `intersperse s xs'
In the second argument of `(:)', namely `y : intersperse s xs'

That clearly points toward the bug in the code. Using this technique you don't have to stare at everything and think hard about the types, as others have suggested doing.

3
votes

I may be wrong, but it seems you're trying to solve a more difficult problem. Your version of intersperse doesn't just intersperse the value with the array, but also flattens it one level.

The List module in Haskell actually provides an intersperse function. It puts in the value given between every element in the list. For example:

intersperse 11 [1, 3, 5, 7, 9] = [1, 11, 3, 11, 5, 11, 7, 11, 9]
intersperse "*" ["foo","bar","baz","quux"] = ["foo", "*", "bar", "*", "baz", "*", "quux"]

I'm assuming this is what you want to do because it's what my professor wanted us to do when I was learning Haskell. I could, of course, be totally out.

0
votes

Also I found this which explains the meaning of the error.

Every time the interpreter/compiler gives me this error it's because I'm using some type-parametrized tuple as formal parameter. Everything works correctly by removing the type definition of the function, which was containing type variables.

I still cannot figure out how to both fix it and keep the function type definition.