Running Free with the Monads

Run free with
the monads!
Free Monads for fun and profit
@KenScambler
#scalamelb March 2014

The problem
• Separation of concerns is paramount to software
• In FP, we try to banish effects to the peripheries of
our programs
• Results and decisions must be represented as
data, such as ADTs
• Interpretation can happen later
• Not super expressive though.

Decision/Interpretation
(tangled)
def updateAccount(user: User, db: KVStore): Unit = {
val account = db.get(user.id)
if (!account.suspended)
db.put(user.id, account.updateSpecialOffers)
else if (account.abandoned)
db.delete(user.id)
}

Decisions as data
sealed trait KVSAction
case class Put(key: String,
value: String) extends KVSAction
case class Delete(key: String) extends KVSAction
case object NoAction extends KVSAction

Decision
def chooseAction(user: User,
account: Account): KVSAction = {
if (!account.suspended)
Put(user.id, account.updateSpecialOffers)
else if (account.abandoned)
Delete(user.id)
else
NoAction
}

Interpretation
def interpret(action: KVSAction): Unit = {
action match {
case Put(key, value) => db.put(key, value)
case Delete(key) => db.delete(key)
case NoAction => ()
}
}
val account = db.get(bob,id)
interpret(chooseAction(bob, account))

How far can we push it?
• Can our pure “decision” data be as sophisticated
as a program?
• Can we create DSLs that can be run later in
different ways?
• Can we manipulate & rewrite our “program” on the
fly?
• Conditional logic?
• Loops?
• Coroutines?

How far can we push it?
def updateAccount(user: User): Unit =
for {
account <- getAccount(user.id)
_ <- when(!account.suspended)(
put(user.id, user.updated))
_ <- when(account.abandoned)(
delete(user.id))
} yield ()

The class called “Free”
• Free is a data structure
• Tree of computations
Free[F[_], A]

The class called “Free”
Suspend(F[Free[F,A]])
Return(A)
Free[F[_], A]

Why “free monads”?
If F[_] is a functor, Free is a
monad…… for free!
• This buys us a whole world of existing functionality
• Better abstraction
• Sequential computations
• Elegant imperative-style syntax

Functors
• Functors are things you can map over
• F[A] => (A => B) => F[B]
trait F[A] {
def map(f: A => B): F[B]
}

Functors
trait F[A] {
def map(f: A => B): F[B]
}

Monads
• Monads have a flatMap method that allows you to
chain computations together sequentially
class M[A] {
def map(f: A => B): M[B]
def flatMap(f: A => M[B]): M[B]
}

Monads
• Nesting flatmaps allows sequential actions, ignoring
the specific context!
nbaTeams.flatMap { team =>
team.players.flatMap { player =>
player.gamesPlayed.map { game =>
BasketballCard(team, player, game)
}
}
}

Monads
• Neat comprehension syntax in Scala and Haskell
• Makes it look like a regular program
for {
team <- nbaTeams
player <- team.players
game <- player.gamesPlayed
}
yield BasketballCard(team, player, game)

Back to our regularly
scheduled program…

“Free objects” in maths
• Important concept in maths!
• Many free structures in Category Theory
• Free Monoids, Free Monads, Free Categories, Free
Groups, etc
• It only counts as “free” if the free thing gets
generated in the simplest possible way

Free Blargles from
Fraxblatts
• A Fraxblatt is said to generate a Free Blargle if:
1. The Blargle doesn’t contain anything not directly
produced from a Fraxblatt
2. The Blargle doesn’t contain anything beyond what
it needs to be a Blargle

Free Blargles from
Fraxblatts
• A Fraxblatt is said to generate a Free Blargle if:
1. NO JUNK
2. NO NOISE

Making an honest monad
of it
case class Return[F[_], A](a: A) extends Free[F, A] {
def flatMap(f: A => Free[F, B]): Free[F, B] = ???
}
• Define flatMap for Return:

of it
case class Return[F[_], A](a: A) extends Free[F, A] {
def flatMap(f: A => Free[F, B]): Free[F, B] = f(a)
}

of it
• Define flatMap for Suspend:
case class Suspend[F[_], A](next: F[Free[F,A]])
extends Free[F, A] {
def flatMap(f: A => Free[F, B]): Free[F, B] = ???
}

