What is a Monad? - Computerphile 

xD

.. but before you gained the knowledge, you did not possess the ability to explain them either, so you did not lost anything ;)

“A monad(3) is a monoid(4) in the category(see 1) of endofunctors(5)” (1)A category is the prime structure in category theory(see 2). (2)category theory is a ways of connecting vague mathematical concepts by similar structures of objects from these different theories/concepts. A collection of such connections between objects (and the objects themselves) may be called a category(see 1). (3)A monad can be easily(6) followed on from (1) (2). (4)A monoid can easily(6) be followed on from (1) (2). (5)Blumming magic. (6)10-15 different steps atleast.

@@imnimbusy2885 what are these?

@@imnimbusy2885 Category, not just a set.

And how haskell works

what a shitty professor

There should be way to get refund on your course fee if the prof doesn't deliver. Now as it stands, we pay whether we're getting value from the prof or not

Aka - the professor is pure and has no effects - aka, useless.

drop out xD

At least they're honest

Regex

Before setting out to use Haskell, first dig two graves.

*APL has entered the chat*

Hay! That's my new favorite language your talking about!

It beats ML.

At least he tried explaining what a Monad is, although I doubt that was quite successful

@@theprovidencesalumu Guess that wasn't the right page...

I was already on the next blank page

Came here as I am on the same page as you :D

Which perfectly represented this whole video.

one cosmic ray through a bit cancels all hope in the escape from statistics

Well, that depends on how deeply you believe in mathematics. Monads can be mathematically proven in category theory.

@@GregoryMcCarthy123 The point is that computer failures unrelated to programming can change the infallibility of proven programming (sometimes by literally changing the program). One of the reasons that some mission critical systems are multiple redundant and voting. (Ignoring a discussion of the robustness of the vote collector.)

@@edwardmacnab354 store a single variable 10 times in different parts of memory/hard drive, whenever one of them changes, change it to the value in other memories

@@vadiks20032 management will argue against it calling it redundant . lol

too sad. :D

My first thought

At last, a simple explanation that makes sense.

Really.funny 😂😂👏

it's between gonad and nomad

its the .then() js func xd

A monad is a monoid of the class endofunctor.

@@Fingerblasterstudios Show off :) People should stop saying that. It's not helpful. Then again, I don't think it is supposed to, right?

@@Alkis05 it was something that got burned into my mind somewhere along the way and I only said it to be funny, but I suppose you figured that

It's how many volts in one amper

A monad is a thing that does things. Look it can trimt and flavon and wombnat and you can use then to arrange things, unless you can't. Perfectly clear.

@@vendicarkahn4860 Oh! So it's a function?

@@garorobe if not then what is this montard thing?

Yeah the "don't worry if you don't know Haskell" is incorrect. The difficulty in teaching is it's difficult to gauge how well you're explaining something to people who don't already understand. I've read a lot of far better explanations of monads but because I know F# rather than Haskell I didn't really follow this one since the last few steps were just "unexplained syntax magic happens here".

So what other functional language actually uses monads except Haskell? None that I've seen...

_"at what point did we make a monad? Why is Maybe a monad? What are the characteristics that make it a monad?"_ maybe you know all this already; I don't know if this will help, but here goes: a monad is *_three_* things *_together:_* 1. *_some data in a wrapper_* one explanation I saw in a tutorial for one of the python libraries was, "a monad is just a tuple", and (while it's actually just 1/3 of a monad) this point is what they meant. it doesn't have to be a tuple, but that's one way to represent it. in the video, this was what he was talking about when mentioned type constructors, because types are how Haskell represents it. one way seen it done in Python is with an object-the object wraps the data. you might have, for example: class Failure(): self.value = 9 self.failed = False 2. *_something to wrap the data up_* in the python object example this would be the dunder init: it creates the instance and stores the data inside the wrapper. this is the 'return' he was talking about; it's also called 'unit'. you might have something like: def \_\_init\_\_(self, value, failed=False): self.value = value self.failed = failed 3. *_something to apply a function that works on the_* value *_to the_* whole monad this is bind, >>=. in the Python object example, bind might look like: def bind(self, f): if self.failed: return self else: try: x = f(self.data) return Failure(x) except: return Failure(None, True) so: Failure("9").bind(int).bind(partial(operator.mul, 2).value # "18", no problem Failure("dog").bind(int).bind(partial(operator.mul, 2).value # None, but no problem from trying to multiply it by 2-it never got there *the point is that bind abstracts out the part where you have to unwrap the data before you can **_do_** something with it.* this is analogous to how map or reduce factor the looping out of various tasks.

