A monad is a monoid in the category of endofunctors. Whats the problem?  

Other than audio (unless you have any specific tips), what can I do to make my future videos better? Any feedback (even negative) is strongly appreciated!

This is probably the clearest explanation of a monad I've seen yet. I still don't understand it at all, but it's a really good explanation.

Once you've spent years on wiping every last bit of state from the inherently stateful computer system, developing a perfectly stateless functional language, the monad is a method to remedy your colossal mistake and re-introduce state into your language, except more awkwardly.

Monad: I am a monoid in the category of endofunctors. Me: I don't even know who you are.

Well, that was the most informed 4 minutes I've wasted in my entire career of coding. I didn't regret.

"A Monad is a Monoid in the category of endofunctors. No one actually knows what that means, they'll just parrot "A Monad is a Monoid in the category of endofunctors" at you repeatedly to make themselves look smart" -The guy that did a 9 minute ur mom joke using category theory

I got the math part - really well explained, thank you - but didn't get the coding part. I feel like instead of just saying "...and this Box type is a functor", you could have said "..and this Box type is a functor, since [explanation of how it maps objects and morphisms in one category to objects and morphisms in another]". From that point on, I was lost.

It's useful to know the terms, but I feel like it would more helpful to see a code example with real-world uses, like Errors and Option types.

For anyone still confused but almost there: watch the first monad video again. it makes perfect sense now. i understand everything now and my brain hurts from being so massive and huge now

what does "a coconut is just a nut" mean in category theory?

Great, short explainer for categories, monoids, etc. But the operation you compose for the Box example (3:57) doesn't have anything to do with monads. Composing "map" as you show there with a.map(b).map(c) or a.map(b.map(c)) is just composition of morphisms in the functor and works for all functors. What makes a functor a monad is the *identity* operation (which you correctly write out in 4:00 as x => Box(x)) and a way of composing the functor itself: e.g. being able to turn a Box(Box(x)) into a Box(x). This latter operation is what you're missing; you can think if it as a generic "flatten" operation. Lists are a monad because you can turn any object into a list of just that object (x => [x]) and you can turn a list of lists into a flat list: def flatten(outer: List[List[T]]) -> List[T]: if len(outer) == 0: return [] return [outer[0]] + flatten(outer[1:]) ... or with the Box monad: def flatten(outer: Box[Box[T]]) -> Box[T]: return Box(outer.value.value) This "flatten" is the associative operation that makes things like Box, List, etc into monads. The function x => Box(x) is a functor that maps every type X in the category of the program's types into the type Box[X]. But there are other functions that take some type A and map it to Box[B]. To compose these in a way that satisfies the associativity laws, you need a way to take a -> Box[b] and b -> Box[c] and get a -> Box[c]. This is done through the "bind" operation in a monad, but the secret sauce is that you can write the bind operation as: def bind(box: Box[A], f: A => Box[B]) -> Box[B]: return flatten(box.map(f)) To walk this through, the function f takes an A and returns a Box[B]. When you use that in box.map(f), the map function takes the Box[A], and gives the A inside the Box to the function f, which returns a Box[B]. But the way map() is defined, it puts whatever its argument returned into another Box! So the result of box.map(f) is a Box[Box[B]]. That's why we call flatten() on the result, to turn it into just a Box[B]. When we say there's a monoid defined on these endofunctors, on functions that take an instance of some type A and output a Box of some type B, we give the identity function as x => Box(x), which doesn't alter its argument except for putting it in a Box, and give the way of composing other functions of the form (A -> Box[B]) -> (B -> Box[C]) -> (A -> Box[C]), which we can do by composing map() calls as long as we flatten() the results before shimmying them along. This is why what Haskell calls the "bind" operation (spelled as the infix operator >>=) is called flatMap() in a lot of other languages and libraries: it's doing a map(), followed by a flatten(), and this combined operation gives you the means to compose functions with type signatures that look like A -> Box[B] and B -> Box[C]: Box(a).flatMap(a2BoxB).flatMap(b2BoxC) = Box(a).flatMap(a -> a2BoxB(a).flatMap(b2BoxC)) The reason x => Box(x) is the identity in this monoid is that you can put this function in a flatMap() anywhere and it won't change the Box that you're flatMap()-ing: Box(a).flatMap(x => Box(x)) = Box(a)

I no longer understand what a monad is.

