Monads asking the right question

Monads
Asking the right question

“I'm ready to write my first program. How
can I print some stuff to console?”

“What the *** is a monad?”

1. We understand code
2. It is easier to talk about related ideas and
then abstract to something more general

3. Having abstract model created, we tend to
create metaphors

3. Having abstract model created, we tend to
create metaphors
4. Having all above we can formalize

Android, iOS, Windows Phone
Partner Lookup

case class Geek(name: String, partner: Geek = null, workPlace: WorkPlace)

case class WorkPlace(name: String, street: String)

def partnerLookup(geek: Geek): String =

def partnerLookup(geek: Geek): String = geek.partner.workPlace.street

val cheeseCakeFactory = WorkPlace("Cheese Cake Factory", "Cake Street 1")
val university = WorkPlace("University", "Academic St. 10")

var penny = Geek("Penny", workPlace = cheeseCakeFactory)
var leonard = Geek("Leonard", workPlace = university)

penny = penny.copy(partner = leonard)
leonard = leonard.copy(partner = penny)

println(partnerLookup(leonard))
println(partnerLookup(penny))

println(partnerLookup(leonard)) // output: "Cake Street 1"

println(partnerLookup(penny)) // output: "Academic St. 10"

val rajesh = Geek("Rajesh", workPlace = university)

println(partnerLookup(rajesh))

// java.lang.NullPointerException
// at wtf.examples.A1$.partnerLookUp(A1.scala:14)
// at ...

def partnerLookup(geek: Geek): String = {
}

if(geek != null) {
}

if(geek != null) {
if(geek.partner != null) {
}

if(geek != null) {
if(geek.partner.workPlace != null) {
}

if(geek != null) {
if(geek.partner.workPlace.street != null) {
}

if(geek != null) {
return geek.partner.workPlace.street
}
}
}
}
}

if(geek != null) {
return geek.partner.workPlace.street
}
}
}
}
"not found"
}

println(partnerLookup(penny)) // output: "Academic St. 10"
println(partnerLookup(rajesh)) // output: "not found"

sealed trait Maybe[+A]
case class Some[+A](value: A) extends Maybe[A]

case object None extends Maybe[Nothing]

case object None extends Maybe[Nothing]
object Maybe {
def apply[A](value: A) = Some(value)
}

sealed trait Maybe[+A] {
}
object Maybe {
}
case class Some[+A](value: A) extends Maybe[A] {
}
case object None extends Maybe[Nothing] {
}

def andThen[B](f: A => Maybe[B]): Maybe[B]
}
object Maybe {
}
}
}

}
object Maybe {
}
def andThen[B](f: A => Maybe[B]): Maybe[B] = f(value)
}
}

}
object Maybe {
}
}
def andThen[B](f: Nothing => Maybe[B]): Maybe[B] = this
}

case class Geek(name: String, partner: Maybe[Geek] = wtf.monads.None, workPlace: Maybe[WorkPlace])
case class WorkPlace(name: String, street: Maybe[String])

geek.partner

geek.partner.andThen(g => g.workPlace)

geek.partner.andThen(g => g.workPlace).andThen(wp => wp.street)

geek.partner.andThen(g => g.workPlace).andThen(wp => wp.street) match {
case wtf.monads.Some(street) => street
}

case wtf.monads.None => "not found"
}

println(partnerLookup(leonard))

geek.partner.andThen(p => p.workPlace).andThen(wp => wp.street) match {
}

}

def partnerLookup(geek: Geek): Maybe[String] =
}

with a little bit of magic
For-comprehension

}
def partnerLookup(geek: Geek): Maybe[String] = {
}

}
import Magic._
}

}
import Magic._
for {
p <- geek.partner
wp <- p.workPlace
s <- wp.street
} yield (s)
}

var leonard = Geek("Leonard", workPlace = university, partner = penny)
partnerLookup(leonard) // Some("Cake Street 1")
// how to print it?

def within[B](f: A => B): Maybe[B]
}
object Maybe {
}
}
}

}
object Maybe {
}
}
}
Reuse existing functionality like println

}
object Maybe {
}
def within[B](f: A => B): Maybe[B] = Maybe(f(value))
}
}

}
object Maybe {
}
def within[B](f: A => B): Maybe[B] = Maybe(f(value))
}
def within[B](f: Nothing => B): Maybe[B] = this
}

partnerLookup(leonard)

partnerLookup(leonard).within(println) // output: "Cake Street 1"

Android, iOS, Windows Phone
Ship Inventory

case class Pirate(name: String, ships: Many[Ship])
case class Ship(name: String, hold: Hold)
case class Hold(barrel: Many[Barrel])
case class Barrel(amount: Int)

val jack = Pirate("Captain Jack Sparrow", Many(blackPearl, whitePearl))

val blackPearl = Ship("Black Pearl", blackHold)
val whitePearl = Ship("White Pearl", whiteHold)

val blackHold = Hold(Empty)
val whiteHold = Hold(Many(Barrel(20), Barrel(10)))
val blackPearl = Ship("Black Pearl", blackHold)
val whitePearl = Ship("White Pearl", whiteHold)

sealed trait Many[+A]
case class Const[+A](head: A, tail: Many[A]) extends Many[A]

