Welcome to part 3 of our abstract structures series! This is where we’ll finally start tackling the concept of monads! Many people try to learn monads without having any idea how abstract structure typeclasses works. This is one of the main reasons they struggle! So if you don’t yet understand functors or applicative functors, check out part 1 and part 2 of this series!
By the time you’re done with this article, you’ll be more than ready to actually start writing your own Haskell code! If you’ve never done that before, download our Beginners Checklist to get started!
There are dozens of monad tutorials and descriptions on the internet. The range of analogies in particular is amusing. But here’s my crack at a definition: A Monad wraps a value or a computation with a particular context. A monad must define both a means of wrapping normal values in the context, and a way of combining computations within the context.
This definition is quite broad. So let’s look at a more practical level to try to make sense of this.
The Monad Typeclass
Just like with functors and applicative functors, Haskell represents monads with a type class. It has two functions:
class Monad m where return :: a -> m a (>>=) :: m a -> a -> m b -> m b
These two functions correspond to the two ideas from above. The
return function specifies a how to wrap values in the monad’s context. The
>>= operator, which we call the “bind” function, specifies how to combine two operations within the context. Let’s clarify this further by exploring a few specific monad instances.
The Maybe Monad
Maybe is a functor and an applicative functor, it is also a monad. To motivate the
Maybe monad, let’s consider this code.
maybeFunc1 :: String -> Maybe Int maybeFunc1 “” = Nothing maybeFunc1 str = Just $ length str maybeFunc2 :: Int -> Maybe Float maybeFunc2 i = if i `mod` 2 == 0 then Nothing Else Just ((fromIntegral i) * 3.14159) maybeFunc3 :: Float -> Maybe [Int] maybeFunc3 f = if f > 15.0 then Nothing else $ Just [floor f, ceil f] runMaybeFuncs :: String -> Maybe [Int] runMaybeFuncs input = case maybeFunc1 input of Nothing -> Nothing Just i -> case maybeFunc2 i of Nothing -> Nothing Just f -> maybeFunc3 f
We can see we’re starting to develop a hideous triangle pattern as we continue pattern matching on the results of successive function calls. If we were to add more
Maybe functions onto this, it would keep getting worse. When we consider
Maybe as a monad, we can make the code much cleaner. Let’s take a look at how Haskell implements
Maybe as a monad to see how.
instance Monad Maybe where return = Just Nothing >>= _ = Nothing Just a >>= f = f a
The context the Maybe monad describes is simple. Computations in Maybe can either fail or succeed with a value. We can take any value and wrap it in this context by calling the value a “success”. We do this with the
Just constructor. We represent failure by
We combine computations in this context by examining the result of the first computation. If it succeeded, we takes its value, and pass it to the second computation. If it failed, then we have no value to pass to the next step. So the total computation is a failure. Let’s look at how we can use the bind operator to combine our operations:
runMaybeFuncs :: String -> Maybe [Int] runMaybeFuncs input = maybeFunc1 input >>= maybeFunc2 >>= maybeFunc3
This looks much cleaner! Let’s see why the types work out. The result of
maybeFunc1 input is simply
Maybe Int. Then the bind operator allows us to take this
Maybe Int value and combine it with
maybeFunc2, whose type is
Int -> Maybe Float. The bind operator resolves these to a
Maybe Float. Then we pass this similarly through the bind operator to
maybeFunc3, resulting in our final type,
Your functions will not always combine so cleanly though. This is where
do notation comes into play. We can rewrite the above as:
runMaybeFuncs :: String -> Maybe [Int] runMaybeFuncs input = do i <- maybeFunc1 input f <- maybeFunc2 f maybeFunc3 f
<- operator is special. It effectively unwraps the value on the right-hand side from the monad. This means the value
i has type
Int, even though the result of
Maybe Int. The bind operation happens under the hood. If the function returns
Nothing, then the entire
runMaybeFuncs function will return
At first glance, this looks more complicated than the bind example. However, it gives us a lot more flexibility. Consider if we wanted to add 2 to the integer before calling
maybeFunc2. This is easy to deal with in
do notation, but more difficult when simply using binds:
runMaybeFuncs :: String -> Maybe [Int] runMaybeFuncs input = do i <- maybeFunc1 input f <- maybeFunc2 (i + 2) maybeFunc3 f -- Not so nice runMaybeFuncsBind :: String -> Maybe [Int] runMaybeFuncsBind input = maybeFunc1 input >>= (\i -> maybeFunc2 (i + 2)) >>= maybeFunc3
The gains are even more obvious if we want to use multiple previous results in a function call. Using binds, we would have to continually accumulate arguments in anonymous functions. One note about do notation: we never use
<- to unwrap the final operation in a do-block. Our call to
maybeFunc3 has the type
Maybe [Int]. This is our final type (not
[Int]) so we do not unwrap.
The Either Monad
Now, let’s examine the
Either monad, which is quite similar to the
Maybe monad. Here’s the definition:
instance Monad (Either a) where return r = Right r (Left l) >>= _ = Left l (Right r) >>= f = f r
Maybe either succeeds with a value or fails, the
Either monad attaches information to failures. Just like
Maybe, it wraps values in its context by calling them successful. The monadic behavior also combines operations by short-circuiting on the first failure. Let’s see how we can use this to make our code from above more clear.
maybeFunc1 :: String -> Either String Int maybeFunc1 “” = Left “String cannot be empty!” maybeFunc1 str = Right $ length str maybeFunc2 :: Int -> Either String Float maybeFunc2 i = if i `mod` 2 == 0 then Left “Length cannot be even!” else Right ((fromIntegral i) * 3.14159) maybeFunc3 :: Float -> Either String [Int] maybeFunc3 f = if f > 15.0 then Left “Float is too large!” else $ Right [floor f, ceil f] runMaybeFuncs :: String -> Either String [Int] runMaybeFuncs input = do i <- maybeFunc1 input f <- maybeFunc2 i maybeFunc3 f
Before, every failure just gave us a
>> runMaybeFuncs "" Nothing >> runMaybeFuncs "Hi" Nothing >> runMaybeFuncs "Hithere" Nothing >> runMaybeFuncs "Hit" Just [9,10]
Now when we run our code, we can look at the resulting error string, and this will tell us which function actually failed.
>> runMaybeFuncs "" Left "String cannot be empty!" >> runMaybeFuncs "Hi" Left "Length cannot be even!" >> runMaybeFuncs "Hithere" Left "Float is too large!" >> runMaybeFuncs "Hit" Right [9,10]
Notice we parameterize the
Either monad by the error type. If we have:
maybeFunc2 :: Either CustomError Float …
This function is in a different monad now. It won’t be quite as simple to combine this with our other functions. If you’re curious how we might do this, check out this answer on quora.
The IO Monad
The IO Monad is perhaps the most important monad in Haskell. It is also one of the hardest monads to understand starting out. Its actual implementation is a bit too intricate to discuss when first learning monads. So we’ll learn by example.
The IO monad wraps computations in the following context: “This computation can read information from or write information to the terminal, file system, operating system, and/or network”. If you want to get user input, print a message to the user, read information from a file, or make a network call, you’ll need to do so within the IO Monad. These are “side effects”. We cannot perform them from “pure” Haskell code.
The most important job of pretty much any computer program is to interact with the outside world in some way. For this reason, the root of all executable Haskell code is a function called
main, with the type
IO (). So every program starts in the IO monad. From here you can get any input you need, call into relatively “pure” code with the inputs, and then output the result in some way. The reverse does not work. You cannot call into IO code from pure code, the same way you can call into a
Maybe function from pure code.
Let’s look at a simple program showing a few of the basic IO functions. We’ll use do-notation to illustrate the similarity to the other monads we’ve discussed. We list the types of each IO function for clarity.
main :: IO () main = do -- getLine :: IO String input <- getLIne let uppercased = map Data.Char.toUpper input -- print :: String -> IO () print uppercased
So we see once again each line of our program has type
IO a. (A
let statement can occur in any monad). Just as we could unwrap
i in the maybe example to get an
Int instead of a
Maybe Int, we can use
<- to unwrap the result of
getLine as a
String. We can then manipulate this value using string functions, and pass the result to the
This is a simple echo program. It reads a line from the terminal, and then prints the line back out in all caps. Hopefully it gives you a basic understanding of how IO works. We’ll get into more details in the next couple articles.
At this point, we should finally have a decent grasp on what monads are. But if they don’t make sense yet, don’t fret! It took me a few different tries before I really understood them! Don’t be afraid to take another look at part 1 and part 2 to give yourself a refresher on Haskell structure basics. And definitely feel free to read this article again!
But if you are feeling good, then you’re ready to move on to part 4, where you’ll learn about the
Writer monads. These start to bring us access to some of the functionality you think Haskell might be “missing”.
If you’ve never programmed in Haskell before, hopefully I’ve convinced you that it’s not that scary and you’re ready to check it out! Download our Beginners Checklist to learn how to get started.