I think what this is missing is multiple examples, because what's most amazing about programming with monads is making code that can operate on any monad, when a monad means something totally different for different implementations. A "Box monad" is a lot like an "Option monad", but not very similar to a "List monad", or any other random thing. So then you can write code generic over monads and it will do something totally different depending on what implementation you give it

You lost me in the first 3 seconds but pulled me back for most of the video, only to lose me again in the last minute Great explanation, 10/10

Me after watching the eightth "intuitive introduction" to a complicated topic, and still not understanding anything about it: 🗿

I think the biggest hurdle to really understand monads is that their definition is part of theories that we, as developers, don't give a single flying f*ck about 😅 But to finally being able to conclude this is a relief. Thank you for this awesome video.

I think at 3:19 not the category is called a Monad but monoids inside this category. You are right, that if you look at this category and take the identity object and the product, this forms a Monoid in the algebraic sense, but a categoricaly defined monoid here works a bit differend. You need the product and Id object you mentioned, not to make the category a monoid but to be able to define monoids inside of the category. A monoid is an object m with a morphism from (m x m) to m and one from Id to m. This object then is a Monad. Its an endofunctor with this additional structure in form of those two morphisms (which also have to follow some associativity rules). In Functional Programming the morphism (m x m)->m is often called "flatten" and the morphism Id->m often "return" or "pure"

I've seen a bunch of explanations on what a monad is by this point, and this has to be by far the most understandable I've encountered at this point... thanks! I feel like I actually understand this definition properly now!

Honestly I think videos like this are more likely to contribute to continued skepticism of functional programming instead of winning anyone over.

After a semester of learning about this I thought I understood monads, thanks for correcting my misunderstanding

This is a nice explanation, dude, keep it up!

What you described at 2:41 and 3:14 were not monoids but monoidal categories. A monoid is an object A in a monoidal category (C,x) and a morphism AxA->A satisfying some identities. So at 3:14 you called (End(X), o) a monad, but really it's just a monoidal category. Monads are monoid objects in (End(X), o), that is, they are special endofunctors of X.

Finally someone cuts to the chase and just explains it. THANK YOU.

This explanation is utterly satisfying if you already know what a monad is.

This video is simply wonderful. Thank you!

I think much of the confusion is because you can't implement a monad (like you would implement an interface), you can only create a type which forms a monad(under a specific explicit or implicit trait system), in likely an incomparable way with how others implement theirs (in naming, order, synchronicity, operators vs methods vs free functions, etc, some with weak trait enforcement contacts(eg javascript or typescript), some strong(eg haskell), Some using functions with two arguments, others using functions that return another function, a=> b => op(a)(b) or (a, b) => op(a, b).

Associativity: exists IEEE floating point standard: And I took that personally (with floating point numbers A×B×C doesn't necessarily equal A×C×B due to rounding error, and that's also the reason -ffast-math option exists for many c++ compilers)

I still don't understand what a monad is but the video was entertaining. Good job!

Thanks for covering morphisms, functors. Many people skip that bit. And yes, like others have pointed out, this is by far the crispest explanation. Few more points that would be good to know. 1. - Why is the identity needed to make a Monoid? - What goes wrong if we try to make Monad from a semigroup? and BTW is there a concept of `Group` also? 2. 'Category of endofunctors on a category' Won't that be the category of all morphisms? Or in other words, what is the difference between an endofunctor and a morphism? @AByteofCode

Brief and informative video. Great method to explain!

Good explainer, congrats!! Perfectly clear now.

Thnx for the refreshingly-clear explanation 👍

Wonderful breakdown and explanation

Great video. Small pedantic point on my end: at some point you kind of say that regular endomorphisms, unlike endofunctors, don't have an "observable effect" because they don't explicitly define a mapping of the internal structure of objects. This seems to kind of miss the paradigm shift of that makes category theory so powerful, where the observable effects we care about concern the external structure of morphisms, rather than the internal structure of objects. That is to say, the "observable effect" is "observable" in the sense that it interracts with other morphisms around it in a special way.

SS: YES, straight to the point, I love this format.

Brilliant, i tried watching and reading tens of videos on category theory and couldnt understand anything due to crappy namings, but now i see it is more simple than those words. Thank you for this brillant video!

This video deserves definitely a part #2 , also a part #1

Yea, i agree, that's one of the best monad explanations available on youtube! I firstly thought it will be another "monad is just pattern", but it was clear and correct explaniation! Good Job! (sorrry for bad english)

