From Haskell in Depth by Vitaly Bragilevsky

In this article we’ll discuss several type classes that originated in mathematics (mainly abstract algebra and category theory).

Take 40% off Haskell in Depth by entering fccbragilevsky into the discount code box at checkout at

Unfortunately, there’s a long tradition of difficulty in grasping Haskell’s type classes, which can be partially attributed to the fact that Haskell’s creators kept the mathematical names for these type classes and created a myth that you have to know the math behind them in order to work with the corresponding concepts effectively. I strongly believe that the opposite is true: many programming languages have adopted what was thought of as mathematical ideas and transformed them into purely technical stuff that can be exploited without any fear. In Haskell, we have to stick with the somewhat scary names, but a little technical intuition helps you use these type classes for practical needs.

I recommend reading the Typeclassopedia by Brent Yorgey as a brilliant introduction to type classes for abstracting computations for the mathematically inclined.

Keep in mind that almost every Haskell type class provides you with some generalization across concrete types. Sometimes the same methods are used with values of different types in the same way thanks to type classes. We’ll do the same in this article; the only new thing is that we’ll generalize computations over values of various types. The type classes I’m going to discuss here are presented in Figure 1, where solid arrows represent extending type classes.

Figure 1. Type classes for abstracting computations

As seen in the figure, three groups of type classes stand out:

  • Operation—For abstracting binary operations (combining two values into one of the same type)
  • Computational context—For computing the value of some type in a context, and that computation can be accompanied by some effects
  • Iteration—For repeated computations over some structure, potentially collecting the results in a context

We’ll discuss some aspects of these abstract descriptions and use practical examples.

The only operation, (<>)

When using these two type classes, Semigroup and Monoid, keep one simple rule in mind— provide a generic binary operation over the values of any datatype that defines their instances. The type class Semigroup declares such an operation as:

 (<>) :: Semigroup a => a -> a -> a

Many things can be combined with it. For example:

 ghci> import Data.Semigroup ghci> [1,2,3] <> [4,5,6] [1,2,3,4,5,6] ghci> "Hello " <> "world" "Hello world" ghci> Sum 2 <> Sum 3 Sum {getSum = 5} ghci> Product 2 <> Product 3 Product {getProduct = 6}

Remember that a String is a synonym for a list of Char, and the first two examples share an instance for lists (and this operation is only list concatenation). The third and fourth examples here apply instances which represent addition and multiplication—two basic operations over numeric types. They feature newtype wrappers Sum and Product for any type a with an instance of Num a.

The type class Monoid adds another method:

 mempty :: Monoid a => a

which returns a neutral element:

 ghci> mempty :: [Int] [] ghci> mempty :: String ""
 ghci> mempty :: Sum Int Sum {getSum = 0}
 ghci> mempty :: Product Int
 Product {getProduct = 1}

This element is called neutral because it’s expected to satisfy monoid laws, and for any element a:

 mempty <> a == a a <> mempty == a

The empty list, an empty String, and the numbers Sum 0 and Product 1 satisfy these rules with respect to the corresponding operation.

In general, you’d want to use the operation (<>) to accumulate information, like in concatenating lists and other containers (Data.Set or Data.Sequence to name a few), combining configuration properties, and such things. When you encounter a new datatype it’s always a good idea to look for provided instances. If you see instances for Semigroup or

Monoid, then you know that values of this datatype can be combined with (<>). For example:

 ghci> import Data.Text ghci> :info Text data Text instance Monoid Text -- Defined in 'Data.Text' instance Semigroup Text -- Defined in 'Data.Text'

The presence of these instances makes the following possible:

 ghci> :set -XOverloadedStrings ghci> h = "hello" :: Text ghci> c = ", " :: Text ghci> w = ", world" :: Text ghci> h <> c <> w "hello, world"

Other methods in Semigroup and Monoid call binary operations several times:

 sconcat :: Semigroup a => Data.List.NonEmpty.NonEmpty a -> a mconcat :: Monoid a => [a] -> a

