haskell fibonacci-无法构造无限类型：a0 = [a0]

Question

I was trying to get an infinite list of fibonacci numbers in haskell but the following code would not compile:

fib1 x = fib1 (x : (last $ init x) + (last x))
result1 = fib1 [1,2]

I eventually got it to work with this code:

fib2 x y = head y : fib2 y (zipWith (+) x y)
result2 = fib2 [0,1] [1,1]

Still, I do not understand why the first code snippet did not compile. The error is below. I am just looking for an answer as to why the first one doesn't compile but the second does.

p2.hs:3:16:
    Occurs check: cannot construct the infinite type: a0 = [a0]
    In the first argument of `(:)', namely `x'
    In the first argument of `fib1', namely
      `(x : (last $ init x) + (last x))'
    In the expression: fib1 (x : (last $ init x) + (last x))

p2.hs:3:21:
    Occurs check: cannot construct the infinite type: a0 = [a0]
    In the first argument of `(+)', namely `(last $ init x)'
    In the second argument of `(:)', namely
      `(last $ init x) + (last x)'
    In the first argument of `fib1', namely
      `(x : (last $ init x) + (last x))'

p2.hs:3:44:
    Occurs check: cannot construct the infinite type: a0 = [a0]
    Expected type: [[a0]]
      Actual type: [a0]
    In the first argument of `last', namely `x'
    In the second argument of `(+)', namely `(last x)'
    In the second argument of `(:)', namely
      `(last $ init x) + (last x)' Failed, modules loaded: none.

Answer 1

The problem with the first code sample is that there is no way you could write a type annotation for it. It would be infinite. Let's try it anyway:

fib1 x = fib1 (x : (last $ init x) + (last x))

First let's simplify it, because we can replicate the same problem without the last and init stuff:

fib1 x = fib1 (x : undefined)

What is the type of fib1 's argument. On the left, we only see x with no more information about it. We can assume it has some type a . On the right hand side, we try to call the function with argument which must be a list (because it is constructed by : operator). Elements of the list start with x , which has type a . Therefore, the type of fib1 's argument here is [a] . Since we can't call a function with arguments of two different types, even on left side x must have type [a] . But this forces us to update the type on the rigth side to [[a]] . And then again on the left. This process will never stop, the type will grow and grow, because there is no way to unify a with [a] . Therefore there is no valid type for the expression and GHC will reject it.

On the other hand, the second snippet does not have the problem.

fib2 xy = head y : fib2 y (zipWith (+) xy)

We can easily ask GHCi the type of this function, and it will happily answer us:

Prelude> let fib2 xy = head y : fib2 y (zipWith (+) xy) Prelude> :t fib2 fib2 :: Num a => [a] -> [a] -> [a]

That type is perfectly finite.