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

You may have heard that a monad is a monoid in the category of endofunctors, but what does that actually mean? In this video, you'll learn the basics of category theory and understand the infamous sentence!
This is my entry to the summer of math exposition round 2 hosted by ‪@3blue1brown‬.

[@AByteofCode]

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!

[@zyansheep]

This is literally the best video I've seen what a monad is. Good job! I always forgot what endofunctors were when thinking about monads, but your description of the "category of endofunctors" being all the possible mappings to itself of another category is simple and easy to understand. Edit: i think it would have been even better if you added one other code example of a more complicated monad (like Maybe or List)

[@AByteofCode]

@@zyansheep Thanks my man! About the edit, you're right I should have added an example of a monad with actual extra logic, but last time I used an example for a monad, that was the only thing a lot of people got out of it, so thought I would better avoid that :/

[@blehbleh9283]

Your audio has gotten much better

[@LastExceed]

subtitles. NOT hard-subbed (= rendered onto the video), but soft-subbed using youtube's subtitle functionality. simply copy-paste your script. the auto-generated subs aren't always perfect, and especially in a video like this, where every word is chosen carefully, i don't wanna trust a speech-to-text algorithm

[@AByteofCode]

@@LastExceed Pasted in the script, ill trust youtube for the timings for now but I'll check it later when I have time

[@SkyyySi]

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.

[@AByteofCode]

Monad moment :)

[@ludo3941]

Same

[@HcmfWice]

functor = mappable stuff monad = flatmappable stuff that’s all you need to know as a programmer

[@SuperMrMuh]

@@HcmfWice hey there, would you mind elaborating that a little more?

[@siquod]

It's wrong, though.

[@sharpfang]

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.

[@scoreunder]

That is the state monad, there are others which are indispensible even in stateful languages (e.g. lists, promises)

[@AByteofCode]

Made me laugh, good one :)

[@sharpfang]

@@scoreunder All of them are variants of state. List and Log monads are an append-only storage, so a log of states, be it meta- (log) or data- (list) oriented. Promise and Await are encoding execution queue capable of wait states into a finite state machine. Maybe is a 'machine has entered invalid state' state.

[@brendawilliams8062]

That is priceless

[@sharpfang]

@@kittysplode The state was already there, natively. It's still out there, truly reflecting the entire state of the program. It must be there for the CPU to work. And you cobble a replacement substitute together on your own, and haul it around everywhere you need it alongside arguments and return values, while the real thing is already everywhere you might need it, except walled away.

[@randomperson1955]

"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

[@AByteofCode]

What do you call a person reading a paper on category theory? A co-author :)

[@OliverLugg]

A coconut is just a nut.

[@eris4734]

your momad is a your momoid in the category of endofunctors

[@David-gk2ml]

@@OliverLugg loconut

[@KangJangkrik]

@@David-gk2ml it's not a nut

[@pro3757]

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

[@jeffreyjdesir]

underrated ~

[@izaquieluiz]

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

[@AByteofCode]

Glad to hear that lol

[@thatkindcoder7510]

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

[@tiagomacedo7068]

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.

[@MeandrLixy]

Indeed. The moment Box(result) becomes self+result I was lost too. But AFAIU monads in Haskell could be expressed in usual programming terms as 'hiding' in such Boxes some useful payload (with original value) to get extended 'laterial' functionality. And you can put such Boxes to functions which works with original values as expected - and this is all these 'monoids and identity' gibberish are about. If you had function of value sum(value,value) you could call Box sum(Box, Box) and get expected result with some laterial additional computations inside Boxes (for example Box could count up how many additions happend with it's value before). This is why this 'map one category to another' is important in some way.

[@agliacci]

You should watch the original video he did on monads, really helped apply this video in a new light

[@AByteofCode]

I admit the second part was rushed. I was about to leave for holidays and had to rush the ending to upload before the SoMe2 deadline. I'll try my best to not repeat that mistake.

[@badmanjones179]

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

[@besknighter]

You're a genius! Thank you! Both videos actually make so much sense now.

[@C3POtheDragonSlayer]

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)

[@AByteofCode]

Great explanation! The associativity equality shown at the bottom is what I was going to put but thought it'd be too complicated as a thing to show on screen for a few seconds. Otherwise, the "+" "operator" shown in the code example was meant to encapsulate the idea of flattening but I'll admit I left out too many details in the code part :/

[@plopsmcgee9672]

@@AByteofCode I saw that "+" operator and I wondered what the heck it was doing adding two boxes together. It would have been nice to have gotten an explanation.

[@hotharvey2]

Wow this helped me understand a lot more after watching the video. I have been working with flatMap and map in java/scala, and also trying to learn the core functional programming ideas. It's all starting to connect in my head thanks to this, so I really would like to say thank you!!! Are there any books on the subject you'd recommend?

[@C3POtheDragonSlayer]

@@hotharvey2 I recommend Bartosz Milewski's Category Theory for Programmers, which helped me understand the motivation for functional patterns and category theory in general.

[@hotharvey2]

