Fibonacci Function Gallery - Part 2 - One in a series

Fibonacci Func*on Gallery
@philip_schwarz
slides by https://fpilluminated.org/
Scheme
Part 2
• Infinite Stream with Explicit Genera4on
• Infinite Stream with Implicit Defini4on
• Infinite Stream with Unfolding
• Infinite Stream with Itera4on
• Infinite Stream with Scanning

In part one of this series we looked at six
implementa3ons of the Fibonacci func3on. If you are
interested in a quick recap of those func3ons, you can
ﬁnd it on the next slide, otherwise feel free to skip it.

version #1 (naïve)
• not tail-recursive (not stack-safe)
• exponen4al .me complexity
• linear stack frame depth
version #2 (tupling-based)
• not tail-recursive (not stack-safe)
• linear .me complexity
• linear stack frame depth
Implementa3ons explored so far
version #3 (accumulator-based)
• tail-recursive (stack-safe)
def fib(i: Int): Eval[BigInt] = i match
case 0 => Eval.now(0)
case 1 => Eval.now(1)
case _ =>
for
a <- Eval.defer(fib(i - 1))
b <- fib(i - 2)
yield a + b
def fib(i: Int): IO[BigInt] = i match
case 0 => IO.pure(0)
case 1 => IO.pure(1)
case _ =>
for
a <- IO.defer(fib(i - 1))
b <- fib(i - 2)
yield a + b
def fib(i: Int): BigInt =
fibtwo(i).first
def fibtwo(i: Int): (BigInt, BigInt) =
(1 to i).foldLeft(BigInt(0), BigInt(1))
{ case ((a, b), _) => (b, a + b) }
def fib(i: Int): BigInt = i match
case 0 => 0
case 1 => 1
case _ => fib(i - 1) + fib(i - 2)
1
fibtwo(i).first
def fibtwo(i: Int): (BigInt, BigInt) = i match
case 0 => (0, 1)
case _ => fibtwo(i - 1) match
{ case (a, b) => (b, a + b) }
2
tailFib(0, 1, i)
def tailFib(a: BigInt, b: BigInt, i: Int): BigInt =
i match
case 0 => a
case _ => tailFib(b, a + b, i - 1)
3
4 5 6
1 2 3
version #5 (stack-safe naïve - Eval-based)
• not tail-recursive but stack-safe
5
version #6 (stack-safe naïve - IO-based)
• not tail-recursive but stack-safe
6
version #4 (le: fold-based)
• non-recursive (stack-safe)
4

For the next two implementa3ons of the Fibonacci func3on, we are going to turn to
Structure and Interpreta4on of Computer Programs (SICP).
The following 10 slides are a lightning-fast, minimal refresher on (or intro to) the
building blocks used in two implementa3ons of the Fibonacci sequence.
The two implementa3ons, wriDen in the Scheme dialect of Lisp, don’t use plain
sequences, implemented with lists. Instead, they use sequences implemented with
streams, i.e. lazy and possibly inﬁnite sequences.
While a full introduc3on to lists and streams is outside the scope of this deck, let’s
learn (or review) just enough about them to be able to understand the two Fibonacci
sequence implementa3ons that we are interested in.
SICP

3.5 Streams
...
From an abstract point of view, a stream is simply a sequence.
However, we will find that the straighJorward implementa4on of streams as lists (as in sec4on 2.2.1) doesn’t fully reveal the power
of stream processing.
As an alterna4ve, we introduce the technique of delayed evalua(on, which enables us to represent very large (even infinite)
sequences as streams. Stream processing lets us model systems that have state without ever using assignment or mutable data.
Structure and
Interpretation
of Computer Programs
2.2.1 Represen4ng Sequences
Figure 2.4: The sequence 1,2,3,4 represented as a chain of pairs.
One of the useful structures we can build with pairs is a sequence -- an ordered collec<on of data objects. There are, of course, many ways to
represent sequences in terms of pairs. One parDcularly straighEorward representaDon is illustrated in figure 2.4, where the sequence 1, 2, 3, 4 is
represented as a chain of pairs. The car of each pair is the corresponding item in the chain, and the cdr of the pair is the next pair in the chain.
The cdr of the final pair signals the end of the sequence by poinDng to a dis<nguished value that is not a pair, represented in box-and-pointer
diagrams as a diagonal line and in programs as the value of the variable nil. The en<re sequence is constructed by nested cons opera<ons:
(cons 1
(cons 2
(cons 3
(cons 4 nil))))

Construc)ng a plain sequence (list)
> (cons 1
(cons 2
(cons 3
(cons 4 nil))))
(1 2 3 4)
> `(1 2 3 4)
(1 2 3 4)
> 1 :: (2 :: (3 :: (4 :: Nil)))
List(1, 2, 3, 4)
> List(1, 2, 3, 4)
List(1, 2, 3, 4)
> 1 : (2 : (3 : (4 : [])))
[1, 2, 3, 4]
> [1, 2, 3, 4]
[1, 2, 3, 4]
> (cons 1
(cons 2
(cons 3
(cons 4 nil))))
(1 2 3 4)
> (list 1 2 3 4)
(1 2 3 4)

> (def one-through-four `(1 2 3 4))
> (first one-through-four)
1
> (rest one-through-four)
(2 3 4)
> (first (rest one-through-four))
2
> val one_through_four = List(1, 2, 3, 4)
> one_through_four.head
1
> one_through_four.tail
List(2, 3, 4)
> one_through_four.tail.head
2
> one_through_four = [1, 2, 3, 4]
> head one_through_four
1
> tail one_through_four
[2, 3, 4]
> head (tail one_through_four)
2
> (define one-through-four (list 1 2 3 4))
> (car one-through-four)
1
> (cdr one-through-four)
(2 3 4)
> (car (cdr one-through-four))
2
Selec)ng the head and tail of a plain sequence (list)

3.5.1 Streams Are Delayed Lists
As we saw in sec4on 2.2.3, sequences can serve as standard interfaces for combining program modules. We formulated powerful
abstrac4ons for manipula4ng sequences, such as map, ﬁlter, and accumulate, that capture a wide variety of opera4ons in a manner
that is both succinct and elegant.
Structure and
Interpretation
(define (map proc items)
(if (null? items)
nil
(cons (proc (car items))
(map proc (cdr items)))))
(define (filter predicate sequence)
(cond ((null? sequence) nil)
((predicate (car sequence))
(cons (car sequence)
(filter predicate (cdr sequence))))
(else (filter predicate (cdr sequence)))))
(define (accumulate op initial sequence)
(if (null? sequence)
initial
(op (car sequence)
(accumulate op initial (cdr sequence)))))
𝒇𝒐𝒍𝒅𝒓 ∷ 𝛼 → 𝛽 → 𝛽 → 𝛽 → 𝛼 → 𝛽
𝒇𝒐𝒍𝒅𝒓 𝑓 𝑒 = 𝑒
𝒇𝒐𝒍𝒅𝒓 𝑓 𝑒 𝑥: 𝑥𝑠 = 𝑓 𝑥 𝒇𝒐𝒍𝒅𝒓 𝑓 𝑒 𝑥𝑠
map ∷ (α → 𝛽) → [α] → [𝛽]
map f =
map f 𝑥 ∶ 𝑥𝑠 = 𝑓 𝑥 ∶ map 𝑓 𝑥𝑠
:ilter ∷ (α → 𝐵𝑜𝑜𝑙) → [α] → [α]
:ilter p =
:ilter p 𝑥 ∶ 𝑥𝑠 = 𝐢𝐟 𝑝 𝑥
𝐭𝐡𝐞𝐧 𝑥 ∶ :ilter p 𝑥𝑠
𝐞𝐥𝐬𝐞 :ilter p 𝑥𝑠
𝑓𝑜𝑙𝑑𝑟 ∷ 𝛼 → 𝛽 → 𝛽 → 𝛽 → 𝛼 → 𝛽
𝑓𝑜𝑙𝑑𝑟 𝑓 𝑒 = 𝑒
𝑓𝑜𝑙𝑑𝑟 𝑓 𝑒 𝑥: 𝑥𝑠 = 𝑓 𝑥 𝑓𝑜𝑙𝑑𝑟 𝑓 𝑒 𝑥𝑠
map ∷ (α → 𝛽) → [α] → 𝛽
map f =
map f 𝑥 ∶ 𝑥𝑠 = 𝑓 𝑥 ∶ map 𝑓 𝑥𝑠
:ilter ∷ (α → 𝐵𝑜𝑜𝑙) → [α] → [α]
:ilter p =
:ilter p 𝑥 ∶ 𝑥𝑠 = 𝐢𝐟 𝑝 𝑥
𝐭𝐡𝐞𝐧 𝑥 ∶ :ilter p 𝑥𝑠
𝐞𝐥𝐬𝐞 :ilter p 𝑥𝑠

(define (sum-even-fibs n)
(fold-left +
0
(filter even?
(map fib
(iota (+ n 1) 0)))))
(define (fib n)
(cond ((= n 0) 0)
((= n 1) 1)
(else (+ (fib (- n 1))
(fib (- n 2))))))
(defn sum-even-fibs [n]
(reduce +
0
(filter even?
(map fib
(range 0 (inc n))))))
(defn fib [n]
(cond (= n 0) 0
(= n 1) 1
:else (+ (fib (- n 1))
(fib (- n 2)))))
def sum_even_fibs(n: Int): Int =
List.range(0, n+1)
.map(fib)
.filter(isEven)
.fold(0)(_+_)
def fib(n: Int): Int = n match def isEven(n: Int): Boolean =
case 0 => 0 n % 2 == 0
case 1 => 1
case n => fib(n - 1) + fib(n - 2)
sum_even_fibs :: Int -> Int
sum_even_fibs n =
foldl (+)
0
(filter is_even
(map fib
[0..n]))
fib :: Int -> Int is_even :: Int -> Bool
fib 0 = 0 is_even n = (mod n 2) == 0
fib 1 = 1
fib n = fib (n - 1) + fib (n - 2)
mapping, filtering, and folding a plain sequence (list)
☨ FWIW, instead of using the hand-rolled map, ﬁlter and accumulate func3ons seen on the previous slide, we are using built-in func3ons map, ﬁlter and fold-leU.
☨

