# Relationship between monoids and monads in haskell

### Monads are just monoids in the category of endofunctors

In Haskell, functions of type a -> b transform values of type a into . You can think of the difference between applicatives and monads in the. But that's not a general property of monads - just IO. a -- very specific -- relationship between values of a specific domain into a common abstraction. a monad is a monoid object in a category of endofunctors: return is the. Abstraction in Haskell (Monoids, Functors, Monads) . While the standard style of abstractions can be used in Haskell (and often are), we often .. The key difference lies in the fact that instead of combining priorities through.

The former is a bit fancier and more technically correct, but the latter is usually easier to get. You can think of fmap as either a function that takes a function and a functor and then maps that function over the functor, or you can think of it as a function that takes a function and lifts that function so that it operates on functors. Both views are correct and in Haskell, equivalent.

The type fmap replicate What exactly it will do depends on which functor we use it on. If we use fmap replicate 3 on a list, the list's implementation for fmap will be chosen, which is just map.

If we use it on a Maybe a, it'll apply replicate 3 to the value inside the Just, or if it's Nothing, then it stays Nothing. In order for something to be a functor, it should satisfy some laws. All functors are expected to exhibit certain kinds of functor-like properties and behaviors.

They should reliably behave as things that can be mapped over. Calling fmap on a functor should just map a function over the functor, nothing more. This behavior is described in the functor laws. There are two of them that all instances of Functor should abide by.

They aren't enforced by Haskell automatically, so you have to test them out yourself. The first functor law states that if we map the id function over a functor, the functor that we get back should be the same as the original functor.

So essentially, this says that if we do fmap id over a functor, it should be the same as just calling id on the functor. Remember, id is the identity function, which just returns its parameter unmodified. Let's see if this law holds for a few values of functors. We see that if wee fmap id over Just x, the result will be Just id xand because id just returns its parameter, we can deduce that Just id x equals Just x.

So now we know that if we map id over a Maybe value with a Just value constructor, we get that same value back. Seeing that mapping id over a Nothing value returns the same value is trivial.

The second law says that composing two functions and then mapping the resulting function over a functor should be the same as first mapping one function over the functor and then mapping the other one. Formally written, that means that fmap f. Or to write it in another way, for any functor F, the following should hold: If we can show that some type obeys both functor laws, we can rely on it having the same fundamental behaviors as other functors when it comes to mapping.

## Abstraction in Haskell (Monoids, Functors, Monads)

We can know that when we use fmap on it, there won't be anything other than mapping going on behind the scenes and that it will act like a thing that can be mapped over, i. You figure out how the second law holds for some type by looking at the implementation of fmap for that type and then using the method that we used to check if Maybe obeys the first law. If you want, we can check out how the second functor law holds for Maybe. If we do fmap f. If we do fmap f fmap g Nothingwe get Nothing, for the same reason.

OK, seeing how the second law holds for Maybe if it's a Nothing value is pretty easy, almost trivial. How about if it's a Just something value? Well, if we do fmap f. If we do fmap f fmap g Just xwe see from the implementation that fmap g Just x is Just g x. Ergo, fmap f fmap g Just x equals fmap f Just g x and from the implementation we see that this equals Just f g x. If you're a bit confused by this proof, don't worry. Be sure that you understand how function composition works. Many times, you can intuitively see how these laws hold because the types act like containers or functions.

You can also just try them on a bunch of different values of a type and be able to say with some certainty that a type does indeed obey the laws. Let's take a look at a pathological example of a type constructor being an instance of the Functor typeclass but not really being a functor, because it doesn't satisfy the laws.

Let's say that we have a type: It's a data type that looks much like Maybe a, only the Just part holds two fields instead of one. The first field in the CJust value constructor will always have a type of Int, and it will be some sort of counter and the second field is of type a, which comes from the type parameter and its type will, of course, depend on the concrete type that we choose for CMaybe a.