@@C3POtheDragonSlayer I just read the introduction and it seems perfect. Thanks a lot 😀

[@LowestofheDead]

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.

[@AByteofCode]

Although I agree, that wasn't in the scope of the video as it was more of a video about category theory, just I had to find some way to justify uploading it on a byte of *code*. I could make a video about the monad types though, with code examples and what problem each one solves.

[@danielwilkowski5899]

@WaveHello notice, that what @A Byte of Code explain, requires you to use your brain effort to try and understand the concept. With examples, it would be easier to follow, but it would also be easier to come up with misconceptions, because your brain wouldn't be working as hard.

[@yash1152]

@@AByteofCode that would be great

[@AByteofCode]

@@danielwilkowski5899 In my previous video, I used an example but a lot of people thought that example was the only thing you could do with monads. You hit the nail on the head here!

[@christiansheridan3410]

I no longer understand what a monad is.

[@AByteofCode]

The math word and the computer word are related but you can understand one without the other. If you understood the design pattern before but now don't, then ignore the last minute of this video which had a bit of unmarked pseudocode which is what I think may have confused you. If there's any conflicting info in your head rn, would you mind telling me what it is so I can clarify?

[@christiansheridan3410]

@@AByteofCode I think you missed the joke.

[@AByteofCode]

@@christiansheridan3410 I still do lol, what was it?

[@christiansheridan3410]

​@@AByteofCode My view of monads exist in a narrow context. I know what they are from my experience with FP languages. Anything outside of that specific narrow context flies right over my head (especially category theory). It's not that your explanation is bad, it's just that... If someone doesn't have a mathematical background, like myself, it may be futile to explain monads to them in such a way.

[@AByteofCode]

@@christiansheridan3410 Hmm I tried making this explanation so that people without a math background would have a chance of understanding. I do see what you mean though

[@Dango428]

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

[@AByteofCode]

Lmao the last minute isn't that important, was more theoretical than practical (as seen by the ungodly amount of pseudocode i forgot to mention)

[@NICK....]

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

[@troubletruffle154]

Co- basically means "opposite category". So coco- means the opposite of the opposite category.

[@stames2319]

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"

[@yuklam5700]

Agree. Let me rephrase to hopefully make it clearer. I am just a beginner in category theory. Corrections are welcome. The category of endofunctors forms a monoidal category. Functor composition acts as the total, associative operator ⊗. Identity functor acts as the identity object I. Inside a monoidal category, if an object M (here objects are endofunctors) equips with two morphisms μ: M ⊗ M → M and η: I → M, then we call it a monoid in this monoidal category. In particular, monoid objects in category of endofunctors are also called monad. Wiki has more precise definition for monoid: en.m.wikipedia.org/wiki/Monoid_(category_theory) I found Bartosz's lessons extremely useful for understanding category theory. Despite being theoretical, his presentation is programmer friendly. Highly suggest: kzbin.info/aero/PLbgaMIhjbmEnaH_LTkxLI7FMa2HsnawM_

[@AndrewBrownK]

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

[@Brunoenribeiro]

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.

[@monsterhunter445]

Yeah lol

[@WolvericCatkin]

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!

[@JackDespero]

It is weird to put a precise mathematical name to my preferred pattern of programming. I always preferred monads over other type of functions such as functions that change given output parameters. Now I can sound very pedantic when talking about my program at work: "So the attribute function filter is a monad of the class. Any questions? Oh, of course, I will explain what a monad is. A monad of X is a monoid in the ..." My dream come true!

[@AByteofCode]

This is probably 95% of the usage of the definition and I'm down for it!

[@sfulibarri]

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

[@_iyalei]

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

[@TacoDude314]

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.

[@FearlesSLaughteR1]

Let the rest catch up first.

[@thestemgamer3346]

yeah this is one of those things which honestly has to be left out of the discussion because it makes it too long. In order to talk about monoidal categories you need to get a little bit into the weeds of their coherence conditions and possibly require an explanation of the tensor product. Both finite products and coproducts can form symmetric monoidal categories, but what that means really depends on how well you understand products and coproducts. Also there are more abstract definitions were monads are objects in bicategories, which is already losing the spirit of why most programmers care about monads. It's just too deep for most programmers to deal with at the start.

[@TacoDude314]

@@thestemgamer3346 They did talk about monoidal categories in the video, they just (incorrectly) called them monoids while doing so. They could have just mentioned that monoids are objects in the monoidal category they defined and glossed over the associativity and identity conditions given that they already talked about them for monoidal categories. This isn't a matter of which level of abstraction is relevant. They gave an incorrect definition of monads at the lowest level of abstraction. A monad is an endofunctor. I don't think incorrectly calling it the category of all endofunctors is more useful to programmers. Finally, this is a submission to SoME2 a mathematics exposition competition. Of course there should be some level of hand waving to appeal to a lay audience but the definitions should at least be correct, especially when that very definition is the thing being explained.

[@calvinfong7209]

Yeah it's unfortunate that the original quote wasn't "in the monoidal category of endofunctors". Would've saved many man hours of incorrect explanations (and more hours of people listening to these explanations)