Unfortunately, if we represent sequences as lists, this elegance is bought at the price of severe inefficiency with respect to both the
4me and space required by our computa4ons. When we represent manipula4ons on sequences as transforma4ons of lists, our
programs must construct and copy data structures (which may be huge) at every step of a process.
To see why this is true, let us compare two programs for compu4ng the sum of all the prime numbers in an interval. The first
program is wriXen in standard itera4ve style:53
(define (sum-primes a b)
(define (iter count accum)
(cond ((> count b) accum)
((prime? count) (iter (+ count 1) (+ count accum)))
(else (iter (+ count 1) accum))))
(iter a 0))
The second program performs the same computation using the sequence operations of section 2.2.3:
(define (sum-primes a b)
(accumulate +
0
(filter prime? (enumerate-interval a b))))
In carrying out the computa4on, the first program needs to store only the sum being accumulated. In contrast, the filter in the
second program cannot do any tes4ng un4l enumerate-interval has constructed a complete list of the numbers in the interval.
The filter generates another list, which in turn is passed to accumulate before being collapsed to form a sum.
Such large intermediate storage is not needed by the first program, which we can think of as enumera4ng the interval
incrementally, adding each prime to the sum as it is generated.
53 Assume that we have a predicate prime? (e.g., as in sec3on 1.2.6) that tests for primality.
Structure and
Interpretation

The inefficiency in using lists becomes painfully apparent if we use the sequence paradigm to compute the second prime in the
interval from 10,000 to 1,000,000 by evalua4ng the expression
(car (cdr (filter prime?
(enumerate-interval 10000 1000000))))
This expression does find the second prime, but the computa4onal overhead is outrageous. We construct a list of almost a million
integers, filter this list by tes4ng each element for primality, and then ignore almost all of the result.
In a more tradi4onal programming style, we would interleave the enumera4on and the filtering, and stop when we reached the
second prime.
Streams are a clever idea that allows one to use sequence manipula4ons without incurring the costs of manipula4ng sequences as
lists.
With streams we can achieve the best of both worlds: We can formulate programs elegantly as sequence manipula4ons, while
aXaining the efficiency of incremental computa4on.
The basic idea is to arrange to construct a stream only par4ally, and to pass the par4al construc4on to the program that consumes
the stream.
If the consumer aXempts to access a part of the stream that has not yet been constructed, the stream will automa4cally construct
just enough more of itself to produce the required part, thus preserving the illusion that the en4re stream exists.
In other words, although we will write programs as if we were processing complete sequences, we design our stream
implementa4on to automa4cally and transparently interleave the construc4on of the stream with its use.
Structure and
Interpretation

On the surface, streams are just lists with diﬀerent names for the procedures that manipulate them.
There is a constructor, cons-stream, and two selectors, stream-car and stream-cdr, which sa4sfy the constraints
(stream-car (cons-stream x y)) = x
(stream-cdr (cons-stream x y)) = y
There is a dis4nguishable object, the-empty-stream, which cannot be the result of any cons-stream opera4on, and which can be
iden4ﬁed with the predicate stream-null?.54
Thus we can make and use streams, in just the same way as we can make and use lists, to represent aggregate data arranged in a
sequence.
In par4cular, we can build stream analogs of the list opera4ons from chapter 2, such as list-ref, map, and for-each:
(define (stream-ref s n)
(if (= n 0)
(stream-car s)
(stream-ref (stream-cdr s) (- n 1))))
(define (stream-map proc s)
(if (stream-null? s)
the-empty-stream
(cons-stream (proc (stream-car s))
(stream-map proc (stream-cdr s)))))
…
54 In the MIT implementa3on, the-empty-stream is the same as the empty list '(), and stream-null? is the same as null?.
Structure and
Interpretation
(define (list-ref items n)
(if (= n 0)
(car items)
(list-ref (cdr items) (- n 1))))
(define (map proc items)
(if (null? items)
nil
(cons (proc (car items))
(map proc (cdr items)))))

…
To make the stream implementa4on automa4cally and transparently interleave the construc4on of a stream with its use, we will
arrange for the cdr of a stream to be evaluated when it is accessed by the stream-cdr procedure rather than when the stream is
constructed by cons-stream.
…
As a data abstrac4on, streams are the same as lists. The diﬀerence is the 4me at which the elements are evaluated.
With ordinary lists, both the car and the cdr are evaluated at construc4on 4me. With streams, the cdr is evaluated at selec4on
4me.
Structure and
Interpretation
Next, we turn to inﬁnite streams.

Structure and
Interpretation
3.5.2 Infinite Streams
We have seen how to support the illusion of manipula4ng streams as complete en44es even though, in actuality, we compute
only as much of the stream as we need to access. We can exploit this technique to represent sequences efficiently as streams,
even if the sequences are very long. What is more striking, we can use streams to represent sequences that are infinitely long.
For instance, consider the following defini4on of the stream of posi4ve integers:
(define (integers-starting-from n)
(cons-stream n (integers-starting-from (+ n 1))))
(define integers (integers-starting-from 1))
This makes sense because integers will be a pair whose car is 1 and whose cdr is a promise to produce the integers beginning
with 2. This is an infinitely long stream, but in any given 4me we can examine only a finite por4on of it. Thus, our programs will
never know that the en4re infinite stream is not there.
Using integers we can define other infinite streams, such as the stream of integers that are not divisible by 7:
(define (divisible? x y) (= (remainder x y) 0))
(define no-sevens
(stream-filter (lambda (x) (not (divisible? x 7)))
integers))
Then we can find integers not divisible by 7 simply by accessing elements of this stream:
(stream-ref no-sevens 100)
117

Structure and
Interpretation
In analogy with integers, we can define the infinite stream of Fibonacci numbers:
(define (fibgen a b)
(cons-stream a (fibgen b (+ a b))))
(define fibs (fibgen 0 1))
fibs is a pair whose car is 0 and whose cdr is a promise to evaluate (fibgen 1 1).
When we evaluate this delayed (fibgen 1 1), it will produce a pair whose car is 1 and whose cdr is a promise to
evaluate (fibgen 1 2), and so on.
Following that refresher on (or intro to) sequences
implemented as lists or streams, let’s turn to the use of
infinite streams to compute the Fibonacci sequence.
infinite stream
implementa)on
(explicit genera1on)
#7
> (stream-ref fibs 5)
5
12586269025
354224848179261915075
> (define (fib n)
(stream-ref fibs n))
> (fib 50)
12586269025
> (fib 100)
354224848179261915075
Let’s try fibs out
and then define fib.

def fibs: LazyList[BigInt] =
fibgen(0, 1)
def fibgen(a: BigInt, b: BigInt): LazyList[BigInt] =
a #:: fibgen(b, a + b)
(define fibs
(fibgen 0 1))
5
12586269025
354224848179261915075
> fibs(5)
val res0: BigInt = 5
> fibs(50)
> fibs(100)
val res2: BigInt = 354224848179261915075
A stream being a ‘delayed list’, the Scala equivalent is a lazy list.
Here is the Scala version of the Scheme infinite stream implementa4on.
(define (fib n)
(stream-ref fibs n))
Since calling fibs(n) is just as convenient as calling fib(n),
let’s not bother defining a Scala version of fib.
infinite stream
implementa)on
#7

fibgen(0, 1)
The fibgen helper func3on in the infinite stream implementa4on is
one that we also come across in Programming in Scala (see next slide).
infinite stream
implementa)on
#6
def fibFrom(a: Int, b: Int): LazyList[Int] =
a #:: fibFrom(b, a + b)
LazyList example in
Programming in Scala

LazyLists
A lazy list is a list whose elements are computed lazily. Only those elements requested will be computed. A lazy list can, therefore, be infinitely long. Otherwise,
lazy lists have the same performance characteris4cs as lists. Whereas lists are constructed with the :: operator, lazy lists are constructed with the similar-looking
#:: . Here is a simple example of a lazy list containing the integers 1, 2, and 3:
scala> val str = 1 #:: 2 #:: 3 #:: LazyList.empty
val str: scala.collection.immutable.LazyList[Int] = LazyList(<not computed>)
The head of this lazy list is 1, and the tail of it has 2 and 3. None of the elements are printed here, though,
because the list hasn’t been computed yet! Lazy lists are specified to compute lazily, and the toString
method of a lazy list is careful not to force any extra evalua4on.
Below is a more complex example. It computes a lazy list that contains a Fibonacci sequence star4ng with
the given two numbers. A Fibonacci sequence is one where each element is the sum of the previous two
elements in the series:
scala> def fibFrom(a: Int, b: Int): LazyList[Int] =
a #:: fibFrom(b, a + b)
def fibFrom: (a: Int, b: Int)LazyList[Int]
This func4on is decep4vely simple. The first element of the sequence is clearly a, and the rest of the sequence is the Fibonacci sequence star4ng with b followed
by a + b. The tricky part is compu4ng this sequence without causing an infinite recursion. If the func4on used :: instead of #::, then every call to the func4on
would result in another call, thus causing an infinite recursion. Since it uses #::, though, the right-hand side is not evaluated un4l it is requested.
Here are the first few elements of the Fibonacci sequence star4ng witht two ones:
scala> val fibs = fibFrom(1, 1).take(7)
val fibs: scala.collection.immutable.LazyList[Int] = LazyList(<not computed>)
scala> fibs.toList
val res23: List[Int] = List(1, 1, 2, 3, 5, 8, 13)

What do streams look like in Haskell?
They are just lists, because Haskell uses an evaluation strategy called lazy evaluation, in which expressions are only
evaluated as much as required by the context in which they are used.
In Haskell we can create an ordinary list that is potentially infinite: it is only evaluated as much as required by the context.

Here is the Haskell equivalent of the
Scala inﬁnite stream implementa4on.
fibs :: Num t => [t]
fibs = fibgen 0 1
fibgen :: Num t => t -> t -> [t]
fibgen a b = a : fibgen b (a + b)
fibgen(0, 1)
Othe next slide you can see a very
similar Clojure implementa4on.
inﬁnite stream
implementa)on
#7
> fibs(100)
val res0: BigInt = 354224848179261915075
> fibs.take(10).toList
val res1: List[BigInt] = List(0,1,1,2,3,5,8,13,21,34)
> fibs !! 100
354224848179261915075
> (take 10 fibs)
[0,1,1,2,3,5,8,13,21,34]

Lazy Sequences
Lazy sequences are constructed using the macro lazy-seq: (lazy-seq & body)
A lazy-seq invokes its body only when needed, that is, when seq is called directly or indirectly. lazy-seq then caches the
result for subsequent calls. You can use lazy-seq to define a lazy Fibonacci series as follows:
1: (defnlazy-seq-fibo
2: ([]
3: (concat [0 1] (lazy-seq-fibo 0N 1N)))
4: ([a b]
5: (let [n (+ a b)]
6: (lazy-seq
7: (cons n (lazy-seq-fibo b n))))))
On line 3, the zero-argument body returns the concatenation of the basis values [0 1] and then calls the two-argument
body to calculate the rest of the values. On line 5, the two-argument body calculates the next value n in the series, and on
line 7 it conses n onto the rest of the values.
The key is line 6, which makes its body lazy. Without this, the recursive call to lazy-seq-fibo on line 7 would happen
immediately, and lazy-seq-fibo would recurse until it blew the stack. This illustrates the general pattern: wrap the
recursive part of a function body with lazy-seq to replace recursion with laziness.
lazy-seq-fibo works for small values:
(take 10 (lazy-seq-fibo))
-> (0 1 1N 2N 3N 5N 8N 13N 21N 34N)
lazy-seq-fibo also works for large values. Use (rem ... 1000) to print only the last 3 digits of the one millionth Fibonacci number:
(rem (nth (lazy-seq-fibo) 1000000) 1000)
-> 875N
Stuart Halloway
stuarthalloway
infinite stream
implementa)on
#7

