Functional Programming

1
LECTURE 5 LIST COMPREHENSIONS
Graham Hutton University of Nottingham
2
Set Comprehensions
In mathematics, the comprehension notation can be
used to construct new sets from old sets.
x2 x ? 1..5
The set 1,4,9,16,25 of all numbers x2 such that
x is an element of the set 1..5.
3
Lists Comprehensions
In Haskell, a similar comprehension notation can
be used to construct new lists from old lists.
x2 x ? 1..5
The list 1,4,9,16,25 of all numbers x2 such
that x is an element of the list 1..5.
4
Note

• The expression x ? 1..5 is called a generator,
  as it states how to generate values for x.
• Comprehensions can have multiple generators,
  separated by commas. For example

gt (x,y) x ? 1..3, y ? 1..2 (1,1),(1,2),(
2,1),(2,2),(3,1),(3,2)
5

• Changing the order of the generators changes the
  order of the elements in the final list

gt (x,y) y ? 1..2, x ? 1..3 (1,1),(2,1),(
3,1),(1,2),(2,2),(3,2)

• Multiple generators are like nested loops, with
  later generators as more deeply nested loops
  whose variables change value more frequently.

6
Dependant Generators
Later generators can depend on the variables that
are introduced by earlier generators.
(x,y) x ? 1..3, y ? x..3
The list (1,1),(1,2),(1,3),(2,2),(2,3),(3,3) of
all pairs of numbers (x,y) such that x,y are
elements of the list 1..3 and x ? y.
7
Using a dependant generator we can define the
library function that concatenates a list of
lists
concat a ? a concat xss x xs ?
xss, x ? xs
For example
gt concat 1,2,3,4,5,6 1,2,3,4,5,6
8
Guards
List comprehensions can use guards to restrict
the values produced by earlier generators.
x x ? 1..10, even x
The list 2,4,6,8,10 of all numbers x such that
x is an element of the list 1..10 and x is even.
9
Using a guard we can define a function that maps
a positive integer to its list of factors
factors Int ? Int factors n x x ?
1..n , n mod x 0
For example
gt factors 15 1,3,5,15
10
A positive integer is prime if its only factors
are 1 and itself. Hence, using factors we can
define a function that decides if a number is
prime
prime Int ? Bool prime n factors n 1,n
For example
gt prime 15 False gt prime 7 True
11
Using a guard we can now define a function that
returns the list of all primes up to a given
limit
primes Int ? Int primes n x x ?
1..n, prime x
For example
gt primes 40 2,3,5,7,11,13,17,19,23,29,31,37
12
Exercises
A pythagorean triad is triple (x,y,z) of positive
integers such that x2 y2 z2. Using a list
comprehension, define a function
(1)
triads Int ? (Int,Int,Int)
that maps a number n to the list of all triads
with components in the range 1..n.
13
A positive integer is perfect if it equals the
sum of all of its factors, excluding the number
itself. Using a list comprehension, define a
function
(2)
perfects Int ? Int
that returns the list of all perfect numbers up
to a given limit. For example
gt perfects 500 6,28,496
14
LECTURE 6 RECURSIVE FUNCTIONS
Graham Hutton University of Nottingham
15
Introduction
As we have seen, many functions can naturally be
defined in terms of other functions.
factorial Int ? Int factorial n product
1..n
factorial maps any integer n to the product of
the integers between 1 and n.
16
Recursive Functions
In Haskell, functions can also be defined in
terms of themselves. Such functions are called
recursive.
factorial 0 1 factorial n n factorial (n-1)
factorial maps 0 to 1, and any other integer to
the product of itself with the factorial of its
predecessor.
17
For example
factorial 3
18
Why is Recursion Useful?

• Some functions, such as factorial, are simpler to
  define in terms of other functions
• In practice, however, most functions can
  naturally be defined in terms of themselves
• Properties of functions defined using recursion
  can be proved using the simple but powerful
  mathematical technique of induction.

19
Recursion on Lists
Recursion is not restricted to numbers, but can
also be used to define functions on lists.
product Int ? Int product
1 product (xxs) x product xs
product maps the empty list to 1, and any
non-empty list to its head multiplied by the
product of its tail.
20
For example
product 1,2,3
21
Quicksort
The quicksort algorithm for sorting a list of
integers can be specified by the following two
rules

• The empty list is already sorted
• Non-empty lists can be sorted by sorting the tail
  values ? the head, sorting the tail values ? the
  head, and then appending the resulting lists on
  either side of the head value.

22
Using recursion, this specification can be
translated directly into an implementation
qsort Int ? Int qsort
qsort (xxs) qsort a a ? xs, a ? x
x qsort b b ?
xs, b ? x
Note

