The document discusses functional programming concepts like the free monad, which represents a computation as an abstract syntax tree (AST) plus an interpreter. A free monad separates the "what" of a computation, expressed as an AST, from the "how", defined by an interpreter. This allows defining reusable computations without tying them to a particular implementation. The free monad is constructed freely from a functor and gives a monad without extra work. It can be used to sequence computations and interpret them in different ways by providing a natural transformation from the functor to a monad.

1. Drinking the free kool-aidDrinking the free kool-aid
David HoytDavid Hoyt

2. AcknowledgmentsAcknowledgments
Functional Programming in Scala
Compositional Application Architecture With
Reasonably Priced Monads

3. What's the problem?What's the problem?

4. You're not aloneYou're not alone
Took me a while to understandTook me a while to understand
Single pass wasn't enoughSingle pass wasn't enough

5. YawnYawn

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 theNo changes to the
original program!original program!

9. Another tool in your utility belt
Use judiciously
The free monadThe free monad

10. Why do I care?Why do I care?
Purity of abstraction
Reusable definitions
Defer effects

11. Services services servicesServices services services

12. Wheel of doomWheel of doom®?

13. WTFWTF

14. AgendaAgenda
1. Fundamentals
2. Code
3. Intuition
4. Code
5. Wrap-up

15. Design patterns andDesign patterns and
mathematical rigormathematical rigor

16. trait NaturalTransformation[F[_], G[_]] {
def apply[A](given: F[A]): G[A]
}
type ~>[F[_], G[_]] = NaturalTransformation[F, G]
Natural transformationNatural 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 ListOption to List

18. trait Monoid[A] {
def zero: A
def append(a1: A, a2: => A): A
}
MonoidMonoid

19. object stringConcatenation extends Monoid[String] {
val zero: String = ""
def append(a1: String, a2: => String): String = a1 + a2
}
String concatenationString concatenation

20. A, A, A, A, A, A
Free monoidFree 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]
}
FunctorFunctor

22. (F[A], (A => A, A => B, B => C))
Free functorFree functor
aka the CoYonedaaka the CoYoneda

23. Seems uselessSeems 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)))
}
MonadMonad

25. val result: Future[Int] =
for {
value1 <- Future(1)
value2 <- Future(2)
} yield value1 + value2
Sequencing computationSequencing 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 monadIdentity monad

27. Repeat after me...Repeat after me...
Free monad = AST + interpreterFree monad = AST + interpreter

28. Abstract Syntax TreesAbstract Syntax Trees
Expresses computation as dataExpresses computation as data
The "what"

29. InterpreterInterpreter
Gives meaning to the dataGives meaning to the data
The "how"

30. I have a math problemI 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 MonadFree 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 monadsAST 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 MonadFree Monad

36. Free MonadFree 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 MonadFree 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 joinUnable to join

40. Fs all the way downFs 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 monadsWe 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 layersShedding 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 outCheck it out

48. Repeat after me...Repeat after me...
Free monad = AST + interpreterFree 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. NoNo

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 bookRead the book
by Wouter SwierstraData types à la carte

56. Watch the movieWatch the movie
Compositional Application Architecture
​With Reasonably Priced Monads

57. throw new NotImplementedError()throw new NotImplementedError()
Trampolining

58. Honorable mentionsHonorable mentions
Cats
Scalaz

59. ResourcesResources
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. LegalLegal
xkcd