Compu3ng the millionth Fibonacci number using
the Scala version runs out of heap space.
scala> def fibgen(a: BigInt, b: BigInt): LazyList[BigInt] =
| a #:: fibgen(b, a + b)
|
def fibgen(a: BigInt, b: BigInt): LazyList[BigInt]
scala> def fibs: LazyList[BigInt] =
| fibgen(0, 1)
|
def fibs: LazyList[BigInt]
scala> fibs(1_000_000)
java.lang.OutOfMemoryError: Java heap space
at java.base/java.math.BigInteger.add(BigInteger.java:1475)
at scala.math.BigInt.$plus(BigInt.scala:311)
at rs$line$16$.fibgen$$anonfun$1(rs$line$16:2)
at rs$line$16$$$Lambda/0x0000000131684800.apply(Unknown Source)
at scala.collection.immutable.LazyList$Deferrer$.$anonfun$$hash$colon$colon$extension$2(LazyList.scala:1143)
at scala.collection.immutable.LazyList$Deferrer$$$Lambda/0x0000000131659cd8.apply(Unknown Source)
at scala.collection.immutable.LazyList.scala$collection$immutable$LazyList$$state$lzycompute(LazyList.scala:259)
at scala.collection.immutable.LazyList.scala$collection$immutable$LazyList$$state(LazyList.scala:252)
at scala.collection.immutable.LazyList.isEmpty(LazyList.scala:269)
at scala.collection.immutable.LazyList$.$anonfun$dropImpl$1(LazyList.scala:1073)
at scala.collection.immutable.LazyList$$$Lambda/0x0000000131659a20.apply(Unknown Source)
at scala.collection.LinearSeqOps.apply(LinearSeq.scala:131)
at scala.collection.LinearSeqOps.apply$(LinearSeq.scala:128)
at scala.collection.immutable.LazyList.apply(LazyList.scala:240)
... 14 elided
scala>
infinite stream
implementation
(explicit generation)
#7

the Haskell version does not exhaust heap space.
ghci> fibgen a b = a : fibgen b (a + b)
ghci> fibs = fibgen 0 1
ghci> (fibs !! 1000000) > 1
True
ghci>
inﬁnite stream
implementa)on
#7

As a recap, here are the Scheme, Clojure,
Scala, and Haskell versions compared.
inﬁnite stream
implementa)on
#7
(defn lazy-seq-fibo
([]
(concat [0 1] (lazy-seq-fibo 0N 1N)))
([a b]
(let [n (+ a b)]
(lazy-seq
(cons n (lazy-seq-fibo b n))))))
fibgen(0, 1)
(define fibs
(fibgen 0 1))
fibs :: Num t => [t]
fibs = fibgen 0 1
fibgen :: Num t => t -> t -> [t]
fibgen a b = a : fibgen b (a + b)

In the next slide we are going to see:
1) Why I added ‘explicit genera4on’ to the name of the implementa3on we have just seen
2) An even simpler implementa3on that defines an infinite stream implicitly
infinite stream
implementa)on
#7
just seen
coming up next
infinite stream
implementa)on
(implicit defini1on)
#8

Deﬁning streams implicitly
The integers and fibs streams above were defined by specifying ''generating'' procedures that explicitly compute the stream
elements one by one. An alternative way to specify streams is to take advantage of delayed evaluation to define streams
implicitly.
For example, the following expression defines the stream ones to be an infinite stream of ones:
(define ones (cons-stream 1 ones))
This works much like the definition of a recursive procedure: ones is a pair whose car is 1 and whose cdr is a promise to
evaluate ones. Evaluating the cdr gives us again a 1 and a promise to evaluate ones, and so on.
We can do more interesting things by manipulating streams with operations such as add-streams, which produces the
elementwise sum of two given streams
(define (add-streams s1 s2)
(stream-map + s1 s2))
Now we can define the integers as follows:
(define integers (cons-stream 1 (add-streams ones integers)))
This defines integers to be a stream whose first element is 1 and the rest of which is the sum of ones and integers.
Thus, the second element of integers is 1 plus the first element of integers, or 2; the third element of integers is 1 plus the second
element of integers, or 3; and so on.
This definition works because, at any point, enough of the integers stream has been generated so that we can feed it back into
the definition to produce the next integer.
Structure and
Interpretation
The stream-map funcDon used here is a generalisaDon of the one seen in slide
12, in that it allows the mapping of procedures that take mulDple arguments.

We can define the Fibonacci numbers in the same style:
(define fibs
(cons-stream 0
(cons-stream 1
(add-streams (stream-cdr fibs)
fibs))))
This definition says that fibs is a stream beginning with 0 and 1, such that the rest of the stream can be generated by
adding fibs to itself shifted by one place:
1 1 2 3 5 8 13 21 … = (stream-cdr fibs)
0 1 1 2 3 5 8 13 … = fibs
0 1 1 2 3 5 8 13 21 34 … = fibs
SICP
inﬁnite stream
implementa)on
#8

val fibs: LazyList[BigInt] =
BigInt(0) #:: BigInt(1) #:: (fibs zip fibs.tail).map(_+_)
(define fibs
(cons-stream 0
(cons-stream 1
fibs))))
Here is the Scala version of the Scheme inﬁnite
stream implementa3on with implicit deﬁni4on.
1 1 2 3 5 8 13 21 … = (stream-cdr fibs)
0 1 1 2 3 5 8 13 … = fibs
0 1 1 2 3 5 8 13 21 34 … = fibs
scala> fibs(10)
scala> fibs(100)
val res1: BigInt = 354224848179261915075
scala> fibs(1000)
val res2: BigInt = 434665576869374564356885276750406258025646605173717804024817290895365554179490518904038798400792
55169295922593080322634775209689623239873322471161642996440906533187938298969649928516003704476137795166849228875
infinite stream
implementation
(implicit definition)
#8

scala> fibs(100_000)
val res0: BigInt =
25974069347221724166155034021275915414880485386517696584724770703952534543511273686265556772836716744754637587223074432111638399473875091030965697382188304493052287638531334
92135302679278956701051276578271635608073050532200243233114383986516137827238124777453778337299916214634050054669860390862750996639366409211890125271960172105060300350586894
02855810367511765825136837743868493641345733883436515877542537191241050033219599133006220436303521375652542182399869084855637408017925176162939175496345855861630076281991608
11098365263529954406942842065710460449038056471363460330005208522777075544467947237090309790190148604328468198579610159510018506082649192345873133991501339199323631023018641
72536477136266475080133982431231703431452964181790051187957316766834979901682011849907756686456845066287392485603914047605199550066288826345877189410680370091879365001733011
71002831047394745625609144493282137485557386408057981302826664027035429441210491999580313187680589918651342517595991152056315533770399694103551827527491995980225750790203779
81030899229849963044962558140455170002502997643221934621653662108418767454282982613982344783665815880408190033073829395000821320093747154851310272208173054322648669496309879
14714362925554252624043999615326979876807510646819068792118299167964409178271868561702918102212679267401362650499784968843680975254700131004574186406448299485872551744746695
65187912691699324456481767332225714931496776334584662383033382023970243685947828764187578857291071013370030009422933359729277919140921280490154597626279105705524815888405177
94181929052167695766087488155678601288183543542923073978101547857013284386127286201766539534449930019800629538936985500723286651317181135886613537472684585432548981137176605
19461693791688442534259478126310388952047956594380715301911253964847112638900713362856910155145342332944128435722099628674611942095166100230974070996553190050815866991144544
26478828726428450172533204864831945789203998489382363674561822037509734856684743388724904933703163382657176072977889179891366732519062324711803728017392157239082276922807729
24566627505383375006926077210593619421268920302567443565378008318306375933345023502569729065152853271943677560156660399164048825639676930792905029514886934137991251748566670
74717514938979038653338139534684837808612673755438382110844897653836848318258836339917310455850905663846202501463131183108742907729262215943020429159474030610183981685506695
02619737615085717611994758757221298720531206079186498036159609233959410411863516885488391191851790615115627529361584900087215019222651178531508925102752804515123860379218469
21215338292871369243215273327141574788295902601571954853164447945467502858402360002383447905203451080332820138038807089807348326201227952633606773669875783326254859449060219
17368867786241120562109836985019729017715780112040458649153935115783499546100636635745448508241888279067531359950519206222976015376529797308588164873117308237059828489404487
40393205359293597645416556079547247786202996923295613897198946794221872736051233655952113310877875822887959758032045960847902450638519417431261637751045992110248687949634170
68620929088930685252348056925998333775103901013166178123051145719327066291671254465121517468025481903583516889717075706778656188008220346836321018130262329960275994035799977
74046244952114531588370357904483293150007246173417355805567832153454341170020258560809166294198637401514569572272836921963229511187762530753402594781448204657460288485500062
80693481139827601685558407954216205754355729151064153759293902288435612079264370556006236798654438246437394697247194599655579550583803482559783968277608473153025178895171863
07227611036305093600742622617173630586132915440246954329046162586917746305785076749374879923291817501634840688134655343709975893536074051729094126976575932951568186247471276
36468836551757018353417274662607306510451195762866349922848678780591085118985653555434958761664016447588028633629704046289097067736256584300235314749461233912068632146637087
84469921042754156941091224656857120471724113337848981676409692498163342117685715031167104006817530319211541561195804257065869312727621371069747222602965552461105371555453249
97508432752001992143019105053629960070429632978051030666506387862681576587726837451289768507963663710593809112254288358391941211547737599813019216509521401333060709873137329
26518169226845063443954056729812031546392324981793780469103793422169495229100793029949237507299325063050942813902793084134473061411643355614764093104425918481363930542369378
97652052645634764831827263337151211203062923388928648794920973784786188486826080464731953920084039830800880386904955741975621929392211082576639768136104449002472094834032679
67688376213967440757138872928630798218493143438797780887379588968409461434159271317578365114578289355818599029235343888888465874521308381377794436361197628390368945957601203
16502279857901545344747352706972851454599861422902737291131463782045516225447535356773622793648545035710208644541208984235038908770223039849380214734809687433336225449150117
41175157070456105089527400020638049796796040261781866448124854726963082347337724554339051984130876978127656591676422902294818176307571025579336500815228638363449313808997178
50870708636322058690189383777660630060667577324272729292474212952650007066467227300099561241914091389846752249557907293984956087504566942177715511073466304566039441362358884
43676215273928597072287937355966723924613827468703217858459948257514745406436460997059316120596841560473234396652457231650317792833860590388360417691428732735703986803342604
67007171736357309112298130690328613712259793709660577517296452826375743407579228218074435290866960685402171859789116633386385858973620911424843217864503947919542420819162608
85710691104339948014730131008698488664307212167624731196181907378207665829682807960794822595490363282665780069948568253005364366748225346037051345036031521542969439918662368
57638062351209884448741138600171173647632126029961408561925599707566827866778732377419444462275399909291044697716476151118672327238679208133367306181944849396607123345271856
52025364362196419878275297881306008031314181706931446822118927578497828109436775154071010635055379800384221904550848223938699329692665922111274269813306230007346562849809363
66930494468016285537126334126203784919194986000972008367278766507868863069334189952257683143908324848863403189401941610369798438333466086767094316436535384309121578155435128
52077720858098902099586449602479491970687230765687109234380719509824814473157813780080639358418756655098501321882852840184981407690738507369535377711880388528935347600930338
59869160828933542114772293656190727626460372602723932099118782040706741227225812076672904007192423793033097213236418409395610299597129179982829000953914738243780277905111203
09545825328887211461701334403859396540478061993332245473178034073409025121302172795957538631581488103929524754109438805550983826276331276067181261710220113561818007754002275
16734144169216424973175621363128588281978005788832454534581522434937268133433997710512532081478345067139835038332901313945986481820272322043341930929011907832896569222878337
49735430156172282911562732946881485328192210075237362682764315268573549322302801810144964900901552924863833888566489300225097434360120081436515362536919944670971112695196672
57800618912154402224875646015546328120919458246535574320476442126507906552082083379760714651275083204871652715774723258872757611283575921325539344462894332581050286335836692
91828566894736223508250294964065798630809614341696830467595174355313224362664207197608459024263017473392225291248366316428006552870975051997504913009859468071013602336440164
40017918861085323076499171437205446782359721176046515320016308533631935158964589068172237281231032027189791795127279965605369403211124284659099455638021546131610626752163380

