List comprehension vs zipWith in Haskell - haskell

Question

This is code #1:
fibs = 0:1:zipWith (+) fibs (tail fibs)
I wrote the same code with list comprehension (code #2):
fibs' = 0:1:[x+y|x<-fibs',y<-tail fibs']
but code #1 produces the Fibonnacci numbers while code #2 produces 0 1 1 1 1
Why does this happen?

Answer 1

List comprehensions such as [x+y|x<-fibs',y<-tail fibs'] will generate x+y for all combinations of x,y extracted from the two lists. For instance,
[ (x,y) | x<-[1..10] , y<-[1..10] ]
will generate all the 100 pairs, essentially computing the cartesian product of the two lists.
Zipping the lists instead only generates pairs for the corresponding elements, yielding only 10 pairs.
Parallel list comprehensions instead work as zip does. For instance,
[ (x,y) | x<-[1..10] | y<-[1..10] ]
will return the same 10 pairs as zip. You can enable this Haskell extension by adding {-# LANGUAGE ParallelListComp #-} at the beginning of your file.
Personally, I do not use this extension much, preferring to explicitly use zip instead.

Answer 2

List comprehensions over multiple lists do not work like zip/zipWith - each element of one list is combined with each element of the other list rather than being combined pair-wise. To illustrate this difference, look at this simpler example:
xs = [1,2]
ys = [3, 4]
zipped = zipWith (+) xs ys -- [4, 6]
comprehended = [x+y | x <- xs, y <- ys] [4, 5, 5, 6]
To get the behavior of zip in a list comprehension, you'd need to use the GHC extension for parallel list comprehensions, which allows you to write this:
parallelComp = [x+y | x <- xs | y <- ys] -- [4, 6]

Answer 3

The reason is: it's not the same code. :) The first sample uses zipWith which is applying (+) pairwise. The second one does something like Cartesian product, but instead of returning pair (x,y) it returns x+y.
Compare:
zip [1..5] [2..6] === [(1,2),(2,3),(3,4),(4,5),(5,6)]
With:
[ (x,y) | x <- [1..5], y <- [2..6] ] === [(1,2),(1,3),(1,4),(1,5),(1,6),
(2,2),(2,3),(2,4),(2,5),(2,6),
(3,2),(3,3),(3,4),(3,5),(3,6),
(4,2),(4,3),(4,4),(4,5),(4,6),
(5,2),(5,3),(5,4),(5,5),(5,6)]

Answer 4

The list comprehension
[ x + y | x <- xs, y <- ys ]
equals (more or less) to the following imperative pseudocode
list = emptyList
foreach (x in xs) {
foreach (y in ys) {
append (x+y) to list
}
}
return list
However, if that ys is an infinitive list, as in your code #2, then the result list will be
list = emptyList
x = head of xs
foreach (y in ys) {
append (x+y) to list
}
return list
That is why you got that list consists of 0, 1, 1, ... .

Answer 5

You can get the behaviour you want using ZipList rather than []. Since ZipList is not a monad you cannot use monadic do. Instead you have to use applicative do, also known as "arrow notation"! :)
{-# LANGUAGE Arrows #-}
import Prelude hiding (id, (.))
import Control.Arrow
import Control.Applicative
import Control.Category
data A f a b = A (f (a -> b))
type Arr f a = A f () a
runA :: A f a b -> f (a -> b)
runA (A f) = f
arrOfApp :: Functor f => f a -> Arr f a
arrOfApp = A . fmap const
appOfArr :: Functor f => Arr f a -> f a
appOfArr = fmap ($ ()) . runA
The definitions above are rather similar to those you can find in optparse-applicative.
zipListArr :: [a] -> Arr ZipList a
zipListArr = arrOfApp . ZipList
getZipListArr :: Arr ZipList a -> [a]
getZipListArr = getZipList . appOfArr
instance Applicative f => Category (A f) where
id = A (pure id)
A f . A g = A ((.) <$> f <*> g)
instance Applicative f => Arrow (A f) where
arr f = A (pure f)
first (A f) = A (fmap first f)
fibs' :: [Int]
fibs' = 0 : 1 : (getZipListArr $ proc () -> do
x <- zipListArr fibs' -< ()
y <- zipListArr (tail fibs') -< ()
returnA -< x + y)
*Main> take 10 fibs'
[0,1,1,2,3,5,8,13,21,34]