but to have a monad in computer science you need three different functions constructor, the map function, and the bind function The constructor creates instances of Foo The map function maps transformations of x -> y to Foo(x) -> Foo(y) The bind function maps transformations of x -> Foo(y) to Foo(x) -> Foo(y) The original paper about monads in computer science specifies you need all three in order to have any semblance of useful composition. In C#, "map" is called Select, and "bind" is SelectMany In JS, Rust, and Scala, "map" is map, and "bind" is flatMap in Haskell, "map" is map or fmap, and "bind" is >>=

I'll need a minute to take in everything that you present in this vid - but I think if I try I actually _will_ be able to understand it, since the explanation is clear. Thanks!

Given that everyone writes monads when they need them, but don't call them this way, I'm still unsure why we need to call them that way or explain them this way. "A monad is a function that wraps stuff to do (like type validation, error handling) around a value that may (for example) cause troubles if left unchecked. The monad will return the same inout value if it's valid, or a replacement of the desired type, so it's not even ALWAYS an identity." There.

The most interesting things about monads is, i can do safe IO operation when wrapping IO operation inside "monad-like" types in imperative language, this also can make me write less boilerplate code for error checking.

A monad is a gonad that has not yet been invited to the category of exofunctors.

This is interesting and I think that it would make sense for you to go further on the topic please 🙏🏼 find out the time and the energy we all need to have more because it was just not enough 😅

Thank you, this was much more clear than programming books trying to explain by analogy instead of using mathematics, which made no sense to me.

Loving this content 🎉

Great video, if you make a video about an example of this in more code that would definitely help! And at 1:25 What does it mean that the end result should not depend on when you went through a functor in the structure? Also wouldn’t all category possess the properties you mentioned making them all semigroups?

The first part of the video was excellent, but when you started explaining the connection to programming, it would be great if you slowed down and showed the correspondence between terms in category theory and terms in programming

Great analysis

Beautifully explained ❤

This video was awesome! And I love how straightforward the box type is 😁. Would have loved an extra 30 seconds showing how to use this in a productive way! Like, how this translates into an 'IOMonad'

If I cared more I would understand. However, I can appreciate how much effort you put into the animations.

Is it important for the function input type to match the function output type? I raised this question in SO and was told that every type belongs to the same category! So the function can take in an integer (a type) and return a string (also a type) - and nothing is violated. (Of course I am omitting the generics with templates here for simplicity).

So there is this thing called category theory and I'm trying to make sense of it. The tool I use to make sense of it is "understanding," which is a functor that returns an updated version of the thing I still call "me". Therefore, understanding is an endofunctor. If I understand endofunctors *then* understand monoids it's the same as understanding monoids and *then* understanding endofunctors. Therefore, understanding is a monoid within the category of me.

Very nice explanation 👌

Great explanation!! Your videos thumbnail seems to make me wanna watch it even if I don't want to learn what monad is.

3:35 - "this box right here" what exactly is this sentence referring to? the arrow points to `self.value` which is not a box (except for nested boxes, but that wasn't mentioned anywhere) 3:46 - what does it mean to add a box to another box ? the code shown here throws a type error (TypeError: unsupported operand type(s) for +: 'Box' and 'Box'). the following explanation "the rest of the method is simply combining two boxes in order to return one" doesnt explain *how* this combination works either 3:58 - the receiver of the latter `map` in the second line is a function instead of a box, which means its a completely different function that just happens to have the same name. how is this a valid comparison ? and why isn't this mentioned?

The first part was really intuitive, thanks for that. Up to the point, what it all ment. The last part was a bit on a rush. But I understand, that this video was ment to be a short introduction, so maybe that wasn‘t even your intention.

"You may have heard that a monad is a monoid in the category of endofunctors" - How did you know? I literally hear this all the time.

went to a bootcamp, they thought monads was a good topic for a 3 day r&d project... horrible experience but today I understand why, thank you

I know that concepts click at different times for different people. Some may find this too advanced and some may find it too simplistic. But it was exactly at the conscise-but-precise level I needed to FINALLY feel for the first time like I understood the diabolic sentence! Now let's see how long that feeling lasts :). Thank you very much, great video!

I don't know how to write a class in C++ for my project, and here i am watching a video about monads.

The virgin repeater vs. the Chad corrector (of monad definitions)

this is the best ever explanation

I think the biggest misstep in this otherwise flawless video is this: right at the end, you blaze through all that math you've carefully built up and just assert that it is what it is in code. It's not clear what makes map an endofunctor, what the category is (Box or the object it holds?), or why we can call that a category. The transformation undergone through that endofunctor is also vague. Oh, and on second thought, I'm docking 10 points for sticking an undefined and totally handwaved addition operation in there between a value of type Box and the value returned from func.

I am not a category theory specialist, but to make your explanation truly usefull, you should mention the flatMap, which allows to composite monads. As if you return a Promise from a Promise, it is still a Promise, this operation makes monad whatever the definition says.

me hearing "endofunctors map each object to another object in the category" and instantly saying "group theory? :)" out loud

Can you please elaborate more on functors, like how will it map morphisms and objects in two different categories? And what are these morphisms and objects that are being mapped in terms of programming... Plus, how do endofunctors map to themselves

Honestly can't believe you did this in 4 minutes.

I have a few questions: 1) How can a category 'come along' with an operator? Does that mean that for certain categories specific operators are defined that follow certain properties? Or do the operators define the structure of the category itself? 2) Would it then be correct to say that a category includes morphisms, objects AND optionally, some operators? Thanks! Amazing video

