Folding Unfolded - Polyglot FP for Fun and Profit - Haskell and Scala

See how recursive functions and structural induction relate to recursive datatypes
Follow along as the fold abstraction is introduced and explained
Watch as folding is used to simplify the definition of recursive functions over recursive datatypes
Part 1 - through the work of
Folding Unfolded
Polyglot FP for Fun and Profit
Haskell and Scala
Graham Hutton
@haskellhutt
@philip_schwarzslides by https://www.slideshare.net/pjschwarz
Richard Bird
http://www.cs.ox.ac.uk/people/richard.bird/

Richard Bird
@philip_schwarz
This slide deck is almost entirely centered on material from Richard Bird’s fantastic book, Introduction to Functional
Programming using Haskell.
I hope he’ll forgive me for relying so heavily on his work, but I couldn’t resist using extensive excerpts from his compelling book
to introduce and explain the concept of folding.
http://www.cs.ox.ac.uk/people/richard.bird/
https://en.wikipedia.org/wiki/Richard_Bird_(computer_scientist)

3.1 Natural Numbers
The natural numbers are the numbers 0, 1, 2 and so on, used for counting. The type 𝑵𝒂𝒕 is introduced by the declaration
𝐝𝐚𝐭𝐚 𝑵𝒂𝒕 = 𝒁𝒆𝒓𝒐 | 𝑺𝒖𝒄𝒄 𝑵𝒂𝒕
𝑵𝒂𝒕 is our first example of a recursive datatype declaration. The definition says that Zero is a value of 𝑵𝒂𝒕, and that Succ 𝑛 is a
value of 𝑵𝒂𝒕 whenever 𝑛 is. In particular, the constructor 𝑺𝒖𝒄𝒄 (short for ‘successor’), has type 𝑵𝒂𝒕 → 𝑵𝒂𝒕. For example, each of
𝒁𝒆𝒓𝒐, 𝑺𝒖𝒄𝒄 𝒁𝒆𝒓𝒐, 𝑺𝒖𝒄𝒄 (𝑺𝒖𝒄𝒄 𝒁𝒆𝒓𝒐)
is an element of 𝑵𝒂𝒕. As an element of 𝑵𝒂𝒕 the number 7 would be represented by
𝑺𝒖𝒄𝒄 (𝑺𝒖𝒄𝒄 (𝑺𝒖𝒄𝒄 (𝑺𝒖𝒄𝒄 (𝑺𝒖𝒄𝒄 (𝑺𝒖𝒄𝒄 (𝑺𝒖𝒄𝒄 𝒁𝒆𝒓𝒐))))))
Every natural number is represented by a unique value of 𝑵𝒂𝒕. On the other hand, not every value of 𝑵𝒂𝒕 represents a well-
defined natural number. In fact 𝑵𝒂𝒕 also contains the values ⊥, 𝑺𝒖𝒄𝒄 ⊥, 𝑺𝒖𝒄𝒄 (𝑺𝒖𝒄𝒄 ⊥), and so on. These additional values will
be discussed later.
Let us see how to program the basic arithmetic and comparison operations on 𝑵𝒂𝒕. Addition can be defined by
+ ∷ 𝑵𝒂𝒕 → 𝑵𝒂𝒕 → 𝑵𝒂𝒕
𝑚 + 𝒁𝒆𝒓𝒐 = 𝑚
𝑚 + 𝑺𝒖𝒄𝒄 𝑛 = 𝑺𝒖𝒄𝒄 𝑚 + 𝑛
This is a recursive definition, defining + by pattern matching on the second argument. Since every element of 𝑵𝒂𝒕, apart for ⊥, is
either 𝒁𝒆𝒓𝒐 or of the form Succ 𝑛, where 𝑛 is an element of 𝑵𝒂𝒕, the two patterns in the equations for + are disjoint and cover all
numbers apart from ⊥.
… Richard Bird

Here is how 𝒁𝒆𝒓𝒐 + 𝑺𝒖𝒄𝒄 (𝑺𝒖𝒄𝒄 𝒁𝒆𝒓𝒐) would be evaluated:
𝒁𝒆𝒓𝒐 + 𝑺𝒖𝒄𝒄 (𝑺𝒖𝒄𝒄 𝒁𝒆𝒓𝒐)
= { second equation for +, i.e. 𝑚 + 𝑺𝒖𝒄𝒄 𝑛 = 𝑺𝒖𝒄𝒄 𝑚 + 𝑛 }
𝑺𝒖𝒄𝒄 𝒁𝒆𝒓𝒐 + 𝑺𝒖𝒄𝒄 𝒁𝒆𝒓𝒐
𝑺𝒖𝒄𝒄 𝑺𝒖𝒄𝒄 (𝒁𝒆𝒓𝒐 + 𝒁𝒆𝒓𝒐)
= { first equation for +, i.e. 𝑚 + 𝒁𝒆𝒓𝒐 = 𝑚 }
𝑺𝒖𝒄𝒄 (𝑺𝒖𝒄𝒄 𝒁𝒆𝒓𝒐)
…it is not a practical proposition to introduce natural numbers through the datatype 𝑵𝒂𝒕: arithmetic would be just too inefficient.
In particular, calculating 𝑚 + n would require (𝑛 + 1) evaluation steps. On the other hand, counting on your fingers is a good way
to understand addition.
Given +, we can define ×:
(×) ∷ 𝑵𝒂𝒕 → 𝑵𝒂𝒕 → 𝑵𝒂𝒕
𝑚 × 𝒁𝒆𝒓𝒐 = 𝒁𝒆𝒓𝒐
𝑚 × 𝑺𝒖𝒄𝒄 𝑛 = 𝑚 × 𝑛 + 𝑚
Given ×, we can define exponentiation (↑) by
(↑) ∷ 𝑵𝒂𝒕 → 𝑵𝒂𝒕 → 𝑵𝒂𝒕
𝑚 ↑ 𝒁𝒆𝒓𝒐 = 𝑺𝒖𝒄𝒄 𝒁𝒆𝒓𝒐
𝑚 ↑ 𝑺𝒖𝒄𝒄 𝑛 = 𝑚 ↑ 𝑛 × 𝑚
…
Richard Bird

On the next slide we show the definitions of +, ×,
and ↑ again, and have a go at implementing the
three operations in Scala, together with some tests.

val `(+)`: Nat => Nat => Nat =
m => {
case Zero => m
case Succ(n) => Succ(m + n)
}
implicit class NatOps(m: Nat){
def +(n: Nat) = `(+)`(m)(n)
def ×(n: Nat) = `(×)`(m)(n)
def ↑(n: Nat) = `(↑)`(m)(n)
}
sealed trait Nat
case class Succ(n: Nat) extends Nat
case object Zero extends Nat
val `(×)`: Nat => Nat => Nat =
m => {
case Zero => Zero
case Succ(n) => (m × n) + m
}
val `(↑)`: Nat => Nat => Nat =
m => {
case Zero => Succ(Zero)
case Succ(n) => (m ↑ n) × m
}
; assert(0 + 0 == 0) ; assert(Zero + Zero == Zero)
; assert(0 + 1 == 1) ; assert(Zero + Succ(Zero) == Succ(Zero))
; assert(1 + 0 == 1) ; assert(Succ(Zero) + Zero == Succ(Zero))
; assert(1 + 1 == 2) ; assert(Succ(Zero) + Succ(Zero) == Succ(Succ(Zero)))
; assert(2 + 3 == 5) ; assert(Succ(Succ(Zero)) + Succ(Succ(Succ(Zero))) == Succ(Succ(Succ(Succ(Succ(Zero))))))
; assert(0 * 0 == 0) ; assert((Zero × Zero) == Zero)
; assert(1 * 0 == 0) ; assert((Succ(Zero) × Zero) == Zero)
; assert(0 * 1 == 0) ; assert((Zero × Succ(Zero)) == Zero)
; assert(1 * 1 == 1) ; assert((Succ(Zero) × Succ(Zero)) == Succ(Zero))
; assert(1 * 2 == 2) ; assert((Succ(Zero) × Succ(Succ(Zero))) == Succ(Succ(Zero)))
; assert(2 * 3 == 6) ; assert((Succ(Succ(Zero)) × Succ(Succ(Succ(Zero)))) == Succ(Succ(Succ(Succ(Succ(Succ(Zero)))))))
; assert(Math.pow(1,0) == 1) ; assert( (Succ(Zero) ↑ Zero) == Succ(Zero) )
; assert(Math.pow(2,2) == 4) ; assert( (Succ(Succ(Zero)) ↑ Succ(Succ(Zero))) == Succ(Succ(Succ(Succ(Zero)))) )

The remaining arithmetic operation common to all numbers is subtraction (−). However, subtraction is a partial operation on
natural numbers. The definition is
− ∷ 𝑵𝒂𝒕 → 𝑵𝒂𝒕 → 𝑵𝒂𝒕
𝑚 − 𝒁𝒆𝒓𝒐 = 𝑚
𝑺𝒖𝒄𝒄 𝑚 − 𝑺𝒖𝒄𝒄 𝑛 = 𝑚 − 𝑛
This definition uses pattern matching on both arguments; taken together, the patterns are disjoint but not exhaustive. For
example,
𝑺𝒖𝒄𝒄 𝒁𝒆𝒓𝒐 − 𝑺𝒖𝒄𝒄 (𝑺𝒖𝒄𝒄 𝒁𝒆𝒓𝒐)
= { second equation for −, i.e. 𝑺𝒖𝒄𝒄 𝑚 − 𝑺𝒖𝒄𝒄 𝑛 = 𝑚 − 𝑛 }
𝒁𝒆𝒓𝒐 − 𝑺𝒖𝒄𝒄 𝒁𝒆𝒓𝒐
= { case exhaustion }
⊥
The hint ‘case exhaustion’ in the last step indicates that no equation for − has a pattern that matches (𝒁𝒆𝒓𝒐 − 𝑺𝒖𝒄𝒄 𝒁𝒆𝒓𝒐).
More generally, 𝑚 − 𝑛 = ⊥ if 𝑚 < 𝑛. The partial nature of subtraction on the natural numbers is the prime motivation for
introducing the integer numbers; over the integers, − is a total operation.
...Finally, here are two more examples of programming with 𝑵𝒂𝒕. The factorial and Fibonacci functions are defined by
𝑓𝑎𝑐𝑡 ∷ 𝑵𝒂𝒕 → 𝑵𝒂𝒕
𝑓𝑎𝑐𝑡 𝒁𝒆𝒓𝒐 = 𝑺𝒖𝒄𝒄 𝒁𝒆𝒓𝒐
𝑓𝑎𝑐𝑡 𝑺𝒖𝒄𝒄 𝑛 = 𝑺𝒖𝒄𝒄 𝑛 × 𝑓𝑎𝑐𝑡 𝑛
𝑓𝑖𝑏 ∷ 𝑵𝒂𝒕 → 𝑵𝒂𝒕
𝑓𝑖𝑏 𝒁𝒆𝒓𝒐 = 𝑺𝒖𝒄𝒄 𝒁𝒆𝒓𝒐
𝑓𝑖𝑏 𝑺𝒖𝒄𝒄 𝒁𝒆𝒓𝒐 = 𝑺𝒖𝒄𝒄 𝒁𝒆𝒓𝒐
𝑓𝑖𝑏 𝑺𝒖𝒄𝒄 𝑺𝒖𝒄𝒄 𝑛 = 𝑓𝑖𝑏 𝑺𝒖𝒄𝒄 𝑛 + 𝑓𝑖𝑏 𝑛 Richard Bird