[@thestemgamer3346]

​@@TacoDude314 oh I agree, anything incorrect should be called out. Especially when this topic pops up, in the context of computer programming, there are a lot of incorrect definitions. And if you want to treat the subject categorically, you can't really pull any punches. There are a few other issues with the video, for example, divisibility is not the same as division or inverses (mentioned 2:33). Also map wouldn't form a monoid, it is simply an endofunctor, you would need a different object which encapsulates the composition of multiple maps to be able to form a monoid. For example, people often confuse the monad object with the object itself. Which isn't really true. Are list's monads, or are they just types in which there exists a monad object which acts through the bind function? A lot of people assume that lists are monads and functors, because they take typeclasses to be like inheritance and so instancing a typeclass creates this "IS A" relationship in their minds. So a list "IS" a monad to them, when this is really not the case. Like you mentioned monads are just endofunctors, but it's more than that, they're the endofunctor created by the composition of adjunctions. The monad is just an object that captures that adjunction. How do you explain this to programmers? You don't, so you just don't mention it. I'm just mentioning that the level of detail required here is often not necessary when addressing this topic to programmers. So it's always going to result in some weird definitions and a lot of missing information. Taking criticism is also an important part of being a content creator too.

[@RSLT]

Brief and informative video. Great method to explain!

[@siquod]

*misinformative

[@a_name662]

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).

[@hotharvey2]

Yes, it's pretty abstract when compared with the usual lessons on Objects and OOP (loosely: class is to an object, as a vehicle is to a car) Monads seem like more of a description of behaviour which is less tangible than object oriented stuff. I would like to point out also, that people tend to see functional programming as a wholly separate ideology and style to OOP, but in reality, if we can understand both and mix+match (e.g rust has great functional aspects) then we will hopefully all be better off.

[@AByteofCode]

You're absolutely right! Writing functional code in an OOP codebase is really powerful. Also yeah in general, FP is quite mathematical and not practical, which makes it overall confusing. Then you add vocabulary; a property in math is different to a property in programming, functors sound like functions but aren't, types are classes but not, etc...

[@intrepiddt]

This video is simply wonderful. Thank you!

[@AByteofCode]

Thanks for the kind words!

[@ehza]

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

[@AByteofCode]

Glad you enjoyed! I absolutely intend do :)

[@JurekOK]

Good explainer, congrats!! Perfectly clear now.

[@AByteofCode]

I'm very happy to hear that!

[@itachi2011100]

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

[@AByteofCode]

Listen to the semester of class over this video. This is a massive oversimplification with more factual issues than I'd like to admit :/

[@okeuwechue9238]

Thnx for the refreshingly-clear explanation 👍

[@AByteofCode]

Glad it was helpful!

[@VishalGokhale]

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

[@AByteofCode]

You kinda just have a table of properties and what you call a set with those properties, so as far as i know some nerd went "yeah monoid is a cool name for this" Also, Group does exist, its just Semigroup but you add Identity and Inverse (which is for each item x there is an item y for which x * y = the identity element). Otherwise, a morphism is an arrow between two objects, and an endofunctor is an arrow from a category to itself. You could say an endofunctor is a morphism from a category to itself (note the endo prefix) but there is a specific term for arrows between categories so we use that instead.

[@uwuzote]

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)

[@AByteofCode]

Well I also happen to have a video about it being a pattern, just wanted to explain the deadly sentence as well :) Thank you very much, and don't worry about the english!

[@selfspectrum9369]

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

[@AByteofCode]

Glad to hear that!

[@Miranda-yc7ll]

this explanation is amazingly smoothly done

[@therealist9052]

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

[@ChronoWrinkle]

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!

[@AByteofCode]

I'm glad it helped!

[@ppppp524]

"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.

[@AByteofCode]

Lmao, it definitively depends on the circles you're a part of.

[@wlfred.ed1930]

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

[@arjix8738]

This video deserves recursive sequels

[@AByteofCode]

The WHAT also yes considering how many mistakes I made I'm gonna need to make 10 correction videos about it lol

[@Wielorybkek]

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

[@maxwibert]

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.

[@AByteofCode]

Very good point

[@youtubehandlesux]

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)

[@ultimatedude5686]

A×(B×C)=A×(C×B) is a result of commutativity, not associativity. Associativity is when (A×B)×C = A×(B×C). Commutativity is when A×B=B×A.

[@alexmedoli]

I can't believe I finally understand the shit! I've come across this years ago. I can't believe it had always been so simple. You've made me feel like a moron and a genius at the same time, congratulations

[@AByteofCode]

Thank you! I'm glad I could help!

[@furrball]

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.

[@calvinfong7209]

It's a joke in a blog post called "a brief incomplete and mostly wrong history of programming". It's said by a Haskell programmer in response to "Haskell is too difficult to learn". The crux of the joke is that it's a mostly useless definition

[@furrball]

@@calvinfong7209 uh... I figured. NOW.

[@ultimatedude5686]

There's a lot more things you can do with Monads than just error handling though. You can access an environment or modify a state, for example. In Haskell, the IO monad is the only way to perform side-effects.

