Monads were created in response to the problems that arise when a pure functional programming language encounters the dirty impurities of the real world. One particular problem that vexed researchers and developers early on was how to represent file I/O in a language such as Haskell. Take a relatively straightforward method such as a function prints a string to the console. It’s pretty obvious that the entire purpose of the function is so that it can execute a side effect. It’s also not clear that this function has a return value. Indeed, in many procedural languages, methods such as Console.WriteLine in C# have a return type of void. Functions that have side effects and have no return value clearly aren’t functions in the mathematical sense.

To address this issue, languages such as Haskell differentiated between pure functions and actions, the latter which is a value that represents the result of a computation that may cause side effects. A monad encapsulates this notion of computations and their state, and provides a way to transition from one computation to the next based on the resulting action from the previous computation. This is known as the bind method, or simply “>>=”. Essentially, it takes the value “wrapped” in the state of the previous action, performs some computation on the unwrapped value, and then wraps the result with the monad. The other important method, return, explicitly wraps some value type “a” with the monad.

This is very abstract, so let’s look at the Haskell IO monad as an example. The bind method would have a function signature of type:

*IO a -> (a -> IO b) -> IO b*

In other words, given some action *IO a*, bind takes a function (call it *F*) that takes in the unwrapped type *a* and returns a wrapped type *b*, applies *F* to *a* and returns the resulting *b* “wrapped” in an IO action. Let’s look at how we would use bind to read a line from the user and output it back to the screen.

The getLine function in Haskell reads a line from standard input and has type *IO String*. *putStrLn* has a return type of *IO ()*. We want to call *getLine*, take the resulting string from that, and call *putStrLn* with it. In the IO bind method, *a* is type *String*, *b* is type Unit (), and the mapping function *F* is *putStrLn*. The *(a -> IO b)* matches up with *(String -> IO ())*

The use of bind would look something like this:

```
getLine >>= \input ->
putStrLn (“You typed “ ++ input)
```

What this has accomplished is the separation of concerns between the side effects of an action with the results of an action. By encapsulating any state changes brought about by a computation inside of a monad, we retain the ability to interact with the results of these computations in a functional way. Thanks to the syntactic sugar that Haskell monads provide, we also get rid of a lot of boilerplate code that would normally be required to pass the state from one computation to the next, as well as any tedious checking that involves. One can easily imagine a scenario in an imperative language that consists of a series of nested if statements in the code that do null pointer checks on the results from a series of computations. The pseudocode of such a scenario might look like:

```
httpRequest = parseHttpRequest()
If (httpRequest != null)
{
queryString = parseQueryString()
If (queryString != null)
{
print(queryString)
}
}
```

Haskell provides syntactic sugar in the form of the “do” notation:

```
Do
Req <- parseHttpRequest()
QueryString <- parseQueryString()
putStrLn QueryString)
```

Where we could imagine there being some sort of monad that would wrap the imaginary request and querystring types returned from parseHttpRequest and parseQueryString respectively. This looks similar to the imperative style of coding where we define a series of computational, but what’s nice about the monad is that if at any point there is an error in the chain of computations, the rest of the computations in the do block are short circuited, bypassing the need for cumbersome if statements along every step in the computation.

This of course, only scratches the surface of what a monad is and what they can be used for, as evidenced by the plethora of guides out there written about them.