See the next slide for a Scala
implementation of the − operation.

− ∷ 𝑵𝒂𝒕 → 𝑵𝒂𝒕 → 𝑵𝒂𝒕
val `(-)`: Nat => Nat => Nat =
m => n => (m,n) match {
case (_,Zero) => m
case (Succ(x),Succ(y)) => x - y
}
; assert(0 - 0 == 0) ; assert(Zero - Zero == Zero)
; assert(1 - 0 == 1) ; assert(Succ(Zero) - Zero == Succ(Zero))
; assert(5 - 3 == 2) ; assert(Succ(Succ(Succ(Succ(Succ(Zero))))) - Succ(Succ(Succ(Zero))) == Succ(Succ(Zero)))
; assert(3 - 5 == -2) ; assert(
Try {
Succ(Succ(Succ(Zero))) - Succ(Succ(Succ(Succ(Succ(Zero)))))
}.toString.startsWith(
"Failure(scala.MatchError: (Zero,Succ(Succ(Zero)))"
)
)
No equation for − has a pattern that matches (𝒁𝒆𝒓𝒐 − 𝑺𝒖𝒄𝒄 𝒁𝒆𝒓𝒐).
Similarly for (𝒁𝒆𝒓𝒐 − 𝑺𝒖𝒄𝒄 (𝑺𝒖𝒄𝒄 𝒁𝒆𝒓𝒐)), (𝒁𝒆𝒓𝒐 − 𝑺𝒖𝒄𝒄 (𝑺𝒖𝒄𝒄(𝑺𝒖𝒄𝒄 𝒁𝒆𝒓𝒐))), etc.
More generally, 𝑚 − 𝑛 = ⊥ if 𝑚 < 𝑛.
𝑚 − 𝑛 throws scala.MatchError if 𝑚 < 𝑛.

@philip_schwarz
On the next slide we show the definitions of 𝑓𝑎𝑐𝑡,
and 𝑓𝑖𝑏 again, and have a go at implementing the
two functions in Scala, together with some tests.

val fact: Nat => Nat = {
case Succ(n) => Succ(n) × fact(n)
}
𝑓𝑎𝑐𝑡 𝒁𝒆𝒓𝒐 = 𝑺𝒖𝒄𝒄 𝒁𝒆𝒓𝒐
𝑓𝑎𝑐𝑡 𝑺𝒖𝒄𝒄 𝑛 = 𝑺𝒖𝒄𝒄 𝑛 × 𝑓𝑎𝑐𝑡 𝑛
𝑓𝑖𝑏 𝒁𝒆𝒓𝒐 = 𝑺𝒖𝒄𝒄 𝒁𝒆𝒓𝒐
𝑓𝑖𝑏 𝑺𝒖𝒄𝒄 𝒁𝒆𝒓𝒐 = 𝑺𝒖𝒄𝒄 𝒁𝒆𝒓𝒐
𝑓𝑖𝑏 𝑺𝒖𝒄𝒄 𝑺𝒖𝒄𝒄 𝑛 = 𝑓𝑖𝑏 𝑺𝒖𝒄𝒄 𝑛 + 𝑓𝑖𝑏 𝑛
val fib: Nat => Nat = {
case Succ(Zero) => Succ(Zero)
case Succ(Succ(n)) => fib(Succ(n)) + fib(n)
}
def factorial(n: Int): Int =
if (n == 0) 1
else n * factorial(n-1)
; assert(factorial(0) == 1) ; assert(fact(Zero) == Succ(Zero))
; assert(factorial(1) == 1) ; assert(fact(Succ(Zero)) == Succ(Zero))
; assert(factorial(2) == 2) ; assert(fact(Succ(Succ(Zero))) == Succ(Succ(Zero)))
; assert(factorial(3) == 6) ; assert(fact(Succ(Succ(Succ(Zero)))) == Succ(Succ(Succ(Succ(Succ(Succ(Zero)))))))
def fibonacci(n: Int): Int =
if (n == 0 || n == 1) 1
else fibonacci(n-1) + fibonacci(n-2)
; assert(fibonacci(0) == 1) ; assert(fib(Zero) == Succ(Zero))
; assert(fibonacci(1) == 1) ; assert(fib(Succ(Zero)) == Succ(Zero))
; assert(fibonacci(2) == 2) ; assert(fib(Succ(Succ(Zero))) == Succ(Succ(Zero)))
; assert(fibonacci(3) == 3) ; assert(fib(Succ(Succ(Succ(Zero)))) == Succ(Succ(Succ(Zero))))
; assert(fibonacci(4) == 5) ; assert(fib(Succ(Succ(Succ(Succ(Zero))))) == Succ(Succ(Succ(Succ(Succ(Zero))))))
; assert(fibonacci(5) == 8) ; assert(fib(Succ(Succ(Succ(Succ(Succ(Zero)))))) == Succ(Succ(Succ(Succ(Succ(Succ(Succ(Succ(Zero)))))))))

3.1.1 Partial numbers
Let us now return to the point about there being extra values in 𝑵𝒂𝒕. The values
⊥, 𝑺𝒖𝒄𝒄 ⊥, 𝑺𝒖𝒄𝒄 (𝑺𝒖𝒄𝒄 ⊥), …
are all different and each is also a member of 𝑵𝒂𝒕. That they exist is a consequence of three facts:
i. ⊥ is an element of 𝑵𝒂𝒕 because every datatype declaration introduces at least one extra value, the undefined value of
the type.
ii. constructor functions of a datatype are assumed to be nonstrict
iii. 𝑺𝒖𝒄𝒄 𝑛 is an element of Nat, whenever 𝑛 is
To appreciate why these extra values are different from one another, suppose we define 𝑢𝑛𝑑𝑒𝑓𝑖𝑛𝑒𝑑 ∷ 𝑵𝒂𝒕 by the equation
𝑢𝑛𝑑𝑒𝑓𝑖𝑛𝑒𝑑 = 𝑢𝑛𝑑𝑒𝑓𝑖𝑛𝑒𝑑. Then
? 𝒁𝒆𝒓𝒐 < 𝑢𝑛𝑑𝑒𝑓𝑖𝑛𝑒𝑑
{Interrupted!}
? 𝒁𝒆𝒓𝒐 < 𝑺𝒖𝒄𝒄 𝑢𝑛𝑑𝑒𝑓𝑖𝑛𝑒𝑑
𝑇𝑟𝑢𝑒
? 𝑺𝒖𝒄𝒄 𝒁𝒆𝒓𝒐 < 𝑺𝒖𝒄𝒄 𝑢𝑛𝑑𝑒𝑓𝑖𝑛𝑒𝑑
{Interrupted!}
? 𝑺𝒖𝒄𝒄 𝒁𝒆𝒓𝒐 < 𝑺𝒖𝒄𝒄 (𝑺𝒖𝒄𝒄 𝑢𝑛𝑑𝑒𝑓𝑖𝑛𝑒𝑑)
𝑇𝑟𝑢𝑒
One can interpret the extra values in the following way: ⊥ corresponds to the natural number about which there is
absolutely no information; 𝑺𝒖𝒄𝒄 ⊥ to the natural number about which the only information is that it is greater than 𝒁𝒆𝒓𝒐;
𝑺𝒖𝒄𝒄 (𝑺𝒖𝒄𝒄 ⊥) to the natural number about which the only information is that it is greater than 𝑺𝒖𝒄𝒄 𝒁𝒆𝒓𝒐; and so on.
Richard Bird