[@furrball]

@@ultimatedude5686 yep, my simpleton definition was also kind of a joke to counter the ultra-abstract one in the video.

[@12kenbutsuri]

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.

[@brecoldyls]

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!

[@connormcmk]

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.

[@connormcmk]

I think this is still wrong but it's fun. Correct me! What's the right way to write this?

[@orterves]

Wonderful breakdown and explanation

[@ChamplooMusashi]

Understanding the theory is honestly way better than people trying to jump straight into code. I've watched and read multiple posts/vids about monoids and this really helps fix up the gaps. Thanks!

[@AByteofCode]

I'm glad to have helped!

[@____uncompetative]

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

[@LastExceed]

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?

[@nicholaspreda90]

Well, what I can make out is that 'self.value' can be of any type, including but not necessarily a 'Box' object. And 'map' returns a 'Box' object of any value, from the existing instance of 'Box' class. So, you can pass 'map' method a theoretical 'function' argument that return a new 'Box' instance that has as its 'value' the original 'Box' the method instance belongs to. Resulting, in short, with a "NewBox.value == OldBox". So "OldBox.map(func).value = OldBox". And that's as far as I got. Because, when he makes the equality "a.map(b).map(c) = a.map(b.map(c))" the obvious problem here is that the 'map' method only takes another method. But 'b' is treated as both a method and a 'Box' class object which makes no sense and pretty much turns the last 30 seconds of the video into non-sense for me as well.

[@AByteofCode]

Oh god that CS part was scuffed lol. "this box right here" was meant to point at the class in general, and the + and associativity maps were pseudocode that I forgot to mention as such. I'm very sorry about all of that :|

[@AByteofCode]

@Nicholas Preda line 1: yes line 2: say the 'function' is a box factory, when called with the value of the previous box, you get a new box. I didn't explain how the combination worked because that is a per-implementation specific detail, and last time I mentionned implementation specifics people thought that was the only option :/ line 3: what I meant was that if we got rid of the "calling the function part" and just assumed that map just took boxes directly, then the map things work.

[@DemPilafian]

@@nicholaspreda90 You're being quite the pentagonator.

[@streetchronicles5693]

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

[@MeefQuesarito]

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

[@Caareystore153]

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.

[@moncefbkb9353]

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

[@NikolajLepka]

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 >>=

[@siquod]

You can construct fmap and join from return and bind. Using only the two methods return and bind was the original Haskell way of defining Monad, which for some reason was not a subclass of Functor. (Haskell also added a fail method, which has no counterpart in category theory and was arguably a design error, because not all monads necessarily have a way to represent failure; think for example of the Identity Monad)

[@octopirate-bak]

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

[@octopirate-bak]

also (in an attempt to understand) said "ok so wait categories represent classes where each instance is an object, and objects can be converted into each other with morphisms oh my god that's where polymorphism comes from"

[@AByteofCode]

IIRC, polymorphism means that a single interface applies to multiple things. So for example, "+" applies to numbers, lists and strings. While the word "morphism" is in both, I'm not sure they're related in meaning

[@CorbinSimpson]

Yes! There are categories whose objects are groups and whose arrows are group homomorphisms. I wonder what monads we might find there.

[@octopirate-bak]

@@AByteofCode I'm gonna research into type theory and get back to you but even in the way you describe it, that sounds like a morphism to me between objects within the same category

[@pro100tom]

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).

[@PauxloE]

A monad can be seen as a mapping between types, together a mapping between functions (between types). So given types X and Y, you'll get M[X] and M[Y], and given f : X → Y, you'll get M(f) : M[X] → M[Y]. And in addition you have M : X → M[X], and it all needs to fit together with the function chaining (M(f ° g) = M(f)°M(g), M(f(x)) = M(f)(M(x)), etc.) M[_] might be a generic type (that's the common case), or it might be a constant type, or some complicated type function.

[@AByteofCode]

The input and output types don't matter. The point of monads (or functors in general) is that the external type (the box) is what matters and stays the same, so usually, unless specific differently, the insides can change type.

[@rauljvila]

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!

[@frittex]

i need an explanation of the explanation

[@AByteofCode]

Are there any specific bits you didn't get or is it just the whole thing? Feel free to add me on discord (username is iwaroz) and we can call.

[@lambdasaturn]

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

[@leshommesdupilly]

So if you're crying about pointers, think about monads

[@ARVash]

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

[@Quiltfish]

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.

[@AByteofCode]

The classic monad experience :) Only way to escape it is to make your own monad video that noone else will understand!

[@chennebicken372]

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.

[@otesunki]

i understood monads but now i understand the bad description of it

[@mathyland4632]

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

[@Luxcium]

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 😅

[@kurtmueller2089]

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

[@addictedyounoob3164]

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

[@przemek9300]

What is a diffrence between endomorphism and identity function?

[@AByteofCode]

That's a good question! I'd say that an endomorphism is given to a specific object, whereas an identity function applies to all objects, but as far as I know, the line is a bit blurry between the two words