56643943188812681994940055370686976218552318589211009634410129335357339184596681975398342846968228894600763520316889220020219313183697575569620611157743058263055358620156378
91246031220672933992617378379625150999935403648731423208873977968908908369996292995391977217796533421249291978383751460062054967341662833487341011097770535898066498136011395
57158432830871394058253527405608101150390794168807919721293314830307263867863141103844312821599493682434299818871976863760449634259752425688618868897898088831586507626260485
64650043228968561492550639688114044004295038942458723822335431010786915173283336047792627277656860761777056168740502577437499837758301438561354272738385897741335269491654839
29721519554793578923866762502745370104660909382449626626935321303744538892479216161188889702077910448563199514826630802879549546453583866307344423753319712279158861707289652
09014984830543598320077132665340729066201677570640969018377120130682324533347796666052532549087360196148037824156607127165038358225728921570820936951099589013285949072430618
33257552012080900071750220229497428018234454137119162984499147222541965946822214682606449618392542496709031040075814888579716722463228870164384039084638567311643081695373267
90303114583680575021119639905615169154708510459700542098571797318015564741406172334145847111268547929892443001391468289103679179216978616582489007322033591376706527676521307
14398530276098847805621699465965546137917498565973922737941672649537780199209835542786617912312669937473077773056932443016683933301155451554265686493749212868704912175424596
78311329692484924667442619990339728256748734602011504422287804661243201830161082321839086547710423982285313165596856880052265714744288233175394565438819286244326625033453881
99590085105211383124491861802624432195540433985722841341254409411771722156867086291742124053110620522842986199273629406208834754853645128123279609097213953775360023076765694
20821994303464878334854449271353945022459133437466493770165560576338469706291872574542650587941463017663976045747431108155674709165270874812526715991379324052730461369396116
98925898083119063225107779285620719994594877006118010022961323045882945584409524966111583428049086438608807964405577636918577437540258968559272525145634043852178258905995539
54627451385454452916761042969267970893580056234501918571489030418495767400819359973218711957496357095967825171096264752068890806407651445893132870767454169607107931692704285
16809341331104635350624220981036321677191042078616218421376393819462569728678141363638962012397691046541895680619732314841422455007161721585132130203068417608721589270209887
91089380810459033972765473264169168454456276007595613671035845756490944306924525320850030910687831575615198475675691912847846546925586651115579134612724253360836351313421839
05177154511228464455136016013513228948543271504760839307556100908786096663870612278690274831819331606701484957163004705262228238406266818448788374548131994380387613830128859
88526420199228618820849958864088852135250145761539648264745102590253074317295689963649961570755185583716593536712544851508936290456773663003556245737477910098799249914696722
40414816012895309440154889426137831400878043114317418580718261851490511387448313584390672289494082582860216502889272283874264327861686903819605301558944594518087351972460082
21529343980828254126128257157209350985382800738560472910941184006084485235377833503306861977724501886364070344973366473100602018128792886991861824418453968994777259482169137
13364747045317297980924584436112961899759569624097184556402051143258959184472492094293030165148871307980210237906553652515478029805940752944051314580755153779486163587990115
81920198088796949671874482241568364635343261602426329347616344581638901638051238941845239734218414968892623984896486420934098166814947711551770095626690298501015135375998012
72501241971119871526593747484778935488777815192931171431167444773882941064615028751327709474504763922874890662989841540259350834035142035136168819248238998027706666916342133
42431205450735938861668769118818577611813577133248396520988208598239129860638682280475436240895652292141085985203733054462595326134023486468927506052689375514840329854208699
12210525970056285767077025676953009789700464089200098521069802954196998021380532957981594782899344432454915653278452238405512404452082264354206563133107029407223715527705042
63482073984454889589248861397657079145414427653584572951329719091947694411910966797474262675590953832039169673494261360032263077428684105040061351052194413778158095005714526
84600981035210924904002795805073643696102124113773971716486952549311480504012656835126882959841398322267637780450062650724173175739521979689075482519932925964980162706866565
80301788774056151671597319273204793762473755058550528396602945669925221736008740812120142090710419375985717214313380174251415824918247109050847159772494170493202541652393232
33258851588893337097136310892571531417761978326033750109026284066415801371359356529278088456305951770081443994114674291850360748852366654744869928083230516815711602911836374
14795849210086052898146954775081233889694315286102120273674704990393041703517134212692348670056662750622905863691188222890317051030540688209697087554532936943406398129769647
80318254516421783473477164710584232385945801830527562139101869976043058440686657123468696794560441557421000391797583489799358827518815246759308789281592434921975453876683056
84668420775409821781247053354523194797398953320175988640281058825557698004397120538312459428957377696001857497335249965013509368925958021863811725906506436882127156815751021
71290076599275037022828396396291597325117341858672102349731776596945428362551937155600914368032931196284254662840314244437064843239037490641081130079284895576724348120009030
98884572709077508736388732996425550504738125289759629348228789176199207251383093882882925104168376227582040819189336036538752841167857037209897188329869219278166296758445801
74911809119663048187434155067790863948831489241504300476704527971283482211522202837062857314244107823792513645086677566622804977211397140621664116324756784216612961477109018
82609467737768640617672148429389497667138012278894130902655351109611834701256519754080709538406091686393690667378662720942943426426040290215831734500372746258899262204987712
11784055633484924903260035085690993823927772974984135656148307882623633223683807098223460122742413790364734517359252157547571609342709351929017239549214264906911152715233381
09124042812102893738488167358953934508930697715522989199698903885883275409044300321986834003470271220020159699371690650330547577095398748580670024491045504890061727189168031
39452803616563394157133463722255047754746075605502410876438212168884891694037125890194849068537972224456200948381949153272450227621858916950740579498375982100660448199651936
01102615769471762025717020486849146168940684041408335875621183192108380056321445620189415059457800253187474719116048406779977654148306221790693308538751292989830095802775541
45435058768984944179136535891620098725222049055183554603706533183176716110738009786625247488691476077664470147193074476302411660335671765564874440577990531996271632972009109
44924921645603061882777294775076477744645258632891915910744425232008291820951802108370035388133098321589460868012795422475207192413464833496391509481309754143324420929993075
14810779190023461281223301617994299306188005334145506339321393396468616164169552202164479954172431711657444713641977332048993650747678441499295480730258564429423817876415064
92878361767978677158510784235702640213388018875601989234056868423215585628508645525258377010620532224244987990625263484010774322488172558602233302076399933854152015343847725
44291789513063705032044491779775237087195827797679968611362653229111862963116468515993466069346055754595606315583003369763400027668515129384363888609082837614115773200352756
51587459065670254394379311048385713132944906049265823631089495350900826731544972263966480886180415739778884728921746189741897217007700098624496537590127270152276345108749069
48012210684952063002519011655963580552429180205586904259685261047412834518466736938580027700252965356366721619883672428226933950325930390994583168665542234654857020875504617
52052185372156728267990341813552060299989536647010655790053212954133692447249221243632452304289518846177912233806967423398069488727058750338922839509513520912310925815900696

