Monads for the working class

Slides for https://github.com/yannick-cw/monads-for-the-working-class

Transcript

1. Monads for the working class with cats
2. Category Theory
3. WTF, why should I care? • make our life easier • help us to separate description and implementation • make implementations easily replaceable we will focus on real and easy examples
4. Typeclasses
5. Ad hoc polymorphism
6. Example If you want to create a Json with circe1, you'll need a typeclass.. // we can't change the user, imagine from a library case class User(name: String, age: Int) // simplification trait Decoder[A] { def toJson(a: A): String } 1 https://github.com/circe/circe
7. Example val userDecoder = new Decoder[User] { def toJson(user: User): String = s"""{ "name" : "${user.name}", "age" : ${user.age}}""" } val me: User = User("Yannick Gladow", 27) userDecoder.toJson(me) // or import io.circe.syntax._ // magic that adds functionality to to our type - simplified me.toJson //res0: String = //"{ // "name" : "Yannick Gladow", // "age" : 27 //}"
8. Example -- Scala 2.12 -- SAM Types // instead of: val userDecoder = new Decoder[User] { def toJson(user: User): String = s"""{ "name" : "${user.name}", "age" : ${user.age}}""" } // Single Abstract Method val userDecoder: Decoder[User] = user => s"""{ "name" : "${user.name}", "age" : ${user.age}}"""
9. There is more, but for us: Add functionality to existing Types
10. Monoid
11. Example case class User(name: String, age: Int) val users1: Map[String, Set[User]] = Map("B" -> Set(User("Brian", 19))) val users2: Map[String, Set[User]] = Map("B" -> Set(User("Bob", 33))) users1 ++ users2
12. Example case class User(name: String, age: Int) val users1: Map[String, Set[User]] = Map("B" -> Set(User("Brian", 19))) val users2: Map[String, Set[User]] = Map("B" -> Set(User("Bob", 33))) users1 ++ users2 res0: Map[String,Set[User]] = Map(B -> Set(User(Bob,33))) Where is Brian?
13. Example How to keep Brian -- the hard way? val users1: Map[String, Set[User]] = Map("B" -> Set(User("Brian", 19))) val users2: Map[String, Set[User]] = Map("B" -> Set(User("Bob", 33))) users1.foldLeft(users2) { case(accumulatedUsers, (category, users)) => accumulatedUsers.updated( key = category, value = accumulatedUsers.getOrElse(category, Set.empty) ++ users ) }
14. Example How to keep Brian -- with Monoids? import cats.implicits._ users1.combine(users2)
15. Example Whats going on? Monoid Typeclasses! trait Monoid[A] { def empty: A def combine(a: A, b: A): A } Adds combination to A
16. Example Actually two monoids in Action // monoid for Sets def setMonoid[A] = new Monoid[Set[A]] { override def empty: Set[A] = Set.empty override def combine(a: Set[A], b: Set[A]): Set[A] = a ++ b } } // monoid for Maps def mapMonoid[K, V](V: Monoid[V]) = new Monoid[Map[K, V]] { def empty: Map[K, V] = Map.empty def combine(map1: Map[K, V], map2: Map[K, V]): Map[K, V] = map1.foldLeft(map2) { case (accumulatedMap, (key, values)) => accumulatedMap.updated( key = key, value = V.combine(values, accumulatedMap.getOrElse(key, V.empty)) ) } }
17. Example How to use them? mapMonoid[String, Set[User]](setMonoid[User]) .combine(users1, users2) // or import cats.implicits._ users1.combine(users2)
18. Example This stuff already exists -- you don't have to define it! But we can for our own types now case class SortedUsers(users: List[User]) implicit val sortedByAgeMonoid = new Monoid[SortedUsers] { def empty: SortedUsers = SortedUsers(List.empty) def combine(a: SortedUsers, b: SortedUsers): SortedUsers = SortedUsers((a.users ::: b.users).sortBy(_.age)) } implicit val sortedByLexicographicOrderMonoid = new Monoid[SortedUsers] { def empty: SortedUsers = SortedUsers(List.empty) def combine(a: SortedUsers, b: SortedUsers): SortedUsers = SortedUsers((a.users ::: b.users).sortBy(_.name)) }
19. Example val yannick = User("Yannick", 27) val brian = User("Brian", 19) val bob = User("Bob", 33) import cats.implicits._ List( SortedUsers(List(yannick)), SortedUsers(List(bob, brian)) ).combineAll/*(sortedByAgeMonoid)*/ // res0: SortedUsers = SortedUsers(List(User(Brian,19), User(Yannick,27), User(Bob,33))) List( SortedUsers(List(yannick)), SortedUsers(List(bob, brian)) ).combineAll/*(sortedByLexicographicOrderMonoid)*/ // res0: SortedUsers = SortedUsers(List(User(Bob,33), User(Brian,19), User(Yannick,27)))
20. Conclusion • everything in the background was already defined, no work for us • use it for existing stuff, like Map • define it when you want to combine your own types once and get everything else for free • define different versions of your Monoid
21. Monoid Laws // associativity combine(combine(x, y), z) == combine(x, combine(y, z)) // identity combine(x, empty) == x combine(empty, x) == x
22. Monoid Laws // breaking the law val divisionMonoid = new Monoid[Double] { def empty: Double = 1.0 def combine(x: Double, y: Double): Double = x / y } // identity combine(empty, x) == x import divisionMonoid._ combine(empty, 2.0) == 2.0 // res3: Boolean = false
23. Monoid Laws // breaking the law val divisionMonoid = new Monoid[Double] { def empty: Double = 1.0 def combine(x: Double, y: Double): Double = x / y } // associativity combine(combine(x, y), z) == combine(x, combine(y, z)) import divisionMonoid._ combine(combine(2.0, 3.0), 4.0) == combine(2.0 ,combine(3.0, 4.0)) // (2 / 3) / 4 == 2 / (3 / 4) // res3: Boolean = false
24. Exercise https://github.com/yannick-cw/monads-for-the-working-class
25. Monads
26. A monad is just a monoid in the category of endofunctors, what's the probleⅿ2? 2 https://stackoverflow.com/questions/3870088/a-monad-is-just-a-monoid-in-the-category-of-endofunctors-whats-the- proble%E2%85%BF
27. Monads are not difficult to understand
28. Representing Failure def getUser(id: Int): User = ???
29. Representing Failure def getUser(id: Int): Option[User] = ???
30. Representing Failure def getUser(id: Int): Option[User] = ??? val success: Option[User] = Some(user) val failure: Option[User] = None
31. Remember Functor?
32. def getUser(id: Int): Option[User] = ??? // db operations
33. def getUser(id: Int): Option[User] = ??? // db operations def updateUser(user: User): User = ??? // db operations
34. def getUser(id: Int): Option[User] = ??? // db operations def updateUser(user: User): User = ??? // db operations val maybeUser1: Option[User] = getUser(1) // how to update this user?
35. def getUser(id: Int): Option[User] = ??? // db operations def updateUser(user: User): User = ??? // db operations val maybeUser1: Option[User] = getUser(1) val updatedUser: Option[User] = maybeUser1.map(user1 => updateUser(user1))
36. That was Easy - Functor
37. But in the real world?
38. def getUser(id: Int): Option[User] = ??? // db operations def updateUser(user: User): User = ??? // db operations
39. def getUser(id: Int): Option[User] = ??? // db operations def updateUser(user: User): Option[User] = ??? // db operations
40. def getUser(id: Int): Option[User] = ??? // db operations def updateUser(user: User): Option[User] = ??? // db operations val maybeUser1: Option[User] = getUser(1) val updatedUser: ??? = maybeUser1.map(user1 => updateUser(user1))
41. def getUser(id: Int): Option[User] = ??? // db operations def updateUser(user: User): Option[User] = ??? // db operations val maybeUser1: Option[User] = getUser(1) val updatedUser: Option[Option[User]] = maybeUser1.map(user1 => updateUser(user1))
42. What now?
43. Flatten to the rescue
44. val updatedUser: Option[Option[User]] = maybeUser1.map(user1 => updateUser(user1)) val flattendUser: ??? = updatedUser.flatten
45. val updatedUser: Option[Option[User]] = maybeUser1.map(user1 => updateUser(user1)) val flattendUser: Option[User] = updatedUser.flatten
46. What just happend?
47. We chained two operations returning Options[User] and flattened them maybeUser1.map(..).flatten
48. Thats it - Monad
49. Let's take a look
50. Monad typeclass
51. // generic definition trait Monad[M[_]] { } // concrete implementation for Option val optionMonad = new Monad[Option] { }
52. trait Monad[M[_]] { def pure[A](a: A): M[A] } val optionMonad = new Monad[Option] { def pure[A](a: A): Option[A] = Option(a) }
53. trait Monad[M[_]] extends Functor[M] { def pure[A](a: A): M[A] def map[A, B](a: M[A], f: A => B): M[B] } val optionMonad = new Monad[Option] { def pure[A](a: A): Option[A] = Option(a) def map[A, B](a: Option[A], f: A => B): Option[B] = a match { case None => None case Some(a) => Some(f(a)) } }
54. trait Monad[M[_]] extends Functor[M] { def pure[A](a: A): M[A] def map[A, B](a: M[A], f: A => B): M[B] def flatten[A](a: M[M[A]]): M[A] } val optionMonad = new Monad[Option] { def pure[A](a: A): Option[A] = Option(a) def map[A, B](a: Option[A], f: A => B): Option[B] = ??? def flatten[A](a: Option[Option[A]]): Option[A] = ??? }
55. val optionMonad = new Monad[Option] { def pure[A](a: A): Option[A] = Option(a) def map[A, B](a: Option[A], f: A => B): Option[B] = ??? def flatten[A](a: Option[Option[A]]): Option[A] = a match { case None => None case Some(x/*Option[A]*/) => x } }
56. We can do .map .flatten now!
57. Lets call it .flatMap from now
58. trait Monad[M[_]] extends Functor[M] { def pure[A](a: A): M[A] def map[A, B](a: M[A], f: A => B): M[B] def flatten[A](a: M[M[A]]): M[A] } val optionMonad = new Monad[Option] { def pure[A](a: A): Option[A] = Option(a) def map[A, B](a: Option[A], f: A => B): Option[B] = ??? def flatten[A](a: Option[Option[A]]): Option[A] = ??? }
59. trait Monad[M[_]] extends Functor[M] { def pure[A](a: A): M[A] def map[A, B](a: M[A], f: A => B): M[B] = ??? def flatMap[A, B](a: M[A], f: A => M[B]): M[B] } val optionMonad = new Monad[Option] { def pure[A](a: A): Option[A] = Option(a) // remember the Db ops def flatMap[A, B](a: Option[A], f: A => Option[B]): Option[B] = ??? }
60. Why no map in optionMonad?
61. We can implement map once and for all for every Monad - See exercise :)
62. Its really just chaining operations returning stuff like Option, Future, Either, Task...
63. def getUser(id: Int): Option[User] = ??? // db operations def updateUser(user: User): Option[User] = ??? // db operations def getUsersCity(user: User): Option[City] = ??? // db operations val optCity: Option[City] = getUser(1) .flatMap( user1 => updateUser(user1.change) .flatMap(user1Changed => getUsersCity(user1Changed)))
64. So much work - so ugly
65. def getUser(id: Int): Option[User] = ??? // db operations def updateUser(user: User): Option[User] = ??? // db operations def getUsersCity(user: User): Option[City] = ??? // db operations val optCity: Option[City] = for { user <- getUser(1) updateUser <- updateUser(user.change) city <- getUsersCity(updateUser) } yield city
66. for is nicer Syntax for .flatMap (and more)
67. Separate logic and implementation
68. Abstraction
69. trait UserRepo[M: Monad] { def getUser(id: Int): M[User] = ??? // db operations def updateUser(user: User): M[User] = ??? // db operations def getUsersCity(user: User): M[City] = ??? // db operations } // M could be Option val optionMonad: Monad[Option]
70. trait UserRepo[M: Monad] { def getUser(id: Int): M[User] = ??? // db operations def updateUser(user: User): M[User] = ??? // db operations def getUsersCity(user: User): M[City] = ??? // db operations }
71. def updateAndGetCity[M: Monad](repo: UserRepo[M]): M[City] = for { user <- repo.getUser(1) updateUser <- repo.updateUser(user.change) city <- repo.getUsersCity(updateUser) } yield city
72. def updateAndGetCity[M: Monad](repo: UserRepo[M]): M[City] = for { user <- repo.getUser(1) updateUser <- repo.updateUser(user.change) city <- repo.getUsersCity(updateUser) } yield city
73. def updateAndGetCity[M: Monad](repo: UserRepo[M]): M[City] = for { user <- repo.getUser(1) updateUser <- repo.updateUser(user.change) city <- repo.getUsersCity(updateUser) } yield city // in production code val city: Future[City] = updateAndGetCity( repo = new UserRepo[Future] { def getUser(id: Int): Future[User] = db.getUser(id) ... } )
74. def updateAndGetCity[M: Monad](repo: UserRepo[M]): M[City] = for { user <- repo.getUser(1) updateUser <- repo.updateUser(user.change) city <- repo.getUsersCity(updateUser) } yield city // in test code val city: Id[City] = updateAndGetCity( repo = new UserRepo[Id] { def getUser(id: Int): Id[User] = User(name = "Pete") ... } )
75. One thing before we are done: Laws
76. def f(i: Int): Option[String] = Some(i.toString) val optionMonad: Monad[Option] //Identity optionMonad.pure(2).flatMap(f) == f(x) Some("2") == Some("2") Some(2).flatMap(i => optionMonad.pure(i)) == Some(2) Some(2) == Some(2)
77. def f(i: Int): Option[String] = Some(i.toString) def g(s: String): Option[Char] = s.headOption //associativity Option(22).flatMap(f).flatMap(g) == Option(22).flatMap(i => f(i).flatMap(g)) Some('2') == Some('2')
78. Breaking it
79. Some(2).flatMap(optionMonad.pure(_)) == Some(2) lazy val printSth: Future[Unit] = Future(println("Hi!")) val futureMonad: Monad[Future] printSth // Hi! printSth .flatMap(sideeffect => futureMonad.pure(sideeffect)) // ??? Nothing, future is done, just once
80. Exercise https://github.com/yannick-cw/monads-for-the-working-class // run tests on change sbt "~test" And set ignore to in for the test you want to make work
81. Applicative
82. Let's look at monads again
83. def getUser(id: Int): Future[User] = ??? // connects to db, takes a while def getUserCity(user: User): Future[City] = ??? def doSomething(user: User, city: City) = ???
84. def getUser(id: Int): Future[User] = ??? // connects to db, takes a while def getUserCity(user: User): Future[City] = ??? def doSomething(user: User, city: City) = ??? for { user1 <- getUser(1) city1 <- getUserCity(user1) } yield doSomething(user1, city1)
85. It's about chaining
86. def getUser(id: Int): Future[User] = ??? // connects to db, takes a while def getUserCity(id: Int): Future[City] = ??? def doSomething(user: User, city: City) = ???
87. def getUser(id: Int): Future[User] = ??? // connects to db, takes a while def getUserCity(id: Int): Future[City] = ??? def doSomething(user: User, city: City) = ??? for { user1 <- getUser(1) city1 <- getUserCity(1) } yield doSomething(user1, city1)
88. Question!
89. def getUser(id: Int): Future[User] = ??? // connects to db, takes a 10 seconds def getUserCity(id: Int): Future[City] = ??? // connects to db, takes a 10 seconds def doSomething(user: User, city: City) = ??? for { user1 <- getUser(1) city1 <- getUserCity(1) } yield doSomething(user1, city1)
90. How can we do that in parallel?
91. Re-use functor?
92. def getUser(id: Int): Future[User] = ??? // connects to db, takes a 10 seconds def getUserCity(id: Int): Future[City] = ??? def doSomething(user: User, city: City) = ??? val futUser: Future[User] = getUser(1).map(user => doSomething(user, ???)) val futCity: Future[City] = getUserCity(1).map(city => doSomething(???, city))
93. No, Applicative!
94. def getUser(id: Int): Future[User] = ??? // connects to db, takes a 10 seconds def getUserCity(id: Int): Future[City] = ??? def doSomething(user: User, city: City) = ??? val futureApplicative: Applicative[Future] futureApplicative .map2(getUser(1), getUserCity(1))(doSomething)
95. def getUser(id: Int): Future[User] = ??? // connects to db, takes a 10 seconds def getUserCity(id: Int): Future[City] = ??? def doSomething(user: User, city: City) = ??? (getUser(1) |@| getUserCity(1)).map(doSomething)
96. Monad was about chaining
97. Applicative for combining without chaining
98. No chaining -> no dependency on earlier results -> parallelism possible
99. no chaining - no flatMap - no flatten - just mapX!
100. def getUser(id: Int): Future[User] = ??? // connects to db, takes a while def getUserCity(user: User): Future[City] = ??? def doSomething(user: User, city: City) = ??? Applicative[Future] .map2(getUser(1), getUserCity(???))(doSomething)
101. Applicative is weaker
102. but more powerful than Functor
103. Functor on steroids def map [A, B ](fa: F[A]) (f: A => B) : F[B] def map2[A, B, C](fa: F[A], fb: F[B])(f: (A, B) => C): F[C]
104. Details
105. trait Applicative[F[_]] { def map2[A,B, C](fa: F[A], fb: F[B])(f: (A, B) => C): F[C] def unit[A](a: A): F[A] }
106. Option Applicative
107. trait Applicative[F[_]] { def map2[A,B, C](fa: F[A], fb: F[B])(f: (A, B) => C): F[C] def unit[A](a: A): F[A] } new Applicative[Option] { def unit[A](a: A): Option[A] = Option(a) }
108. trait Applicative[F[_]] { def map2[A,B, C](fa: F[A], fb: F[B])(f: (A, B) => C): F[C] def unit[A](a: A): F[A] } new Applicative[Option] { def unit[A](a: A): Option[A] = Option(a) def map2[A, B, C](fa: Option[A], fb: Option[B])( f: (A, B) => C): Option[C] = (fa, fb) match { case (Some(a), Some(b)) => Some(f(a, b)) case _ => None } }
109. Is an applicative always a functor?
110. trait Applicative[F[_]] extends Functor[F]{ def map2[A,B, C](fa: F[A], fb: F[B])(f: (A, B) => C): F[C] def unit[A](a: A): F[A] // yes we always can define map in terms of map2 def map[A, B](fa: F[A])(f: A => B): F[B] = ??? }
111. Is a monad always an applicative?
112. trait Applicative[F[_]] extends Monad[F] { def flatMap[A, B](fa: F[A])(f: (A) => F[B]): F[B] = ??? def unit[A](a: A): F[A] = ??? def map2[A, B, C](fa: F[A], fb: F[B])(f: (A, B) => C): F[C] = ???
113. trait Applicative[F[_]] extends Monad[F] { def flatMap[A, B](fa: F[A])(f: (A) => F[B]): F[B] = ??? def unit[A](a: A): F[A] = ??? def map2[A, B, C](fa: F[A], fb: F[B])(f: (A, B) => C): F[C] = flatMap(fa)(a => map(fb)(b => f(a, b))) }
114. trait Applicative[F[_]] extends Monad[F] { def flatMap[A, B](fa: F[A])(f: (A) => F[B]): F[B] = ??? def unit[A](a: A): F[A] = ??? def map2[A, B, C](fa: F[A], fb: F[B])(f: (A, B) => C): F[C] = for { a <- fa b <- fb } yield f(a, b) }
115. back to where we started
116. for { a <- fa b <- fb } yield f(a, b) for { user1 <- getUser(1) city1 <- getUserCity(1) } yield doSomething(user1, city1) How can this than be parallel?
117. We can implement applicative in terms of flatMap, but also give a custom implementation
118. e.g. running futures in parallel
119. Functor map can be implemented in terms of map2
120. Applicative map2 can be implemented in terms of flatMap
121. What does that mean?
122. Monad > Applicative > Functor
123. Why use applicative over monad
124. use the least powerful abstraction that will get the job done. — Travis Brown
125. Why use applicative over monad • special implementation like future for parallel • if we use futures flatMap -> no parallel • datatypes that satisfy Applicatives but not monads • Validation
126. mapX
127. trait Applicative[F[_]] extends Functor[F]{ def map2[A,B, C](fa: F[A], fb: F[B])(f: (A, B) => C): F[C] def unit[A](a: A): F[A] def map3 ... // in terms of map2 def map4 ... def map5 ... }
128. No laws today
129. Exercise https://github.com/yannick-cw/monads-for-the-working-class // run tests on change sbt "~test" And set ignore to in for the test you want to make work