@@thoperSought Thank you very much. This translation into Python really helps. I guess the >>= notation is the part that was the most confusing for me in the video. Could you please by any chance produce a similar example with demonstration of how monads could be used to isolate side-effects? I have just seen a video regarding FP that focused on Clojure implementation and they hinted use of side-effect queues which is an approach that I can understand and atoms which are just pure state containers similar to state vectors in control theory. So I wonder what Haskell does differently there.

@@PterippiGaming The bind operator for a (trivial) logging monad might look something like LogM x >>= f = print "Calling another function"; f x

@@thoperSought That single comment told me more about "What is a Monad?" than the 21 minutes video I just watched. Thanks!

@@matdryz I wanted to write the same comment. The video is really bad.

They were discovered by the pioneers of Category Theory in Mathematics.

You mean the only actual programmers in a field of hobbyists?

so like with... as ...: in python?

If that is what it is, then you just gave one of the best definitions I could ever imagine, because in those few words I feel like I understand exactly what you mean; unlike this 20 minute video.

@@robbiedozier2840 kind of. The with... as... In Python is setting up a nice little box in which you know something (usually a file being open) holds, and outside of that box, you don't have to worry since everything is handled with closing the file, or whatever. A monad is kind of like having a "with .. as" for every line of code. In that sense it's more general, but your intuition is correct.

I like your definition because I can easily understand it, but I have no idea if it's correct.

@@MrBogfrog let me help you. Semicolon is just a >>= operator for datatype which represents state of your program

I just realized I learned enough category theory to finally understand what that means.

Monads are burritos.

Finally some math-friendly, understandable explanation.

a burrito is just a strong monad in the symmetric monoidal category of food

"Category" and "Functor".

Checkout the 'Functional Program Design in Scala' on Coursera, where the Monad is mentioned in First week. I think it has a pretty nature explanation (but not as complete as the HaskellWiki as it is still understandable)

He explains it, it's the notion of effects. A state change program is fraught with effects, notably side effects. Functional programming mitigates that. Hence Haskell is a pure language.

@Peter The Great If you know what it is conceptually then to put you at ease all I can suggest is it's a definition like any other :) You have the strongest definition of a Monad from category theory however the functional programming element of it probably adopt functors loosely.

@@zhy7604 Scala is unbearably tedious though

Monad = a special kind of a "design pattern" in functional programming that allows writing code generically In terms of the video, the term "monad" explained via an example of "maybe monad" design pattern. It shows how a program can be simplified AND allows us to see what "writing code generically" means (e.g. avoid common error checking). Though, in order to truly achieve "writing code generically" it's not enough to have only "maybe monad" and that is why there are exist other monads. The video doesn't show other examples of monads but we can assume that a monad is a "design pattern". But it's "a special kind" of a design pattern, not a generic one. To summarize, knowing what "desing pattern", "a special kind" and "writing code generically" means we should be able to understand what a monad is.

When's that point gonna come around? I still manage to get my runtime frozen with monads from time to time

It's well defined in the field of category theory

So like pointers then.

You just say literally: you never understand monad until you understand them. I suppose this is also monad. Right?

To me a monad is just the pattern of having a method for sequencing indefinitely and a method for what to do once you hit the bedrock of your sequence. For example, if you are processing a list you need a method for navigating the list sequentially and then a method for what to do once youve reach the end of the list.

So what? There are a bazillion other superior ways to do it.

@@vendicarkahn4860 such as?

People who have problems with monads are those who are in-between -- i.e., those that have not programmed that often or have not learned modern programming concepts as exposed by Haskell. Long-term C developers can build monadic functions on their own. In fact some may pull examples from their own projects without realizing that they were using such functions.

Absolutely. Rust basically has monads, but not under a consistent heading. Option and Result (Maybe and Either) have and_then functions which act exactly like monadic bind. They also both implement ToIterator after which you can use flat_map, which is _also_ monadic bind.

Statement separators are also monadic bind, if you look at them the right way.

...which only goes to highlight that we are failing to explain them properly. If it's a concept that pretty much anyone can get their head round, why can't we explain them to each other in a way that's easy to get your head round?

Keith Gaughan This fact has led some people, including myself, to refer to monads as "programmable semicolons."