Note the type Data.List.NonEmpty.NonEmpty in the type signature of sconcat: we have to use it here because sconcat has no idea what to return when given an empty list. Thankfully, the type signature prevents us from running it with an empty list as an argument. The value of the NonEmpty type must have a head with a potentially empty tail.

You can construct such a list with the operation (:|) as follows:

 ghci> 0 :| [1,2,3] 0 :| [1,2,3] ghci> "x" :| [] "x" :| []

The function sconcat takes a nonempty list and applies (<>) several times, accumulating a total value. For example:

 ghci> sconcat ("x" :| ["y", "z"]) "xyz"

The function mconcat does the same thing without this limitation, because it can return mempty whenever it’s given an empty list as an argument.

The definitions of the type classes Semigroup and Monoid are works in progress. Some time ago we only had Monoid; then Semigroup was added, but at that time there were no direct connections between these two classes. In GHC version 8.4 Semigroup became a superclass of Monoid. If you look at their definitions chances are you’ll see traces of their history, such as the method mappend, which is the same as (<>). This mappend method is expected to be removed from the Monoid type class at some time in the future. You can read full details about this plan here:

Mapping, applying, and sequencing in a computational context

Let’s pick apart the title of this subsection. Merriam–Webster gives the following definition of context: the interrelated conditions in which something exists or occurs

Computational context means these interrelated conditions occurred during the process of computation. In Haskell, you can use many different computational contexts: some of them allow you to have side effects, such as input/output (IO) or mutable variables (State, ST), and others support the idea of computation with the potential absence of a result (Maybe, Either) or with the possibility of storing some additional information along with the computation (Writer). You probably came across some of them when you started learning Haskell.

All these contexts share on abstract behavior by allowing you to map, apply, and sequence over them. This behavior is defined by three type classes with fancy names:

  • Functor abstracts mapping over some value in a computational context.
  • Applicative enables applying a function in a context to a value in a context and injecting value into a context.
  • Monad allows sequencing of computations in a context to structure what’s done in the next computation depends on the result of the previous one.

This wording is a textual representation of the type signatures for the following methods:

 fmap :: Functor f => (a -> b) -> f a -> f b pure :: Applicative f => a -> f a (<*>) :: Applicative f => f (a -> b) -> f a -> f b
 (>>=) :: Monad m => m a -> (a -> m b) -> m b

Although these three type classes define other methods as well (you can explore them with the :info GHCi command), these are the most crucial for understanding what’s going on here. We often refer to contexts as functorial, applicative, or monadic if there exists a corresponding instance and we want to specify a particular property.

The words value in a context relate to the type signatures f a or m a, where a is a type of a value (the result of a computation) and f or m restricts the context. In the same way, f (a → b) is a function in a context. Take a look also at the second argument in the type signature of (>>=), (a → m b)—this is what’s meant by “the next computation depends on the result of the previous one” (we call it a monadic function). Some call monads “programmable semicolon” for this reason.

When you look at the particular contexts these methods are concretized and sometimes look quite different, but all of them implement the same ideas of mapping, applying, and sequencing.

You can find many introductory materials on these three type classes—the Typeclassopedia includes many links, and Unit 5 of Get Programming with Haskell by Will Kurt (Manning) describes them in great detail in a practical way—and I won’t attempt to repeat them. Instead, I’ll give you examples of three different contexts and operations over values in them, to make sure that we’re on the same page.

Exploring different contexts in parallel

The type classes we’re talking about share common ideas about behavior. It’s always instructive to go both ways, from common ideas to specific implementations and vice versa. In this subsection you’re advised to follow the path of understanding from particular examples toward general notions. We’ll focus on these three contexts:

  • IO, which allows you to do input/output
  • Writer, which supports logging of additional information along with the process of computations (you can get access to this context after importing the module Control.Monad.Writer)
  • [] (a list), which is the most unusual context of nondeterministic computations

First, let’s look at a few examples of what a value in a context is:

  • getLine :: IO String is a value of type String in a context which is responsible for acquiring it from a side effect of reading user input.
  • writer (42, "step 1\n") :: Writer String Int is a value 42 of type Int which is accompanied by the log "step 1\n" in the form of a String.
  • [1,2,3] :: [Int] is one of the values 1, 2, or 3 of type Int, but we aren’t sure which one is the result of the computations (this uncertainty is what I call nondeterminism).