I am filled with regret for the day I became curious about what a Monad is after a computerphile video, so I searched for it, and now my feed is filled with Monad explainers that don't help me understand Monads. I've long since stopped caring, but keep being recommended more or less accurate-according-to-comments and jargon-heavy videos, this is my new hell. Thanks for trying, though.

so what's the difference between a monoid in a category, compared to an ordinary abstract-algebra monoid? I assume it has to at least satisfy some additional coherence constraints? Being *in* a category, does that mean it's a special kind of object or a morphism or something different? Maybe it's a morphism mapping from products?

Nice one

When he said 'arrows' I got that

What’s the irl object/concept that resembles a monad the most?

Such a clear explanation and yet I'm still confused

What are the morphisms in the category of endofunctors of X?

Good video, man! Maybe not 100%, but it made stuff more clear to me

Can't wait to flaunt the upgraded superior variant "a monad in X is just a monoid in the category of endofunctors of X"

Cool! can I make crysis with it?

When it comes to the coding, just write or use the map function without knowing the theory, it's a lot simpler, intuitive and productive. I guess there are a few positions that are theoretical, with budgets >>> time constraints but generally you don't need to know these things, just write the damn code, 30s and you're done:) Excellent explanation tho!

well done

three boys in france, dind't eveen understood a single word lol

A better explanation of a morphism maybe is like moving from a plumbing system of a city to the subway or electricity network, while mantaining some properties.

Thanks. ;)

2:06 What do you mean by "most operators are total"? How many of them are total, and how many are not?

Learning advanced math must be like being an aerospace engineer that can't fold a paper airplane (and without the salary). 200 IQ but it's only you and a dozen people that can validate it.

Is monad considered also a bullet points that we use?

The only clear explanation of a monad, unfortunately it goes out the other ear until I actually apply it intentionally. Thank you!

Is the map function you're referring to is actually flatmap from Java and Scala? I though map actually didn't flatten the result.

Any applications or use of such strange entities in the real world??? How would one implement such in code? Find it very interesting though.

What is a diffrence between endomorphism and identity function?

epic video :)

Oh wow, there are two monad explanations submitted for SoMe2 now. This is gonna get interesting...

it bugged me for so long why people return M(T) in the mapping function, but that little M(M(T)) => M(T) made everything so clear and me so whole. Edit: wait what? What if the function we are wrapping returns a function instead of a value? How am i supposed to call M(T1=>T2)???

a.map(b.map(c)) so c is a function returning a box because that's the argument map takes. so b.map(c) returns a box and not a function that returns a box. Why can we pass it as a function that returns a box into the a.map call? An instance of the class box is not a function. Isn't that a type error?

"Now we understand", "We know" 😂 "If anything doesn't make sense" 😅

This is good!!! reallly!!! it's really good explanation, the problem is, I still don't understand monad LoL

I was following right until the programming came into picture. That was a "draw the rest of the owl" moment for me. What in the Box example is supposed to be X, what are our objects and morphism, what are our endofunctors, what is the monoid operation and where is the identity endofunctor?

I don't understand how you can "add two Boxes". does the "+" operator used on objects have some meaning in python?