thanks for the only positive comment so far

i have a hit what my gonads are. They are highly fuinctional.

This woulda saved 22 minutes :P

What's a context?

What intermediate value? Why presume there is one?

@@vendicarkahn4860 The intermediate value that you will eventually return, after maybe doing some more things with it. Which may be nothing.

@@davidwuhrer6704 Yup. Monad = Nothing.

XDDD

programming language idea: No. create Nomads

@@sodiboo that'll just give you Nonads

@@sodiboo Nor would give you Nornads. Now, walk backwards far enough away from the screen so that the rn merges visually to an m, -tah-dah-, Nomads

where's the quote from?

not in 7 out of 12 months

@@maximalgamingnl9954 Those are monad stacks.

That makes your comment a recursive one

The summary in the first sentence is a bit off target; the first part describes a type class (which Monad is; another example is Num for numeric, which contains arithmetic operations), and the second part is already enabled by sum types holding fields (which Maybe is; so is Either, and both have instances of Monad). But neither describes the concept of a monad. The prelude describes it thusly: "it is best to think of a monad as an abstract datatype of actions". A monad in Haskell provides a way to sequence processing steps; they could pass information from one to the next, return information, be skipped, repeated, or even reordered. For instance, the STM monad (which allows shared mutable state in multithreaded programs without locking) can repeat actions which it determines need to be retried, and the Maybe monad can skip actions it determines receive no input. The IO monad is the most flexible, as it can perform anything at all, including non-deterministic behaviour; it is also isolated, in that the only thing that performs IO actions is the main function. In effect, the main function's job is to produce the sequence of actions that shall be performed. The Either monad can be easily applied as exceptions are, in that it carries information down the fast Left path as well as the thorough Right path, and the Control.Exception module contains support for translating between this form and IO monad exceptions. Many monads do much simpler work; for instance Identity, First, Last, Max, Min, List (called simply [] in the library), Product and Sum. These are used to take the same internal steps and produce different results from them. State provides a way to carry data past steps, so the steps themselves don't need to forward all state. All of these are deterministic and polymorphic.

The example was how a monad could use used to handle failure, but monads themselves are really about encapsulating the glue that holds a set of sequential steps together. For example, the list monad allows you to write a sequence of steps that are performed for each item in the list, or for pairs/triplets of items in multiple lists; all without writing explicit nested loop code.

Not really. Nomad is a tool that geeks who do not understand input and output use to pretend that input and output is non-existent it their programs, while at the same time performing input and output.

Considering that there is a monad literally called IO which is used to do Input and Output and that monads are used for more than I/O, I do not think saying it is a misunderstanding is either clever or funny.

There's only one problem: Haskell has exceptions that can occur in seemingly pure code. For example: div takes 2 ints and returns an int. What happens when the second parameter is 0? An exception!

Exceptions are side effects.

"A monad is just a monoid in the category of endofunctors. What's the problem?"

You know, I was thinking of the same thing.

@@Adniwhack so glad someone replied, I felt felt so lonely

That was more informative in 20 seconds than this video was in 20 minutes.

Some programmers just write things on the screen without whining that programs should not perform any output.

Well, there's no need to complain in that case, because if you're style of coding is just writing things on your screen, then you're not going to get an output regardless.

*your

It explained the idea perfectly, it's all about the pattern that various effects could happen in a sequence of computations and still you want to "plug" those computations to play nicely together even though the types do not match, that is a monad.

@Shiny: Ever heard of tablets with hand-writing recognition? :p

Admittedly, he failed where all others have failed.

@@capturedflame ok and?

@@capturedflame ok anything else you wanna necro post?

"Monads are everywhere." Pure idiocy. Flatjangs are everywhere because I say so.

​@@vendicarkahn4860You didn't define flatjangs

Except he forgot to explain what a monad is…

That first paragraph could apply to levers in general, not just wheelbarrows.

@@imveryangryitsnotbutter you missed the point genius

@@nunyabiz2016 And you missed mine. How am I, a layperson, supposed to read that paragraph and guess that he means a wheelbarrow, when it could apply to all sorts of ancient inventions? It could be a cart, a hand pump, a crane, or a catapult. Maybe I, a novice programmer, already know what monads are, but I don't know that I know it, because Professor Hutton didn't describe them in a helpful way.

you meant the round thing right ?

That sounds exactly like the point, he described it in such an obtuse way you aren't supposed to know what he's talking about.