Now let’s check the mapping using the method fmap from the Functor type class:

 ghci> fmap (++"!") getLine Hi

The second line, Hi, is the user input, which becomes a value in a context during execution, and the last line is a result of mapping (++"!") over that result.

What about Writer? Take a look:

 ghci> fmap (+1) (writer (42, "step 1\n")) :: Writer String Int WriterT (Identity (43,"step 1\n"))

Apart from the output mess with WriterT and Identity, you can clearly see the new value 43 (the result of mapping (+1) over 42) in an unaltered context—the log doesn’t change. As for the third context:

 ghci> fmap (+1) [1,2,3] [2,3,4]

We have one of the values 2, 3, or 4, each of them being a potential result of nondeterministic mapping of (+1) over 1, 2, or 3. Clearly it’s an ordinary map for lists.

In the next step we’d like to look at these contexts in an applicative setting, to try to see any similarities:

 ghci> pure (++) <*> getLine <*> getLine hello world "helloworld"
 ghci> pure (+) <*> writer (42, "step 1\n") <*> writer (10, "step 2\n") :: Writer String Int WriterT (Identity (52,"step 1\nstep 2\n")) ghci> pure (+) <*> [1,2,3] <*> [4,5,6]

We have a two-argument function which is injected into the context and then applied to two values in a context, and we can clearly see the results of applying "helloworld", 52, or one of the values in the list [5,6,7,6,7,8,7,8,9]. We can also see that the context does its job by getting two user inputs, combining logs, and exploiting nondeterminism (we had three potential results in the first value in a context and three potential results in the second value in a context, and we got nine (=3*3) of them finally).

Let’s look at (>>=), called “bind” for our last example here:

 ghci> getLine >>= putStrLn hello hello
 ghci> writer (42, "step 1\n") >>= (\a -> writer (a+1, "step 2\n"))  :: Writer String Int WriterT (Identity (43,"step 1\nstep 2\n")) ghci> [1,2] >>= (\x -> [x-1, x, x+1])

Try to work out for yourself what’s done here with the result of the first computation and how the contexts reveal themselves. Don’t forget to check the type of (>>=) before you start thinking.

do notation

do notation is a convenient syntactic mechanism for expressing monadic computations, which includes:

  • Sequencing of operations by writing them one after another (as in imperative programming languages)
  • Binding values in a context to names with
  • Constructing succeeding operations with the names bound previously (this is the main feature of the Monad type class)

For example, the following code:

 action t = do   a <- f t
   b <- g a
   h a
   return (k a b)

is de-sugared into:

 action t =   f t >>= \a ->
 a >>= \b ->
 a >>
   return (k a b)

which is effectively

 action t = f t >>= \a -> g a >>= \b -> h a >> return (k a b)

Linearized definitions like this one are almost impossible to read and inconvenient to write; do notation helps a lot.

Note that you can use do notation in any monadic context. For example, the following three fragments are absolutely legitimate. The first context is IO:

 readNumber :: IO Int readNumber = do   s <- getLine
   return (read s)

The second is Writer, where we recursively compute the sum of numbers from 0 to n and log all intermediate arguments (logging is done via the auxiliary function tell from Control.Monad.Writer):

 sumN :: Int -> Writer String Int sumN 0 = writer (0, "finish") sumN n = do   tell (show n ++ ",")
   s <- sumN (n-1)
   return (n + s)

Running this function in the GHCi gives:

 ghci> sumN 5 WriterT (Identity (15,"5,4,3,2,1,finish"))

You can see here that the computations resulted in the number 15, and a full log is also provided.

Some monads support runners, functions that provide unwrapped results. In the case of Writer we’ve the runWriter function, which returns a pair (result, log):

 ghci> runWriter (sumN 5) (15,"5,4,3,2,1,finish")

The third context is a list:

 cartesianProduct  :: [Int] -> [Int] -> [(Int, Int)] cartesianProduct xs ys = do   x <- xs
   y <- ys
   return (x, y)