There is also one further value of 𝑵𝒂𝒕, namely the ‘infinite’ number:
𝑺𝒖𝒄𝒄 (𝑺𝒖𝒄𝒄 (𝑺𝒖𝒄𝒄 (𝑺𝒖𝒄𝒄 … )))
This number can be defined by
𝑖𝑛𝑓𝑖𝑛𝑖𝑡𝑦 ∷ 𝑵𝒂𝒕
𝑖𝑛𝑓𝑖𝑛𝑖𝑡𝑦 = 𝑺𝒖𝒄𝒄 𝑖𝑛𝑓𝑖𝑛𝑖𝑡𝑦
It is different from all the other numbers, because it is the only number 𝑥 for which 𝑺𝒖𝒄𝒄 𝑚 < 𝑥 returns 𝑻𝒓𝒖𝒆 for all finite
numbers 𝑚. In this sense, 𝑖𝑛𝑓𝑖𝑛𝑖𝑡𝑦 is the largest element of 𝑵𝒂𝒕. If we request the value of 𝑖𝑛𝑓𝑖𝑛𝑖𝑡𝑦, then we obtain
? 𝑖𝑛𝑓𝑖𝑛𝑖𝑡𝑦
𝑺𝒖𝒄𝒄 (𝑺𝒖𝒄𝒄 (𝑺𝒖𝒄𝒄 (𝑺𝒖𝒄𝒄 (𝑺𝒖𝒄𝒄 {𝐼𝑛𝑡𝑒𝑟𝑟𝑢𝑝𝑡𝑒𝑑!}
The number 𝑖𝑛𝑓𝑖𝑛𝑖𝑡𝑦 satisfies other properties, in particular 𝑛 + 𝑖𝑛𝑓𝑖𝑛𝑖𝑡𝑦 = 𝑖𝑛𝑓𝑖𝑛𝑖𝑡𝑦, for all numbers 𝑛. The dual equation
𝑖𝑛𝑓𝑖𝑛𝑖𝑡𝑦 + 𝑛 = 𝑖𝑛𝑓𝑖𝑛𝑖𝑡𝑦 holds only for finite numbers 𝑛. We will see how to prove assertions such as these in the next
section.
To summarise this discussion, we can divide the values of 𝑵𝒂𝒕 into three classes:
• The finite numbers, those that correspond to well-defined natural numbers.
• The partial numbers, ⊥, 𝑺𝒖𝒄𝒄 ⊥, and so on.
• The infinite numbers, of which there is just one, namely 𝑖𝑛𝑓𝑖𝑛𝑖𝑡𝑦.
We will see that this classification holds true of all recursive types. There will be the finite elements of the type, the partial
elements, and the infinite elements. Although the infinite natural number is not of much use, the same is not true of the
infinite values of other datatypes.
… Richard Bird

Note that when in this slide deck we mention the concepts of ⊥
and 𝑖𝑛𝑓𝑖𝑛𝑖𝑡𝑦, it is mainly in a Haskell context, as we did in the last
two slides. In particular, we won’t be modelling ⊥ and 𝑖𝑛𝑓𝑖𝑛𝑖𝑡𝑦 in
any of the Scala code you’ll see throughout the deck.

3.2 Induction
In order to reason about the properties of recursively defined functions over a recursive datatype, we can appeal to a principle of
structural induction. In the case of 𝑵𝒂𝒕, the principle of structural induction can be defined as follows: In order to show that some
property 𝑃(𝑛) holds for each finite number 𝑛 of 𝑵𝒂𝒕, it is sufficient to show:
Case (𝒁𝒆𝒓𝒐). That 𝑃(𝒁𝒆𝒓𝒐) holds.
Case (𝑺𝒖𝒄𝒄 𝑛). That if 𝑃(𝑛) holds, then 𝑃(𝑺𝒖𝒄𝒄 𝑛) holds also.
Induction is valid for the same reason that recursive definitions are valid: every finite number is either 𝒁𝒆𝒓𝒐 or of the form
𝑺𝒖𝒄𝒄 𝑛, where 𝑛 is a finite number. If we prove the first case, then we have shown that the property is true for 𝒁𝒆𝒓𝒐; If we also
prove the second case, then we have shown that the property is true for 𝑺𝒖𝒄𝒄 𝒁𝒆𝒓𝒐, since it is true for 𝒁𝒆𝒓𝒐. But now, by the
same argument, it is true for 𝑺𝒖𝒄𝒄 𝑺𝒖𝒄𝒄 𝒁𝒆𝒓𝒐 , and so on.
The principle needs to be extended if we want to assert that some proposition is true for all elements of 𝑵𝒂𝒕, but we postpone
discussion of this point for the following section.
As an example, let’s prove that 𝒁𝒆𝒓𝒐 + 𝑛 = 𝑛 for all finite numbers 𝑛. Recall that + is defined by
The first equation asserts that 𝒁𝒆𝒓𝒐 is a right unit of +. In general, 𝑒 is a left unit of ⊕ if 𝑒 ⊕ 𝑥 = 𝑥 for all 𝑥, and a right unit
of 𝑥 if 𝑥 ⊕ 𝑒 = 𝑥 for all 𝑥. If 𝑒 is both a left unit and a right unit of an operator ⊕, then it is called the unit of ⊕. The
terminology is appropriate since only one value can be both a left and right unit. So, by proving that 𝒁𝒆𝒓𝒐 is a left unit , we
have proved that 𝒁𝒆𝒓𝒐 is the unit of +.
Richard Bird

Proof. The proof is by induction on 𝑛. More precisely, we take for 𝑃(𝑛) the assertion that 𝒁𝒆𝒓𝒐 + 𝑛 = 𝑛. This equation is
referred to as the induction hypothesis.
Case (𝒁𝒆𝒓𝒐). We have to show 𝒁𝒆𝒓𝒐 + 𝒁𝒆𝒓𝒐 = 𝒁𝒆𝒓𝒐, which is immediate from the first equation defining +.
Case (𝑺𝒖𝒄𝒄 𝑛). We have to show that 𝒁𝒆𝒓𝒐 + 𝑺𝒖𝒄𝒄 𝑛 = 𝑺𝒖𝒄𝒄 𝑛, which we do by simplifying the left-hand expression:
𝒁𝒆𝒓𝒐 + 𝑺𝒖𝒄𝒄 𝑛
𝑺𝒖𝒄𝒄 (𝒁𝒆𝒓𝒐 + 𝑛)
= { induction hypothesis}
𝑺𝒖𝒄𝒄 𝑛
☐
This example shows the format we will use for inductive proofs, laying out each case separately and using a ☐ to mark the end.
The very last step made use of the induction hypothesis, which is allowed by the way induction works.
…
3.2.1 Full Induction
In the form given above, the induction principle for 𝑵𝒂𝒕 suffices only to prove properties of the finite members of 𝑵𝒂𝒕. If we
want to show that a property 𝑃 also hold for every partial number, then we have to prove three things:
Case (⊥). That 𝑃(⊥) holds.
Case (𝒁𝒆𝒓𝒐). That 𝑃(𝒁𝒆𝒓𝒐) holds.
Case (𝑺𝒖𝒄𝒄 𝑛). That if 𝑃(𝑛) holds, then 𝑃(𝑺𝒖𝒄𝒄 𝑛) holds also.
We can omit the second case, but then we can conclude only that 𝑃(𝑛) holds for every partial number. The reason the
principle is valid is that is that every partial number is either ⊥ or of the form 𝑺𝒖𝒄𝒄 𝑛 for some partial number 𝑛. Richard Bird

To illustrate, let us prove the somewhat counterintuitive result that 𝑚 + 𝑛 = 𝑛 for all numbers 𝑚 and all partial numbers 𝑛.
Proof. The proof is by partial number induction on 𝑛.
Case (⊥). The equation 𝑚 + ⊥ = ⊥ follows at once by case exhaustion in the definition of +. That is, ⊥ does not match either of
the patterns 𝒁𝒆𝒓𝒐 or 𝑺𝒖𝒄𝒄 𝑛.
Case (𝑺𝒖𝒄𝒄 𝑛). For the left-hand side, we reason
𝑚 + 𝑺𝒖𝒄𝒄 𝑛
𝑺𝒖𝒄𝒄 (𝑚 + 𝑛)
= { induction hypothesis}
𝑺𝒖𝒄𝒄 𝑛
Since the right-hand side is also 𝑺𝒖𝒄𝒄 𝑛, we are done.
3.2.2 Program synthesis
In the proofs above we defined some functions and then used induction to prove a certain property. We can also view
induction as a way to synthesise definitions of functions so that they satisfy the properties we want.
Let us illustrate with a simple example. Suppose we specify subtraction of natural numbers by the condition
𝑚 + 𝑛 − 𝑛 = 𝑚
for all 𝑚 and 𝑛. The specification does not give a constructive definition of − , merely a property that it has to satisfy.
However, we can do an induction proof on 𝑛 of the equation above, but view the calculation as a way of generating a suitable
definition of − .
Richard Bird

Unlike previous proofs, we reason with the equation as a whole, since simplification of both sides independently is not
possible if we do not know what all the rules of simplification are.
Case (𝒁𝒆𝒓𝒐). We reason
𝑚 + 𝒁𝒆𝒓𝒐 − 𝒁𝒆𝒓𝒐 = 𝑚
≡ { first equation for +, i.e. 𝑚 + 𝒁𝒆𝒓𝒐 = 𝑚 }
Hence we can take 𝑚 − 𝒁𝒆𝒓𝒐 = 𝑚 to satisfy the case. The symbol ≡ is used to separate steps of the calculation since we are
calculating with mathematical assertions, not with values of a datatype.
Case (𝑺𝒖𝒄𝒄 𝑛). We reason
𝑚 + 𝑺𝒖𝒄𝒄 𝑛 − 𝑺𝒖𝒄𝒄 𝑛 = 𝑚
≡ { second equation for +, i.e. 𝑚 + 𝑺𝒖𝒄𝒄 𝑛 = 𝑺𝒖𝒄𝒄 𝑚 + 𝑛 }
𝑺𝒖𝒄𝒄 𝑚 + 𝑛 − 𝑺𝒖𝒄𝒄 𝑛 = 𝑚
≡ { hypothesis 𝑚 + 𝑛 − 𝑛 = 𝑚}
𝑺𝒖𝒄𝒄 𝑚 + 𝑛 − 𝑺𝒖𝒄𝒄 𝑛 = 𝑚 + 𝑛 − 𝑛
Replacing 𝑚 + 𝑛 in the last equation by 𝑚, we can take 𝑺𝒖𝒄𝒄 𝑚 − 𝑺𝒖𝒄𝒄 𝑛 = 𝑚 − 𝑛 to satisfy the case. Hence we have derived
This is the program for − seen earlier.
Richard Bird

After that look at structural induction, it is finally time to
see how Richard Bird introduces the concept of folding.

3.3 The fold function
Many of the recursive definitions seen so far have a common pattern, exemplified by the following definition of a function 𝑓:
𝑓 ∷ 𝑵𝒂𝒕 → 𝐴
𝑓 𝒁𝒆𝒓𝒐 = 𝑐
𝑓 𝑺𝒖𝒄𝒄 𝑛 = ℎ 𝑓 𝑛
Here, 𝐴 is some type, 𝑐 is an element of 𝐴, and ℎ ∷ 𝐴 → 𝐴 . Observe that 𝑓 works by taking an element of 𝑵𝒂𝒕 and replacing
𝒁𝒆𝒓𝒐 by 𝑐 and 𝑺𝒖𝒄𝒄 by ℎ. For example, 𝑓 takes
𝑺𝒖𝒄𝒄 (𝑺𝒖𝒄𝒄 (𝑺𝒖𝒄𝒄 𝒁𝒆𝒓𝒐)) to ℎ (ℎ (ℎ 𝑐))
The two equations for 𝑓 can be captured in terms of a single function, 𝑓𝑜𝑙𝑑𝑛, called the 𝑓𝑜𝑙𝑑 function for 𝑵𝒂𝒕. The definition is
𝑓𝑜𝑙𝑑𝑛 ∷ 𝛼 → 𝛼 → 𝛼 → 𝑵𝒂𝒕 → 𝛼
𝑓𝑜𝑙𝑑𝑛 ℎ 𝑐 𝒁𝒆𝒓𝒐 = 𝑐
𝑓𝑜𝑙𝑑𝑛 ℎ 𝑐 𝑺𝒖𝒄𝒄 𝑛 = ℎ 𝑓𝑜𝑙𝑑𝑛 ℎ 𝑐 𝑛
In particular, we have
𝑚 + 𝑛 = 𝑓𝑜𝑙𝑑𝑛 𝑺𝒖𝒄𝒄 𝑚 𝑛
𝑚 × 𝑛 = 𝑓𝑜𝑙𝑑𝑛 + 𝑚 𝒁𝒆𝒓𝒐 𝑛
𝑚 ↑ 𝑛 = 𝑓𝑜𝑙𝑑𝑛 × 𝑚 𝑺𝒖𝒄𝒄 𝒁𝒆𝒓𝒐 𝑛
It follows also that the identity function 𝑖𝑑 on 𝑵𝒂𝒕 satisfies 𝑖𝑑 = 𝑓𝑜𝑙𝑑𝑛 𝑺𝒖𝒄𝒄 𝒁𝒆𝒓𝒐. A suitable 𝑓𝑜𝑙𝑑 function can be defined for
every recursive type, and we will see other 𝑓𝑜𝑙𝑑 functions in the following chapters.
Richard Bird

𝑚 + 𝑛 = 𝑓𝑜𝑙𝑑𝑛 𝑺𝒖𝒄𝒄 𝑚 𝑛
𝑚 × 𝑛 = 𝑓𝑜𝑙𝑑𝑛 + 𝑚 𝒁𝒆𝒓𝒐 𝑛
𝑚 ↑ 𝑛 = 𝑓𝑜𝑙𝑑𝑛 × 𝑚 𝑺𝒖𝒄𝒄 𝒁𝒆𝒓𝒐 𝑛
𝑓𝑜𝑙𝑑𝑛 ∷ 𝛼 → 𝛼 → 𝛼 → 𝑵𝒂𝒕 → 𝛼
𝑓𝑜𝑙𝑑𝑛 ℎ 𝑐 𝒁𝒆𝒓𝒐 = 𝑐
𝑓𝑜𝑙𝑑𝑛 ℎ 𝑐 𝑺𝒖𝒄𝒄 𝑛 = ℎ 𝑓𝑜𝑙𝑑𝑛 ℎ 𝑐 𝑛
@philip_schwarz
Just to reinforce the ideas on the previous slide, here are the original definitions
of +, × and ↑, and next to them, the new definitions in terms of 𝑓𝑜𝑙𝑑𝑛.
And the next slide is the same but in terms of Scala code.

m => {
case Zero => m
case Succ(n) => Succ(m + n)
}
m => {
case Zero => Zero
case Succ(n) => (m × n) + m
}
m => {
case Succ(n) => (m ↑ n) × m
}
m => n => foldn((x:Nat) => x + m, Zero, n)
def foldn[A](h: A => A, c: A, n: Nat): A =
n match {
case Zero => c
case Succ(n) => h(foldn(h,c,n))
}
m => n => foldn((x:Nat) => x × m, Succ(Zero), n)
m => n => foldn(Succ,m,n)

In the examples above, each instance of 𝑓𝑜𝑙𝑑𝑛 also returned an element of 𝑵𝒂𝒕. In the following two examples, 𝑓𝑜𝑙𝑑𝑛
returns an element of (𝑵𝒂𝒕, 𝑵𝒂𝒕):
𝑓𝑎𝑐𝑡 = 𝑠𝑛𝑑 Š 𝑓𝑜𝑙𝑑𝑛 𝑓 (𝒁𝒆𝒓𝒐, 𝑺𝒖𝒄𝒄 𝒁𝒆𝒓𝒐)
where 𝑓 𝑚, 𝑛 = (𝑺𝒖𝒄𝒄 𝑚, 𝑺𝒖𝒄𝒄 (𝑚) × 𝑛)
𝑓𝑖𝑏 = 𝑓𝑠𝑡 Š 𝑓𝑜𝑙𝑑𝑛 𝑔 (𝒁𝒆𝒓𝒐, 𝑺𝒖𝒄𝒄 𝒁𝒆𝒓𝒐)
where 𝑔 𝑚, 𝑛 = (𝑛, 𝑚 + 𝑛)
The function 𝑓𝑎𝑐𝑡 computes the factorial function and function 𝑓𝑖𝑏 computes the Fibonacci function. Each program works by first
computing a more general result, namely an element of (𝑵𝒂𝒕, 𝑵𝒂𝒕), and then extracts the required result. In fact,
𝑓𝑜𝑙𝑑𝑛 𝑓 𝒁𝒆𝒓𝒐, 𝑺𝒖𝒄𝒄 𝒁𝒆𝒓𝒐 𝑛 = 𝑛, 𝑓𝑎𝑐𝑡 𝑛
𝑓𝑜𝑙𝑑𝑛 𝑔 𝒁𝒆𝒓𝒐, 𝑺𝒖𝒄𝒄 𝒁𝒆𝒓𝒐 𝑛 = 𝑓𝑖𝑏 𝑛, 𝑓𝑖𝑏 𝑺𝒖𝒄𝒄 𝑛
These equations can be proved by induction. The program for 𝑓𝑖𝑏 is more efficient than a direct recursive definition. The
recursive program requires an exponential number of + operations, while the program above requires only a linear number. We
will discuss efficiency in more detail in chapter 7, where the programming technique that led to the invention of the new program
for 𝑓𝑖𝑏 will be studied in a more general setting.
There are two advantages of writing recursive definitions in terms of 𝑓𝑜𝑙𝑑𝑛. Firstly, the definition is shorter; rather than having to
write down two equations, we have only to write down one. Secondly, it is possible to prove general properties of 𝑓𝑜𝑙𝑑𝑛 and use
them to prove properties of specific instantiations. In other words, rather than having to write down many induction proofs, we
have only to write down one.
Richard Bird

Now let’s have a very quick look at the
datatype for lists, and at induction over lists.

4.1.1 Lists as a datatype
A list can be constructed from scratch by starting with the empty list and successively adding elements one by one. One can add
elements to the front of the list, or to the rear, or to somewhere in the middle. In the following datatype declaration, nonempty
lists are constructed by adding elements to the front of the list:
𝐝𝐚𝐭𝐚 𝑳𝒊𝒔𝒕 𝛼 = 𝑵𝒊𝒍 | 𝑪𝒐𝒏𝒔 𝛼 (𝑳𝒊𝒔𝒕 𝛼)
…The constructor (short for ‘construct’ – the name goes back to the programming language LISP) adds an element to the front of
the list. For example, the list 1,2,3 would be represented as the following element of 𝑳𝒊𝒔𝒕 𝑰𝒏𝒕:
𝑪𝒐𝒏𝒔 1 (𝑪𝒐𝒏𝒔 2 (𝑪𝒐𝒏𝒔 3 𝑵𝒊𝒍 ))
In functional programming, lists are defined as elements of 𝑳𝒊𝒔𝒕 𝛼. The syntax [𝛼] is used instead of 𝑳𝒊𝒔𝒕 𝛼, the constructor 𝑵𝒊𝒍 is
written as [ ], and the constructor 𝑪𝒐𝒏𝒔 is written as infix operator (∶). Moreover, (∶) associates to the right, so
1,2,3 = 1: 2: 3: [ ] = 1 ∶ 2 ∶ 3 ∶ [ ]
In other words, the special syntax on the left can be regarded as an abbreviation for the syntax on the right, which is also special,
but only by virtue of the fact that the constructors are given nonstandard names.
Like functions over other datatypes, functions over lists can be defined by pattern matching.
Richard Bird

Before moving on to the topic of induction over lists, Richard Bird gives
an example of a function defined over lists using pattern matching, but
the function he chooses is the equality function, whereas we are going
to choose the sum function, just to keep things simpler.
𝑠𝑢𝑚 ∷ [𝑰𝒏𝒕] → 𝑰𝒏𝒕
𝑠𝑢𝑚 [ ] = 0
𝑠𝑢𝑚 𝑥: 𝑥𝑠 = 𝑥 + (𝑠𝑢𝑚 𝑥𝑠)
val sum : List[Int] => Int = {
case Nil => 0
case x :: xs => x + sum(xs)
}
assert( sum( 4 :: (5 :: (6 :: Nil)) ) == 15)

sealed trait Nat
case class Succ(n: Nat) extends Nat
case object Zero extends Nat
sealed trait List[+A]
case class Cons[+A](head: A, tail: List[A]) extends List[A]
case object Nil extends List[Nothing]
m => { case Zero => m
case Succ(n) => Succ(m + n) }
implicit class NatSyntax(m: Nat){
def +(n: Nat) = `(+)`(m)(n)
}
val sum: List[Nat] => Nat = {
case Nil => Zero
case Cons(x, xs) => x + sum(xs)
}
assert( sum( Cons(
Succ(Zero), // 1
Cons(
Succ(Succ(Zero)), // 2
Cons(
Succ(Succ(Succ(Zero))), // 3
Nil))) )
== Succ(Succ(Succ(Succ(Succ(Succ(Zero))))))) // 6
𝑠𝑢𝑚 ∷ 𝑳𝒊𝒔𝒕 𝑵𝒂𝒕 → 𝑵𝒂𝒕
𝑠𝑢𝑚 𝑵𝒊𝒍 = 𝒁𝒆𝒓𝒐
𝑠𝑢𝑚 𝑪𝒐𝒏𝒔 𝑥 𝑥𝑠 = 𝑥 + (𝑠𝑢𝑚 𝑥𝑠)
𝐝𝐚𝐭𝐚 𝐋𝐢𝐬𝐭 α = 𝐍𝐢𝐥 | 𝐂𝐨𝐧𝐬 α (𝐋𝐢𝐬𝐭 α)
Same as on the previous slide, but this time
using Nat rather than Int, just for fun.

4.1.2 Induction over Lists
Recall from section 3.2 that, for the datatype 𝑵𝒂𝒕 of natural numbers, structural induction is based on three cases: every element
of 𝑵𝒂𝒕 is either ⊥, or 𝒁𝒆𝒓𝒐, or else has the form 𝑺𝒖𝒄𝒄 𝑛 for some element 𝑛 of 𝑵𝒂𝒕. Similarly, structural induction on lists is also
based on on three cases: every list is either the undefined list ⊥, the empty list [ ], or else has the form 𝑥: 𝑥𝑠 for some 𝑥 and list
𝑥𝑠.
To show by induction that a proposition 𝑃(𝑥𝑠) holds for all lists 𝑥𝑠 it suffices therefore to establish three cases:
Case (⊥). That 𝑃(⊥) holds.
Case ([ ]). That 𝑃([ ]) holds.
Case 𝑥: 𝑥𝑠 . That if 𝑃(𝑥𝑠) holds, then 𝑃(𝑥: 𝑥𝑠) also holds for every 𝑥.
If we prove only the second two cases, then we can conclude only that 𝑃(𝑥𝑠) holds for every finite list; if we prove only the first
and third cases. Then we can conclude only that 𝑃(𝑥𝑠) holds for every partial list. If 𝑃 takes the form of an equation, as all of our
laws do, then proving the first and third cases is sufficient to show that 𝑃(𝑥𝑠) holds for every infinite list. Partial lists and infinite
lists are described in the following section. Examples of induction proofs are given throughout the remainder of the chapter.
Richard Bird

Richard Bird provides other examples of recursive functions
over lists. Let’s see some of them: list concatenation,
flattening of lists of lists, list reversal and length of a list.
When looking at the first one, i.e. concatenation, let’s also
see an example of proof by structural induction on lists.
@philip_schwarz

4.2.1 Concatenation
Two lists can be concatenated to form one longer list. This function is denoted by the binary operator ⧺ (pronounced
‘concatenate’). As two simple examples, we have
? 1,2,3 ⧺ 4,5
1,2,3,4,5
? 1,2 ⧺ ⧺ 1
1,2,1
The formal definition of ⧺ is
(⧺) ∷ [α] → [α] → [α]
⧺ 𝑦𝑠 = 𝑦𝑠
𝑥: 𝑥𝑠 ⧺ 𝑦𝑠 = 𝑥 ∶ (𝑥𝑠 ⧺ 𝑦𝑠)
Concatenation takes two lists, both of the same type, and produces a third list, again of the same type. Hence the type assignment.
The definition of ⧺ is by pattern matching on the left-hand argument; the two patterns are disjoint and cover all cases, apart from
the undefined list ⊥. It follows by case exhaustion that ⊥ ⧺ 𝑦𝑠 = ⊥.
However, it is not the case that 𝑦𝑠 ⧺ ⊥ = ⊥. For example,
? 1,2,3 ⧺ 𝑢𝑛𝑑𝑒𝑓𝑖𝑛𝑒𝑑
1,2,3{𝐼𝑛𝑡𝑒𝑟𝑟𝑢𝑝𝑡𝑒𝑑!}
The list 1,2,3 ⧺ ⊥ is a partial list; In full form it is the list 1: 2: 3: ⊥. The evaluator can compute the first three elements, but
thereafter it goes into a nonterminating computation, so we interrupt it.
The second equation for ⧺ is very succinct and requires some thought. Once one has come to grips with the definition of ⧺, one Richard Bird

has understood a good deal about how lists work in functional programming. Note that the number of steps required to compute
𝑥𝑠 ⧺ 𝑦𝑠 is proportional to the number of elements in 𝑥𝑠.
1, 2 ⧺ 3, 4, 5
= { notation}
(1 ∶ 2 ∶ ⧺ (3 ∶ (4 ∶ 5 ∶ [ ] ))
= { second equation for ⧺, i.e. 𝑥: 𝑥𝑠 ⧺ 𝑦𝑠 = 𝑥 ∶ (𝑥𝑠 ⧺ 𝑦𝑠) }
1 ∶ ( 2 ∶ ⧺ (3 ∶ (4 ∶ 5 ∶ [ ] )))
= { second equation for ⧺ }
1 ∶ (2 ∶ ( ⧺ (3 ∶ (4 ∶ 5 ∶ [ ] ))))
= { first equation for ⧺ i.e. , ⧺ 𝑦𝑠 = 𝑦𝑠 }
1 ∶ (2 ∶ (3 ∶ (4 ∶ 5 ∶ [ ] )))
= { notation}
1, 2, 3, 4, 5
Concatenation is an associative operation with with unit :
𝑥𝑠 ⧺ 𝑦𝑠 ⧺ 𝑧𝑠 = 𝑥𝑠 ⧺ (𝑦𝑠 ⧺ 𝑧𝑠)
𝑥𝑠 ⧺ = ⧺ 𝑥𝑠 = 𝑥𝑠
Let us now prove by induction that ⧺ is associative.
Proof. The proof is by induction on 𝑥𝑠.
Case (⊥). For the left-hand side, we reason
⊥ ⧺ (𝑦𝑠 ⧺ 𝑧𝑠)
= { case exhaustion}
⊥ ⧺ 𝑧𝑠
= { case exhaustion}
⊥
Richard Bird

The right-hand side simplifies to ⊥ as well, establishing the case.
Case ([ ]). For the left hand side, we reason
[ ] ⧺ (𝑦𝑠 ⧺ 𝑧𝑠)
= { first equation for ⧺ i.e. , ⧺ 𝑦𝑠 = 𝑦𝑠 }
(𝑦𝑠 ⧺ 𝑧𝑠)
The right-hand side simplifies to(𝑦𝑠 ⧺ 𝑧𝑠) as well, establishing the case.
Case 𝑥 ∶ 𝑥𝑠 . For the left hand side, we reason
((x ∶ 𝑥𝑠) ⧺ 𝑦𝑠) ⧺ 𝑧𝑠
= { second equation for ⧺, i.e. 𝑥: 𝑥𝑠 ⧺ 𝑦𝑠 = 𝑥 ∶ (𝑥𝑠 ⧺ 𝑦𝑠) }
( 𝑥 ∶ 𝑥𝑠 ⧺ 𝑦𝑠) ⧺ 𝑧𝑠
= { second equation for ⧺ }
𝑥 ∶ ( 𝑥𝑠 ⧺ 𝑦𝑠 ⧺ 𝑧𝑠)
= { induction hypothesis }
𝑥 ∶ (𝑥𝑠 ⧺ 𝑦𝑠 ⧺ 𝑧𝑠)
For the right-hand side we reason
(x ∶ 𝑥𝑠) ⧺ (𝑦𝑠 ⧺ 𝑧𝑠)
= { second equation for ⧺, i.e. 𝑥 ∶ 𝑥𝑠 ⧺ 𝑦𝑠 = 𝑥 ∶ (𝑥𝑠 ⧺ 𝑦𝑠) }
𝑥 ∶ (𝑥𝑠 ⧺ (𝑦𝑠 ⧺ 𝑧𝑠))
The two sides are equal, establishing the case.
…Note that associativity is proved for all lists, finite, partial or infinite. Hence we can assert that ⧺ is associative without
qualification…. Richard Bird

4.2.2 Concat
Concatenation performs much the same function for lists as the union operator ∪ does for sets. A companion function is concat,
which concatenates a list of lists into one long list. This function, which roughly corresponds to the big-union operator ⋃ for sets
of sets, is defined by
concat ∷ [ α ] → [α]
concat =
concat 𝑥𝑠: 𝑥𝑠𝑠 = 𝑥𝑠 ⧺ 𝑐𝑜𝑛𝑐𝑎𝑡 𝑥𝑠𝑠
For example,
?[ 1, 2 ⧺ ⧺ 3, 2,1 ]
1,2,3, 2,1
4.2.3 Reverse
Another basic function on lists is reverse, the function that reverses the order of elements in a finite list. For example:
? reverse “Madam, I’m Adam.”
“.MadA m’I ,madaM”
The definition is
reverse ∷ α → [α]
reverse =
reverse 𝑥 ∶ 𝑥𝑠 = 𝑟𝑒𝑣𝑒𝑟𝑠𝑒 𝑥𝑠 ⧺ [𝑥]
In words, to reverse a list 𝑥 ∶ 𝑥𝑠 , one reverses 𝑥𝑠, and then adds 𝑥 to the end. As a program, the above definition is not very Richard Bird

efficient: on a list of length 𝑛, it will need a number of reduction steps proportional to 𝑛2 to deliver the reversed list. The first
element will be appended to the end of a list of length 𝑛 − 1 , which will take about 𝑛 − 1 steps, the second element will be
appended to a list of length 𝑛 − 2 , taking 𝑛 − 2 steps, and so on. The total time is therefore about
𝑛 − 1 + 𝑛 − 2 + ⋯ 1 = 𝑛(𝑛 − 1)/2 steps
A more precise analysis is given in chapter 7, and a more efficient program for reverse is given in section 4.5.
4.2.2 Length
The length of a list is the number of elements it contains:
𝑙𝑒𝑛𝑔𝑡ℎ ∷ [α] → 𝑰𝒏𝒕
𝑙𝑒𝑛𝑔𝑡ℎ [ ] = 0
𝑙𝑒𝑛𝑔𝑡ℎ 𝑥: 𝑥𝑠 = 1 + 𝑙𝑒𝑛𝑔𝑡ℎ 𝑥𝑠
The nature of the list element is irrelevant when computing the length of a list, whence the type assignment. For example,
? 𝑙𝑒𝑛𝑔𝑡ℎ [𝑢𝑛𝑑𝑒𝑓𝑖𝑛𝑒𝑑, 𝑢𝑛𝑑𝑒𝑓𝑖𝑛𝑒𝑑]
2
However, not every list has a well-defined length. In particular, the partial lists ⊥, 𝑥 ∶ ⊥, 𝑥 ∶ 𝑦 ∶ ⊥, and so on, have an undefined
length. Only finite lists have well-defined lengths. The list ⊥, ⊥ is a finite list, not a partial list, because it is the list ⊥ ∶ ⊥ ∶ [ ],
which ends in [ ], not ⊥. The computer cannot produce the elements, but it can produce the length of the list.
…
Richard Bird

4.3 Map and filter
Two useful functions on lists are map and £ilter. The function map applies a function to each element of a list. For example
? 𝑚ap square [9, 3] ? 𝑚ap (<3) [1, 2, 3] ? 𝑚ap nextLetter “HAL”
[81, 9] [𝑇𝑟𝑢𝑒, 𝑇𝑟𝑢𝑒, 𝐹𝑎𝑙𝑠𝑒] “IBM”
The definition is
map ∷ (α → 𝛽) → [α] → [𝛽]
map f =
map f 𝑥 ∶ 𝑥𝑠 = 𝑓 𝑥 ∶ map 𝑓 𝑥𝑠
…
4.3 filter
The second function, filter, takes a Boolean function p and a list xs and returns that sublist of xs whose elements satisfy p. For
example,
? £ilter even [1,2,4,5,32] ? (sum Š map square Š £ilter even) [1. . 10]
[2,4,32] 220
The last example asks for the sum of the squares of the even integers in the range 1..10.
The definition of filter is
£ilter ∷ (α → 𝐵𝑜𝑜𝑙) → [α] → [α]
£ilter p =
£ilter p 𝑥 ∶ 𝑥𝑠 = 𝐢𝐟 𝑝 𝑥 𝐭𝐡𝐞𝐧 𝑥 ∶ £ilter p 𝑥𝑠 𝐞𝐥𝐬𝐞 £ilter p 𝑥𝑠
… Richard Bird

Now let’s look at fold functions over lists.

4.5 The fold functions
We have seen in the case of the datatype 𝑵𝒂𝒕 that many recursive definitions can be expressed very succinctly using a
suitable 𝑓𝑜𝑙𝑑 operator. Exactly the same is true of lists. Consider the following definition of a function ℎ :
ℎ [ ] = 𝑒
ℎ 𝑥: 𝑥𝑠 = 𝑥 ⊕ ℎ 𝑥𝑠
The function ℎ works by taking a list, replacing [ ] by 𝑒 and ∶ by ⊕, and evaluating the result. For example, ℎ converts the list
𝑥1 ∶ (𝑥2 ∶ 𝑥3 ∶ 𝑥4 ∶ )
to the value
𝑥1 ⊕ (𝑥2 ⊕ (𝑥3 ⊕ 𝑥4 ⊕ 𝑒 ))
Since ∶ associates to the right, there is no need to put in parentheses in the first expression. However, we do need to put in
parentheses in the second expression because we do not assume that ⊕ associates to the right.
The pattern of definition given by ℎ is captured in a function 𝑓𝑜𝑙𝑑𝑟 (prounced ‘fold right’) defined as follows:
𝑓𝑜𝑙𝑑𝑟 ∷ 𝛼 → 𝛽 → 𝛽 → 𝛽 → 𝛼 → 𝛽
𝑓𝑜𝑙𝑑𝑟 𝑓 𝑒 = 𝑒
𝑓𝑜𝑙𝑑𝑟 𝑓 𝑒 𝑥: 𝑥𝑠 = 𝑓 𝑥 𝑓𝑜𝑙𝑑𝑟 𝑓 𝑒 𝑥𝑠
We can now write h = 𝑓𝑜𝑙𝑑𝑟 ⊕ 𝑒. The first argument of 𝑓𝑜𝑙𝑑𝑟 is a binary operator that takes an 𝛼-value on its left and an a 𝛽–
value on its right, and delivers a 𝛽–value. The second argument of 𝑓𝑜𝑙𝑑𝑟 is a 𝛽-value. The third argument is of type 𝛼 , and the
result is of type 𝛽. In many cases, 𝛼 and 𝛽 will be instantiated to the same type, for instance when ⊕ denotes an associative
operation. Richard Bird

In the next slide we look at how some of the recursively
defined functions on lists that we have recently seen can be
redefined in terms of 𝑓𝑜𝑙𝑑𝑟.
To aid comprehension, I have added the original function
definitions next to the new definitions in terms of 𝑓𝑜𝑙𝑑𝑟. For
reference, I also added the definition of 𝑓𝑜𝑙𝑑𝑟.

The single function foldr can be used to define almost every function on lists that we have met so far. Here are just some
examples:
concat = 𝑓𝑜𝑙𝑑𝑟 (⧺) [ ]
reverse = 𝑓𝑜𝑙𝑑𝑟 𝑠𝑛𝑜𝑐
𝑤ℎ𝑒𝑟𝑒 𝑠𝑛𝑜𝑐 𝑥 𝑥𝑠 = 𝑥𝑠 ⧺ [𝑥]
𝑙𝑒𝑛𝑔𝑡ℎ = 𝑓𝑜𝑙𝑑𝑟 𝑜𝑛𝑒𝑝𝑙𝑢𝑠 0
𝑤ℎ𝑒𝑟𝑒 𝑜𝑛𝑒𝑝𝑙𝑢𝑠 𝑥 𝑛 = 1 + 𝑛
…
𝑠𝑢𝑚 = 𝑓𝑜𝑙𝑑𝑟 + 0
map ∷ (α → 𝛽) → [α] → [𝛽]
map 𝑓 = 𝑓𝑜𝑙𝑑𝑟 𝑐𝑜𝑛𝑠 Š 𝑓
𝑤ℎ𝑒𝑟𝑒 𝑐𝑜𝑛𝑠 𝑥 𝑥𝑠 = 𝑥 ∶ 𝑥𝑠
…
concat =
concat 𝑥𝑠: 𝑥𝑠𝑠 = 𝑥𝑠 ⧺ 𝑐𝑜𝑛𝑐𝑎𝑡 𝑥𝑠𝑠
reverse =
reverse 𝑥 ∶ 𝑥𝑠 = 𝑟𝑒𝑣𝑒𝑟𝑠𝑒 𝑥𝑠 ⧺ [𝑥]
𝑙𝑒𝑛𝑔𝑡ℎ [ ] = 0
𝑙𝑒𝑛𝑔𝑡ℎ 𝑥: 𝑥𝑠 = 1 + 𝑙𝑒𝑛𝑔𝑡ℎ 𝑥𝑠
𝑠𝑢𝑚 [ ] = 0
𝑠𝑢𝑚 𝑥: 𝑥𝑠 = 𝑥 + (𝑠𝑢𝑚 𝑥𝑠)
map ∷ (α → 𝛽) → [α] → [𝛽]
map f =
map f 𝑥 ∶ 𝑥𝑠 = 𝑓 𝑥 ∶ map 𝑓 𝑥𝑠
𝑓𝑜𝑙𝑑𝑟 ∷ 𝛼 → 𝛽 → 𝛽 → 𝛽 → 𝛼 → 𝛽
𝑓𝑜𝑙𝑑𝑟 𝑓 𝑒 𝑥: 𝑥𝑠 = 𝑓 𝑥 𝑓𝑜𝑙𝑑𝑟 𝑓 𝑒 𝑥𝑠 Richard Bird

On the next slide, the same code, translated into Scala
@philip_schwarz

def foldr[A,B](f: A => B => B)(e: B)(xs: List[A]): B =
xs match {
case Nil => e
case x::xs => f(x)(foldr(f)(e)(xs))
}
def concatenate[A]: List[A] => List[A] => List[A] =
xs => ys => xs match {
case Nil => ys
case x :: xs => x :: concatenate(xs)(ys)
}
def concat[A]: List[List[A]] => List[A] =
foldr(concatenate[A])(Nil)
def reverse[A]: List[A] => List[A] = {
def snoc[A]: A => List[A] => List[A] =
x => xs => concatenate(xs)(List(x))
foldr(snoc[A])(Nil)
}
def length[A]: List[A] => Int = {
def oneplus[A]: A => Int => Int = x => n => 1 + n
foldr(oneplus)(0)
}
val sum: List[Int] => Int = {
val plus: Int => Int => Int = a => b => a + b
foldr(plus)(0)
}
def map[A,B]: (A => B) => List[A] => List[B] = {
def cons: B => List[B] => List[B] = x => xs => x :: xs
f => foldr(cons compose f)(Nil)
}
𝑓𝑜𝑙𝑑𝑟 ∷ 𝛼 → 𝛽 → 𝛽 → 𝛽 → 𝛼 → 𝛽
(⧺) ∷ [α] → [α] → [α]
𝑥: 𝑥𝑠 ⧺ 𝑦𝑠 = 𝑥 ∶ (𝑥𝑠 ⧺ 𝑦𝑠)
concat = 𝑓𝑜𝑙𝑑𝑟 (⧺) [ ]
𝑙𝑒𝑛𝑔𝑡ℎ = 𝑓𝑜𝑙𝑑𝑟 𝑜𝑛𝑒𝑝𝑙𝑢𝑠 0
𝑤ℎ𝑒𝑟𝑒 𝑜𝑛𝑒𝑝𝑙𝑢𝑠 𝑥 𝑛 = 1 + 𝑛
𝑠𝑢𝑚 = 𝑓𝑜𝑙𝑑𝑟 + 0
map ∷ (α → 𝛽) → [α] → [𝛽]
map 𝑓 = 𝑓𝑜𝑙𝑑𝑟 𝑐𝑜𝑛𝑠 Q 𝑓
𝑤ℎ𝑒𝑟𝑒 𝑐𝑜𝑛𝑠 𝑥 𝑥𝑠 = 𝑥 ∶ 𝑥𝑠

assert( concatenate(List(1,2,3))(List(4,5)) == List(1,2,3,4,5) )
assert( concat(List(List(1,2), List(3), List(4,5))) == List(1,2,3,4,5) )
assert( reverse(List(1,2,3,4,5)) == List(5,4,3,2,1) )
assert( length(List(0,1,2,3,4,5)) == 6 )
assert( sum(List(2,3,4)) == 9 )
val mult: Int => Int => Int = a => b => a * b
assert( map(mult(10))(List(1,2,3)) == List(10,20,30))
Here a some sample tests for the
Scala functions on the previous slide.

It turns out that if it is possible to define a function on lists both using a recursive definition and
using a definition in terms of 𝑓𝑜𝑙𝑑𝑟, then there is a technique that can be used to go from the
recursive definition to the definition using 𝑓𝑜𝑙𝑑𝑟.
I came across the technique in the following paper by the author of Programming in Haskell:
The tutorial (which I shall be referring to as TUEF), shows how to apply the technique to the
sum function and the map function, which is the subject of the next five slides. Note: in the
paper, the 𝑓𝑜𝑙𝑑𝑟 function is referred to as 𝑓𝑜𝑙𝑑.
@philip_schwarz

3 The universal property of fold
As with the fold operator itself, the universal property of 𝒇𝒐𝒍𝒅 also has its origins in recursion theory. The first systematic use of the
universal property in functional programming was by Malcolm (1990a), in his generalisation of Bird and Meerten’s theory of lists (Bird,
1989; Meertens, 1983) to arbitrary regular datatypes. For finite lists, the universal property of 𝒇𝒐𝒍𝒅 can be stated as the following
equivalence between two definitions for a function 𝑔 that processes lists:
𝑔 = 𝑣 ⟺ 𝑔 = 𝑓𝑜𝑙𝑑 𝑓 𝑣
𝑔 𝑥 ∶ 𝑥𝑠 = 𝑓 𝑥 𝑔 𝑥𝑠
In the right-to-left direction, substituting 𝑔 = 𝑓𝑜𝑙𝑑 𝑓 𝑣 into the two equations for 𝑔 gives the recursive definition for 𝑓𝑜𝑙𝑑. Conversely,
in the left-to-right direction the two equations for g are precisely the assumptions required to show that 𝑔 = 𝑓𝑜𝑙𝑑 𝑓 𝑣 using a simple
proof by induction on finite lists (Bird, 1998). Taken as a whole, the universal property states that for finite lists the function 𝑓𝑜𝑙𝑑 𝑓 𝑣 is
not just a solution to its defining equations, but in fact the unique solution…. The universal property of 𝒇𝒐𝒍𝒅 can be generalised to
handle partial and infinite lists (Bird, 1998), but for simplicity we only consider finite lists in this article.
Graham Hutton
@haskellhutt

3.3 Universality as a definition principle
As well as being used as a proof principle, the universal property of 𝒇𝒐𝒍𝒅 can also be used as a definition principle that guides the
transformation of recursive functions into definitions using 𝑓𝑜𝑙𝑑. As a simple first example, consider the recursively defined function
𝑠𝑢𝑚 that calculates the sum of a list of numbers:
𝑠𝑢𝑚 ∷ 𝐼𝑛𝑡 → 𝐼𝑛𝑡
𝑠𝑢𝑚 = 0 𝑚
𝑠𝑢𝑚 𝑥 ∶ 𝑥𝑠 = 𝑥 + 𝑠𝑢𝑚 𝑥𝑠
Suppose now that we want to redefine 𝑠𝑢𝑚 using 𝑓𝑜𝑙𝑑. That is, we want to solve the equation 𝑠𝑢𝑚 = 𝑓𝑜𝑙𝑑 𝑓 𝑣 for a function f and a
value 𝑣. We begin by observing that the equation matches the right-hand side of the universal property, from which we conclude that
the equation is equivalent to the following two equations:
𝑠𝑢𝑚 = 𝑣
𝑠𝑢𝑚 𝑥 ∶ 𝑥𝑠 = 𝑓 𝑥 (𝑠𝑢𝑚 𝑥𝑠)
From the first equation and the definition of 𝑠𝑢𝑚, it is immediate that 𝑣 = 0.
Graham Hutton
@haskellhutt

From the second equation, we calculate a definition for f as follows:
⇔ { Definition of 𝑠𝑢𝑚 }
𝑥 + 𝑠𝑢𝑚 𝑥𝑠 = 𝑓 𝑥 (𝑠𝑢𝑚 𝑥𝑠)
⇐ { † Generalising (𝑠𝑢𝑚 𝑥𝑠) to 𝑦 }
𝑥 + 𝑦 = 𝑓 𝑥 𝑦
⇔ { Functions }
𝑓 = (+)
That is, using the universal property we have calculated that:
𝑠𝑢𝑚 = 𝑓𝑜𝑙𝑑 + 0
Note that the key step (†) above in calculating a definition for 𝑓 is the generalisation of the expression 𝑠𝑢𝑚 𝑥𝑠 to a fresh variable 𝑦. In fact,
such a generalisation step is not specific to the 𝑠𝑢𝑚 function, but will be a key step in the transformation of any recursive function into a
definition using fold in this manner.
𝑠𝑢𝑚 ∷ 𝐼𝑛𝑡 → 𝐼𝑛𝑡
𝑠𝑢𝑚 = 0 𝑚
𝑠𝑢𝑚 𝑥 ∶ 𝑥𝑠 = 𝑥 + 𝑠𝑢𝑚 𝑥𝑠
𝑠𝑢𝑚 = 𝑣
Graham Hutton
@haskellhutt

Of course, the 𝑠𝑢𝑚 example above is rather artificial, because the definition of 𝑠𝑢𝑚 using 𝑓𝑜𝑙𝑑 is immediate. However, there are many
examples of functions whose definition using 𝑓𝑜𝑙𝑑 is not so immediate. For example, consider the recursively defined function 𝑚𝑎𝑝 𝑓 that
applies a function 𝑓 to each element of a list:
𝑚𝑎𝑝 ∷ 𝛼 → 𝛽 → 𝛼 → 𝛽
𝑚𝑎𝑝 𝑓 =
𝑚𝑎𝑝 𝑓 𝑥 ∶ 𝑥𝑠 = 𝑓 𝑥 ∶ 𝑚𝑎𝑝 𝑓 𝑥𝑠
To redefine 𝑚𝑎𝑝 𝑓 using 𝑓𝑜𝑙𝑑 we must solve the equation 𝑚𝑎𝑝 𝑓 = 𝑓𝑜𝑙𝑑 𝑣 𝑔 for a function 𝑔 and a value 𝑣. By appealing to the
universal property, we conclude that this equation is equivalent to the following two equations:
𝑚𝑎𝑝 𝑓 = 𝑣
𝑚𝑎𝑝 𝑓 𝑥 ∶ 𝑥𝑠 = 𝑔 𝑥 (𝑚𝑎𝑝 𝑓 𝑥𝑠)
From the first equation and the definition of 𝑚𝑎𝑝 it is immediate that 𝑣 = [ ].
Graham Hutton
@haskellhutt
substitute 𝑚𝑎𝑝 𝑓 for 𝑔 and 𝑔 for 𝑓

From the second equation, we calculate a definition for 𝑔 as follows:
⇔ { Definition of 𝑚𝑎𝑝 }
𝑓 𝑥 ∶ 𝑚𝑎𝑝 𝑓 𝑥𝑠 = 𝑔 𝑥 (𝑚𝑎𝑝 𝑓 𝑥𝑠)
⟸ { Generalising (𝑚𝑎𝑝 𝑓 𝑥𝑠) to 𝑦𝑠 }
𝑓 𝑥 ∶ 𝑦𝑠 = 𝑔 𝑥 𝑦𝑠
⇔ { Functions }
𝑔 = 𝜆𝑥 𝑦𝑠 → 𝑓 𝑥 ∶ 𝑦𝑠
That is, using the universal property we have calculated that
𝑚𝑎𝑝 𝑓 = 𝑓𝑜𝑙𝑑 𝜆𝑥 𝑦𝑠 → 𝑓 𝑥 ∶ 𝑦𝑠 [ ]
In general, any function on lists that can be expressed using the 𝑓𝑜𝑙𝑑 operator can be transformed into such a definition using the
universal property of 𝑓𝑜𝑙𝑑.
Graham Hutton
@haskellhutt
𝑚𝑎𝑝 ∷ 𝛼 → 𝛽 → 𝛼 → 𝛽
𝑚𝑎𝑝 𝑓 = 𝑣

There are several other interesting things in TUEF that we’ll be looking at.
I like its description of 𝑓𝑜𝑙𝑑𝑟 (see right), because it reiterates a key point (see left) made by Richard Bird about recursive functions on lists.
Consider the following definition of a function ℎ :
ℎ [ ] = 𝑒
ℎ 𝑥: 𝑥𝑠 = 𝑥 ⊕ ℎ 𝑥𝑠
The function ℎ works by taking a list, replacing [ ] by 𝑒 and ∶ by ⊕, and evaluating
the result. For example, ℎ converts the list
𝑥1 ∶ (𝑥2 ∶ 𝑥3 ∶ 𝑥4 ∶ )
to the value
𝑥1 ⊕ (𝑥2 ⊕ (𝑥3 ⊕ 𝑥4 ⊕ 𝑒 ))
Since ∶ associates to the right, there is no need to put in parentheses in the first
expression. However, we do need to put in parentheses in the second expression
because we do not assume that ⊕ associates to the right.
The pattern of definition given by ℎ is captured in a function 𝑓𝑜𝑙𝑑𝑟 (prounced ‘fold
right’) defined as follows:
𝑓𝑜𝑙𝑑𝑟 ∷ 𝛼 → 𝛽 → 𝛽 → 𝛽 → 𝛼 → 𝛽
2 The fold operator
The fold operator has its origins in recursion theory (Kleene, 1952), while the use of fold as
a central concept in a programming language dates back to the reduction operator of APL
(Iverson, 1962), and later to the insertion operator of FP (Backus, 1978). In Haskell, the fold
operator for lists can be defined as follows:
𝑓𝑜𝑙𝑑 :: 𝛼 → 𝛽 → 𝛽 → 𝛽 → 𝛼 → 𝛽
𝑓𝑜𝑙𝑑 𝑓 𝑣 = 𝑣
𝑓𝑜𝑙𝑑 𝑓 𝑣 𝑥 ∶ 𝑥𝑠 = 𝑓 𝑥 𝑓𝑜𝑙𝑑 𝑓 𝑣 𝑥𝑠
That is, given a function f of type 𝛼 → 𝛽 → 𝛽 and a value 𝑣 of type 𝛽, the function
𝑓𝑜𝑙𝑑 𝑓 𝑣 processes a list of type 𝛼 to give a value of type 𝛽 by replacing the nil
constructor at the end of the list by the value 𝑣, and each cons constructor ∶ within
the list by the function 𝑓. In this manner, the 𝑓𝑜𝑙𝑑 operator encapsulates a simple pattern
of recursion for processing lists, in which the two constructors for lists are simply
replaced by other values and functions.

(⧺) ∷ [α] → [α] → [α]
𝑥: 𝑥𝑠 ⧺ 𝑦𝑠 = 𝑥 ∶ (𝑥𝑠 ⧺ 𝑦𝑠)
Concatenation takes two lists, both of
the same type, and produces a third
list, again of the same type.
Remember the list concatenation function we saw earlier?
In TUEF we find a definition of concatenation in terms of 𝑓𝑜𝑙𝑑𝑟 (which it calls 𝑓𝑜𝑙𝑑)
(⧺) ∷ [α] → [α] → [α]
⧺ 𝑦𝑠 = 𝑓𝑜𝑙𝑑 ∶ 𝑦𝑠
assert( concatenate(List(1,2,3))(List(4,5)) == List(1,2,3,4,5) )
def concatenate[A]: List[A] => List[A] => List[A] =
xs => ys => xs match {
case Nil => ys
case x :: xs => x :: concatenate(xs)(ys)
}
def concatenate[A]: List[A] => List[A] => List[A] = {
def cons: A => List[A] => List[A] =
x => xs => x :: xs
xs => ys => foldr(cons)(ys)(xs)
}

Remember the £ilter function we saw earlier?
In TUEF we find a definition of £ilter in terms of 𝑓𝑜𝑙𝑑𝑟 (which as we saw, it calls 𝑓𝑜𝑙𝑑)
£ilter ∷ (α → 𝐵𝑜𝑜𝑙) → [α] → [α]
£ilter p =
£ilter p 𝑥 ∶ 𝑥𝑠 = 𝐢𝐟 𝑝 𝑥 𝐭𝐡𝐞𝐧 𝑥 ∶ £ilter p 𝑥𝑠 𝐞𝐥𝐬𝐞 £ilter p 𝑥𝑠
£ilter ∷ (α → 𝐵𝑜𝑜𝑙) → [α] → [α]
£ilter p = 𝑓𝑜𝑙𝑑 (𝜆𝑥 𝑥𝑠 → 𝐢𝐟 𝑝 𝑥 𝐭𝐡𝐞𝐧 𝑥 ∶ 𝑥𝑠 𝐞𝐥𝐬𝐞 𝑥𝑠) [ ]
def filter[A]: (A => Boolean) => List[A] => List[A] = p => {
case Nil => Nil
case x :: xs => if (p(x)) x :: filter(p)(xs) else filter(p)(xs)
}
def filter[A]: (A => Boolean) => List[A] => List[A] = p =>
foldr((x:A) => (xs:List[A]) => if (p(x)) (x::xs) else xs)(Nil)
val gt: Int => Int => Boolean = x => y => y > x
assert(filter(gt(5))(List(10,2,8,5,3,6)) == List(10,8,6))

Not every function on lists can be defined as an instance of 𝑓𝑜𝑙𝑑𝑟. For example, zip cannot be so defined. Even for those that
can, an alternative definition may be more efficient. To illustrate, suppose we want a function decimal that takes a list of digits
and returns the corresponding decimal number; thus
𝑑𝑒𝑐𝑖𝑚𝑎𝑙 [𝑥0, 𝑥1, … , 𝑥n] = ∑!"#
$
𝑥 𝑘10($&!)
It is assumed that the most significant digit comes first in the list. One way to compute decimal efficiently is by a process of
multiplying each digit by ten and adding in the following digit. For example
𝑑𝑒𝑐𝑖𝑚𝑎𝑙 𝑥0, 𝑥1, 𝑥2 = 10 × 10 × 10 × 0 + 𝑥0 + 𝑥1 + 𝑥2
This decomposition of a sum of powers is known as Horner’s rule.
Suppose we define ⊕ by 𝑛 ⊕ 𝑥 = 10 × 𝑛 + 𝑥. Then we can rephrase the above equation as
𝑑𝑒𝑐𝑖𝑚𝑎𝑙 𝑥0, 𝑥1, 𝑥2 = (0 ⊕ 𝑥0) ⊕ 𝑥1 ⊕ 𝑥2
This is almost like an instance of 𝑓𝑜𝑙𝑑𝑟, except that the grouping is the other way round, and the starting value appears on the
left, not on the right. In fact the computation is dual: instead of processing from right to left, the computation processes from
left to right.
This example motivates the introduction of a second fold operator called 𝑓𝑜𝑙𝑑𝑙 (pronounced ‘fold left’). Informally:
𝑓𝑜𝑙𝑑𝑙 ⊕ 𝑒 𝑥0, 𝑥1, … , 𝑥𝑛 − 1 = … ((𝑒 ⊕ 𝑥0) ⊕ 𝑥1) … ⊕ 𝑥 𝑛 − 1
The parentheses group from the left, which is the reason for the name. The full definition of 𝑓𝑜𝑙𝑑𝑙 is
𝑓𝑜𝑙𝑑𝑙 ∷ 𝛽 → 𝛼 → 𝛽 → 𝛽 → 𝛼 → 𝛽
𝑓𝑜𝑙𝑑𝑙 𝑓 𝑒 = 𝑒
𝑓𝑜𝑙𝑑𝑙 𝑓 𝑒 𝑥: 𝑥𝑠 = 𝑓𝑜𝑙𝑑𝑙 𝑓 𝑓 𝑒 𝑥 𝑥𝑠 Richard Bird

For example
𝑓𝑜𝑙𝑑𝑙 ⊕ 𝑒 𝑥0, 𝑥1, 𝑥2
= 𝑓𝑜𝑙𝑑𝑙 ⊕ 𝑒 ⊕ 𝑥0 𝑥1, 𝑥2
= 𝑓𝑜𝑙𝑑𝑙 ⊕ 𝑒 ⊕ 𝑥0 ⊕ 𝑥1 𝑥2
= 𝑓𝑜𝑙𝑑𝑙 ⊕ (( 𝑒 ⊕ 𝑥0 ⊕ 𝑥1) ⊕ 𝑥2) [ ]
= ((𝑒 ⊕ 𝑥0) ⊕ 𝑥1) ⊕ 𝑥2
If ⊕ is associative with unit 𝑒, then 𝑓𝑜𝑙𝑑𝑟 ⊕ 𝑒 and 𝑓𝑜𝑙𝑑𝑙 ⊕ 𝑒 define the same function on finite lists, as we will see in
the following section.
As another example of the use of 𝑓𝑜𝑙𝑑𝑙, consider the following definition:
reverse′ ∷ α → [α]
reverse′ = 𝑓𝑜𝑙𝑑𝑙 𝑐𝑜𝑛𝑠
𝑤ℎ𝑒𝑟𝑒 𝑐𝑜𝑛𝑠 𝑥𝑠 𝑥 = 𝑥 : 𝑥𝑠
Note the order of the arguments to cons; we have 𝑐𝑜𝑛𝑠 = 𝑓𝑙𝑖𝑝 (∶), where the standard function 𝑓𝑙𝑖𝑝 is defined by 𝑓𝑙𝑖𝑝𝑓 𝑥 𝑦 =
𝑓 𝑦 𝑥. The function reverse′ , reverses a finite list. For example:
reverse′ 𝑥0, 𝑥1, 𝑥2
= 𝑐𝑜𝑛𝑠(𝑐𝑜𝑛𝑠(𝑐𝑜𝑛𝑠 [ ] 𝑥0) 𝑥1) 𝑥2
= 𝑐𝑜𝑛𝑠(𝑐𝑜𝑛𝑠 𝑥1 𝑥0) 𝑥2
= 𝑐𝑜𝑛𝑠 𝑥1, 𝑥0 𝑥2
= 𝑥2, 𝑥1, 𝑥0
One can prove that reverse′ = reverse by induction, or as an instance of a more general result in the following section. Of
greater importance than the mere fact that reverse can be defined in a different way, is that reverse′ gives a much more
efficient program: reverse′ takes time proportional to n on a list of length 𝑛, while reverse takes time proportional to 𝑛2.
Richard Bird

def reverse'[A]: List[A] => List[A] = {
def cons: List[A] => A => List[A] =
xs => x => x :: xs
foldl(cons)(Nil)
}
assert( reverse'(List(1,2,3,4,5)) == List(5,4,3,2,1) )
def reverse[A]: List[A] => List[A] = {
def snoc[A]: A => List[A] => List[A] =
x => xs => concatenate(xs)(List(x))
foldr(snoc[A])(Nil)
}
def concatenate[A]: List[A] => List[A] => List[A] = {
def cons: A => List[A] => List[A] =
x => xs => x :: xs
xs => ys => foldr(cons)(ys)(xs)
}
assert( reverse(List(1,2,3,4,5)) == List(5,4,3,2,1) )
(⧺) ∷ [α] → [α] → [α]
⧺ 𝑦𝑠 = 𝑓𝑜𝑙𝑑 ∶ 𝑦𝑠
reverse′ ∷ α → [α]
reverse′ = 𝑓𝑜𝑙𝑑𝑙 𝑐𝑜𝑛𝑠
𝑤ℎ𝑒𝑟𝑒 𝑐𝑜𝑛𝑠 𝑥𝑠 𝑥 = 𝑥 : 𝑥𝑠
Here we can see the Scala version of
reverse’, and how it compares with reverse
@philip_schwarz

That’s it for part 1. I hope you enjoyed that.
There is still a lot to cover of course, so I’ll see you in part 2.

Folding Unfolded - Polyglot FP for Fun and Profit - Haskell and Scala

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Was ist angesagt?

Was ist angesagt? (20)

Ähnlich wie Folding Unfolded - Polyglot FP for Fun and Profit - Haskell and Scala

Ähnlich wie Folding Unfolded - Polyglot FP for Fun and Profit - Haskell and Scala (20)

Mehr von Philip Schwarz

Mehr von Philip Schwarz (20)

Kürzlich hochgeladen

Kürzlich hochgeladen (20)

Folding Unfolded - Polyglot FP for Fun and Profit - Haskell and Scala