Monads for Humans

Paradigm Blend

Knowledge Gap for Devs

Those interested in Monads have no good starting places

Category Theory

Functional abstractions are patterns

Origin in math

What’s a Monad?

A Monad is just a Monoid in the category of endofunctors

Monads are not

metaphors

Functors

From the ground up

Functors are

Type Constructors - F[A]

containercontainerss

Functors need to have a map function

You did take PLP with Wallingford, right?

MaMapp

def map[A,B](cont: List[A], f: A => B)

Apply the function f to each elementHigher Order Higher Order

FunctionsFunctionsHigher Order Higher Order

FunctionsFunctions

Functors need a map method

Functors are containers

Lift arity-1 function to a function that works on computational context

Applicative Functors

currying functions is fun

Applicative Applicative FunctorsFunctors

Lifts an n-arity function to work on computational context through currying.

x => (y => x + y)

Currying?

Applicative is just a more generalized Functor

pure(+) <*> pure(3) <*> pure(4)

Applicative Style

Functors lift 1-arity

Applic lift n-arity

RecaRecap:p:

a distant cousinMonoidMonoid

Type-class which have values that can be

Binary operation must be associative

combinecombinedd

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

MonadMonadThe Main Attraction

Structure computations

Compose functions of different types that can be logically combined

Monads in a purely functional language (Haskell)

Monads in Scala

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)}

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

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)}

 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.”

FIN?

Monads and Scala

For - Comprehensions

Scala has Monads everywhere!

Scala recognizes monadic code.

val first = List(1)val second = List(4)val third = List(8)

for {  x <- first  y <- second  z <- third}yield ( x + y + z)

first flatMap {  x => second flatMap {    y=> third map {      z => x + y + z    )  ))

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