Monad Transformers

This chapter shows how the functionality of different monads can be combined into a single monad. Creating such combinations is relatively straightforward for applicative functors. We have seen that two different constructions can be used for this purpose – products and compositions. Unfortunately, neither works for monads. The product of two monads is not a monad and the composition of two monads is not a monad.

For the first few years of Haskell’s existence, there was no other way to create custom monads with combined effects than to write them from scratch. This involved a lot of boilerplate and required substantial expertise. Hence, researchers have long sought a way to make it possible to combine existing monads. This would avoid the boilerplate and make custom monads more widely accessible.

Eventually, an out-of-the-box solution was found: monad transformers. The idea is no longer to combine monads but rather to transform an existing monad...

Combining monadic effects

Before we solve the problem of combining different monadic effects in the standard Haskell way, let’s illustrate the problem on a small example application. We’ll also discuss the solution of writing a custom monad, which seems the most obvious but is not a best practice.

Logging revisited

Let’s make the logging functionality from the previous chapter a bit more sophisticated by adding several requirements. Recall that previously, we used the Writer [String] monad for logging. To accommodate the new requirements, we will have to come up with a custom monad, which we’ll call App.

These are the requirements:

We want to distinguish different levels of importance for the logged messages:

data LogLevel = Mundane | Important | Critical
  deriving (Eq, Ord, Show)

When we record a message in the log, we have to supply the logging level:
```
log :: LogLevel -> String -> App ()
```
It is convenient to set up a few...

Monad transformers

While two monads cannot be combined easily to form a third monad, there is a different mechanism, called monad transformers, that allows us to augment an existing monad with additional functionality.

The Reader transformer

As a first example of a (monad) transformer, we will visit the monad transformer, which adds the reading effect to an existing monad. This transformer is represented as follows:

Control.Monad.Trans.Reader
newtype ReaderT r m a = ReaderT { runReaderT :: r -> m a }
  deriving Functor

As we can see, this looks a lot like the definition of Reader r a from the previous chapter. The main difference is that it takes an additional type parameter, m, for the monad that is being augmented. For example, we would use this as ReaderT Config (Writer Log) to augment the Writer Log monad with an implicit environment. That would give us our first App representation. Similarly, we get the second App representation by transforming IO into...

Other monad transformers

With the notable exception of the IO monad, which is a special case because it is built into the language, most other monads have a corresponding monad transformer. As they mostly follow the same approach as ReaderT, we’ll only review them briefly.

The StateT and WriterT transformers

The transformers for the state and writer effects have the closest resemblance to ReaderT:

Control.Monad.Trans.State
newtype StateT s m a = StateT { runStateT :: s -> m (a, s) }
Control.Monad.Trans.Writer
newtype WriterT w m a = WriterT { runWriterT :: m (a, w) }

As monad transformers, they have appropriate Monad instances:

Control.Monad.Trans.State
instance Monad m => Monad (StateT s m)
Control.Monad.Trans.Writer
instance (Monad m, Monoid w) => Monad (WriterT w m)

We haven’t shown the implementation because it is very similar to the ones for State s and Writer w from the previous chapter. Instead, we will show the full MonadTrans instances...

Monad subclasses

The six monad transformers, together with an appropriate base monad such as Identity or IO, allow us to put together a large number of different monads. Given the many choices for the monad that’s used by an application, we often do not want to fix the monad up front:

We may not have a full overview of the effects that are required by the application before we start writing parts of it
We may want to reuse different programs or parts of programs with different monads
We may want to quickly adapt an existing program to additional requirements, which may entail incorporating additional effects

To support these and similar scenarios, Haskell programmers can make use of type classes to abstract over the particular monad being used while still imposing requirements on it. These type classes are known as Monad subclasses, and there is one for each effect.

The MonadReader type class

Our first Monad subclass is for the reader effect:

...

Monad transformer gotchas

There are two aspects of monad transformers that you will run into sooner or later. I will share them here so that you’ll be prepared.

Effect interaction

When stacking different two monad transformers, T1 and T2, to combine two effects, you have a choice. Do you use T1 (T2 Identity) or T2 (T1 Identity)? Does it matter which one you choose?

In some cases, it doesn’t matter. For instance, in our earlier example of logging with levels, we combined the reader and writer effects, like so:

type App = ReaderT Config (Writer Log)

Recall that, because Writer w is defined as WriterT w Identity, this comes down to the following:

type App = ReaderT Config (WriterT Log Identity)

However, we could also have written the following:

type App = WriterT Log (ReaderT Config Identity)

As we have only interacted with this monad through the overloaded ask and tell operations, the only thing we need to change is the implementation of runApp:

...

