Monads are functional programming constructs that allow computations to be structured and composed in a purely functional way. They provide a way to compose functions of different types that can be logically combined. In Scala, monads can be represented using classes with map and flatMap methods, and for-comprehensions provide a cleaner syntax for working with monadic code. Some examples of monads in Scala include Option, List, and Writer.

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