Drinking the free kool-aid

An introduction to the free monad and fundamental concepts required to gain intuition about its use.

Addendum: Referenced presentation title was wrong. It should be "Composable application architectures with reasonably priced monads."

Transcript

1. Drinking the free kool-aid Drinking the free kool-aid David Hoyt David Hoyt
2. Acknowledgments Acknowledgments Functional Programming in Scala Compositional Application Architecture With Reasonably Priced Monads
3. What's the problem? What's the problem?
4. You're not alone You're not alone Took me a while to understand Took me a while to understand Single pass wasn't enough Single pass wasn't enough
5. Yawn Yawn
6. for { _ <- tell("Twitter handle(s):", "tpolecat") handles <- ask("tpolecat") tweets <- getTweets(handles.split(',')) done <- displayTweets(tweets) } yield done Given this program: Given this program:
7. Let's run it like this... Let's run it like this...
8. No changes to the No changes to the original program! original program!
9. Another tool in your utility belt Use judiciously The free monad The free monad
10. Why do I care? Why do I care? Purity of abstraction Reusable definitions Defer effects
11. Services services services Services services services
12. Wheel of doom Wheel of doom®?
13. WTF WTF
14. Agenda Agenda 1. Fundamentals 2. Code 3. Intuition 4. Code 5. Wrap-up
15. Design patterns and Design patterns and mathematical rigor mathematical rigor
16. trait NaturalTransformation[F[_], G[_]] { def apply[A](given: F[A]): G[A] } type ~>[F[_], G[_]] = NaturalTransformation[F, G] Natural transformation Natural transformation
17. class Option[A] class List[A] object optionToList extends (Option ~> List) { def apply[A](given: Option[A]): List[A] = given.toList } Option to List Option to List
18. trait Monoid[A] { def zero: A def append(a1: A, a2: => A): A } Monoid Monoid
19. object stringConcatenation extends Monoid[String] { val zero: String = "" def append(a1: String, a2: => String): String = a1 + a2 } String concatenation String concatenation
20. A, A, A, A, A, A Free monoid Free monoid Stuff this next to that. Stuff this next to that. Kind of looks like a List. Kind of looks like a List.
21. trait Functor[F[_]] { def map[A, B](fa: F[A])(fn: A => B): F[B] } Functor Functor
22. (F[A], (A => A, A => B, B => C)) Free functor Free functor aka the CoYoneda aka the CoYoneda
23. Seems useless Seems useless Yup. Yup. Except... Except...
24. trait Monad[M[_]] { def pure[A](given: A): M[A] def flatMap[A, B](given: M[A])(fn: A => M[B]): M[B] } trait Monad[M[_]] extends Functor[M] { def pure[A](given: A): M[A] def flatMap[A, B](given: M[A])(fn: A => M[B]): M[B] override def map[A, B](given: M[A])(fn: A => B): M[B] = flatMap(given)(a => pure(fn(a))) } Monad Monad
25. val result: Future[Int] = for { value1 <- Future(1) value2 <- Future(2) } yield value1 + value2 Sequencing computation Sequencing computation
26. type Id[A] = A implicit object Identity extends Monad[Id] { def pure[A](given: A): Id[A] = given def map[A, B](given: Id[A])(fn: A => B): Id[B] = fn(given) def flatMap[A, B](given: Id[A])(fn: A => Id[B]): Id[B] = fn(given) } Identity monad Identity monad
27. Repeat after me... Repeat after me... Free monad = AST + interpreter Free monad = AST + interpreter
28. Abstract Syntax Trees Abstract Syntax Trees Expresses computation as data Expresses computation as data The "what"
29. Interpreter Interpreter Gives meaning to the data Gives meaning to the data The "how"
30. I have a math problem I have a math problem (there are several interpretations of that statement...) (yes, I mean all of them at once...) (cue the IDE already!)
31. What's 1 + 2? What's 1 + 2? (why didn't you cut to the IDE?!) (don't let the audience see this!)
32. You did what with that? You did what with that? That's right, I interpreted the sh** out of that.(NSFW?)
33. sealed trait Free[F[_], A] Free Monad Free Monad
34. case class Return[F[_], A](given: A) extends Free[F, A] case class FlatMap[F[_], A, B](given: Free[F, A], fn: A => Free[F, B]) extends Free[F, B] AST for monads AST for monads
35. sealed trait Free[F[_], A] { self => def map[B](fn: A => B): Free[F, B] = flatMap(a => Return(fn(a))) def flatMap[B](fn: A => Free[F, B]): Free[F, B] = FlatMap(self, (a: A) => fn(a)) } Free Monad Free Monad
36. Free Monad Free Monad sealed trait Context[A] val result: Free[Context, String] = for { hope <- Return[Context, String]("hope") it <- Return[Context, String]("it") works <- Return[Context, String]("works") } yield s"$hope $it $works"
37. Free Monad Free Monad sealed trait Context[A] val result: Free[Context, String] = Return[Context, String]("hope") flatMap { hope => Return[Context, String]("it") flatMap { it => Return[Context, String]("works") map { works => s"$hope $it $works" } } }
38. Which is really... Which is really... FlatMap(Return("hope"), hope => FlatMap(Return("it"), it => FlatMap(Return("works"), works => Return(s"$hope $it $works"))))
39. def join[A](ffa: F[F[A]]): F[A] = ??? Unable to join Unable to join
40. Fs all the way down Fs all the way down F[F[F[F[F[F[F[F[F[F[F[F[F[F[F[F[A]]]]]]]]]]]]]]]]
41. So what you're saying is... So what you're saying is... We have a monad for monads We have a monad for monads but it doesn't do monad-y things... but it doesn't do monad-y things...
42. Now you're getting it! Now you're getting it!
43. Shedding layers Shedding layers def runFree[F[_], G[_], A](given: Free[F, A]) (nat: F ~> G) (implicit G: Monad[G]): G[A]
44. How is it "free"? How is it "free"? If F is a functor, we get a monad without having to do any extra work! sealed trait Free[F[_], A]
45. Free as in beer? Free as in beer? Free in this context means generated freely in the sense that [a foo] itself doesn’t need to have any [foo] structure of its own. - Functional Programming in Scala
46. Did he really just say "free foo"? Did he really just say "free foo"? Yes. Yes.
47. Check it out Check it out
48. Repeat after me... Repeat after me... Free monad = AST + interpreter Free monad = AST + interpreter
49. Can I compose different Fs? Can I compose different Fs? (Great question! You read my mind!)
50. What I mean is... What I mean is... trait Foo[A] trait Bar[A] val foo: Free[Foo, A] = ??? val bar: Free[Bar, A] = ??? for { _ <- foo _ <- bar } yield ()
51. No No
52. Well, yes! Well, yes!
53. What?! What?!
54. Coproducts to the rescue! Coproducts to the rescue! (honorable mention: monad transformers) case class Coproduct[F[_], G[_], A]()
55. Read the book Read the book by Wouter Swierstra Data types à la carte
56. Watch the movie Watch the movie Compositional Application Architecture ​ With Reasonably Priced Monads
57. throw new NotImplementedError() throw new NotImplementedError() Trampolining
58. Honorable mentions Honorable mentions Cats Scalaz
59. Resources Resources Learning Scalaz (coproducts) Data types à la carte Free Monads and the Yoneda Lemma Free Monads Are Simple
60. Where's the source? Where's the source? https://github.com/davidhoyt/kool-aid
61. Legal Legal xkcd