[@CorbinSimpson]

@@AByteofCode An identity arrow is the unique endomorphism which serves as a unit under composition of arrows. This should feel like a monoid.

[@mikaylamaki4689]

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'

[@AByteofCode]

Eventually, I'll make a practical video about monads, but i don't want half my channel to be about them either so it'll probably be in a while :/

[@golden_smiles]

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.

[@yuris10101]

this is the best ever explanation

[@AByteofCode]

Thank you!

[@return6005]

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

[@AByteofCode]

And both submissions were contributed to by the person who made the other submission :) We were gonna make one together but ended up not

[@GaganGrewalf095]

Beautifully explained ❤

[@AByteofCode]

Thank you!

[@jimitsoni18]

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

[@AByteofCode]

Gotta remember that at its core, category theory is all about abstracting abstraction and that functors are purely theoretical ideas. The question of "how" as a generality thus doesn't make much sense. You can do whatever mappings you want however you want them. The only rules for you to be able to call them functors are that every single object & morphism from A must map to something in B (plus a consistency thing explained in the video). Take the category of positive numbers and the category of negative numbers (we'll define morphisms as being +1 or -1 depending on which ctgry). You can create a functor by mapping the number 1 to -1, number 2 to -2 and so on, then map the arrow "1 to 2" to "-1 to -2" and so on. This is just one example, you can make whatever objects you want (objects are generally data like numbers, strings, bools, custom classes, etc) and morphisms are just things you can do to a piece of data to make it another piece of data of the same type. An endofunctor just means you have the same category at the start and the end. For example one endofunctor on numbers could be "1 to 2" and "2 to 3" and so on with mapping the "1->2" arrow to the "2->3" arrow, etc. If I haven't answered your question in a satisfying way let me know!

[@jimitsoni18]

@@AByteofCode thanks for responding, this whole thing just feels like an abstraction over/a subset of relationship algebra.

[@AByteofCode]

@@jimitsoni18 I don't have any experience with relationship algebra but the if you think its abstracting something then you're probably right :)

[@Seltyk]

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.

[@asdfghyter]

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?

[@argothiel]

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

[@AByteofCode]

I'm not even sure there is a number for how many operators there are. Off the bat, I can think of one non total operator and tons of total ones, so hopefully that answers the question :)

[@iliya-malecki]

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)???

[@ultimatedude5686]

The only way to call M(T1=>T2) is to use the mapping function. You could, for example, apply a value of M(T1) by using the mapping (T1=>T2)=>M(T2), which could be defined using map combined with the value of M(T1). After mapping, this would give a value of type M(M(T2)), and you could then apply the join function to finally get M(T2). If this is confusing, I'd recommend that you play around with a programming language like Haskell which implements Monads and has a nice syntax for working with them.

[@iliya-malecki]

@@ultimatedude5686 Wow this really is confusing. Thank you very much, I don't yet understand how to get to (T1=>T2) if I have M(T1=T2) which I'm supposed to not treat like a function, but I guess Haskell with help with that

[@ultimatedude5686]

@@iliya-malecki If you have a M(T1 => T2), and a function (T1 => T2) => T3, you can get an M(T3).

[@iliya-malecki]

@@ultimatedude5686 okay now it is perfectly clear, thank you so much

[@kiyasuihito]

Loving this content 🎉

[@AByteofCode]

Glad to hear that!

[@kartikfire]

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

[@AByteofCode]

Thank you so much!

[@4.0.4]

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.

[@thestemgamer3346]

okay but what about comonads??

[@AByteofCode]

Not too sure, but I do know what a cocomonad is :)

[@Draizil]

It's like a monad but in the reverse ;)

[@AceofSpades5757]

Such a clear explanation and yet I'm still confused

[@com0oan]

Probably the best functional progm. video i've ever seen!

[@zlovredniyTip]

But how is monad related to side effects? That's its sales pitch in haskell.

[@GoddamnAxl]

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

[@AByteofCode]

The most common joke answer is a burrito. A burrito is just a tortilla containing something, and whats inside doesn't really matter too much. You can open the burrito and modify whats inside (add or remove ingredients) and you end up with another burrito. We can say that this transformation is a functor, since you can pretty much apply a transformation like "add a piece of avocado" to any burrito. However, this functor ends up in the same category of burrito, making it an endofunctor. We could thus say that a burrito is a sort of endofunctor. However, you can combine burritos (remove one tortilla and mix them, for example) while flattening (two burritos give you one). This operation fits the identity (combine with an empty burrito), commutative (if you mix, end result is same no matter the input order) and total (end result is same type as inputs), thus making a monoid. As a result, a burrito is a monad. For real, category theory is all about abstracting abstraction. We can create analogies using real life but not much more than that.

[@GoddamnAxl]

@@AByteofCode i understood nothing 9 months ago when I asked this...but now I watch the video again while studying functional programming and abstract algebra it just makes every sense. Your vid is definitetly the best on this topic bro!

[@AByteofCode]

@@GoddamnAxl Thank you :D I appreciate the kind words!