Let's play with our new type to get some intuition for it. Let's make this an instance of Functor so that everytime we use fmap, the function gets applied to the second field, whereas the first field gets increased by 1. Everything seems cool so far, we can even play with this a bit: In order to see that something doesn't obey a law, it's enough to find just one counter-example. We know that the first functor law states that if we map id over a functor, it should be the same as just calling id with the same functor, but as we've seen from this example, this is not true for our CMaybe functor.

Even though it's part of the Functor typeclass, it doesn't obey the functor laws and is therefore not a functor. If someone used our CMaybe type as a functor, they would expect it to obey the functor laws like a good functor. But CMaybe fails at being a functor even though it pretends to be one, so using it as a functor might lead to some faulty code.

When we use a functor, it shouldn't matter if we first compose a few functions and then map them over the functor or if we just map each function over a functor in succession.

But with CMaybe, it matters, because it keeps track of how many times it's been mapped over. If we wanted CMaybe to obey the functor laws, we'd have to make it so that the Int field stays the same when we use fmap. At first, the functor laws might seem a bit confusing and unnecessary, but then we see that if we know that a type obeys both laws, we can make certain assumptions about how it will act.

If a type obeys the functor laws, we know that calling fmap on a value of that type will only map the function over it, nothing more. This leads to code that is more abstract and extensible, because we can use laws to reason about behaviors that any functor should have and make functions that operate reliably on any functor. All the Functor instances in the standard library obey these laws, but you can check for yourself if you don't believe me. And the next time you make a type an instance of Functor, take a minute to make sure that it obeys the functor laws.

Once you've dealt with enough functors, you kind of intuitively see the properties and behaviors that they have in common and it's not hard to intuitively see if a type obeys the functor laws. But even without the intuition, you can always just go over the implementation line by line and see if the laws hold or try to find a counter-example. We can also look at functors as things that output values in a context. For instance, Just 3 outputs the value 3 in the context that it might or not output any values at all.

If you think of functors as things that output values, you can think of mapping over functors as attaching a transformation to the output of the functor that changes the value.

Another example is mapping over functions. The result is still a function, only when we give it a number, it will be multiplied by three and then it will go through the attached transformation where it will be added to three. This is what happens with composition. Applicative functors In this section, we'll take a look at applicative functors, which are beefed up functors, represented in Haskell by the Applicative typeclass, found in the Control.

As you know, functions in Haskell are curried by default, which means that a function that seems to take several parameters actually takes just one parameter and returns a function that takes the next parameter and so on. That's why we can call a function as f x y or as f x y. This mechanism is what enables us to partially apply functions by just calling them with too few parameters, which results in functions that we can then pass on to other functions. So far, when we were mapping functions over functors, we usually mapped functions that take only one parameter.

Let's take a look at a couple of concrete examples of this. From the instance implementation of Maybe for Functor, we know that if it's a Just something value, it will apply the function to the something inside the Just. We get a function wrapped in a Just! We see how by mapping "multi-parameter" functions over functors, we get functors that contain functions inside them. So now what can we do with them? Well for one, we can map functions that take these functions as parameters over them, because whatever is inside a functor will be given to the function that we're mapping over it as a parameter.

With normal functors, we're out of luck, because all they support is just mapping normal functions over existing functors. But we can't map a function that's inside a functor over another functor with what fmap offers us. We could pattern-match against the Just constructor to get the function out of it and then map it over Just 5, but we're looking for a more general and abstract way of doing that, which works across functors.

Meet the Applicative typeclass. It lies in the Control. It doesn't provide a default implementation for any of them, so we have to define them both if we want something to be an applicative functor. The class is defined like so: Let's start at the first line. It starts the definition of the Applicative class and it also introduces a class constraint.

It says that if we want to make a type constructor part of the Applicative typeclass, it has to be in Functor first. That's why if we know that if a type constructor is part of the Applicative typeclass, it's also in Functor, so we can use fmap on it. The first method it defines is called pure. Its type declaration is pure:: Because Haskell has a very good type system and because everything a function can do is take some parameters and return some value, we can tell a lot from a type declaration and this is no exception.

