Skip to main content

Functional Programming:  2020-2021



Preliminary ExaminationsComputer Science and Philosophy

Preliminary ExaminationsComputer Science

Preliminary ExaminationsMathematics and Computer Science

Schedule AMSc in Computer Science



The lectures for this course will be pre-recorded.
The lectures will be released at the start of each week, on Panopto (click Recorded Lectures>2020-21>Functional Programming)
They will be supported by a live discussion (which will take via MS Teams on Fridays 11-12 Weeks 1-8)

This is a first course in programming. It makes use of a programming language called Haskell, in which programs can be viewed as mathematical functions. This makes the language very powerful, so that we can easily construct programs that would be difficult or very large in other languages.

An important theme of the course is how to apply mathematical reasoning to programs, so as to prove that a program performs its task correctly, or to derive it by algebraic manipulation from a simpler but less efficient program for the same problem.

The course provides hands-on experience of programming through two lab exercises: the first one aims to make you acquainted with the mechanics of writing Haskell programs, and the second one tackles a more challenging programming task.

Learning outcomes

At the end of the course the student will be able to:

  1. Write programs in a functional style;
  2. Reason formally about functional programs;
  3. Use polymorphism and higher-order functions;
  4. Reason about the time and space complexity of programs.


  • Programming by writing functions: expressions, values, types, evaluation. Function definitions in Haskell scripts, interactive sessions. Mathematical functions as programs, function application as program execution; lists for sequencing, and function composition as a program structuring tool.
  • Strong typing. Basic types, constructed types (sums and products); constructors, selectors, and discriminators; definitions by pattern matching. Parametric polymorphism, type classes and ad-hoc polymorphism; recursive types. Lists, finite and infinite lists; list comprehensions, standard list functions including map, filter, concat.
  • Evaluation as computation, evaluation order; recursive definitions, non-termination and an outline of the idea of computability. Sorting as an example; the concept of efficiency of evaluation, and the asymptotic complexity of a calculation.
  • Sudoku solver as an example; the idea of infeasibly inefficient algorithms.
  • Proofs by induction. The take lemma, induction on finite lists, induction on infinite lists. The notion of chain completeness.
  • Folds on data structures. Left- and right- folds on lists.  Fold fusion.  Standard functions as instances of folds. Scans as folds. Unfolds. Writing programs by solving equations for unknown functions.
  • Efficiency improvement techniques involving accumulating parameters. Associativity and the relationship between left- and right-folds. Log time exponentiation.
  • Countdown as an example. Abstract syntax trees. Tabulation and dynamic programming.
  • Parsers as an example. The idea of parser combinators, as an introduction to monads. The do notation.


Principles of functional programming: expressions, evaluations, functions, and types. Type definitions and built-in types: numbers, characters, strings and lists. Basic operations on lists, including map, fold and filter, together with their algebraic properties. Recursive definitions and structural induction. Simple program calculation. Infinite lists and their uses. Further data structures: binary trees, general trees. Use of trees for representing sets and symbolic data. Normal order reduction and lazy evaluation. Simple cost models for functional programs; time and space complexity.

Reading list

Course text:

Either of

  • Richard Bird, Introduction to Functional Programming using Haskell, second edition, Prentice-Hall International, 1998.
  • Graham Hutton, Programming in Haskell (2nd edition), Cambridge University Press, 2016.

Additional Reading:

  • Richard Bird, Thinking Functionally With Haskell, Cambridge University Press, October 2014.
  • Bryan O'Sullivan, Don Stewart, and John Goerzen, Real World Haskell, O'Reilly Media, 2008.
  • Miran Lipovača, Learn You a Haskell for Great Good! A Beginner's Guide, No Starch Press, 2011.
  • Simon Thompson, Haskell: The Craft of Functional Programming, Addison-Wesley, 1996.
  • Paul Hudak, The Haskell School of Expression, Cambridge University Press, 2000.
  • Paul Chiusano and Rúnar Bjarnason, Functional Programming in Scala. Manning Publications Co., 2014.
  • The Haskell standard Prelude