Fast Track to Haskell

2 days

A course targetting developers with knowledge in any programming language, but with no or just limited knowledge of Haskell. The course covers all the basics of the Haskell language, the Haskell type system, and the core libraries. The course does not merely show language features, but emphasizes the philosophy of Haskell and functional programming as well. It shows how programmers can use the type system to work for them and let it guide them in writing their programs, and it demonstrates how to systematically structure code (both with and without side-effects) in a language like Haskell.

Haskell being the prime example of a well-designed purely functional programming language, this course is also excellent for people who are generally interested in functional programming, but want to apply concepts of functional programming in other languages such as for example Scala or F#.

This course is designed such that it covers all the presequisites of the other courses, and can therefore be combined with other courses.


Day 1

A Quick Tour of Haskell

  • An overview of all important Haskell concepts

Type-directed Programming

  • Pattern matching and function definitions
  • Basic datatypes: lists, Bool, tuples, Maybe
  • Defining new datatypes
  • Haskell syntax

Polymorphism and higher-order functions

  • Parametric polymorphism
  • Overloading and type classes
  • Basic type classes: Eq, Ord, Show, Read
  • Numeric types and classes
  • Higher-order functions: filter, map, …
  • Composing functions
  • Abstracting from design patterns: foldr, foldl, …
  • The Functor class
  • Haskell module system
  • Finite maps and sets

Day 2


  • How to model side effects in Haskell
  • The IO type
  • Composing IO actions
  • How to separate IO code from “pure” code
  • do notation
  • IO-based libraries (random numbers, file IO, …)
  • Derived high-level IO functions

Testing (if time permits)

  • QuickCheck, a library for testing in Haskell
  • Properties as Haskell functions
  • Random test-case generation
  • How to debug code using QuickCheck
  • How QuickCheck works internally
  • Advanced ways to define properties
  • How to tweak test-case generation
  • The HPC (Haskell Program Coverage) tool


  • Abstracting from common patterns
  • How Maybe-based code can be simplified
  • How explicit state passing can be modelled
  • The Monad class
  • More monad examples
  • IO as a monad
  • Library functions on monads


The base price of this course is GBP 3000 (single lecturer) or GBP 4500 (two lecturers). The base price excludes VAT and any other applicable taxes as well as travel costs which depend on the location of the course venue.

We generally recommend two lecturers, as it will allow a better ratio between lecturers and participants during the exercises, and will thereby encourage particpants to ask more questions. We strongly encourage to use two lecturers if there are more than five participants.

We offer on-site consulting in combination with on-site courses at a reduced daily rate.

If you are interested in this course, or for more information, please e-mail us with as many details as possible.

Why Well-Typed

Our teachers have more than a decade of experience with Haskell, functional programming, compiler design, and related areas. They have been training people at all experience levels, both in academia and in industry.

The insight they brought about how to think in Haskell was great and something that would be very difficult to get from a book or online.

— Anonymous