Summary

In this chapter, we studied how custom monads, which combine several effects, can be assembled using monad transformers. These transformers augment a monad with the specified functionality, typically of an additional effect.

Chapter 13, Domain-Specific Languages, starts the final part of this book. We will move on from studying Haskell’s hierarchy of type constructor classes and focus our attention on application-oriented aspects. The first topic, which we studied in this chapter, is a language-oriented approach to problem-solving. By creating a new language tailored to a particular problem domain, we can more easily solve problems in that domain.

Questions

Answer the following questions to test your knowledge of this chapter:

What is a monad transformer?
What are the important monad transformers?
What is a monad subclass?
What are the important monad subclasses?

Answers

Here are the answers to this chapter’s questions:

A monad transformer is a type constructor, T, that transforms any monad, M, into a new monad, T M. Moreover, T must be an instance of the MonadTrans type class:
```
class MonadTrans t where
        lift :: Monad m => m a -> t m a
```
Monad transformers are typically used to augment existing monad with the functionality of an additional effect.
The important monad transformers are:

...

The rest of the chapter is locked

You have been reading a chapter from

Soar with Haskell

Published in: Dec 2023 Publisher: Packt ISBN-13: 9781805128458

Register for a free Packt account to unlock a world of extra content!

A free Packt account unlocks extra newsletters, articles, discounted offers, and much more. Start advancing your knowledge today.

Sign up now

Unlock this book and the full library FREE for 7 days

Get unlimited access to 7000+ expert-authored eBooks and videos courses covering every tech area you can think of

Start free trial

Renews at €14.99/month. Cancel anytime}

Authors (1)

Tom Schrijvers

Tom Schrijvers is a professor of computer science at KU Leuven in Belgium since 2014, and previously from 2011 until 2014 at Ghent University in Belgium. He has over 20 years of research experience in programming languages and has co-authored more than 100 scientific papers. Much of his research focuses on functional programming and on the Haskell programming language in particular: he has made many contributions to the language, its ecosystem and applications, and chaired academic events like the Haskell Symposium. At the same time, he has more than a decade of teaching experience (including functional programming with Haskell) and received several teaching awards.

Personalised recommendations for you

Based on your interests and search pattern

C++ Programming for Linux Systems

This book covers the essential system programming tools and helps you explore the features of C++20. It emphasizes important details to maintain code quality and tackle everyday challenges of developing software for high performance, optimization, and more.

Sep 2023 9 hours 36 minutes

Expert C++

Discover advanced programming techniques, the latest features of C++17 and C++20, and best practices for memory management, debugging, testing, and large-scale application design with Expert C++. Ideal for experienced developers advancing to proficient programmers and building professional-grade C++ applications.

Aug 2023 20 hours 8 minutes

iOS 17 Programming for Beginners

iOS 17 Programming for Beginners, Eighth Edition is your comprehensive guide to learning the art of iOS app development. Whether you dream of creating the next chart-topping app or simply want to enhance your programming skills, this book is your trusted companion on this exciting journey.

Oct 2023 20 hours 8 minutes

Developer Career Masterplan

Written by industry experts that have spent the last 20+ years helping developers grow their career path towards senior developer positions and beyond. This book provides a comprehensive guide, sharing examples and stories from their global careers. By the end, you’ll have the knowledge to create a clear career progression plan as a technical professional.

Sep 2023 10 hours 20 minutes

Refactoring with C#

In Refactoring with C#, you’ll explore the process of safely refactoring modern .NET code using Visual Studio features, advanced unit tests, AI assistance, and custom Roslyn analyzers.

Nov 2023 14 hours 28 minutes

Python Real-World Projects

Amplify your developer journey by curating a dynamic project portfolio that outshines traditional resumes. Delve into the Python realm through immersive projects, mastering core concepts while constructing comprehensive modules and applications. From data acquisition prowess to impactful data visualization, Python Real-World Projects arms you with essential skills to beat the competition.

Sep 2023 15 hours 56 minutes

The MVVM Pattern in .NET MAUI

The MVVM Pattern in .NET MAUI enables developers to master MVVM principles and effectively apply them to .NET MAUI. This book uses real-life examples and covers complex problems to help you successfully apply MVVM with .NET MAUI to confidently develop robust and high-performing cross-platform apps.

Nov 2023 12 hours 52 minutes

Extending Microsoft Business Central with Power Platform

Extending Business Central with the Power Platform is a step-by-step guide for Business Central professionals to create solutions that automate business processes, explain complex workflow approvals, and integrate with hundreds of other systems, without traditional development. It’ll guide you in customizing Business Central with Power Platform.

Aug 2023 15 hours 16 minutes