[@lowpolyduck]

When he said 'arrows' I got that

[@thevalarauka101]

this category theory thing reminds me of group theory

[@AByteofCode]

Something I forgot to mention is that in category theory, the "objects" are generally meant to be data structures like groups, as category theory can be vaguely described as group theory but the objects are groups (or replace group with any other structure). This is also why we talk about morphisms, they're the same ones!

[@user-wr4yl7tx3w]

Can you make more videos on category theory

[@AByteofCode]

Are there any specific topics you'd want talked about? Otherwise I do have long term plans for a series about abstract algebra which would certainly have an episode about categories

[@Tobiky]

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

[@AByteofCode]

No worries, and thank you!

[@andrevandenheever6740]

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

[@AByteofCode]

If haskell counts as the real world, then yes. Otherwise, promises in javascript are monads, and so are lists when using flatMap.

[@pastebee2812]

Time to be very pedantic: almost every single definition in this video is wrong in at least one way. "You'd notice that morphisms can be composed together" Actually you probably wouldn't notice that, because with how you just defined them, it's not true. The composition operator on morphisms is something that a category is required to have, and is not at all trivial. Since morphisms can't really be distinguished any other way, most collections of objects and morphisms have multiple possible composition operators. "One interesting thing to note is that you can have an arrow from an object to itself" Yes, and you're required to. Each object must have an identity morphism, such that composing any morphism with an identity gives you back the same morphism. "A collection of objects and the morphisms they have between each other is known as a category" A collection of objects, morphisms, composition, and identities, is a category. "[Functors] are kind of morphisms between categories" Actually, they are exactly morphism between categories: by definition, morphisms in the category of categories are functors. "The only rule is that structure must be preserved. This means that given a certain path that requires passing through a functor, the end result shouldn't depend on when you went through it." I don't understand what this means well enough to claim that it's wrong, but at the very least it's not how I would phrase it. The requirement on a functor for preserving structure is that F(f ∘ g) = F(f) ∘ F(g), where ∘ is composition and f, g are morphisms, and F(1) = 1, where 1 is the identity morphism. "Most categories come alongside operators, which are essentially functions taking two elements of the category and returning something else" Actually, in the case a monoidal category at least, they're functors, not functions - meaning they also map pairs of morphisms to morphisms. "A category with a total and associative operator is known as a semigroup" A set with a total and associative operator is a semigroup. The name for a category with a total associative operator seems to be a "semigroupal category". "If the category also has an identity element then it becomes a monoid" Similar objection - a monoid is a set with a total associative unital operation, a category with an operation like that is a monoidal category. "We now understand every individual word of the infamous sentence" Nope. This is the first big issue: you actually completely skipped over what monoids are, and only defined monoidal categories. So, given a monoidal category C, with associative operation ⊗ and identity object I, what is a monoid? Well, it is: * An object M. * A morphism η : I -> M * A morphism μ : M ⊗ M -> M Such that: * μ ∘ η ⊗ 1 = 1, applying the identity on the left does nothing. * μ ∘ 1 ⊗ η = 1, applying the identity on the right does nothing. * μ ∘ μ ⊗ 1 = μ ∘ 1 ⊗ μ, brackets don't matter Technically I myself am skipping over a bit of the formalism here: in a general monoidal category, I ⊗ M and M (for example) are not necessarily the same object, they are only required to be isomorphic (with the isomorphisms also having coherence conditions). However, in the category of endofunctors they are the same object, and it isn't too hard to insert the associators and unitors where necessary to get the "proper" definition, so we can keep going with this. If the above definition looks intimidating, you can effectively think of it as being the same conditions as a monoid: the operation must be associative, and we must have an identity. It's just that what exactly that means in a general category is a little weird, as in an arbitrary category, objects don't really have elements. Also keep in mind that what a "binary operation" actually means, is defined by what ⊗ is, this will be important later. "Well in reality, the sentence is actually wrong!" Luckily, we are saved from irony here by the fact that you are actually correct in this objection. "Then, take every single functor it has from itself to itself, and put all of them in a separate category. We now have the category of endofunctors of X." Alright, time for a second big block of text. This is not "the category of endofunctors": it is indeed a category with endofunctors in it, but "the category of endofunctors" refers to a specific category in which the morphisms between the functors are natural transformations. Given two categories C and D, and functors F, G : C -> D, a natural transformation α : F -> G must, for each object X in C, give you a morphism α(X) : F(X) -> G(X). In other words, it "maps between" the functors, in the sense that for each object X, it gives you a morphism from F(X) to G(X). Natural transformations also have the condition that they must be "natural". This means that for objects A, B in C, and a morphism f : A -> B, α(B) ∘ F(f) = G(f) ∘ α(A). In other words, it doesn't matter whether you apply a morphism and then the natural transformation, or the natural transformation and then a morphism. [continued in reply because what i wrote was too long]

[@pastebee2812]