of it
• We need to map over the functor
def flatMap(f: A => Free[F, B]): Free[F, B] = {
F??? map ???
}
}
F[???]

of it
• “next” is the only F we have lying around
next map {free => ???}
}
}
F[Free[F, ???]]

of it
• flatMap is almost the only thing we can do to a Free
next map {free => free.flatMap(???)}
}
}
F[Free[F, ???]]

of it
• Mapping function f will turn our As into Free[F, B]s
next map {free => free.flatMap(f)}
}
}
F[Free[F, B]]

of it
• Wrapping in Suspend matches the type signature!
Suspend(next map {free => free.flatMap(f)})
}
}
Free[F, B]

of it
• Cleaning up the syntax a bit…
Suspend(next map (_ flatMap f))
}
}

Stepping through flatMap
Let’s plug in a really simple functor and see what
happens.
case class Box[A](a: A)

Stepping through flatMap
Let’s plug in a really simple functor and see what
happens.
case class Box[A](a: A) {
def map[B](f: A => B) = Box(f(a))
}

that.flatMap(banana =>
Return(banana.peel))

liftF
Let’s automate creating the Suspend cell!
F[A] => Free[F, A]
=>

More flatmapping
for {
a <- liftF( Box(1) )
b <- liftF( Box(2) )
c <- liftF( Box(3) )
} yield a + b + c

for {
} yield a + b + c
1

for {
} yield a + b + c
2

for {
} yield a + b + c
3

for {
} yield a + b + c
6

Free[Box, A]
• Chain of nothings, resulting in a single value
• Not very useful!

Free[List, A]
for {
a <- liftF( List(1,2,3) )
b <- liftF( List(a,a*2) )
c <- liftF( Nil )
} yield a + b + c

for {
c <- liftF( Nil )
} yield a + b + c
1 2 3

for {
c <- liftF( Nil )
} yield a + b + c
1 2
2 4
3 6

for {
c <- liftF( Nil )
} yield a + b + c

Free[List,A]
• Branching tree shape, with data at the leaves
• Empty lists can terminate the tree, not just Return.
• Again, not super useful.
The functor controls the branching
factor!

Funky functions
• Functors are not just data structures that hold values
• They are computations!
• Free’s real power is unleashed when the Functor
maps over functions!

Free[Function0, A]
• No-arg functions, basically a lazy value
• Flatmapping the free composes functions
• Doesn’t actually run any code

Free[Function0, A]
for {
a <- liftF(() => 2 + 3)
b <- liftF(() => a * 2)
c <- liftF(() => a * b)
} yield a + b + c

for {
a <- liftF(() => 2 + 3)
b <- liftF(() => a * 2)
c <- liftF(() => a * b)
} yield a + b + c
=> 2 + 3

for {
a <- liftF(() => 2 + 3)
b <- liftF(() => a * 2)
c <- liftF(() => a * b)
} yield a + b + c
2 + 3=>

for {
a <- liftF(() => 2 + 3)
b <- liftF(() => a * 2)
c <- liftF(() => a * b)
} yield a + b + c
=>
2 + 3

for {
a <- liftF(() => 2 + 3)
b <- liftF(() => a * 2)
c <- liftF(() => a * b)
} yield a + b + c
=> => 2 + 3=>

Trampolines
• Believe it or not, Free[Function0,A] is incredibly
useful!
• Also known as Trampoline[A]
• Moves tail calls onto the heap, avoiding stack
overflows
• The best we can get for mutual tail recursion on the
JVM

Trampolines
• Let’s take a look at some code…

Little languages
• Small, imperative DSLs
• Don’t directly do anything, can be interpreted
many ways
• Functionally pure and type-safe

A key-value store DSL
• A bit like the KVSAction ADT way back at the start
• There’s a “type hole” for the next thing
• That means…. we can make it a Functor!
• Mechanical translation from corresponding API
functions

