Thesis

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

Functors are containers
Type Constructors - F[A]

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

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

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

Applicative Functors
Applicative Functors
currying functions is fun

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

x => (y => x + y)

Applicative is just a more generalized Functor

Applicative Style

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

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

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

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

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

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 { first flatMap {
x <- first x => second flatMap {
y <- second y=> third map {
z <- third z => x + y + z
} )
yield ( 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

Thesis

More Related Content

What's hot (18)

Similar to Thesis (20)

Thesis