2. Paradigm Blend
Knowledge Gap for Devs

3. Those interested in Monads have no good
starting places
Category Theory

4. Functional abstractions are
patterns
Origin in math

5. What’s a Monad?
A Monad is just a Monoid in the category
of endofunctors

6. Monads are not
metaphors

7. Functors
From the ground up

8. Functors are containers
Type Constructors - F[A]

9. Functors need to have a Map function
map
You did take PLP with Wallingford,
right?

10. def map[A,B](cont: List[A], f: A => B)
Apply the function f to each element
Higher Order Functions
Higher Order Functions

11. Functors need a map method
Functors are containers
Lift arity-1 function to a function
that works on computational
context

12. Applicative Functors
Applicative Functors
currying functions is fun

13. Lifts an n-arity function to work on
computational context through
currying.
Currying?
x => (y => x + y)

14. Applicative is just a more generalized Functor

15. Applicative Style
pure(+) <*> pure(3) <*> pure(4)

16. Recap:
Functors lift 1-arity
Applic lift n-arity

17. Monoid
a distant cousin

18. Type-class which have values that can
be combined
Binary operation must be associative

19. object StringMonoid {
def mAppend(x: String, y: String): String = x + y
def mEmpty: String = ""
}

20. Monad
The Main Attraction

21. Structure computations
Compose functions of different types that can
be logically combined

22. Monads in a purely functional language
(Haskell)
Monads in Scala

23. case class Identity[A](value: A) {
def map[B](f: A => B) = Identity(f(value))
def flatMap[B](f: A => Identity[B]) (value)
def unit(a: A) = Identity(a)
}

24. object Monoid {
def append(a1: List[A], a2: List[A]) = a1 ::: a2
def empty = Nil
}

25. case class Writer[Log, A](log: Log, value: A) {
def map[B](f: A => B) = Writer(log, f(value))
def flatMap[B](f: A => Writer[Log, B])(m: Monoid[Log]) = {
val x: Writer[Log,B] = f(value)
Writer(m.append(log, x.log), x.value)
}
def unit[Log, A](value: A)(m: Monoid[Log]) =
Writer(m.empty, value)
}

26. def main(args: Array[String]) {
val start = 3
val finalWriter =
for(a <- addOne(start);
b <- intString(a);
c <- lengthGreaterThan5(b);
d <- noLog(oneOrZero(c));
e <- squareOf(d)
) yield e
}
“Adding one to 3.
Changing 4 to a String.
Checking if length is greater than 5.
Squaring 1.”

27. FIN?

28. Monads and Scala
For - Comprehensions

29. Scala has Monads everywhere!
Scala recognizes monadic code.

30. val first = List(1)
val second = List(4)
val third = List(8)
for { first flatMap {
x <- first x => second flatMap {
y <- second y=> third map {
z <- third z => x + y + z
} )
yield ( x + y + z) )
)

31. case class Transaction(memberInfo: Option[MemberInfo], id: String)
case class MemberInfo(privateInfo: Option[PrivateMember], birthdate:
String)
case class PrivateInfo(socialSecurityNumber: String)
val ssNumber = “389-39-2983”
val priv = PrivateInfo(ssNumber)
val member = MemberInfo(priv, “10-20-87”)
val optionalTransaction = Transaction(member, “28948”)
for {
transaction <- optionalTransaction
memberInfo <- transaction.memberInfo
privInformation <- memberInfo.privateInfo
}
yield privInformation.socialSecurityNumber