Advanced Functional Programming in Haskell
This page is based off the teachings of Professor Graham Hutton, University of Nottingham. He has approved the creation of this page and usage of his resources.
Last updated
This page is based off the teachings of Professor Graham Hutton, University of Nottingham. He has approved the creation of this page and usage of his resources.
Last updated
This is an advanced course on functional programming in Haskell. It is designed for second year computing students in Nottingham, but the lectures are also made available on .
The course is based on part II of . It is recommended for following the course, to purchase the below textbook, watch the youtube videos, slides are provided below to follow along, and then to try out to programming examples with resources below as well. All resources and links are provided at the bottom of the page. All credit goes to the , University of Nottingham
The course expands beyond the basics into advanced patterns, type classes, and program reasoning. Key lectures include:
Course Overview 2–4. Sudoku Solver Series – Building and optimizing a Sudoku solver in Haskell 5–6. Functors & Applicative Functors 7–10. Monads – From basic introduction to generic laws and use cases (Maybe, List, State) 11–12. Program Reasoning & Induction 13–15. Performance & Compiler Correctness – Techniques like fast reverse/flatten and verifying compiler behavior
Plus: YouTube playlists, overview slides, Sudoku solver code, and full standard prelude reference
Use it as your central hub for videos, slides, and example code.
Watch in order—each builds on the previous one:
Lectures 2–4: Code a Sudoku solver from scratch, iteratively improving performance
Lectures 5–10: Deep dive into functors, applicatives, and monads—including real-world monad usage in Haskell
Lectures 11–12: Learn how to formally reason and prove properties about functional programs
Lectures 13–15: Tackle efficiency (e.g., removing append overhead) and understand compiler verification
Highly aligns with the course. Reading alongside lectures reinforces:
Category-theoretic intuition behind functors/applicatives/monads
Inductive proofs and reasoning
Lazy evaluation optimizations
Download and run the Sudoku solver code provided
Tinker with functor/applicative/monad instances—maybe create a small parsing program or build a custom monad
Implement the "fast reverse" or "fast flatten" strategies using difference lists
Walk through the compiler correctness lecture by experimenting with simple interpreters or compiling toy expressions
Use induction and reasoning techniques shown in lectures 11–12 to validate your programs
Explore equational reasoning (e.g., proving map fusion or monad laws)
Editor – VS Code with Haskell extensions, or your preferred Haskell IDE
Hoogle – invaluable for searching type signatures and library functions
YouTube – study at your pace; pause and rewind where needed
Type everything by hand even if slides include code
Pause frequently during monad sections—these can be non-trivial
When reasoning, write proofs step-by-step in your notes or code comments
Use Git to version control your solutions (especially for the Sudoku solver or monad experiments)
Advanced topics you’ll be ready for next:
Category theory applied to Haskell (e.g., Profunctors, Arrows)
Concurrency and streaming libraries (e.g. Conduit, STM)
Formal verification tools (e.g., Liquid Haskell, Agda)
Additional material:
GHC – install via
()
(internal version of this page)
(for all things Haskell)
(the Glasgow Haskell Compiler)
(for searching the libraries)