03951563677360671090505662996035718764232479207528361608055976977787564767672105212223271848214844466312614875842260926088757643317310232637688648225946912110323677375581
22133470556805958008310127481673962019583598023967414489867276845869819376783757167936723213081586191045995058970991064686919463448038574143829629547131372173669836184558
14450574867612432245151994336218291619146802609112179300186478805006135160314435007618921344160248809174105123229035717920549792797092450247994084269615881844261616378004
47594782122408732041244211691998055726491182436619218357147628914258057718717436880003241130087048193739622950171430900984769272374988759386399425305953316078916188108635
05982444578942799346514915952884869757488025823353571677864826828051140885429732788197765736966005727700162592404301688659946862983717270595809808730901820120931003430058
79655269478804980920548430546761103465474806729067439976361259243463771999584386281239198547020241488007688081884808789239159136946329311327684932977720164664172758725912
23547844808134333280500877588552646861195769621722393086937957571658218524162043419723839899327348034292623407223381551022091012629492497424232716988420232973032601617905
75673111235465890298298313115123607606773968998153812286999642014609852579793691246016346088762321286205634215901479188632194659637483482564291616278532948239313229440231
04327728876813955021334826638868745325928158785450389099156194963247885503509028939097371898800399902613201587267863787309567810962531100805448941885798356590206368069964
31650339120299443277267708693052407184165920700961392864019667257500870122181497331336958096003697517649513500402859262492033981110149532275336218445007443315624345324842
17986108346261345897591234839970751854223281677187215956827243245910829019886390369784542622566912542747056097567984857136623679023878478161201477982939080513150258174523
77352951016529693456278612224115078358775537334837276443983808200066721474003446632277691893696761287898348894209468810230842703645285450496675969731883604449670285319063
73969163579809288657199353977234954867871804164014152814894437850362910715178052858575839877111454742401564164771941163913549354667555935926088492005463846854030280809364
17250583653368093407225310820844723570226809826951426162451204040711501448747856199922814664565893938488028643822313849852328452360667045805113679663751039248163336173274
54727577563681097734453927582756059742516070546868965779453052160231593986578097480151541498709777807870535705800847237689242218975031275852714017311762127989874495840619
98439133656802977212087519349885044997139142851580323248230213406303125860726245416377652345055220510863182853596585207081733927095664450114040551065790550374177803933516
58360904543047721422281816832539613634982525215232257690920254216409657452618066051777901592902884240599998882753691957540116954696152270401280857579766154722192925655963
99182094889464265751228876633030213374636744921744935163710472573298083281272646818775935658421838359470279201366390768974173896225257578266399080979264701140758036785059
93818871845600946958332707751261812820153910417739509182441375619999378192403624695582359241714787027794484431087519018074141102903707060520851629757983617542510416422448
67577350756338018895379263183389855955956527857227926155524494739363665533904528656215464288343162282921123290451842212532888101415884061619939195042230059898349966569463
58018681671707481882321584864773438678091156466075517538555222442852404946803369229998930078390002069012151774069642857393019691050098827852305379763794025796895329511243
61667789105855572133817890899454539479159273749586002682378444868720372434888346168562900978505324970369333619424398028823643235538082080038757417109692897254998785662530
48867033095150518452126944989251596392079421452606508516052325614861938282489838000815085351564642761700832096483117944401971780149213345335903336672376719229722069970766
05548245224741692777463752213520171623172213763244569915402239549415822741893058991174693177377651873585003231801443288391637424379585469569122177409894861151556404660956
50945381155209218637115186845625432750478705300069984231401801694211091059254935961167194576309623288312712683285017603217716804002496576741869271132155732700499357099423
24416387089242427584407651215572676037924765341808984312676941110313165951429479377670698881249643421933287404390485538222160837088907598277390184204138197811025854537088
58670145062357851396010998747605253545010043935306207243970997644514679099338144899464460978095773195360493873495002686056455569322422969181563029392248760647087343116638
42054424896287602136502469918930401125131038350856219080602708666048735858490017042009239297891939381251167984217881152092591304355723216356608956035143838839390189531662
74355609970015699780289236362349895374653428746875
scala>

Earlier I said that in Haskell, streams are just ordinary lists, because we can create an ordinary
list that is poten4ally infinite: it is only evaluated as much as required by the context.
Remember the first Scheme example of an implicitly defined infinite stream?
(define ones (cons-stream 1 ones))
Here is how it looks in Haskell.
> ones = 1 : ones
> head ones
1
> tail (head ones)
1
> ones !! 100
1
> take 10 ones
[1,1,1,1,1,1,1,1,1,1]

To understand the cause of this inefficiency, let’s begin the calcula3on of, say, 𝑓𝑖𝑏 8 :
𝑓𝑖𝑏 8
⇒ 𝑓𝑖𝑏 7 + 𝑓𝑖𝑏 6
⇒ 𝑓𝑖𝑏 6 + 𝑓𝑖𝑏 5 + 𝑓𝑖𝑏 5 + 𝑓𝑖𝑏 4
⇒ 𝑓𝑖𝑏 5 + 𝑓𝑖𝑏 4 + 𝑓𝑖𝑏 4 + 𝑓𝑖𝑏 3 + 𝑓𝑖𝑏 4 + 𝑓𝑖𝑏 3 + 𝑓𝑖𝑏 3 + 𝑓𝑖𝑏 2
⇒
𝑓𝑖𝑏 4 + 𝑓𝑖𝑏 3 + 𝑓𝑖𝑏 3 + 𝑓𝑖𝑏 2
+
+
+
…
It is easy to see that this calcula4on is blowing up exponen4ally. That is, to compute the nth Fibonacci number will
require a number of steps propor4onal to 2n. Sadly, many of the computa4ons are being repeated, but in general we
cannot expect a Haskell implementa3on to realise this and take advantage of it. So what do we do?
Paul E. Hudak
Remember the passage (in slide 3 of part 1) in which Paul Hudak asked what should be done
to address the fact that the 4me complexity of the naïve implementa3on is exponen4al?
His answer, in the next four slides, is the Haskell version of the infinite stream
implementa3on with implicit defini4on.
naïve
implementa)on
#1
𝑓𝑖𝑏 ∷ 𝐼𝑛𝑡𝑒𝑔𝑒𝑟 → 𝐼𝑛𝑡𝑒𝑔𝑒𝑟
𝑓𝑖𝑏 0 = 1
𝑓𝑖𝑏 1 = 1
𝑓𝑖𝑏 𝑛 = 𝑓𝑖𝑏 𝑛 − 1 + 𝑓𝑖𝑏 𝑛 − 2

Paul E. Hudak
One solu4on is to construct the Fibonacci sequence directly as an infinite stream. The key to this construc4on is no4cing
that if we add pointwise the Fibonacci sequence to the tail of the Fibonacci sequence, we get the tail of the tail of the
Fibonacci sequence.
1 1 2 3 5 8 13 21 … = Fibonacci sequence
1 2 3 5 8 13 21 34 … = tail of Fibonacci sequence
2 3 5 8 13 21 34 55 … = tail of tail of Fibonacci sequence
This leads naturally to the following defini4on of the Fibonacci sequence:
𝑓𝑖𝑏𝑠 ∷ 𝐼𝑛𝑡𝑒𝑔𝑒𝑟
𝑓𝑖𝑏𝑠 = 1 ∶ 1 ∶ 𝑧𝑖𝑝𝑊𝑖𝑡ℎ + 𝑓𝑖𝑏𝑠 (𝑡𝑎𝑖𝑙 𝑓𝑖𝑏𝑠)
Note the concise and naturally recursive nature of this defini4on. Evalua4ng 𝑡𝑎𝑘𝑒 10 𝑓𝑖𝑏𝑠 yields:
[1,1,2,3,5,8,13,21,34,55]
as expected.
DETAILS
Try running take n fibs with successively larger values of n; you will find that it runs very fast, even though the Fibonacci
numbers start geng quite large. In fact, in Hugs the 3me is dominated by how long it takes to print the numbers; try
running fibs !! 1000 to see how quickly a single value can be computed and printed.
This program is very efficient. To see why, we can proceed by calcula4on.
infinite stream
implementa)on
#8

Paul E. Hudak
The first step is easy:
𝑓𝑖𝑏𝑠
⇒ 1 ∶ 1 ∶ 𝑎𝑑𝑑 𝑓𝑖𝑏𝑠 (𝑡𝑎𝑖𝑙 𝑓𝑖𝑏𝑠)
where, for succinctness, I have wriDen 𝒂𝒅𝒅 for 𝒛𝒊𝒑𝑾𝒊𝒕𝒉 + .
However, if we now simply subs3tute the defini3on of 𝑓𝑖𝑏𝑠 for both of its occurrences, we find ourselves heading toward the
same exponen4al blow-up that we saw earlier:
⇒ 1 ∶ 1 ∶ 𝑎𝑑𝑑 1 ∶ 1 ∶ 𝑎𝑑𝑑 𝑓𝑖𝑏𝑠 𝑡𝑎𝑖𝑙 𝑓𝑖𝑏𝑠
(𝑡𝑎𝑖𝑙 (1 ∶ 1 ∶ 𝑎𝑑𝑑 𝑓𝑖𝑏𝑠 (𝑡𝑎𝑖𝑙 𝑓𝑖𝑏𝑠)))
Fortunately, a Haskell implementa4on will be cleverer than this by sharing 𝑓𝑖𝑏𝑠 as well as its tail. Star4ng from the
beginning again, this sharing is no4ceable immediately aUer the first step:
𝑓𝑖𝑏𝑠
⇒ 1 ∶ 1 ∶ 𝑎𝑑𝑑 𝑓𝑖𝑏𝑠 (𝑡𝑎𝑖𝑙 𝑓𝑖𝑏𝑠)
At which point, we can express the sharing of the tail using a 𝒘𝒉𝒆𝒓𝒆 clause:
⇒ 1 ∶ 𝑡𝑓
𝒘𝒉𝒆𝒓𝒆 𝑡𝑓 = 1 ∶ 𝑎𝑑𝑑 𝑓𝑖𝑏𝑠 (𝑡𝑎𝑖𝑙 𝑓𝑖𝑏𝑠)
⇒ 1 ∶ 𝑡𝑓
𝒘𝒉𝒆𝒓𝒆 𝑡𝑓 = 1 ∶ 𝑎𝑑𝑑 𝑓𝑖𝑏𝑠 𝑡𝑓

Paul E. Hudak
We can also express the sharing of the tail of the tail in prepara4on for unfolding 𝒂𝒅𝒅 (I will use 𝒕𝒇𝟐, 𝒕𝒇𝟑, and so on, for the
names of the successive tails):
⇒ 1 ∶ 𝑡𝑓
𝒘𝒉𝒆𝒓𝒆 𝑡𝑓 = 1 ∶ 𝑡𝑓2
𝒘𝒉𝒆𝒓𝒆 𝑡𝑓2 = 𝑎𝑑𝑑 𝑓𝑖𝑏𝑠 𝑡𝑓
Finally, we can unfold 𝒂𝒅𝒅 to yield:
⇒ 1 ∶ 𝑡𝑓
𝒘𝒉𝒆𝒓𝒆 𝑡𝑓2 = 2 ∶ 𝑎𝑑𝑑 𝑡𝑓 𝑡𝑓2
Repea4ng this process, we introduce even more sharing, and unfold 𝒂𝒅𝒅 again:
⇒ 1 ∶ 𝑡𝑓
𝒘𝒉𝒆𝒓𝒆 𝑡𝑓2 = 2 ∶ 𝑡𝑓3
𝒘𝒉𝒆𝒓𝒆 𝑡𝑓3 = 𝑎𝑑𝑑 𝑡𝑓 𝑡𝑓2
⇒ 1 ∶ 𝑡𝑓
𝒘𝒉𝒆𝒓𝒆 𝑡𝑓3 = 3 ∶ 𝑎𝑑𝑑 𝑡𝑓2 𝑡𝑓3
But now note that 𝒕𝒇 is only used in one place, and thus might as well be eliminated, yielding:
⇒ 1 ∶ 1 ∶ 𝑡𝑓2