• This is probably the simplest implementation of
  quicksort in any programming language!

23
For example (abbreviating qsort as q)
q 3,2,4,1,5
24
Exercises
(1)
Define a recursive function
insert Int ? Int ? Int
that inserts an integer into the correct position
in a sorted list of integers. For example
gt insert 3 1,2,4,5 1,2,3,4,5
25
(2)
Define a recursive function
isort Int ? Int
that implements insertion sort, which can be
specified by the following two rules

• The empty list is already sorted
• Non-empty lists can be sorted by sorting the tail
  and inserting the head into the result.

26
(3)
Define a recursive function
merge Int ? Int ? Int
that merges two sorted lists of integers to give
a single sorted list. For example
gt merge 2,5,6 1,3,4 1,2,3,4,5,6
27
(4)
Define a recursive function
msort Int ? Int
that implements merge sort, which can be
specified by the following two rules

• Lists of length ? 1 are already sorted
• Other lists can be sorted by sorting the two
  halves and merging the resulting lists.

28
(5)
Test both sorting functions using Hugs to see how
they compare. For example
gt set s gt isort (reverse 1..500) gt msort
(reverse 1..500)
The command set s tells Hugs to give some
useful statistics after each evaluation.
29
LECTURE 7 HIGHER-ORDER FUNCTIONS
Graham Hutton University of Nottingham
30
Introduction
A function is called higher-order if it takes a
function as an argument or returns a function as
a result.
twice (a ? a) ? a ? a twice f x f (f x)
twice is higher-order because it takes a function
as its first argument.
31
Why Are They Useful?

• Common programming idioms, such as applying a
  function twice, can naturally be encapsulated as
  general purpose higher-order functions
• Special purpose languages can be defined within
  Haskell using higher-order functions, such as for
  list processing, interaction, or parsing
• Algebraic properties of higher-order functions
  can be used to reason about programs.

32
The Map Function
The higher-order library function called map
applies a function to every element of a list.
map (a ? b) ? a ? b
For example
gt map (1) 1,3,5,7 2,4,6,8
33
The map function can be defined in a particularly
simple manner using a list comprehension
map f xs f x x ? xs
Alternatively, for the purposes of proofs, the
map function can also be defined using recursion
map f map f (xxs) f x map f xs
34
The Filter Function
The higher-order library function filter selects
every element from a list that satisfies a
predicate.
filter (a ? Bool) ? a ? a
For example
gt filter even 1..10 2,4,6,8,10
35
Filter can be defined using a list comprehension
filter p xs x x ? xs, p x
Alternatively, it can be defined using recursion
filter p filter p (xxs) p x
x filter p xs otherwise filter p xs
36
The Foldr Function
A number of functions on lists can be defined
using the following simple pattern of recursion
f v f (xxs) x ? f xs
f maps the empty list to a value v, and any
non-empty list to a function ? applied to its
head and f of its tail.
37
For example
v 0 ?
sum 0 sum (xxs) x sum xs
v 1 ?
product 1 product (xxs) x product xs
v True ?
and True and (xxs) x and xs
38
The higher-order library function foldr (fold
right) encapsulates this simple pattern of
recursion, with the function ? and the value v as
arguments. For example
sum foldr () 0 product foldr () 1 and
foldr () True
39
Foldr itself can be defined using recursion
foldr (?) v v foldr (?) v (xxs) x
? foldr (?) v xs
In practice, however, it is better to think of
foldr non-recursively, as simultaneously
replacing each cons in a list by a function, and
by a value.
40
For example
sum 1,2,3
Replace each cons by and by 0.
41
Why Is Foldr Useful?

• Some recursive functions on lists, such as sum,
  are simpler to define using foldr
• Properties of functions defined using foldr can
  be proved using algebraic properties of foldr,
  such as fusion and the banana split rule
• Advanced program optimisations can be simpler if
  foldr is used in place of explicit recursion.

42
Exercises
(1)
What are higher-order functions that return
functions as results better known as?
(2)
Express the comprehension f x x ? xs, p x
using the functions map and filter.
(3)
Show how the functions length, reverse, map f and
filter p could be re-defined using foldr.
43
LECTURE 8 FUNCTIONAL PARSERS
Graham Hutton University of Nottingham
44
What is a Parser?
A parser is a program that analyses a piece of
text to determine its syntactic structure.
45
Functional Parsers
In a functional language such as Haskell, parsers
can naturally be viewed as functions.
type Parser String ? Tree
A parser is a function that takes a string and
returns some form of tree.
46
However, a parser might not require all of its
input string, so we also return any unused input
type Parser String ? (Tree,String)
A string might be parsable in many ways,
including none, so we generalize to a list of
results
type Parser String ? (Tree,String)
47
Finally, a parser might not always produce a
tree, so we generalize to a value of any type
type Parser a String ? (a,String)
Note