When we say inside it, we're using the box analogy again, even though we've seen that it doesn't always stand up to scrutiny. We take a value and we wrap it in an applicative functor that has that value as the result inside it. A better way of thinking about pure would be to say that it takes a value and puts it in some sort of default or pure context—a minimal context that still yields that value.

It's a sort of a beefed up fmap. When I say extract, I actually sort of mean run and then extract, maybe even sequence. We'll see why soon. Let's take a look at the Applicative instance implementation for Maybe. We said earlier that it's supposed to take something and wrap it in an applicative functor. We can't extract a function out of a Nothing, because it has no function inside it.

So we say that if we try to extract a function from a Nothing, the result is a Nothing. If the first parameter is not a Nothing, but a Just with some function inside it, we say that we then want to map that function over the second parameter.

This also takes care of the case where the second parameter is Nothing, because doing fmap with any function over a Nothing will return a Nothing. If any of the parameters is Nothing, Nothing is the result.

Let's give this a whirl. Use pure if you're dealing with Maybe values in an applicative context i. The first four input lines demonstrate how the function is extracted and then mapped, but in this case, they could have been achieved by just mapping unwrapped functions over functors.

The last line is interesting, because we try to extract a function from a Nothing and then map it over something, which of course results in a Nothing. With normal functors, you can just map a function over a functor and then you can't get the result out in any general way, even if the result is a partially applied function. Applicative functors, on the other hand, allow you to operate on several functors with a single function. Let's take a look, step by step.

This is because of partial application. This is one of the applicative laws. We'll take a closer look at them later, but for now, we can sort of intuitively see that this is so. Think about it, it makes sense. Like we said before, pure puts a value in a default context.

If we just put a function in a default context and then extract and apply it to a value inside another applicative functor, we did the same as just mapping that function over that applicative functor. This is why Control. Here's how it's defined: The f in the function declaration here is a type variable with a class constraint saying that any type constructor that replaces f should be in the Functor typeclass. The f in the function body denotes a function that we map over x.

The fact that we used f to represent both of those doesn't mean that they somehow represent the same thing. If the parameters weren't applicative functors but normal values, we'd write f x y z. Let's take a closer look at how this works. We have a value of Just "johntra" and a value of Just "volta" and we want to join them into one String inside a Maybe functor.

How cool is that? Had any of the two values been Nothing, the result would have also been Nothing. So far, we've only used Maybe in our examples and you might be thinking that applicative functors are all about Maybe. There are loads of other instances of Applicative, so let's go and meet them! Lists actually the list type constructor, [] are applicative functors. Here's how [] is an instance of Applicative: Or in other words, a minimal context that still yields that value.

The minimal context for lists would be the empty list, [], but the empty list represents the lack of a value, so it can't hold in itself the value that we used pure on. That's why pure takes a value and puts it in a singleton list. Similarly, the minimal context for the Maybe applicative functor would be a Nothing, but it represents the lack of a value instead of a value, so pure is implemented as Just in the instance implementation for Maybe.

It's implemented with a list comprehension. But the thing here is that the left list can have zero functions, one function, or several functions inside it. The right list can also hold several values. That's why we use a list comprehension to draw from both lists. We apply every possible function from the left list to every possible value from the right list. The resulting list has every possible combination of applying a function from the left list to a value in the right one.

Every function in the left list is applied to every function in the right one. If we have a list of functions that take two parameters, we can apply those functions between two lists. Using the applicative style with lists is fun! You can view lists as non-deterministic computations. A value like or "what" can be viewed as a deterministic computation that has only one result, whereas a list like [1,2,3] can be viewed as a computation that can't decide on which result it wants to have, so it presents us with all of the possible results.

Using the applicative style on lists is often a good replacement for list comprehensions. In the second chapter, we wanted to see all the possible products of [2,5,10] and [8,10,11], so we did this: This can be done in the applicative style as well: If we wanted all possible products of those two lists that are more than 50, we'd just do: Another instance of Applicative that we've already encountered is IO.

This is how the instance is implemented: We used do syntax to implement it here. Another way of writing this would be to use the applicative style. If we regress to the box analogy, we can imagine getLine as a box that will go out into the real world and fetch us a string.