Once you have natural transformations, you can also compose them. Given categories C and D, functors F, G, H : C -> D, and natural transformations η : F -> G, ε : G -> H, there is a natural transformation ε ∘ η : F -> H given by (ε ∘ η)(X) = ε(X) ∘ η(X). This is natural because (ε ∘ η)(B) ∘ F(f) = ε(B) ∘ η(B) ∘ F(f) = ε(B) ∘ G(f) ∘ η(A) = H(f) ∘ ε(A) ∘ η(A) = H(f) ∘ (ε ∘ η)(A). The identity natural transformations 1 : F -> F that consist of identity morphisms are an identity of this composition, which means that for categories C and D, there is a category of functors from C to D, where the objects are functors, the morphisms are natural transformations, composition is composition of natural transformations, and identities are the identity natural transformations. (Note: this composition operation is usually called "vertical" composition because there is also a separate "horizontal" composition, but horizontal composition is not relevant here). Now we have the category of endofunctors. "But how do we make that a monoid?" A monoidal category. "We give it a total and associative operator, as well as an identity element" Well yes, but you do need to specify what those actually are. Since these are functors from a category to itself, they can be composed (if you have functors F : C -> D and G : D -> E, G ∘ F : C -> E is the functor such that (G ∘ F)(X) = G(F(X)) and (G ∘ F)(f) = G(F(f))), so we make our binary operation ⊗ be composition of functors. The identity of the composition of functors is the identity functor, which sends everything to itself, so now this is a monoidal category. [EDIT: actually no it's not! I missed something here; see the next reply] "This category we just made is a monad!" No, a monoid within that category is a monad. Third block of text... I've technically already explained everything necessary, but let's expand what a monoid in this category actually means. We have an object M, so that's an endofunctor from X to X. We have a morphism from the identity functor to M. Morphisms in this category are natural transformations, so that means we have a natural transformation from the identity functor to M. This means that for each object A in X, we have a morphism A -> M(A), such that it doesn't matter whether you apply some other morphism from A -> B before or after this one. We have a morphism from M ⊗ M to M. Morphisms are again natural transformations, so this is a natural transformation from M ⊗ M to M, meaning for each A, we have a morphism (M ⊗ M)(A) -> M(A). What is (M ⊗ M)(A)? Well, ⊗ is functor composition, so it's M(M(A)). This means we have morphisms of the form M(M(A)) -> M(A). If you have an M(M(M(A))), there are two ways to reduce that to an M(A). Associativity says they're the same. If you have an M(A), you can use the identity, either outside as M(A) -> M(M(A)) or inside by applying M to A -> M(A), to get an M(M(A)), then turn it back into M(A). Doing this doesn't change anything. "Ok, but what does that have to do with programming?" Well, it's still all very abstract: we need to decide what the category X actually is. Essentially, it's "the category of types": objects are types, morphisms are functions, composition is composition of functions, identities are identity functions. So... M is an endofunctor from X to X. This means that for each object in X, which is a type T, it gives you a new type, M(T). Also, for each morphism f : T -> U, which is a function, it gives you a function M(f) : M(T) -> M(U). This looks a lot like map. It looks even more like map when you look at the constrains on a functor: mapping with the identity changes nothing, and mapping with the composition of two functions is the same as mapping with one then the other. So basically, this means M is a type constructor with a map, like "list" or your "Box" or rust "Option"/haskell "Maybe". For each type A, we have a function A -> M(A). This effectively means you can take any value, and put it "in" M. This is also required to act nicely with map: mapping a function over the result of this is the same as just applying the function beforehand. For each type A, we have a function M(M(A)) -> M(A). This means you can collapse multiple layers of M into just one. Naturality once again means that it doesn't do anything weird with map: if you use two maps to change M(M(A)) to M(M(B)) then collapse it, or collapse M(M(A)) first to M(A) and then apply map, you get the same thing. Associativity means that the two ways to collapse M(M(M(A))) are the same. Identity means that using the A -> M(A) then collapsing, in either of the two possible ways, doesn't change anything. Usually, these operations are called "return" (A -> M(A)) and "join" (M(M(A)) -> M(A)). The natural next question is, what on earth does any of this mean? Well, even after formulating the laws, monads are somewhat infamous for the difficulty of explaining why they're actually useful. To be completely honest, that is an entirely separate issue from the category-theoretic definition (it's entirely possible to define and understand monads with no category theory at all by just stating a few laws), so I recommend anyone who wants to understand why this is actually a useful concept in programming should google around for monad tutorials until they find something that works. Understanding what concept it's meant to wrap around is something that's a lot harder to just throw a wall of text at than expanding "monoid in the category of endofunctors" to obtain the monad laws, so I'm not going to attempt it here. This comment [two comments now!] is already far too long.

[@pastebee2812]

Something I missed: we do "sort of" have a binary operation ⊗ as composition of functors, but actually we don't, because ⊗ itself has to be a functor. This means we also need to be able to combine two morphisms, f : A -> B and g : C -> D to form f ⊗ g : A ⊗ C -> B ⊗ D. This must also have the property that it preserves composition. I'm currently not in a good situation to think properly about this in order to write it all out, but I think the operation we're looking for here is horizontal composition.

[@alxjones]

