Thinking about Haskell?
Whether you're just beginning, or ready to put principles into practice, we're your guide.

Using Nix as a Makefile

One of our first video series was about how we run Type Classes on Amazon EC2 using NixOS. We’re starting to expand our Nix content a bit more now, with some introductory discussion of what Nix is, and a comparison between a Nix file and a Makefile which if you’re familiar with Make will help convey what you might use Nix for.

Haskell art: the Julia set

You may have noticed some recent colorful additions to our page headers, such as on the Validation and Web servers courses. More than mere decorations, these are also Haskell demonstrations! We have discussions of how they were generated in our Art section. Today we’ve added a page on the Julia set that you see at the top of our home page, produced using the fractal-hs package.


The reference series on algebras that began with Semigroup has escalated to Semiring. We’ve given the semiring page an extensive update that includes a more in-depth discussion of tropical semirings and some useful thoughts on why you might care about the semiring of types.

Python data classes and Haskell records

This Python lesson discusses a decorator called dataclass. The primary role of a Python data class is to simply hold the values that were passed as constructor arguments. This feature strongly resembles Haskell datatypes, particularly when we use Haskell’s record syntax.

A spoonful of Enum

We’re writing the Python course in a slightly different style from most of Type Classes, because it is aimed at a more focused audience. The idea is that if you are already familiar with Python, then we want to leverage as much of your existing Python knowledge as possible as you learn Haskell. For example, we’re not including quite as many type signatures in our explanations as we normally would, and we defer the introduction of some aspects of Haskell to minimize the amount of patience required if you just want to answers to questions of the form ‘I know how to do this thing in Python; how do I do it in Haskell?’ This post is about one particular small choice regarding range syntax.

The zip function in Python and Haskell

The latest Python lesson is all about zipping, a notion also sometimes referred to as aligning. We discuss three Python functions: zip, zip_longest, and enumerate. The Haskell translations of the examples involve the these package, which we’ve discussed previously in Functortown.


Courses are series about a particular topic meant to be watched in order. Some will be more theory-and-fundamentals oriented, while some will focus on building a project. Each course has clearly identified prerequisites and goals, to help you choose which courses are right for you.

Web Servers, at a low level
6 videos; 49 minutes
This course starts by discussing what HTTP and web servers are and follows the HTTP specification in building a Haskell web server from scratch. This includes explaining different character encodings and the differences between the Haskell Text and ByteString types.
This course will be a complete survey of functors, addressing such issues as what functors are in general and how the different functors are related to each other. It will be a long course, spending 3-5 lessons on each typeclass, and cover Functor, Bifunctor, Applicative, Traversable, Monad, Contravariant, and Profunctor, with motivating examples and discussions of what each is good for, the laws governing each, and how to property test instances.
Explore native GUI programming in Haskell! This course is all about making native clock applications. We’re starting off the course by alternating between Julie using fltkhs and Chris using gtk3. Each lesson explains aspects of the library, illuminates important Haskell concepts such as concurrency primitives and implicit parameters, and gives you some basis for comparing libraries for your own native GUI application projects.
The Validation Course
9 videos; 150 minutes
Starting from basic conditional statements and pattern matching, we build a suite of functions to validate user inputs, refactoring along the way to see what benefits using Maybe, Either, and Validation types brings, as well as using newtype to differentiate inputs. We also demonstrate the difference between Applicative and Monad.
NixOS on AWS
5 videos; 36 minutes
Writing a script with Turtle to launch/update an EC2 instance


Each article explains a single, sometimes small, Haskell topic in detail. Some articles include video. Haskell reference pages supplement, but are independent of, the courses and projects. Haskellers of any level will find them useful as reference.

Transformers and deriving
We walk through a common use case for ReaderT from the transformers library and use it to illustrate type aliases, newtypes, and various approaches for typeclass deriving, using the GeneralizedNewtypeDeriving and DerivingVia GHC extensions.
Thread concepts
Concurrency is a great strength of Haskell’s, in part thanks to the runtime system which provides lightweight threads. You can also create OS threads (called “bound” threads), which is sometimes needed for FFI.
Primitives, levity, and boxing
GHC makes it possible to access a lot of internals that most programming languages would hide away entirely. Rarely do you need them, but we get curious when we hear people talk about primitive, lifted, and boxed types.
Compile-time evaluation
A straightforward common application of the often-daunting Template Haskell: How to make constant expressions evaluate during compilation to avoid one source of runtime errors.
Understanding contravariance
23-minute video
Contravariant functors can seem difficult to approach, but in this article, we look at them as a variation on a familiar theme: function composition.
Understanding profunctors
Once you’ve understood contravariant functors, you are so ready for profunctors! Profunctors extend and generalize the concept of a functor, but under the hood, they’re still made of function composition.
Introduction to GHC language extensions
GHC Haskell has a lot of language extensions, ranging from very simple syntactic extensions to very complex type drama. This article helps you understand what extensions are, how to use them, and which ones are especially useful as your first extensions.
Type applications
7-minute video
One of the first language extensions we recommend for Haskell learners and one we use often while teaching, TypeApplications lets you visibly apply functions to type arguments. We demonstrate several common use cases.
Scoped type variables
9-minute video
Another useful language extension that we recommend for learners and pros alike, ScopedTypeVariables lets you extend the scope of a type variable over a whole function, including its subexpressions.
Overloaded strings
13-minute video
You will certainly run into this language extension often. This opinionated piece explains what it is and why it’s so common as well as when you might not want to use it.
Monomorphism restriction
Sometimes your functions aren’t as polymorphic as you thought they were. This article helps you understand why the monomorphism restriction exists and how to work with it.


Switching to Haskell doesn’t mean you have to start over learning how to code. Our transitions content is geared toward explaining how concepts from other languages relate to Haskell, so you can advantage of what you already know as you get started in Haskell. We focus on Java, JavaScript, and Python.

Operators in JavaScript and Haskell
8-minute video
Transfer your knowledge of JS operator tricks into Haskell
A JavaScript WAT and monoidal folds
We examine a puzzling fact about Math.max() < Math.min() and what it has to do with monoids. This is a two-part article covering Haskell’s folds (compared to JavaScript reduce), monoids, and identity values.
Function decorators in Python
If you like Python decorators, you’ll love higher-order functions. Here we show a direct comparison between decorators in the Flask framework and higher-order functions in scotty, a Haskell web framework.


This section covers topics that aren’t about the Haskell language itself, but about software that helps you be more productive with it.

Viewing type information in GHCi
Master the :type command and never be at a loss for knowledge of types
Typed holes
Get the compiler to help you develop code incrementally
GHCi configuration
Customize your Haskell REPL
Using ghcid
A simple but incredibly convenient tool that shows compile output in real-time as you edit.