WHAT???? Why have I been looking through monads for so long then While I've used option many times in rust

​@Matthew And googling brought up this video. Are you just saying to look at another resource because it may be more helpful, because if so, that's kind of the point of their comment.

I've used Haskell before and trust me, Haskell is not the problem here.

@@donwald3436 Well, maybe Haskell is why we don't even understand the problem...

sharpfang How long does it take to pick up a new programming language? Half a day? Get to it.

@@donwald3436 Until you start understanding advanced concepts in it? muuuch longer. Especially concepts absent in other languages you know.

Exaclty! You can't do proper programing without breaking huevos. The man is a charlatan, he probably doesn't even own a black tail-coat.

Condolences. :)

@@DavidLindes I also spend a couple of recent years using Scala, so double condolences please.

LOL AMEN! In Java, for int division by zero, you really have no choice but to throw an ArithmeticException because the result cannot be valid. It is undefined, but int variables can’t deal with that. For floats or doubles, the divide-by-zero result would be NaN (or maybe Infinity), and the calling code would need to check for that. FUN! 😒

North Georgia Hawg inbefore 1000’s of stacktraces

@@kencarp57 You can always write your own abstractions on top of primitives

Same reaction here -- frustrating to watch as the camera keeps switching away from the material, right as you try to absorb it. Also not a great viewing angle -- hard to make out the Haskell symbols at 360p.

that's the difference between a photographer and a mere cameraman

17:10 ...

