Question: Consider the following (Haskell) code:

```
fib=0:1:zipWith (+) fib (tail fib)

```

A coworker is trying to assert that this is not a recursive function because `fib` is simply a list that defines itself with itself and that is somehow different than a function that does the same. I think he's smoking crack. 

What do you think?

Answer: 
The fibonacci definition with zipWith is not a recursive function, in fact there is no function involved, fib is a list (data) that is lazily self-defined, utilizing Haskell's lazy semantic. In a sense, you can call it recursive list or recursive data; but not recursive function.

It may be difficult to wrap your head around recursive list since very little programming languages have anything close, but you'll notice that in Haskell all functions takes exactly one paramater. `fib` does not take any parameter, because it's not a function. Since there is no function involved, you can't have recursive function.

Your coworker isn't smoking crack, he's enlightened (or smoking crack, if that's your definition of enlightenment).
Since most answers support your coworker with respect to the *function* part of: "`fib` is *not* a recursive function." I'd like to elaborate on on the recursive part Conor McBride hinted at in his answer.

The definition given for `fib` is *not* recursive, it is *co-recursive*. 

Co-recursion looks a lot like recursion in that, as many posters have pointed out, the LHS of the definition appears on the RHS too. But there is no base case. Recursion and corecursion "run in opposite directions". 

The above definition of `fib` starts from the initial values 0 and 1 and moves "up" from there and keeps on going. 
On the other hand a recursive definition of, say (a function calculating) the n-th Fibonacci number

```
fib' 0 = 0
fib' 1 = 1
fib' n = fib' (n-1) + fib' (n-2)

```

walks "downwards" from the n-th number until it reaches the base cases and there stops.

I guess this vindicates the crackhead in both points :-)

---

For further reading check out the wikipedia article on [Corecursion](http://en.wikipedia.org/wiki/Corecursion) and the links there. If you can get you hands on it, Chapter 10 of *The Haskell Road to Logic, Maths and Programming* by Kees Doets and Jan van Eijck may be worth a peek.