sealed trait KVS[Next]
case class Put[Next](key: String,
value: String,
next: Next) extends KVS[Next]
case class Delete[Next](key: String,
case class Get[Next](key: String,
onValue: String => Next) extends KVS[Next]

value: String,
Just have a slot for the
next thing, if we don’t
care about a result
value

value: String,
Have a Result => Next
function, if we want to
“return” some Result.

Which looks a bit like…
def put[A](key: String, value: String): Unit
def delete[A](key: String): Unit
def get[A](key: String): String

Which is a bit like…
def put[A](key: String, value: String): Unit
def delete[A](key: String): Unit
def get[A](key: String): String

A functor for our KVS
new Functor[KVS] {
def map[A,B](kvs: KVS[A])(f: A => B): KVS[B] =
kvs match {
case Put(key, value, next) =>
Put(key, value, f(next))
case Delete(key, next) =>
Delete(key, f(next))
case Get(key, onResult) =>
Get(key, onResult andThen f)
}
}

new Functor[KVS] {
kvs match {
}
}
To map over the next
value, just apply f

new Functor[KVS] {
kvs match {
}
}
To map over a function
yielding the next value,
compose f with it

Lifting into the Free
Monad
def put(key: String, value: String): Free[KVS, Unit] =
liftF( Put(key, value, ()) )
def get(key: String): Free[KVS, String] =
liftF( Get(key, identity) )
def delete(key: String): Free[KVS, Unit] =
liftF( Delete(key, ()) )

Monad
Initialise with Unit,
when we don’t care
about the value

Monad
Initialise with the
identity function, when
we want to return a
value

Composable scripts
def modify(key: String,
f: String => String): Free[KVS, Unit] =
for {
v <- get(key)
_ <- put(key, f(v))
} yield ()

Harmless imperative code
val script: Free[KVS, Unit] =
for {
id <- get(“swiss-bank-account-id”)
_ <- modify(id, (_ + 1000000))
_ <- put(“bermuda-airport”, “getaway car”)
_ <- delete(“tax-records”)
} yield ()

Pure interpreters
type KVStore = Map[String, String]
def interpretPure(kvs: Free[KVS, Unit],
table: KVStore): KVStore =
kvs.resume.fold({
interpretPure(onResult(table(key)), table)
interpretPure(next, table + (key -> value))
interpretPure(next, table - key)
}, _ => table)

Pure interpreters
kvs.resume.fold({
}, _ => table)
KVStore is immutable

Pure interpreters
kvs.resume.fold({
}, _ => table)
F[Free[F, A]] / A
Resume and fold…

Pure interpreters
kvs.resume.fold({
}, _ => table)
KVS[Free[KVS, Unit]] / Unit
Resume and fold…

Pure interpreters
kvs.resume.fold({
}, _ => table)
When resume finally returns
Unit, return the table

Effectful interpreter(s)
type KVStore = mutable.Map[String, String]
def interpretImpure(kvs: Free[KVS,Unit],
table: KVStore): Unit =
kvs.go {
onResult(table(key))
table += (key -> value)
next
table -= key
next
}

Effectful interpreters
kvs.go {
next
table -= key
next
}
Mutable map

Effectful interpreters
kvs.go {
next
table -= key
next
}
def go(f: F[Free[F, A]] => Free[F, A]): A

How-to summary
1. Fantasy API
2. ADT with type hole for next value
3. Functor definition for ADT
4. Lifting functions
5. Write scripts
6. Interpreter(s)

Conclusion
• Free Monads are really powerful
• Separate decisions from interpretation, at a more
sophisticated level
• Type-safe
• Easy to use!

Conclusion
• Express your decisions in a “little language”
• Pause and resume programs, co-routine style
• Rewrite programs macro-style
• Avoid stack overflows with Trampolines
This is a great tool to have in your toolkit!

Further reading
• Awodey, Category Theory
• Bjarnason, Dead Simple Dependency Injection
• Bjarnason, Stackless Scala with Free Monads
• Doel, Many roads to Free Monads
• Ghosh, A Language and its Interpretation: Learning
Free Monads
• Gonzalez, Why Free Monads Matter
• Haskell.org, Control.Monad.Free
• Perrett, Free Monads, Part 1
• Scalaz, scalaz.Free

Further reading
https://github.com/kenbot/free

Thank you
Hope you enjoyed hearing about Free Monads!

Running Free with the Monads

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (20)

Similaire à Running Free with the Monads

Similaire à Running Free with the Monads (20)

Plus de kenbot

Plus de kenbot (11)

Dernier

Dernier (20)

Running Free with the Monads