Paul E. Hudak
At this point, we can begin to repeat the sequence of introducing a new 𝒘𝒉𝒆𝒓𝒆 clause to capture sharing, unfolding 𝒂𝒅𝒅,
and then elimina4ng the outermost 𝒘𝒉𝒆𝒓𝒆 binding. This will yield successively longer versions of the result. Here is one
more applica4on of that sequence:
⇒ 1 ∶ 1 ∶ 𝑡𝑓2
𝒘𝒉𝒆𝒓𝒆 𝑡𝑓4 = 𝑎𝑑𝑑 𝑡𝑓2 𝑡𝑓3
⇒ 1 ∶ 1 ∶ 𝑡𝑓2
⇒ 1 ∶ 1 ∶ 2 ∶ 𝑡𝑓3
The reason why there are always at least two 𝒘𝒉𝒆𝒓𝒆 clauses is that Ribs recurses on itself as well as its tail. The elimina4on
of the 𝒘𝒉𝒆𝒓𝒆 clause corresponds to the garbage collec4on of unused memory by an implementa4on.
Although this process may seem a bit tedious, it is important only when wan4ng to reason about the eﬃciency (in 4me and
space) of the calcula4on. If you are just interested in the resul4ng values, you can, of course, use the exponen4ally
expanding calcula4on, with no fear that you might get a diﬀerent answer.

ghci> fibs = 0 : 1 : zipWith (+) fibs (tail fibs)
ghci> fibs !! 100000
2597406934722172416615503402127591541488048538651769658472477070395253454351127368626555677283671674475463758722307443211163839947387509103096569738218830449305228763853133
4921353026792789567010512765782716356080730505322002432331143839865161378272381247774537783372999162146340500546698603908627509966393664092118901252719601721050603003505868
9402855810367511765825136837743868493641345733883436515877542537191241050033219599133006220436303521375652542182399869084855637408017925176162939175496345855861630076281991
6081109836526352995440694284206571046044903805647136346033000520852277707554446794723709030979019014860432846819857961015951001850608264919234587313399150133919932363102301
8641725364771362664750801339824312317034314529641817900511879573167668349799016820118499077566864568450662873924856039140476051995500662888263458771894106803700918793650017
3301171002831047394745625609144493282137485557386408057981302826664027035429441210491999580313187680589918651342517595991152056315533770399694103551827527491995980225750790
2037798103089922984996304496255814045517000250299764322193462165366210841876745428298261398234478366581588040819003307382939500082132009374715485131027220817305432264866949
6309879147143629255542526240439996153269798768075106468190687921182991679644091782718685617029181022126792674013626504997849688436809752547001310045741864064482994858725517
4474669565187912691699324456481767332225714931496776334584662383033382023970243685947828764187578857291071013370030009422933359729277919140921280490154597626279105705524815
8884051779418192905216769576608748815567860128818354354292307397810154785701328438612728620176653953444993001980062953893698550072328665131718113588661353747268458543254898
1137176605194616937916884425342594781263103889520479565943807153019112539648471126389007133628569101551453423329441284357220996286746119420951661002309740709965531900508158
6699114454426478828726428450172533204864831945789203998489382363674561822037509734856684743388724904933703163382657176072977889179891366732519062324711803728017392157239082
2769228077292456662750538337500692607721059361942126892030256744356537800831830637593334502350256972906515285327194367756015666039916404882563967693079290502951488693413799
1251748566670747175149389790386533381395346848378086126737554383821108448976538368483182588363399173104558509056638462025014631311831087429077292622159430204291594740306101
8398168550669502619737615085717611994758757221298720531206079186498036159609233959410411863516885488391191851790615115627529361584900087215019222651178531508925102752804515
1238603792184692121533829287136924321527332714157478829590260157195485316444794546750285840236000238344790520345108033282013803880708980734832620122795263360677366987578332
6254859449060219173688677862411205621098369850197290177157801120404586491539351157834995461006366357454485082418882790675313599505192062229760153765297973085881648731173082
3705982848940448740393205359293597645416556079547247786202996923295613897198946794221872736051233655952113310877875822887959758032045960847902450638519417431261637751045992
1102486879496341706862092908893068525234805692599833377510390101316617812305114571932706629167125446512151746802548190358351688971707570677865618800822034683632101813026232
9960275994035799977740462449521145315883703579044832931500072461734173558055678321534543411700202585608091662941986374015145695722728369219632295111877625307534025947814482
0465746028848550006280693481139827601685558407954216205754355729151064153759293902288435612079264370556006236798654438246437394697247194599655579550583803482559783968277608
4731530251788951718630722761103630509360074262261717363058613291544024695432904616258691774630578507674937487992329181750163484068813465534370997589353607405172909412697657
5932951568186247471276364688365517570183534172746626073065104511957628663499228486787805910851189856535554349587616640164475880286336297040462890970677362565843002353147494
6123391206863214663708784469921042754156941091224656857120471724113337848981676409692498163342117685715031167104006817530319211541561195804257065869312727621371069747222602
9655524611053715554532499750843275200199214301910505362996007042963297805103066650638786268157658772683745128976850796366371059380911225428835839194121154773759981301921650
9521401333060709873137329265181692268450634439540567298120315463923249817937804691037934221694952291007930299492375072993250630509428139027930841344730614116433556147640931
0442591848136393054236937897652052645634764831827263337151211203062923388928648794920973784786188486826080464731953920084039830800880386904955741975621929392211082576639768
1361044490024720948340326796768837621396744075713887292863079821849314343879778088737958896840946143415927131757836511457828935581859902923534388888846587452130838137779443
6361197628390368945957601203165022798579015453447473527069728514545998614229027372911314637820455162254475353567736227936485450357102086445412089842350389087702230398493802
1473480968743333622544915011741175157070456105089527400020638049796796040261781866448124854726963082347337724554339051984130876978127656591676422902294818176307571025579336
5008152286383634493138089971785087070863632205869018938377766063006066757732427272929247421295265000706646722730009956124191409138984675224955790729398495608750456694217771
5511073466304566039441362358884436762152739285970722879373559667239246138274687032178584599482575147454064364609970593161205968415604732343966524572316503177928338605903883
6041769142873273570398680334260467007171736357309112298130690328613712259793709660577517296452826375743407579228218074435290866960685402171859789116633386385858973620911424
8432178645039479195424208191626088571069110433994801473013100869848866430721216762473119618190737820766582968280796079482259549036328266578006994856825300536436674822534603
7051345036031521542969439918662368576380623512098844487411386001711736476321260299614085619255997075668278667787323774194444622753999092910446977164761511186723272386792081
3336730618194484939660712334527185652025364362196419878275297881306008031314181706931446822118927578497828109436775154071010635055379800384221904550848223938699329692665922
1112742698133062300073465628498093636693049446801628553712633412620378491919498600097200836727876650786886306933418995225768314390832484886340318940194161036979843833346608
6767094316436535384309121578155435128520777208580989020995864496024794919706872307656871092343807195098248144731578137800806393584187566550985013218828528401849814076907385
0736953537771188038852893534760093033859869160828933542114772293656190727626460372602723932099118782040706741227225812076672904007192423793033097213236418409395610299597129
1799828290009539147382437802779051112030954582532888721146170133440385939654047806199333224547317803407340902512130217279595753863158148810392952475410943880555098382627633
1276067181261710220113561818007754002275167341441692164249731756213631285882819780057888324545345815224349372681334339977105125320814783450671398350383329013139459864818202
7232204334193092901190783289656922287833749735430156172282911562732946881485328192210075237362682764315268573549322302801810144964900901552924863833888566489300225097434360
1200814365153625369199446709711126951966725780061891215440222487564601554632812091945824653557432047644212650790655208208337976071465127508320487165271577472325887275761128
3575921325539344462894332581050286335836692918285668947362235082502949640657986308096143416968304675951743553132243626642071976084590242630174733922252912483663164280065528
7097505199750491300985946807101360233644016440017918861085323076499171437205446782359721176046515320016308533631935158964589068172237281231032027189791795127279965605369403

