A Monads Approach for Beginners, in Scala | Rock the JVM
Вставка
- Опубліковано 15 чер 2024
- Written version: blog.rockthejvm.com/monads/
This video is for Scala programmers with some essential skills (generics, Options and how flatMap works on lists). In here, I'll try to arrive at the monad structure by writing code and solving programming problems, instead of weird mexican-food analogies or blackboard abstract math.
Monads are inherently abstract, but we'll write concrete examples, and then derive the structure of a monad and the monad properties ("laws") starting from the concrete and then generalizing the ideas. We'll write some 150 lines of code in this video alone.
Contents:
0:00 Intro and requirements
1:00 The ETW pattern and monad structure
10:50 Example 1: a census application
17:05 Example 2: async calls in an online store
24:51 Example 3: double-for "loops"
28:28 The monad properties
Follow Rock the JVM on:
LinkedIn: / rockthejvm
Twitter: / rockthejvm
Blog: rockthejvm.com/blog
-------------------------------------------------------------------------
Home: rockthejvm.com
------------------------------------------------------------------------- - Наука та технологія
One of the best Monad laws I've ever seen. Very nice man!
Thanks!
Such a brilliant explanation. Thank you very much!
Was waiting for such a Video. I loved the explanation at the end for the monadic laws and it did help a lot by giving concrete examples. Something that can be added as an extra to your advanced scala course. Great Video as always !! :)
Glad you liked it!
Very clearly explained. The examples used are good for helping me understand the concept. Thank you very much!
Thanks Daniel, really appreciate, I'm studying Cats right now but this video was very clear and helpful!
Absolutely best description/explanation I have seen! It "clicked"
Great to hear!
Thank you for the video, I really like the examples !
I liked very much that you skipped the theory and stick to the behavior of the code, you can always read more about the theory if you want but explanations like this with demostration on the the terminal, I think is what is most valuable for this video. Keep up the good work! and thank you very much!
You've got talent for keeping watcher's attention through whole 40min video :) Thanks for great content!
Thanks - glad it's useful!
This video FINALLY made me understand HOW to use monads!
That's my goal!
I have read articles and books, cried tears of blood while going thru them. And then I find this.. Wow -- well done. If your courses are like this.. I am a buyer for sure. Keep up the excellent work.
Such awesome praise, thanks! I have lots of content like this on the site.
Bravo!!! There are no bad students , just incompetent teachers. I am proud to say I CAME ACROSS THE BEST TEACHER!!! Kudos to you Daniel :)
Such high praise, thanks!
I really learned a lot from this vid! Thanks! I’m not a Scala dev but I think I can use that new flatMap approach when working with Stream API from Java 8!
Amazing, that's my goal for these videos - transferrable skills!
I am so happy I went through this video. 40 mins felt a bit too much, but I guess it was required to understand. Thanks a lot.
Glad it was useful!
The first time I watch the video, I still didn't understand Monads. But, in the second, I got it.
Thank you!
Glad it clicked!
Amazing video. Thanks a lot.
Thank you for the video daniel.
done lots of haskell a while back but never heard of the 'm-word', gonna embrace it :-)
God explanation, thank you man now i understand that sh`t !!!
You have really awesome teach skill !!!
thank you, I read cats book, too hard to understand, but I got all after watching your video.
Great video explaining a topic that often gets beginners confused.
I would add that most developers have used monads in some way without knowing the underlying concept:
- async/await especial syntax is kind of the same as 'for comprehension' but specialized for async code. Instead of using 'await' you use '
Well said!
Excellent video, sad that so few people have seen it.
great explanation!
thanks man!
Glad it helped!
Thank you for this wonderful video as well. I always press 'like' button. From my understanding, I presume 'for-comprehension' for List(1,2,3) and List('a', 'b', 'c') would yield a cartesian product..
Thank you!
Yes, that's true.
Dude, you should really have some commercial videos made! You are the best :)
Thanks! Check out the Rock the JVM website, I have full-blown courses on a ton of stuff.
I've heard that Monad has one more property - anyone who got understanding Monad immediately looses ability to explain it to other people. You proved it's not true. Thank you for the fantastic Monad explanation!
Thanks!!
Very well done 👍
Really useful video!
scala 'for' reminds me of do/return from haskell
amazing video, thanks
Glad you liked it!
Love it 👍
Monster!!! Thank u man
Glad it clicked!
Weekends are good learning scala.
I know, right? :D
At 31:02 you mentioned ‘Monad(x).flatMap(f) == f(x)’ , I am afraid this is not always right.
If we try: ‘def createVector(x:Int) = Vector(x, x+1) ; List(3).flatMap(createVector) ‘ the result should be ‘List(3, 4)’ but according to your formula it would be ‘createVector(3, 4)’ i.e. ‘Vector(3, 4)’
The correct explanation can be ‘Monad(x).flatMap(f) == Monad(x).map(f).flatten’ which one can consider as ‘Monad( f(x).flatten )’ .
Think of it as just flattening the inside structures.
Hope this is helpful.
Thank you for the great video.
You're mixing lists with vectors, which are obviously different things. Even so, the returned type is still a supertype of both, which still satisfies the law.
The monad laws as I stated them in the video are still true for functions returning lists.
you are awesome..!
14:21 you didn't mention not returning null which cause esoteric null pointer exceptions which is another benefit of option
cool!
Isn't the prop 2) a special case of prop 1) when f = x => Monad(x) ?
Please do an explanation of tagless final 👍
oh that's would be great!
genious
I have an issue with the first monad rule, at least as it was described here. Is it correct to assume, that in the formula:
```Monad(x) .flatMap(f) == f(x)```
the function is not just a function, but a function that can returns a Monad of the same type, and can be described as
```f[T](x: T): Monad[T]```
Am I correct to assume that? I can see that it's true for lists, but I am not sure whether it's true in general terms. Because *Option(12).flatMap(_ * 2)* is not equal to 12 * 2, it is *Option(12 * 2)*
UPD: same goes for the third rule. I guess we cannot just apply flatmap to the result of *f(x)* if it is not a monad itself.
Your counterexamples are improperly typed - you can't say Option(12).flatMap(_ * 2), but rather Option(12).flatMap(Some(_ * 2)), in which case the law holds. Same for the third law.
It's not that you can assume f to be of type T => Monad[T], but you MUST assume that by the type signature of flatMap.
@@rockthejvm thank you!
rocks
This is what I learned about Monads
(1) Monad - has a pure constructor, and a flatMap
(2) Monad(x).flatMap(f) == f(x)
(3) Monad(v).flatMap(x => Monad(x)) == Monad(v) // Useless
(4) Monad(v).flatMap(f).flatMap(g) ==
Monad(v).flatMap(x => f(x).flatMap(g))
I feel so outdated. I seem to have not touch maths for the last 12 years, and nothing other than Java, until a few months ago.
Is there a list of what types of variables are monads? List, Futures, Options.. but what else? BTW Great video!!
Lots of things are monads. Just remember the monad properties.
Reader, Writer, Eval, State, IO are other examples of monads.
Thank you 😄
thank you. p.s. would be nice if the text font size was extremely larger.
Got it - are you watching the videos on mobile?
@@rockthejvm no. im used to not having to go to fullscreen/look fairly close. "programming in mosh" on youtube usually has text size bigger than one would code with but I think it benefits not only mobile, but on pc is also window mode more readable than smaller font looks in fullscreen.
(8:57) line 12-13 the function actually does synchronized twice, Is that necessary for the purpose?
Can I write this instead?
def flatMap[S] (transformer: T => S): SafeValue[S] = {
SafeValue(transformer(internalValue))
}
@@mourikogoro9709 there is no double locking in this example.
What you're suggesting is a map function (not flatMap).
@@rockthejvm Am I really misunderstand? Why?
1st synchronized is during apply the function's argument (i.e. transformer: T => SafeValue[S])
2nd is the synchronized block of the flatMap function itself
@@mourikogoro9709 the transformer argument is a function value which can be anything; it has nothing to do with the transform method of the previous SafeValue implementation
Why flatMap which makes us transform the thing into a SafeValue again? Why not use map, so we dont have to write the "wrap" step in our transformation function?
flatMap is useful when all you have is functions returning SafeValues - if you simply map the transformations, you'll get a SafeValue[SafeValue[...]], which is not what you want
@@rockthejvm Ohh okay, I was thinking maybe there was a way to avoid those nested Monads without using flatMap. But I guess not. Thanks for the awesome content
Sorry I forgot, why you keep on saying never use Double for money in app, can you please elaborate this ?
Doubles can't represent tens and hundredths with full precision, which means you can lose cents on every operation. Use decimals instead.
@@rockthejvm Is there any blog you have written around it ?
Can u upload more video about implicit ?
And some functional topic like fold, foldLeft and foldRight
He has a course on all of that on Udemy :)
@@sherwin96 I have learned that but feel not enough :# at advanced scala course :V
@@Code4Life if you haven't done the Coursera scala specialization,, that is something I would suggest you look into. It really dives deep when you talk about those functions. It also covers implicit's in its entirety. You won't get anything better, especially if you solve the assignments.
>hey bro monads are easy just read an article or two, you will understand them
>search monad on youtube
>all videos are 30+ minutes
h-haha functional programming is cool, oop suck amirite guizzz
All important questions in life take time to properly sink in.
At 30:22 you enumerate Option, Try, Future, List as Monads but Future actually is NOT a monad!!!
There's this age-old discussion whether a Future is a monad or not, since it includes the passage of time. For beginners (which is the scope of this video), we'll just consider Future to be a monad.
Scala users still haven't switched to Kotlin?
Not until Kotlin has this sort of power
The problem with monads is that once you know what is, you lose the ability to explain it
The color theme makes it hard and boring to follow, please change the theme to atom one dark theme.
WTF? Is this an explanation for beginners? Of what?
Still looks like rocket science?