All this video is kind of a "why". If it was a proper "what", he should have explained SemiGroups, Monoids, Functors, and Endofunctors... Actually he showed the Maybe Monad as an Endofunctor (he didn't say anything about the >>= associative properties)

So if we did away with wrapping altogether, we could avoid all this confusion, right?

Of course you could avoid the Monad confusion but at the expense of more verbose and quite possibly more bug-prone code. Being able to concisely pass values wrapped with metadata along a chain of processing steps is useful. With better explaining, it could be useful to more people, without as much confusion.

This became understandable to me only after watching the monad video by “Studying with Alex” Highly recommended for programmers from OOP land

@@vikingthedude thank you!!! I'll check that channel out!!

he literally does exactly what you're asking around 16:05

@@thoperSought I disagree. Where’s the definition there?!? If you’d said 16:44, that would have been closer, but it still falls short to me.

@@DavidLindes I'm not sure of the exact time stamp, but the point is that the definition of a monad is that it's the combination of the three things he's explaining *_around_* 16:05

@@thoperSought I stand by my original statement. The pieces have been explained, but the word has not been defined. And as for your attempt at a definition, too much of “the three things he’s explaining around 16:05” are specific to the Maybe monad, so that doesn’t help me understand what a monad _in general_ actually is, really. Thankfully, Wikipedia did _slightly_ better, and I have some idea now. That doesn’t invalidate the critique of the video content, however. (Which I rewatched all of, and still didn’t catch a definition.)

@@DavidLindes so, I def. see where you're coming from-I didn't get it when I originally watched this video, either. otoh, you asked for him to _"circle back and _*_define_*_ monads in terms of these concepts,"_ which I argue that he did. you're right that he did it at 16:44. he laid out the three components Maybe, and then said, _"A monad is some kind of type constructor, ..., together with two functions that have these two types here."_ I would argue that it's not sufficient-that _no_ definition _can_ be sufficient-unless *_you_* have enough background in specific cases to see what the monad factors out. I watched a talk once where the speaker compared some code using fold/reduce with a few similar for loops, and showed how fold was factoring the looping out of the code. map (which you may know can be defined in terms of fold) does the same thing. a monad factors *_something else_* out of code in *_the same way_* that fold factors out the looping. one of the things that makes this really difficult is that the "something else" with monads is harder to pinpoint, and a lot more stuff fits into that slot.

No that's mad.

That's just the dyslexic ones.

Monads ride on calems.

Maybe...

I think they are called Contractors.

In the video: >>= is the flatMap f is the transform There’s also “return”, which wraps any given content into a new monad, to take us from the ordinary code to the monadic code.

First get confortable with functional programming in general with non-pure functional programming language like ocaml/F#/Scala, Monad is not the first step of functional programming at all. When you feel confortable with functional programming in general, then learn what is a semi group, a monoid, a functor, an applicative, and then a monad. See all of them as kind of an interface with rules to respect. Like a design pattern.

He doesn't really emphasize it in the video, but the heart and soul of every monad is its bind function (>>=). A monad is any data type that has a bind operator. bind is what implements the defining effects of the monad. Instead of chaining operations with composition, as in y = g(f(x)), you chain impure operations with bind: yM = (M x) >>= h >>= j.

Adding to this: this is because most programmers are trained with ALGOL/C like syntax.

The Applied Category Theorist in me wants to be angry, but instead I am now resolute on playing this video in front of this weekend's Applied Category Theory #3 conference at UC Riverside to prompt discussion!

A monad isn't a function, exactly. It's more like an interface with two methods, "bind" and "unit". The point of it is to create an algebra. A simple example is array APIs: methods on arrays that return arrays, like map, filter, flatten, etc. In that case "bind" is flatmap (map followed by flatten). You can use this pattern in very many ways. It's extremely useful. In the case of side effects, imagine rewriting a function that does terminal IO so that it instead returns data. E.g. instead of "print('hello')", you do "return {action: 'print', data: 'hello'}". Now your function doesn't do IO; it returns data that specifies what IO should happen. You can continue like this, removing explicit IO from all of your functions. That works until you come to a case where the IO depends on some earlier IO event. E.g. the user types their name and you want to print "hello ${user}". To do that, you can use a monad. The monad is providing a sort of algebra of IO streams with operations like "take this IO stream, and return an IO stream that has output 'hello'". "Take this IO stream that has output 'hello', and return an IO stream that has output 'hello' and input the user's name". "Take this IO stream that has input the user's name, and return an IO stream that has output "hello ${user}". Etc. The point of all this is it removes side effects from your code (making it easier to test, and more composable), and in languages like haskell it allows them to type check IO operations, which is pretty cool.

OK showing my age, How does this compare to CodeBlocks in Clipper i.e. functions that could be passed as parameters or embedded in the syntax of array manipulation for tasks like custom sort orders.

I had never heard of Clipper or CodeBlocks, but after a quick google it looks like a syntax for writing first-class functions which you might then pass to a high-order function like sort (or flatmap). This is a language feature required for pretty much any functional programming pattern, including monads, but isn't otherwise specifically related.

Thanks; sort of what I was expecting.I accept it may not be the academic equivalent but I was using this sort of stuff 27 years ago. A lot of programmers I have known have utilised language functionality to at least partially mimic features that became available in later languages because it made their dayjob easier . This is where a lot of the 'meh' factor comes from when we see academics going on about the latest big thing.

GTG3000 i thought he explained it pretty well, if you didn’t understand this maybe you should start learning about some of the basics of functional programming before learning about these kinds of things?

@@aNotoriousPhD Yes, learn what a monad is, and then watch the video again.

I don’t see why I would do this when I Can just use a language that is useful for the thing I’m trying to do.

richtourist I don't understand Haskell, what I know about FP is some untyped lambda calculus basics, a few days of practicing in Scala and one day of practicing in Scheme to this day, but I still understand this video.

I assume that there are more complex cases where it simplifies things. I would have loved to learn about these.

​@@aheendwhz1 buy his book:)

That was the easy to understand part of the video. If you can't get past that bit then don't bother with the monad part.

It's just weird looking algebra with a bit of extra notation (the :: "has type" syntax). My uni does a discrete maths course that uses pseudo-Haskell, and a lot of people complained that they needed to know Haskell. I understand the intuitive complaint. It needs to be better explained how it's exactly like things you already learned early on in secondary.

Started to look into haskell yesterday. Today this was not that hard.

"It's just weird looking algebra with a bit of extra notation " bruh, that applies for, like ..., the domain of all of Haskell.

@@holonholon1141 I think you misunderstand the complaint. You need to already understand the underlying *meaning* and *idea*, which is kinda weird and alien to most people. The syntax is secondary.

No problem understanding coming from a swift background. If you scratched the surface of functional programming this should make sense.