2111242846590994556380215461316106267521633805664394318881268199494005537068697621855231858921100963441012933535733918459668197539834284696822889460076352031688922002021931318
3697575569620611157743058263055358620156378912460312206729339926173783796251509999354036487314232088739779689089083699962929953919772177965334212492919783837514600620549673416
6283348734101109777053589806649813601139557158432830871394058253527405608101150390794168807919721293314830307263867863141103844312821599493682434299818871976863760449634259752
4256886188688978980888315865076262604856465004322896856149255063968811404400429503894245872382233543101078691517328333604779262727765686076177705616874050257743749983775830143
8561354272738385897741335269491654839297215195547935789238667625027453701046609093824496266269353213037445388924792161611888897020779104485631995148266308028795495464535838663
0734442375331971227915886170728965209014984830543598320077132665340729066201677570640969018377120130682324533347796666052532549087360196148037824156607127165038358225728921570
8209369510995890132859490724306183325755201208090007175022022949742801823445413711916298449914722254196594682221468260644961839254249670903104007581488857971672246322887016438
4039084638567311643081695373267903031145836805750211196399056151691547085104597005420985717973180155647414061723341458471112685479298924430013914682891036791792169786165824890
0732203359137670652767652130714398530276098847805621699465965546137917498565973922737941672649537780199209835542786617912312669937473077773056932443016683933301155451554265686
4937492128687049121754245967831132969248492466744261999033972825674873460201150442228780466124320183016108232183908654771042398228531316559685688005226571474428823317539456543
8819286244326625033453881995900851052113831244918618026244321955404339857228413412544094117717221568670862917421240531106205228429861992736294062088347548536451281232796090972
1395377536002307676569420821994303464878334854449271353945022459133437466493770165560576338469706291872574542650587941463017663976045747431108155674709165270874812526715991379
3240527304613693961169892589808311906322510777928562071999459487700611801002296132304588294558440952496611158342804908643860880796440557763691857743754025896855927252514563404
3852178258905995539546274513854544529167610429692679708935800562345019185714890304184957674008193599732187119574963570959678251710962647520688908064076514458931328707674541696
0710793169270428516809341331104635350624220981036321677191042078616218421376393819462569728678141363638962012397691046541895680619732314841422455007161721585132130203068417608
7215892702098879108938081045903397276547326416916845445627600759561367103584575649094430692452532085003091068783157561519847567569191284784654692558665111557913461272425336083
6351313421839051771545112284644551360160135132289485432715047608393075561009087860966638706122786902748318193316067014849571630047052622282384062668184487883745481319943803876
1383012885988526420199228618820849958864088852135250145761539648264745102590253074317295689963649961570755185583716593536712544851508936290456773663003556245737477910098799249
9146967224041481601289530944015488942613783140087804311431741858071826185149051138744831358439067228949408258286021650288927228387426432786168690381960530155894459451808735197
2460082215293439808282541261282571572093509853828007385604729109411840060844852353778335033068619777245018863640703449733664731006020181287928869918618244184539689947772594821
6913713364747045317297980924584436112961899759569624097184556402051143258959184472492094293030165148871307980210237906553652515478029805940752944051314580755153779486163587990
1158192019808879694967187448224156836463534326160242632934761634458163890163805123894184523973421841496889262398489648642093409816681494771155177009562669029850101513537599801
2725012419711198715265937474847789354887778151929311714311674447738829410646150287513277094745047639228748906629898415402593508340351420351361688192482389980277066669163421334
2431205450735938861668769118818577611813577133248396520988208598239129860638682280475436240895652292141085985203733054462595326134023486468927506052689375514840329854208699122
1052597005628576707702567695300978970046408920009852106980295419699802138053295798159478289934443245491565327845223840551240445208226435420656313310702940722371552770504263482
0739844548895892488613976570791454144276535845729513297190919476944119109667974742626755909538320391696734942613600322630774286841050400613510521944137781580950057145268460098
1035210924904002795805073643696102124113773971716486952549311480504012656835126882959841398322267637780450062650724173175739521979689075482519932925964980162706866565803017887
7405615167159731927320479376247375505855052839660294566992522173600874081212014209071041937598571721431338017425141582491824710905084715977249417049320254165239323233258851588
8933370971363108925715314177619783260337501090262840664158013713593565292780884563059517700814439941146742918503607488523666547448699280832305168157116029118363741479584921008
6052898146954775081233889694315286102120273674704990393041703517134212692348670056662750622905863691188222890317051030540688209697087554532936943406398129769647803182545164217
8347347716471058423238594580183052756213910186997604305844068665712346869679456044155742100039179758348979935882751881524675930878928159243492197545387668305684668420775409821
7812470533545231947973989533201759886402810588255576980043971205383124594289573776960018574973352499650135093689259580218638117259065064368821271568157510217129007659927503702
2828396396291597325117341858672102349731776596945428362551937155600914368032931196284254662840314244437064843239037490641081130079284895576724348120009030988845727090775087363
8873299642555050473812528975962934822878917619920725138309388288292510416837622758204081918933603653875284116785703720989718832986921927816629675844580174911809119663048187434
1550677908639488314892415043004767045279712834822115222028370628573142441078237925136450866775666228049772113971406216641163247567842166129614771090188260946773776864061767214
8429389497667138012278894130902655351109611834701256519754080709538406091686393690667378662720942943426426040290215831734500372746258899262204987712117840556334849249032600350
8569099382392777297498413565614830788262363322368380709822346012274241379036473451735925215754757160934270935192901723954921426490691115271523338109124042812102893738488167358
9539345089306977155229891996989038858832754090443003219868340034702712200201596993716906503305475770953987485806700244910455048900617271891680313945280361656339415713346372225
5047754746075605502410876438212168884891694037125890194849068537972224456200948381949153272450227621858916950740579498375982100660448199651936011026157694717620257170204868491
4616894068404140833587562118319210838005632144562018941505945780025318747471911604840677997765414830622179069330853875129298983009580277554145435058768984944179136535891620098
7252220490551835546037065331831767161107380097866252474886914760776644701471930744763024116603356717655648744405779905319962716329720091094492492164560306188277729477507647774
4645258632891915910744425232008291820951802108370035388133098321589460868012795422475207192413464833496391509481309754143324420929993075148107791900234612812233016179942993061
8800533414550633932139339646861616416955220216447995417243171165744471364197733204899365074767844149929548073025856442942381787641506492878361767978677158510784235702640213388
0188756019892340568684232155856285086455252583770106205322242449879906252634840107743224881725586022333020763999338541520153438477254429178951306370503204449177977523708719582
7797679968611362653229111862963116468515993466069346055754595606315583003369763400027668515129384363888609082837614115773200352756515874590656702543943793110483857131329449060
4926582363108949535090082673154497226396648088618041573977888472892174618974189721700770009862449653759012727015227634510874906948012210684952063002519011655963580552429180205
5869042596852610474128345184667369385800277002529653563667216198836724282269339503259303909945831686655422346548570208755046175205218537215672826799034181355206029998953664701
0655790053212954133692447249221243632452304289518846177912233806967423398069488727058750338922839509513520912310925815900696039515636773606710905056629960357187642324792075283
6160805597697778756476767210521222327184821484446631261487584226092608875764331731023263768864822594691211032367737558122133470556805958008310127481673962019583598023967414489

86727684586981937678375716793672321308158619104599505897099106468691946344803857414382962954713137217366983618455814450574867612432245151994336218291619146802609112179300186
47880500613516031443500761892134416024880917410512322903571792054979279709245024799408426961588184426161637800447594782122408732041244211691998055726491182436619218357147628
91425805771871743688000324113008704819373962295017143090098476927237498875938639942530595331607891618810863505982444578942799346514915952884869757488025823353571677864826828
05114088542973278819776573696600572770016259240430168865994686298371727059580980873090182012093100343005879655269478804980920548430546761103465474806729067439976361259243463
77199958438628123919854702024148800768808188480878923915913694632931132768493297772016466417275872591223547844808134333280500877588552646861195769621722393086937957571658218
52416204341972383989932734803429262340722338155102209101262949249742423271698842023297303260161790575673111235465890298298313115123607606773968998153812286999642014609852579
79369124601634608876232128620563421590147918863219465963748348256429161627853294823931322944023104327728876813955021334826638868745325928158785450389099156194963247885503509
02893909737189880039990261320158726786378730956781096253110080544894188579835659020636806996431650339120299443277267708693052407184165920700961392864019667257500870122181497
33133695809600369751764951350040285926249203398111014953227533621844500744331562434532484217986108346261345897591234839970751854223281677187215956827243245910829019886390369
78454262256691254274705609756798485713662367902387847816120147798293908051315025817452377352951016529693456278612224115078358775537334837276443983808200066721474003446632277
69189369676128789834889420946881023084270364528545049667596973188360444967028531906373969163579809288657199353977234954867871804164014152814894437850362910715178052858575839
87711145474240156416477194116391354935466755593592608849200546384685403028080936417250583653368093407225310820844723570226809826951426162451204040711501448747856199922814664
56589393848802864382231384985232845236066704580511367966375103924816333617327454727577563681097734453927582756059742516070546868965779453052160231593986578097480151541498709
77780787053570580084723768924221897503127585271401731176212798987449584061998439133656802977212087519349885044997139142851580323248230213406303125860726245416377652345055220
51086318285359658520708173392709566445011404055106579055037417780393351658360904543047721422281816832539613634982525215232257690920254216409657452618066051777901592902884240
59999888275369195754011695469615227040128085757976615472219292565596399182094889464265751228876633030213374636744921744935163710472573298083281272646818775935658421838359470
27920136639076897417389622525757826639908097926470114075803678505993818871845600946958332707751261812820153910417739509182441375619999378192403624695582359241714787027794484
43108751901807414110290370706052085162975798361754251041642244867577350756338018895379263183389855955956527857227926155524494739363665533904528656215464288343162282921123290
45184221253288810141588406161993919504223005989834996656946358018681671707481882321584864773438678091156466075517538555222442852404946803369229998930078390002069012151774069
64285739301969105009882785230537976379402579689532951124361667789105855572133817890899454539479159273749586002682378444868720372434888346168562900978505324970369333619424398
02882364323553808208003875741710969289725499878566253048867033095150518452126944989251596392079421452606508516052325614861938282489838000815085351564642761700832096483117944
40197178014921334533590333667237671922972206997076605548245224741692777463752213520171623172213763244569915402239549415822741893058991174693177377651873585003231801443288391
63742437958546956912217740989486115155640466095650945381155209218637115186845625432750478705300069984231401801694211091059254935961167194576309623288312712683285017603217716
80400249657674186927113215573270049935709942324416387089242427584407651215572676037924765341808984312676941110313165951429479377670698881249643421933287404390485538222160837
08890759827739018420413819781102585453708858670145062357851396010998747605253545010043935306207243970997644514679099338144899464460978095773195360493873495002686056455569322
42296918156302939224876064708734311663842054424896287602136502469918930401125131038350856219080602708666048735858490017042009239297891939381251167984217881152092591304355723
21635660895603514383883939018953166274355609970015699780289236362349895374653428746875
ghci>

In the next two slides, Stuart Halloway shows us a
Clojure version of the current inﬁnite stream
implementa3on, and in doing so, explains why we should
be careful not to hold on to the head of a lazy sequence.

Losing your head
There’s one last thing to consider when working with lazy sequences. Lazy sequences let you define a large
(possibly infinite) sequence and then work with a small part of that sequence in memory at a given moment. This
clever ploy will fail if you (or some API) unintentionally hold a reference to the part of the sequence you no longer
care about.
The most common way this can happen is if you accidentally hold the head (first item) of a sequence. In the
examples in previous sections, each variant of the Fibonacci numbers was defined as a function returning a
sequence, not the sequence itself.
You could define the sequence directly as a top-level var:
; holds the head (avoid!)
(defhead-fibo (lazy-cat [0N 1N] (map + head-fibo (rest head-fibo))))
This definition uses lazy-cat, which is like concat except that the arguments are evaluated only when needed. This
is a very pretty definition, in that it defines the recursion by mapping a sum over (each element of the Fibonaccis)
and (each element of the rest of the Fibonaccis).
Stuart Halloway
stuarthalloway
inﬁnite stream
implementa)on
#8

head-fibo works great for small Fibonacci numbers:
(take 10 head-fibo)
-> [0N 1N 1N 2N 3N 5N 8N 13N 21N 34N]
but not so well for huge ones:
(nth head-fibo 1000000)
-> java.lang.OutOfMemoryError : GC overhead limit exceeded
The problem is that the top-level var head-fibo holds the head of the collection. This prevents the garbage collector
from reclaiming elements of the sequence after you’ve moved past those elements. So, any part of the Fibonacci
sequence that you actually use gets cached for the life of the value referenced by head-fibo, which is likely to be the
life of the program.
Unless you want to cache a sequence as you traverse it, you must be careful not to keep a reference to the head of
the sequence. As the head-fibo example demonstrates, you should normally expose lazy sequences as a function
that returns the sequence, not as a var that contains the sequence. If a caller of your function wants an explicit
cache, the caller can always create its own var. With lazy sequences, losing your head is often a good idea.
Stuart Halloway
stuarthalloway
inﬁnite stream
implementa)on
#8

