For my first post in the coolcodesnippets series I'll write about one of my favorite pieces of code:
fibs = 1 : 1 : zipWith (+) fibs (tail fibs)
This Haskell oneliner makes an infinite, lazily calculated list of all the fibonacci numbers. Since it's infinite and lazily calculated, printing it just prints the fibonacci sequence as fast as the computer can calculate them, and it makes a pretty interesting pattern of continually growing arcs from left to right.
Working with the list is pretty convenient:
first_ten_fibs = take 10 fibs
even_fibs = filter ((==0) . (`rem` 2)) fibs
squared_fibs = map (^2) fibs
This snippet will look pretty alien if you don't know Haskell, but it's pretty simple once you understand its components.
Prepending with :
In Haskell, :
prepends to a list. More accurately, it returns a new list with the element prepended.
> ls = 1 : [5, 10, 15]
> ls
[1,5,10,15]
 you can compound it:
> ls = 1 : 5 : [10, 15]
> ls
[1, 5, 10, 15]
 it needs to be applied to a list:
> ls = 1 : 2 : 3  type error since 3 is not a list
That takes care of the first part. 1 : 1 : (...)
means that the list will start with [1, 1]. This also means that zipWith (+) fibs (tail fibs)
is a list.
zipWith
zipWith
should be pretty familiar to anyone familiar with functional concepts from languages like Python or Rust. The syntax for zipWith
is zipWith (function) (list A) (list B)
. All it does is iterate over the lists in parallel and apply the function to the elements.
In Python, for example, zipWith
can be implemented like this:
def zipWith(f, l1, l2):
return [f(a, b) for (a, b) in zip(l1, l2)]
Keep in mind that zip
(in Haskell and Python) turns two lists [a0, a1, ...]
and [b0, b1, ...]
into [(a0, b0), (b0, b1), ...]
.
So now that we know how zipWith
works, let's look at its arguments:

(+)
is the function 
fibs
is the first list 
tail fibs
is the second list
(+)
definitely won't look like a function if you're not familiar with Haskell. In Haskell, operators are just infix functions, and you can turn them into prefix functions by surrounding them in parentheses. That means that (+)
is just a function which takes two arguments and returns their sum.
fibs
might also seem pretty strange as an argument, it's what we're trying to define. This works because variables are actually just functions in Haskell, so they can be recursive. For example, this is perfectly valid Haskell:
> a = a
In this case, a
never evaluates to anything; it's a recursive function without a base case.
So when Haskell comes across fibs
as the first argument of zipWith
, it just evaluates it. It's the same thing with tail fibs
. tail
in Haskell just returns a list containing all but the first element of the list:
> ls = [1, 2, 3, 4]
> tail ls
[2, 3, 4]
Let's trace what Haskell tries to do when you want to evaluate fibs
, element by element
Element 0: 1
Element 1: 1
These two were defined at the start with `1 : 1 : ...`
Element 2: 2
zipWith (+) fibs (tail fibs) =
fibs: [1, 1, ..]
+ +
(tail fibs): [1, ..]
= [2, ..]
Element 3: 3
zipWith (+) fibs (tail fibs) =
fibs: [1, 1, 2, ..]
+ + +
(tail fibs): [1, 2, ..]
= [2, 3, ..]
The important bit here is that we get to use the element that was calculated in the previous step
Element 4: 5
zipWith (+) fibs (tail fibs) =
fibs: [1, 1, 2, 3, ..]
+ + + +
(tail fibs): [1, 2, 3, ..]
= [2, 3, 5, ..]
And so on