Bindng is really the core magic of Monads, and why we have to define each one uniquely. Let's pretend you have some Context that has a type slot. You've seen Maybe a = Just a | Nothing. But let's ignore the specific context for now. What binding does is take a value with Context, and a function that takes a value and returns a new Context value, and then systematically plumbs that context all the way through. Let's get concrete to help show what that means. Imagine a monad with NO context, "Identity." Identity a = Identity a. Pretty useless except for specialist purposes. But consider it for a second. What does something like this program "do": (Identity 5) >>= \x -> return x + 1 It makes an Identity 6. Now, Identity has 0 context at all, right? So it's really easy. All the bind operator does is pattern match out the number and pass it forwards to the new function. But now think about it, what happens if we used Maybe. We've got 2 cases: (Just 5) >>= \x -> return x + 1 (Nothing) >>= \x -> return x + 1 For the first case, the bind operator's function says, "Oh I have a value. I'll pass that along to the function, and then return what it returns." This is exactly like what the Identity monad did, right? The second case though, the bind operator looks and sees it has a Nothing. "Well dang, I can't even CALL that next function, I have nothing to give it at all. Literally the only thing I could possibly do that would typecheck is return Nothing. I have no other options." I hope this helps explain what binding is and how the program "knows" not to do the extra work of calling forward. Monads are very powerful because they actually model programs that build programs, at runtime. This is fundamentally more awesome than if statements. Let me show you one final (simplified) example. Let's imagine we have an imaginary function httpGet. Its type is Url -> Maybe String (please note, this is not the real world type we'd use and we could never use it, but bear with me for a moment I'm explaining something bigger here). When you need to do 2 of these in one function and use their values, Maybe suddenly makes our life incredibly easy. fetchUserDetails :: String -> Maybe UserRecord fetchUserProfile userName = do userDetails

The reason that this monadic approach is nice is that it abstracts the "checking" away. The failure "propagates" if it occurs.

I'd also recommend Scott Wlaschin's talks and blogs on "railway-oriented programming." This is the best explanation of this that I've encountered.

@@KirinDave Hi there! I know it's been over a year since you posted this comment, but I'd like to thank you regardless. This is honestly the best explanation for monads I've ever heard. I've been struggling with the concept for a while and I finally get how straightforward it is now. Thanks!

@@gogogalian I'm proud I could help you.

Monads let you write imperative code using functions, in a way that makes it clear "why" you're ding things instead of "how" you do them. There's more than one monad. The thing he presents in the video is a Maybe monad (also known as Option, in other languages). It allows you to turn a partial function (a function that isn't defined for some inputs) into pure function (that is defined for all inputs). The "Nothing" state basically indicates that the operation can't be performed. It's not really meant for propagating proper errors. It's meant for short-circuiting chained functions and forcing you to handle edge cases. For error propagation, there's an Result monad. It has an Ok(value) for success and Err(value) for failure. Just like the Nothing value in Maybe, the error value short-circuits chained functions. But unlike Nothing, it actually carries a payload (typically the error message), that then has to be explicitly handled. In both cases, it gives you more freedom in "when", "where" and "how" you handle the failure states. Another very common monad is an Iterator. It generalizes iteration of elements. It lets you write code that "doesn't care" where the values come from or where they go. You can have a function that accepts an iterator and it will work the same way whether you feed it with collection, yielding procedure, network socket, channel, file, or anything that can be iterated in some sense. You can transform the iterated elements (even fallibly), turn them into iterators and flatten, you can collect them into data structures, reduce or fold the iterator to a single value (such as min/max/first/last, even fallibly), chain different iterators together etc. Monads also work well together. For example, you can filter an Iterator over Maybes by skipping the Nothing values. Or transform Iterator over Results into iterator that short-circuits on the Errors. Or you can turn Maybe into Result, by providing the error variant. Or turn it into an iterator over zero/one element. There are many other monads, such as loggers, permutations, readers, writers, environment monads,...

A freakin' men. I love haskell, but more explanations need to show examples of these concepts in the more commonly used languages. Just to bounce off of this, if you're in C#, then it's worth noting that IEnumerable is also a monad. "SelectMany" is the same as ">>=". I think that javascript's promises are another example of a monad. I believe then() is the monadic bind operator.

Meh. I believe I roughly understand the concept of monads, and I still think it's mostly useless for real world applications. People can manipulate optional types, promises, observables and exceptions without ever having to wrap their head around ">>= : m a -> (m a -> b) -> m b". In 99% of real-world cases, developers only need "a ?? b" and "a?.b", and the mathematical background is useless.

@@Olivman7 guess your world is different from mine then :)

I've been learning Haskell for some time while being only briefly exposed to Java. But calling them "Optional.of()" and "Optional.flatMap()" rather than "return" and ">>=" makes the concept so much easier for me to understand. Another proof that naming is the hardest problem in computer science, I guess.

What about streams in Java 8? Don't they follow monad laws.