• For simplicity, we will only consider parsers
  that either fail and return the empty list of
  results, or succeed and return a singleton list.

48
Primitive Parsers

• The parser item fails if the input is empty, and
  consumes the first character otherwise

item Parser Char item ?inp ? case inp of
?
(xxs) ? (x,xs)
49

• The parser failure always fails

failure Parser a failure ?inp ?

• The parser return v always succeeds, returning
  the value v without consuming any input

return a ? Parser a return v ?inp ?
(v,inp)
50
Sequencing
A sequence of parsers can be combined as a single
composite parser using the keyword do. For
example
p Parser (Char,Char) p do x ? item
item y ? item return (x,y)
51
Note

• If any parser in a sequence of parsers fails,
  then the sequence as a whole fails
• The values returned by intermediate parsers are
  discarded by default, but if required can be
  named using the ? operator
• The value returned by the last parser is the
  value returned by the sequence as a whole.

52
Example Using all the primitives introduced so
far, we can now define a parser for specific
characters.
char Char ? Parser Char char x do y ? item
if x y then return
x else failure
53
Choice
The parser p q behaves as the parser p if it
succeeds, and the parser q otherwise
() Parser a ? Parser a ? Parser a p q
?inp ? case p inp of
? q inp (v,out) ?
(v,out)
54
Arithmetic Expressions
Consider a simple form of arithmetic expressions
built up from single digits using


(
)
such that

• and associate to the right
• has higher priority than .

55
Formally, the syntax of such expressions is
defined by the following context free grammar
expr ? term ('' expr ? ?) term ? factor
('' term ? ?) factor ? digit ? '(' expr
') digit ? 0' ? 1' ? ? 9'
56
This grammar can now be translated directly into
a parser that evaluates expressions. For example
expr Parser Int expr do t ? term
do char '' e ? expr
return (t e) return
t factor Parser Int factor digit do
char ( e ? expr
char )
return e
57
Exercises
58
LECTURE 9 DEFINING TYPES
Graham Hutton University of Nottingham
59
Data Declarations
A new type can be defined by specifying its set
of values using a data declaration.
data Bool False True
Bool is a new type, with two new values False and
True.
60
Values of new types can be used in the same ways
as those of built in types. For example, given
data Answer Yes No Unknown
we can define
answers Answer answers
Yes,No,Unknown flip Answer ?
Answer flip Yes No flip No Yes flip
Unknown Unknown
61
The constructors in a data declaration can also
have parameters. For example, given
data Shape Circle Float Rect Float
Float
we can define
square Float ? Shape square n
Rect n n area Shape ? Float area
(Circle r) pi r2 area (Rect x y) x y
62
Similarly, data declarations themselves can also
have parameters. For example, given
data Maybe a Nothing Just a
we can define
return a ? Maybe a return x Just
x (gtgt) Maybe a ? (a ? Maybe b) ? Maybe
b Nothing gtgt _ Nothing Just x gtgt f f x
63
Recursive Types
In Haskell, new types can be defined in terms of
themselves. That is, types can be recursive.
data Nat Zero Succ Nat
Nat is a new type, with constructors Zero Nat
and Succ Nat ? Nat.
64
Note

• A value of type Nat is either Zero, or of the
  form Succ n where n Nat. That is, Nat
  contains the following infinite sequence of
  values

Zero
Succ Zero
Succ (Succ Zero)
65

• We can think of values of type Nat as natural
  numbers, where Zero represents 0, and Succ
  represents the successor function (1 ).
• For example, the value

Succ (Succ (Succ Zero))
represents the natural number
66
Using recursion, it is easy to define functions
that convert between values of type Nat and Int
nat2int Nat ? Int nat2int Zero
0 nat2int (Succ n) 1 nat2int n int2nat
Int ? Nat int2nat 0 Zero int2nat
(n1) Succ (int2nat n)
67
Arithmetic Expressions
Consider a simple form of expressions built up
from integers using addition and multiplication.
68
Using recursion, a suitable new type to represent
such expressions can be defined by
data Expr Val Int Add Expr Expr
Mul Expr Expr
For example, the expression on the previous slide
would be represented as follows
Add (Val 1) (Mul (Val 2) (Val 3))
69
Using recursion, it is now easy to define
functions that process expressions. For example
size Expr ? Int size (Val n)
1 size (Add x y) size x size y size (Mul x y)
size x size y eval Expr ?
Int eval (Val n) n eval (Add x y) eval x
eval y eval (Mul x y) eval x eval y
70
Exercises