the Scala version also runs out of heap space.
This is true of all the Scala implementa3ons in this
deck, so I am going to stop repea3ng it.
scala> val fibs: LazyList[BigInt] =
| BigInt(0) #:: BigInt(1) #:: (fibs zip fibs.tail).map(_+_)
|
val fibs: LazyList[BigInt] = LazyList(<not computed>)
scala> fibs(1_000_000)
java.lang.OutOfMemoryError: Java heap space
at scala.math.BigInt.$plus(BigInt.scala:311)
at rs$line$1$.$init$$$anonfun$1$$anonfun$1$$anonfun$1(rs$line$1:1)
at rs$line$1$$$Lambda$1668/0x00000008015cc580.apply(Unknown Source)
at scala.collection.immutable.LazyList.$anonfun$mapImpl$1(LazyList.scala:517)
at scala.collection.immutable.LazyList$$Lambda$1671/0x00000008015cab18.apply(Unknown Source)
at scala.collection.immutable.LazyList$.$anonfun$dropImpl$1(LazyList.scala:1073)
at scala.collection.immutable.LazyList$$$Lambda$1663/0x000000080159f248.apply(Unknown Source)
at scala.collection.LinearSeqOps.apply(LinearSeq.scala:131)
at scala.collection.LinearSeqOps.apply$(LinearSeq.scala:128)
at scala.collection.immutable.LazyList.apply(LazyList.scala:240)
... 14 elided
scala>
inﬁnite stream
implementa)on
#8

I didn’t know that these days, compu3ng the
Fibonacci sequence is actually an example in the
Scala API documenta4on for LazyList (see next slide).

This class implements an immutable linked list. We call it "lazy" because it computes its elements only when they are needed.
Elements are memoized; that is, the value of each element is computed at most once.
Elements are computed in-order and are never skipped. In other words, accessing the tail causes the head to be computed first.
How lazy is a LazyList? When you have a value of type LazyList, you don't know yet whether the list is empty or not. If you learn that it is non-empty, then you also know that the head
has been computed. But the tail is itself a LazyList, whose empDness-or-not might remain undetermined.
A LazyList may be infinite. For example, LazyList.from(0) contains all of the natural numbers 0, 1, 2, and so on. For infinite sequences, some methods (such as count, sum, max or min)
will not terminate.
Here is an example:
import scala.math.BigInt
object Main extends App {
BigInt(0) #:: BigInt(1) #:: fibs.zip(fibs.tail).map { n => n._1 + n._2 }
fibs.take(5).foreach(println)
}
Note that the definiDon of fibs uses val not def. The memoization of the LazyList requires us to have somewhere to store the informaDon and a val allows us to do that.
Further remarks about the seman<cs of LazyList:
• Though the LazyList changes as it is accessed, this does not contradict its immutability. Once the values are memoized they do not change. Values that have yet to be memoized sDll
"exist", they simply haven't been computed yet.
• One must be cauDous of memoiza<on; it can eat up memory if you're not careful. That's because memoiza<on of the LazyList creates a structure much
like scala.collecDon.immutable.List. As long as something is holding on to the head, the head holds on to the tail, and so on recursively. If, on the other hand, there is nothing holding on to
the head (e.g. if we used def to define the LazyList) then once it is no longer being used directly, it disappears.

the Haskell version does not exhaust heap space.
ghci> fibs = 0 : 1 : zipWith (+) fibs (tail fibs)
ghci> (fibs !! (1000000)) > 1
True
ghci>
inﬁnite stream
implementa)on
#8

fibs = 0 : 1 : zipWith (+) fibs (tail fibs)
As a recap, here are the Scheme, Clojure,
Scala, and Haskell versions compared.
(define fibs
(cons-stream 0
(cons-stream 1
fibs))))
inﬁnite stream
implementa)on
#8
(def fibs (lazy-cat [0N 1N] (map + fibs (rest fibs))))

Next, consider the leU-fold based implementa3on from part 1. Note how range (1 to i)
is only used to control the number of steps in the folding process. It is only the length of
the range that maDers, not its values. e.g. the range may just as well be (-1 to -i).
fibtwo(i).first
(1 to i).foldLeft(BigInt(0), BigInt(1))
{ case ((a, b), _) => (b, a + b) }
One way to eliminate the need for the range is
to use the unfold function provided by LazyList.
fibtwo(i).first
LazyList.unfold((BigInt(0), BigInt(1)))
{ case (a, b) => Some((a, b), (b, a + b)) }(i)
inﬁnite stream
implementa)on
(unfolding)
#9

Next, we can simplify the unfolding implementa3on
by using the iterate func3on provided by LazyList.
fibtwo(i).first
fibtwo(i).first
LazyList.iterate((BigInt(0), BigInt(1)))
{ case (a, b) => (b, a + b) }(i)
inﬁnite stream
implementa)on
(itera1on)
#10

Remember the first implementa3on of the Fibonacci sequence
in this deck, which was based on an implicit defini4on?
infinite stream
implementa)on
#8
To conclude the deck, in the next four slides we look at another
implementa3on that is also based on an implicit defini4on.

infinite stream
implementa)on
(scanning)
#11
fibs :: Num a => [a]
fibs = 0 : scanl (+) 1 fibs
LeU scan func3on scanl is similar to leU fold func3on foldl,
but returns a list of successive reduced values from the le].
𝑠𝑐𝑎𝑛𝑙 ⊕ 𝑒 𝑥0, 𝑥1, 𝑥2
⬇
[𝑒, 𝑒 ⊕ 𝑥0, (𝑒 ⊕ 𝑥0) ⊕ 𝑥1, ((𝑒 ⊕ 𝑥0) ⊕ 𝑥1) ⊕ 𝑥2]
𝑓𝑜𝑙𝑑𝑙 ∷ 𝛽 → 𝛼 → 𝛽 → 𝛽 → 𝛼 → 𝛽
𝑓𝑜𝑙𝑑𝑙 𝑓 𝑒 = 𝑒
𝑓𝑜𝑙𝑑𝑙 𝑓 𝑒 𝑥: 𝑥𝑠 = 𝑓𝑜𝑙𝑑𝑙 𝑓 𝑓 𝑒 𝑥 𝑥𝑠
𝑠𝑐𝑎𝑛𝑙 ∷ 𝛽 → 𝛼 → 𝛽 → 𝛽 → 𝛼 → [𝛽]
𝑠𝑐𝑎𝑛𝑙 𝑓 𝑒 = [𝑒]
𝑠𝑐𝑎𝑛𝑙 𝑓 𝑒 𝑥: 𝑥𝑠 = 𝑒 ∶ 𝑠𝑐𝑎𝑛𝑙 𝑓 𝑓 𝑒 𝑥 𝑥𝑠
𝑓𝑜𝑙𝑑𝑙 ⊕ 𝑒 𝑥0, 𝑥1, 𝑥2
⬇
((𝑒 ⊕ 𝑥0) ⊕ 𝑥1) ⊕ 𝑥2
Here we define the Fibonacci sequence simply as the result of consing
0 (the first Fibonacci number) onto the result of doing a leU scan of
the sequence itself with addi3on and an ini3al accumulator of 1.
Here is a less efficient, but easier to understand defini3on of a leU scan. Given a func3on 𝑓, an ini3al accumulator 𝑒, and a
list of items 𝑥𝑠, scanl first uses the inits func3on to compute the ini4al segments of the given list, and then maps each
resul3ng segment to the result of folding the segment using the given func3on 𝑓 and the given ini3al accumulator 𝑒.
𝑠𝑐𝑎𝑛𝑙 ∷ 𝛽 → 𝛼 → 𝛽 → 𝛽 → 𝛼 → [𝛽]
𝑠𝑐𝑎𝑛𝑙 𝑓 𝑒 𝑥𝑠 = 𝑚𝑎𝑝 𝑓𝑜𝑙𝑑𝑙 𝑓 𝑒 𝑖𝑛𝑖𝑡𝑠 𝑥𝑠
𝑖𝑛𝑖𝑡𝑠 𝑥0, 𝑥1, 𝑥2 = [[ ], 𝑥0 , 𝑥0, 𝑥1 ,
𝑥0, 𝑥1, 𝑥2 ]
Here is an example of inits being used to
compute the ini4al segments of a small list.

To understand how ﬁbs works, on the next slide we go through the steps involved in the evalua3on of
scanl (+) 0 [1,2,3]
and on the subsequent slide we go through a similar exercise for the evalua3on of

numbers scanl (+) 0 … accumulator
[1,2,3] ? N/A
[1,2,3] 0 : ? 0
[1,2,3] 0 : 1 : ? 0 + 1 = 1
[1,2,3] 0 : 1 : 3 : ? 1 + 2 = 3
[1,2,3] 0 : 1 : 3 : 6 : [] 3 + 3 = 6
[0,1,3,6]

numbers scanl (+) 0 … accumulator
[1,2,3] ? N/A
[1,2,3] 0 : ? 0
[1,2,3] 0 : 1 : ? 0 + 1 = 1
[1,2,3] 0 : 1 : 3 : ? 1 + 2 = 3
[1,2,3] 0 : 1 : 3 : 6 : [] 3 + 3 = 6
[0,1,3,6]
fibs scanl (+) F1 … accumulator
F0 : … ? N/A
F0 : … F1 : ? F1
F0 : … F1 : F2 : ? F1 + F0 = F2
F0 : … F1 : F2 : F3 : ? F2 + F1 = F3
F0 : … F1 : F2 : F3 : F4 : ? F3 + F2 = F4
[F1,F2,F3,F4,…?…]
F0 = 0
F1 = 1
F2 = 1
F3 = 2
F4 = 3
…

BigInt(0) #:: fibs.scan(BigInt(1))(_+_)
inﬁnite stream
implementa)on
(scanning)
#11
fibs :: Num a => [a]
Here is the Scala version of the Haskell implementa3on.
Scala func3on scan just delegates to func3on scanLeU.

To conclude this deck, the next slide contains the Scala version
of the ﬁve implementa3ons that we have seen in the deck.

fibgen(0, 1)
infinite stream
implementation
#7
infinite stream
implementa)on
#8
infinite stream
implementa)on
(scanning)
#11
fibtwo(i).first
LazyList.iterate((BigInt(0), BigInt(1)))
{ case (a, b) => (b, a + b) }(i)
infinite stream
implementa)on
(itera1on)
#10
fibtwo(i).first
infinite stream
implementa)on
(unfolding)
#9

The next slide is the same as the previous one, except
that implementa3ons #9 and #10 have been simpliﬁed
so that they consist of a single ﬁbs func3on with the
same signature as the other implementa3ons.

fibgen(0, 1)
infinite stream
implementation
#7
infinite stream
implementa)on
#8
infinite stream
implementa)on
(scanning)
#11
LazyList.iterate((BigInt(0), BigInt(1))){
case (a, b) => (b, a + b)
}.map(_.first)
infinite stream
implementa)on
(itera1on)
#10
LazyList.unfold((BigInt(0), BigInt(1))){
case (a, b) => Some((a, b), (b, a + b))
}.map(_.first)
infinite stream
implementa)on
(unfolding)
#9

That’s all for part 2.
I hope you found it useful.

Fibonacci Function Gallery - Part 2 - One in a series

More Related Content

Similar to Fibonacci Function Gallery - Part 2 - One in a series (20)

More from Philip Schwarz (20)

Recently uploaded (20)

Fibonacci Function Gallery - Part 2 - One in a series