case object Empty extends Many[Nothing]

case object Empty extends Many[Nothing]
object Many {
def apply[A](elements: A*): Many[A] = {
if(elements.length == 1) Const(elements(0), Empty)
else Const(elements(0), apply(elements.drop(1) : _*))
}
}

sealed trait Many[+A] {
def andThen[B](f: A => Many[B]): Many[B]
def within[B](f: A => B): Many[B]
}

case class Const[+A](head: A, tail: Many[A]) extends Many[A] {
def andThen[B](f: A => Many[B]): Many[B] = ...
def within[B](f: A => B): Many[B] = ...
}

def andThen[B](f: A => Many[B]): Many[B] = ...
def within[B](f: A => B): Many[B] = Const(f(head), tail.within(f))
}

def andThen[B](f: A => Many[B]): Many[B] =
concat( f(head), tail.andThen(f) )
}

private def concat[A](first: Many[A],
second: Many[A]): Many[A] = { … }
}

private def concat[A](first: Many[A],
second: Many[A]): Many[A] = { … }
}
case object Empty extends Many[Nothing] {
def andThen[B](f: Nothing => Many[B]): Many[B] = this
def within[B](f: Nothing => B): Many[B] = this
}

val blackPearl = Ship("Black Pearl", Hold(Empty))
val whitePearl = Ship("White Pearl",
Hold(Many(Barrel(20), Barrel(10))))

jack.ships.andThen(ship => ship.hold.barrel)
.within(barrel => barrel.amount)

import Magic._
val amounts = for {
ship <- jack.ships
barrel <- ship.hold.barrel
} yield (barrel.amount)

import Magic._
val amounts = for {
ship <- jack.ships
barrel <- ship.hold.barrel
} yield (barrel.amount)
println(amounts) // Const(20,Const(10,Empty))

● We've seen two wrapping classes.

● All have andThen method.

● All have andThen method.
● Each can take a function that can be called
on a value wrapped by the structure (which
can be empty or there can be multiple
instances of it).

Both were examples of a
Monad!

Monad is a container, a box.
A box in which we can store
an object. Wrap it.

an object, a value.
A box that has a common
interface, which allows us to
do one thing: connect
sequence of operations on the
content of the box.

an object, a value.
content of the box.
andThen means "do the next
things".

an object, a value.
content of the box.
andThen means "do the next
things".
But the way it is done depends
on a box.

Monad is an abstract data type.

It has two operators: andThen and unit

object Maybe {
}

bind (>>=) // formal name

bind (>>=) // formal name
flatMap // in Scala

import Magic._
for {
p <- geek.partner
wp <- p.workPlace
s <- wp.street
} yield (s)
}

object Magic {
case class RichMaybe[A](m: Maybe[A]) {
def flatMap[B](f: A => Maybe[B]): Maybe[B] = m.andThen(f)
def map[B](f: A => B): Maybe[B] = m.within(f)
}
implicit def enrich[A](m: Maybe[A]) = RichMaybe(m)
}

for {
p <- geek.partner
wp <- p.workPlace
s <- wp.street
} yield (s)
}

It has two operators: bind and unit

It has two operators: bind and unit
Those operators must follow certain rules:
1. associativity
2. left identity
3. right identity

1. associativity
2. left identity
3. right identity
unit acts approximately as a
neutral element of bind

1. associativity
2. left identity
3. right identity
unit allows us to put value
into the box without
damaging it

1. associativity
2. left identity
3. right identity
unit(x).flatMap(f) == f(x)
m.flatMap(unit) == m
unit allows us to put value
into the box without
damaging it

1. associativity
2. left identity
3. right identity
“Binding two functions in
succession is the same as
binding one function that can
be determined from them”

1. associativity
2. left identity
3. right identity
m.flatMap{f(_)}.flatMap.{g(_)}
==
m.flatMap{f(_).flatMap.{g(_)}}
“Binding two functions in
succession is the same as
binding one function that can
be determined from them”

Paweł Szulc
http://rabbitonweb.com

Paweł Szulc
@rabbitonweb

Paweł Szulc
@rabbitonweb
https://github.
com/rabbitonweb/monads_asking_the_right_
question

Images used
http://beforeitsnews.com/business/2014/02/career-tips-how-to-look-presentable-for-a-job-interview-2591264.html
http://phantommagician.deviantart.com/art/Cursed-Gold-183261313
http://carlosandgabbysbrooklyn.com/Burritos.html
http://channel9.msdn.com/Forums/Coffeehouse/442850-Sign-up-for-American-Programmer-C9park
https://www.pinterest.com/sandinarvaez/cute-graphics-and-patterns/
http://dsmconsulting.com.au/whats-in-the-box/
http://www.concordmonitor.com/home/4293575-95/cat-cats-videos-henri
https://www.pinterest.com/JoanneBest3/cats-in-boxes/
http://essaylab.org/
http://www.fanpop.com/clubs/pirates-of-the-caribbean/
http://library.sun.ac.za/SiteCollectionImages/search/Launch-Button.jpg

Monads asking the right question

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to Monads asking the right question

Similar to Monads asking the right question (20)

More from Pawel Szulc

More from Pawel Szulc (20)

Recently uploaded

Recently uploaded (20)

Monads asking the right question