That's why we can do stuff like: They are rarely used with the applicative style outside of code golf, but they're still interesting as applicatives, so let's take a look at how the function instance is implemented.

A minimal default context that still yields that value as a result. That's why in the function instance implementation, pure takes a value and creates a function that ignores its parameter and always returns that value.

So what goes on here? We don't often use functions as applicatives, but this is still really interesting. Try playing with the applicative style and functions to build up an intuition for functions as applicatives. An instance of Applicative that we haven't encountered yet is ZipList, and it lives in Control.

It turns out there are actually more ways for lists to be applicative functors. That would result in a list with two values, namely [4,4].

Because one type can't have two instances for the same typeclass, the ZipList a type was introduced, which has one constructor ZipList that has just one field, and that field is a list. It applies the first function to the first value, the second function to the second value, etc. Because of how zipWith works, the resulting list will be as long as the shorter of the two lists. It takes a value and puts it in a list that just has that value repeating indefinitely.

This might be a bit confusing since we said that pure should put a value in a minimal context that still yields that value. And you might be thinking that an infinite list of something is hardly minimal.

### Monoids, Functors, Applicatives, and Monads: 10 Main Ideas | Monad Madness

But it makes sense with zip lists, because it has to produce the value on every position. If we zip a finite list with an infinite list, the length of the resulting list will always be equal to the length of the finite list. So how do zip lists work in an applicative style?

Oh, the ZipList a type doesn't have a Show instance, so we have to use the getZipList function to extract a raw list out of a zip list. About Monoids, Functors, Applicatives, and Monads: Monoids, functors, applicatives, and monads are all different algebras Types like IO a are not monads themselves, they have some properties about how they can be combined together that means they follow the monad algebra.

Just like we can use the natural numbers to add or multiply, we can use IO in a way that is monadic or applicative. In some cases, IO values can also be combined using the monoid algebra, and they can always be transformed using properties of functors. Lists are a common example of functors as well, but you can also combine them in other ways that follow a variety of other algebras. But long story short: All of these algebras are ideas from category theory that are also useful in programming.

However, Haskell is particularly expressive in its ability to specify which types follow which sorts of algebras, and so you hear Haskellers talk about them a lot.

But what if your value was enclosed in some sort of a container? For example, if you know how to turn an integer into a string, do you know how to turn a list of integers into a list of strings?

An example specialized to lists is the following: That is why the Maybe a type is used when we want to deal with computations that can fail e. Finally, we also have a function for creating a container with a single value inside it, called pure. Monads also have to do with combining containers together, and they do so using basically a special type of function composition. Function composition has two main ideas: If you have two functions, f:: There is an identity function, id:: It also comes with two laws: Function composition is associative: Therefore, there is no use in typing out parentheses, so we often just write f.

Composition with the identity function has no effect: Turns out we also have two analogous functions for dealing with this space of functions: These two functions define the monad algebra. We can use the monad algebra, for example, when we want to compose different IO actions together.

- Monoids, Functors, Applicatives, and Monads: 10 Main Ideas
- Monad (functional programming)
- Functors, Applicative Functors and Monoids

The IO function readFile:: If we wanted to combine these functions together into some printFile:: But monadic function composition does know how to compose the side effects of each action, and the types work out too. Therefore, we can define: This is always a total function, and can be done without any loss of information.

For Maybe Int types, for example, it is easy to extract 3 when you are given Just 3, but how can you extract a value out of Nothing? With [a], you lose some information when you have to extract a single value out of a list with multiple values in it, and you fail when you try to extract a value from an empty list.

Therefore, when dealing with values inside a particular container type, we cannot extract a value from that container, but if the container follows the different algebras we discussed, we are guaranteed that there are four types of operations we can do that will not fail: In a different viewpoint, we can say that applicatives and monads are the algebra of things that have side effects. Lists provide the side effect of having an arbitrary number of return values, and other container types like trees provide a similar side effect except the return values also have some structural relationships between them.