This is close enough to get by, but there are some terminology mix-ups that might be confusing to some: You claim to have a category of endofunctors, but you really just have a bunch of endofunctors. Without the morphisms, it's not really clear what this category even is. In the case of the category of endofunctors, the morphisms are natural transformations. Once you give it the bifunctor (operator), it doesn't become a monoid itself, it becomes a monoidal category. A monoid is an object in that category along with a pair of morphisms that take elements from the respective product object and identity object into itself. Because the objects are endofunctors in X and the morphisms are natural transformations in X, that monoid object is called a monad in X. For a type constructor like Box to be a monad, it needs a few things: (1) a way to turn any object into a "wrapped" one, i.e. a constructor, (2) a way to turn any function between types into a function between "wrapped" types, i.e. a map implementation, and (3) a way to turn a "doubly wrapped" object into a "singly wrapped" one, i.e. a flatten implementation. You can get away with implementing just a flatmap to get (2) and (3) in one go, which is what you do here after supposing that f returns a Box type. You call "map" a monoid in the category of boxes, but a monoid is an object and the objects in our category are endofunctors, which "map" is not an example of. Instead, the type constructor Box, with the object constructor and the (flat)map implementation, is the monoid, and thus the monad. Also, Box is a monad in the category of ALL endofunctors on the category of types, and represents a single object. All the individual Box types are objects in the base category of types. You could probably consider these objects with the morphisms defined by the natural transformations to be a subcategory of the category of types, and I believe it would be monoidal, but there would be no monads because it isn't a category of endofunctors. I recognize that this is incredibly pedantic, so anyone who understood the video just fine can ignore this. But if you know a bit of category theory and were having trouble filling in the gaps from this video, I hope this helps some.

[@metanick1837]

Great analysis

[@parlor3115]

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

[@rowenaochotorena9681]

Is monad considered also a bullet points that we use?

[@AByteofCode]

I'm not sure I fully get what you mean, but in programming, seeing monads as programmable bullet points is far from the most far fetched monad metaphor I've heard.

[@jakub7321]

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

[@pastebee2812]

The operator isn't really part of the category at all, it's an additional thing that you can have along with a category. For example a "monoidal category" is a category, an operation on that category, and an object within the category, and some conditions to do with associativity and the identity. Informally you do sometimes end up conflating these sorts of extra structures on categories with the categories themselves, but all that "a category" actually has is objects, morphisms, a way to compose the morphisms (which must be associative), and identity morphisms (which must do nothing when composed with other things). This video misses quite a bit of the actual details imo, if you want to properly understand what's going on I'd recommend using a resource that covers this stuff slower and in more detail.

[@jakub7321]

Thanks! Any such resources that you would specifically recommend?

[@pastebee2812]

Wikipedia and nLab are what I've mostly been using to learn this stuff, they're rather information-dense sometimes so it can take some time to understand what on earth they're talking about but when you do that it always ends up working (or at least it always has for me). This video kzbin.info/www/bejne/r3LMZIuNeKeeetE and the link to a dissertation in a description are also pretty good, they don't cover everything but what they do cover is done slower and with a lot of examples which might be easier than just staring at piles of notation. The video does claim to have asterisks, but having rewatched it, basically everything they say is correct, the only asterisk I can see (other than the things that are intentionally vague) is the fact that they gloss over size issues - technically you can't construct "the category of categories" because that would contain itself and then issues happen, so you actually construct the category of small categories or whatever. It doesn't explain "a monoid in the category of endofunctors", but the dissertation defines natural transformations and monoidal categories, so then you just need monoids, defined here ncatlab.org/nlab/show/monoid+in+a+monoidal+category or here en.wikipedia.org/wiki/Monoid_(category_theory) (these definitions are identical), and the monoidal category of endofunctors, which I haven't managed to find a full description of(...?) but (I think) it's the category in which objects are endofunctors, morphisms are natural transformations, composition of morphisms is vertical composition, product of objects is composition, and product of morphisms is horizontal composition. I suspect the internet in general probably isn't too bad at this if you look for things that are designed to be telling you about general category theory instead of a random SoME2 youtube video trying to explain monads. If you leave out too many details everything will fall apart eventually, so any large internally consistent resource on category theory will probably cover all of what's going on. (They definitely wouldn't be able to get away with this video's definition of "category", which is actually a description of a directed multigraph, not a category; or the definition of "functor", which isn't a description of anything at all because it doesn't actually mean anything)

[@jakub7321]

👍I'll be on the lookout for resources

[@AByteofCode]

The thing about a random dude on the internet explaining monads, 100% accurate lol. I'm here to give general ideas of obscure CS stuff, not replace a math teacher :)

[@ravimaithreyregulagedda2158]

Didn’t stemgamer do a video on this exact same topic for some2 like a month ago

[@AByteofCode]

He helped me with this video a bit. We were gonna do his together but didn't and just both made our own versions seperately.

[@chenyang_wu]

An instance of Box is an endofunctor and the Box class is the category of endofunctors? I can't see how this matches the definition of endofunctors and is entirely lost from then on.