We can apply the function cartesianProduct to some lists and see the results in the following GHCi session:

 ghci> cartesianProduct [1..2] [1..3] [(1,1),(1,2),(1,3),(2,1),(2,2),(2,3)]

Every do-block corresponds to exactly one monadic context, it’s instructive to understand which Monad you work in every moment as the observable results crucially depend on that. It’s a common mistake to expect something which isn’t handled by the context in use.

do notation is de-sugared into the following monadic operations:

 (>>=) :: Monad m => m a -> (a -> m b) -> m b
 (>>) :: Monad m => m a -> m b -> m b

where the last operation, (>>), is a simplified version of (>>=) without dependency on the result of the previous computation. You can find details about desugaring do notation in the Typeclassopedia ( and many other sources.

Folding and traversing

The last two classes in the Figure 2.7 are Foldable and Traversable—both of them capture the idea of processing a container, a collection of values, with different possibilities.

Any Foldable instance should implement one of the following methods:

 class Foldable (t :: * -> *) where   foldMap :: Monoid m => (a -> m) -> t a -> m
   foldr :: (a -> b -> b) -> b -> t a -> b   ...

Both of them should iterate over t a, a container t with elements of type a, process every element and combine all the results. Foldable contains sixteen methods. About half of them are various sorts of folding, namely processing container elements using specific operations; others include length, elem, and maximum. All of these were once list methods that were later generalized to support other containers too.

The type class Traversable is both simpler (it has only four methods, and two of them repeat the other two in a richer context, existing only for historical reasons) and more complex due to combining the effects of Functor, Applicative, Monad, and Foldable. This is the definition of Traversable:

 class (Functor t, Foldable t) => Traversable (t :: * -> *) where   traverse :: Applicative f => (a -> f b) -> t a -> f (t b)
   sequenceA :: Applicative f => t (f a) -> f (t a)
   mapM :: Monad m => (a -> m b) -> t a -> m (t b)
   sequence :: Monad m => t (m a) -> m (t a)
   {-# MINIMAL traverse | sequenceA #-}

The method traverse goes over every element in a container (the second argument) and applies its first argument to an element effectively, as in Applicative f. Due to constraints to t and f, the actions performed in traverse greatly depend on the particular instances, and it’s hard to talk about it in general.

Let’s look at a simple example. From the type signature of the method traverse we can see that it requires two arguments: a function a → f b returning a value in an applicative context and a container t a of elements of type a. Let’s take a list of Int values as a container and IO as an applicative context. Then we need some function returning a value in IO—for example:

 addNumber :: Int -> IO String
 addNumber n = pure (++) <*> pure (show n ++ " ")  <*> getLine

This function’s type is compatible with traverse: it takes a number, turns it into a String, and concatenates it with the line from the user input. Now we’re ready to see traverse in action:

 ghci> traverse addNumber [1..5] aaa bbb ccc ddd eee
 ["1 aaa","2 bbb","3 ccc","4 ddd","5 eee"]

Here, I’ve entered five lines and then numbered them. It’s always useful to check the types:

 ghci> :t traverse addNumber [1..5] traverse addNumber [1..5] :: IO [String]

We’ve a list of String in the context of IO and this particular call to traverse has the type:

    (a   -> f  b)      -> t a   -> f  (t b)
    (Int -> IO String) -> [Int] -> IO [String]

The module Data.Foldable provides traverse_, a function similar to traverse which doesn’t collect results of the individual computations:

 traverse_  :: (Applicative f, Foldable t) => (a -> f b) -> t a -> f ()

Always follow the types; they help you a lot in understanding abstract functions. Try to use the same approach for sequenceA: choose any container (take a list as the simplest one; Maybe works too) and any applicative context (try Writer!) and then construct a call to sequenceA. You’ll definitely see what’s going on there.

Writing code with respect to Foldable and Traversable, as opposed to relying on a specific container or data structure, allows you to change the container whenever you like.

As a result, you can improve the efficiency of your code without rewriting it.

If you want to see more, check out the book on Manning’s liveBook platform here.