Dr Frankenfunctor and

the Monadster

@ScottWlaschin

fsharpforfunandprofit.com/monadster

Warning

This talk contains:

– gruesome topics

– strained analogies

– discussion of monads

Not suitable for sensitive people (seriously)

Functional programmers

love composition...

A function Input Output

function A function B Compose

function A function B

function A and B

Easy!

... But here is a challenge for

function composition

function A Input Output

function B Input Output 1

Output 2

function C Input 1 Output 1

Output 2 Input 2

function D Input 1 Output Input 2

function A Input Output

function B Input Output 1

Output 2

function D Input 1 Output Input 2

How to compose?

function A Input Output

function B Input Output 1

Output 2

function D Input 1 Output Input 2

How to compose?

The answer: monads!

The spread of the monad

• 1990 ACM Conference on LISP and Functional Programming

First monad in captivity

The terrible events at the 1990 ACM Conference on LISP and Functional Programming

The spread of the monad

• 1990 ACM Conference on LISP and Functional Programming

• 1991 Eugenio Moggi, "Notions of computation and monads"

• 1992 Philip Wadler, "Monads for Functional Programming"

• 1999 Noel Winstanley, "What the hell are Monads?"

• 2004 Greg Buchholz, "Monads in Perl"

• 2005 Eric Kow, "Of monads and space suits"

• 2006 Eric Kow, Monads as nuclear waste containers

• 2009 James Iry, "A monad is just a monoid in the category of endofunctors,

what's the problem?"

• It’s everywhere now

The spread of the monad

• 1990 ACM Conference on LISP and Functional Programming

• 1991 Eugenio Moggi, "Notions of computation and monads"

• 1992 Philip Wadler, "Monads for Functional Programming"

• 1999 Noel Winstanley, "What the hell are Monads?"

• 2004 Greg Buchholz, "Monads in Perl"

• 2005 Eric Kow, "Of monads and space suits"

• 2006 Eric Kow, Monads as nuclear waste containers

• 2009 James Iry, "A monad is just a monoid in the category of endofunctors,

what's the problem?"

• It’s everywhere now

No wonder people think monads are dangerous

The secret history of the monad

• 1816 Dr Frankenfunctor creates the Monadster

• 1990 ACM Conference on LISP and Functional Programming

• 1991 Eugenio Moggi, "Notions of computation and monads"

• 1992 Philip Wadler, "Monads for Functional Programming"

• 1999 Noel Winstanley, "What the hell are Monads?"

• 2004 Greg Buchholz, "Monads in Perl"

• 2005 Eric Kow, "Of monads and space suits"

• 2006 Eric Kow, Monads as nuclear waste containers

• 2009 James Iry, "A monad is just a monoid in the category of endofunctors,

what's the problem?"

• And 100's more

The topic of this talk

The story of the Monadster

The creature was built from body parts of various shapes

The various parts were assembled into a whole

The body was animated in a single instant, using a

bolt of lightning to create the vital force.

... The Monadster

The “mark of the lambda”

But how was it done?

I have devoted many years of

research into this matter...

At last, I can reveal the secret

techniques of Dr Frankenfunctor!

Warning: These are powerful techniques and can be used for good or evil...

I know of a young, innocent developer who was traumatized for life.

Dr Frankenfunctor's toolbox

1. Modelling with pure functions

2. Wrapping a function in a type

3. Transforming parts into other parts

4. Combining two parts into one

5. Combining live and dead parts

6. Chaining “part-creating” functions together

7. A general way of combining any number of parts

I don’t expect you to remember all this!

Goal is just to demystify and give an overview

Technique 1: Modelling with pure functions

Become alive!

Vital force

Dead part Live part

Don't try this at home

Live body part

Vital force

Become alive!

Remaining vital force

Dead body part

Two inputs

Live body part

Vital force

Become alive!

Remaining vital force

Dead body part

Two outputs

Live body part

Vital force

Become alive!

Remaining vital force

Dead body part

Less vital force available afterwards

Live body part

Vital force

Become alive!

Remaining vital force

Dead body part

No globals, no mutation!

But now you have two

problems...

Live part B

Vital force

Become alive B!

Remaining vital force

Dead part B

Live part A

Vital force

Become alive A!

Remaining vital force

Dead part A

How to connect the force between two steps?

Live part B

Vital force

Become alive B!

Remaining vital force

Dead part B

Live part A

Vital force

Become alive A!

Remaining vital force

Dead part A

How to combine the two outputs?

Technique 2: Wrapping the "Become Alive" function

Also, introducing schönfinkelling

Moses Schönfinkel

invented schönfinkelling

Moses Schönfinkel

invented schönfinkelling

Haskell Curry

gave his name to currying

Input A Uncurried Function

Input B Output C

Curried Function

Input A Intermediate

Function Output C Input B

What is currying?

after currying

Currying means that *every* function has one input

// naming a lambda Func<int,int> add1 = (y => 1 + y) // using it var three = add1(2)

Currying examples

// naming a lambda let add1 = (fun y -> 1 + y) // using it let three = add1 2

Currying examples

// returning a lambda with baked in "x" let add x = (fun y -> x + y) // creating an intermediate function let add1 = add 1 // (fun y -> 1 + y) // using it let three = add1 2

Currying examples

// "inlining" the intermediate function let three = (add 1) 2

// returning a lambda with baked in "x" let add x = (fun y -> x + y)

Currying examples

// removing the parens let three = add 1 2

Currying examples

// returning a lambda with baked in "x" let add x = (fun y -> x + y)

Live part A

Vital force

Become alive!

Remaining vital force

Dead part A

Currying "become alive!"

Become alive!

Dead part A Vital force

Live part A

Currying "become alive!"

Become alive!

Dead part A Vital force

M<Live Part A>

Live part A

Wrapping the function

"M" is for "Monadster"

Become alive!

Dead part A Vital force

M<Live Part A>

Live part A

Wrapping the function

Dead part A

M<Live Part A> Create step in

recipe

Wrapping the function

An "M-making" function

Remember -- this is *not* a live part , it's a "potential" live part

M<Live Part A> Run

Live part A

Remaining vital force

Running the function

Vital force

M<Live Part A> Run

Live part A

Remaining vital force

Running the function

Vital force

Become alive!

Vital force

Live part A

M<Live Part A>

Show me the code

Left Leg

let makeLiveThingM deadThing = // the inner one-argument function let becomeAlive vitalForceInput = ... do stuff ... return two outputs // wrap the inner function in the "M" wrapper M becomeAlive

Creating M-things

let makeLiveThingM deadThing = // get essence of dead thing let essence = getEssenceOfDeadThing deadThing // the inner one-argument function let becomeAlive vitalForceInput = // get a unit of vital force let unitOfForce, remainingForce = getVitalForce vitalForce // create a live thing let liveThing = new LiveThing(essence, unitOfForce) // return the live thing and remaining force (liveThing, remainingVitalForce) // return a pair // wrap the inner function in the "M" wrapper M becomeAlive

Creating M-things

let makeLiveThingM deadThing = // get essence of dead thing let essence = getEssenceOfDeadThing deadThing // the inner one-argument function let becomeAlive vitalForceInput = // get a unit of vital force let unitOfForce, remainingForce = getVitalForce vitalForce // create a live thing let liveThing = new LiveThing(essence, unitOfForce) // return the live thing and remaining force (liveThing, remainingVitalForce) // return a pair // wrap the inner function in the "M" wrapper M becomeAlive

Creating M-things

let makeLiveThingM deadThing = // get essence of dead thing let essence = getEssenceOfDeadThing deadThing // the inner one-argument function let becomeAlive vitalForceInput = // get a unit of vital force let unitOfForce, remainingForce = getVitalForce vitalForce // create a live thing let liveThing = new LiveThing(essence, unitOfForce) // return the live thing and remaining force (liveThing, remainingVitalForce) // return a pair // wrap the inner function in the "M" wrapper M becomeAlive

Creating M-things

let makeLiveThingM deadThing = // get essence of dead thing let essence = getEssenceOfDeadThing deadThing // the inner one-argument function let becomeAlive vitalForceInput = // get a unit of vital force let unitOfForce, remainingForce = getVitalForce vitalForce // create a live thing let liveThing = new LiveThing(essence, unitOfForce) // return the live thing and remaining force (liveThing, remainingVitalForce) // return a pair // wrap the inner function in the "M" wrapper M becomeAlive

Creating M-things

let makeLiveThingM deadThing = // get essence of dead thing let essence = getEssenceOfDeadThing deadThing // the inner one-argument function let becomeAlive vitalForceInput = // get a unit of vital force let unitOfForce, remainingForce = getVitalForce vitalForce // create a live thing let liveThing = new LiveThing(essence, unitOfForce) // return the live thing and remaining force (liveThing, remainingVitalForce) // return a pair // wrap the inner function in the "M" wrapper M becomeAlive

Creating M-things

let makeLiveThingM deadThing = // get essence of dead thing let essence = getEssenceOfDeadThing deadThing // the inner one-argument function let becomeAlive vitalForceInput = // get a unit of vital force let unitOfForce, remainingForce = getVitalForce vitalForce // create a live thing let liveThing = new LiveThing(essence, unitOfForce) // return the live thing and remaining force (liveThing, remainingVitalForce) // return a pair // wrap the inner function in the "M" wrapper M becomeAlive

Creating M-things

makeLiveThingM : DeadThing -> M<LiveThing>

// create DeadLeftLeg let deadLeftLeg = DeadLeftLeg "Boris" // create a M<LiveLeftLeg> let leftLegM = makeLiveLeftLegM deadLeftLeg // potential leg only! // now pretend that vital force is available let vf = {units = 10} // make a real left leg by running leftLegM let liveLeftLeg, remainingForce = runM leftLegM vf // output: // liveLeftLeg : LiveLeftLeg = // LiveLeftLeg ("Boris",{units = 1}) // remainingForce : VitalForce = {units = 9}

Demo – Left Leg

Technique 3:

Transforming live parts

A Broken Arm

Dead Broken Arm

What we've got

Live Healed Arm

What we want

Healing a broken arm

Live Healed Arm Live Broken Arm HealBrokenArm

We have this function!

Live Healed Arm

...But we want one of these! How can we get it?

Healing a broken arm

Dead Broken Arm

We have one of these...

Create

Dead Broken Arm Dead Healed Arm

Live Healed Arm

Healing a broken arm

HealBrokenArm

Create

Dead Broken Arm Dead Healed Arm

Live Healed Arm

No. We can only heal live arms

Healing a broken arm

HealBrokenArm

Dead Broken Arm

Live Healed Arm Live Broken Arm

Create

HealBrokenArm

Healing a broken arm

Dead Broken Arm

Live Healed Arm Live Broken Arm

Create

HealBrokenArm

No. We can't create live things directly, only M-type things

Healing a broken arm

Dead Broken Arm

M<Live Healed Arm> M<Live Broken Arm>

Create

HealBrokenArm

Healing a broken arm

Dead Broken Arm

M<Live Healed Arm>

M<Live Broken Arm>

Create

HealBrokenArm

No. "HealBrokenArm" doesn't work on M-type things

Healing a broken arm

Dead Broken Arm

M<Live Healed Arm> M<Live Broken Arm>

Create

HealBrokenArmM

We need a special "HealBrokenArmM" that works on M-type things

Where can we get it from?

Healing a broken arm

Live Healed Arm Live Broken Arm HealBrokenArm

Healing a broken arm

M<Live Healed Arm> M<Live Broken Arm> HealBrokenArmM

This is what we’ve got

This is what we want

Live Healed Arm Live Broken Arm HealBrokenArm

Healing a broken arm

M<Live Healed Arm> M<Live Broken Arm> HealBrokenArmM

map

"map" is generic for M-things

Normal World

a b

"map" is generic for M-things

Normal World

a b

map

"map" is generic for M-things

Normal World

a b

map

World of M<_> things

M<a> M<b>

A function in the world of M-things

“lifting”

Show me the code

Broken Arm and "map"

let map f bodyPartM = // the inner one-argument function let becomeAlive vitalForce = // get the input body part by running the M-thing let bodyPart,remainingVitalForce = runM bodyPartM vitalForce // transform the body part using the function let transformedBodyPart = f bodyPart // return the transformed part and remaining force (transformedBodyPart, remainingVitalForce) // wrap the inner function in the "M" wrapper M becomeAlive

Transformation function M-thing to transform

let map f bodyPartM = // the inner one-argument function let becomeAlive vitalForce = // get the input body part by running the M-thing let bodyPart,remainingVitalForce = runM bodyPartM vitalForce // transform the body part using the function let transformedBodyPart = f bodyPart // return the transformed part and remaining force (transformedBodyPart, remainingVitalForce) // wrap the inner function in the "M" wrapper M becomeAlive

let map f bodyPartM = // the inner one-argument function let becomeAlive vitalForce = // get the input body part by running the M-thing let bodyPart,remainingVitalForce = runM bodyPartM vitalForce // transform the body part using the function let transformedBodyPart = f bodyPart // return the transformed part and remaining force (transformedBodyPart, remainingVitalForce) // wrap the inner function in the "M" wrapper M becomeAlive

let map f bodyPartM = // the inner one-argument function let becomeAlive vitalForce = // get the input body part by running the M-thing let bodyPart,remainingVitalForce = runM bodyPartM vitalForce // transform the body part using the function let transformedBodyPart = f bodyPart // return the transformed part and remaining force (transformedBodyPart, remainingVitalForce) // wrap the inner function in the "M" wrapper M becomeAlive

let map f bodyPartM = // the inner one-argument function let becomeAlive vitalForce = // get the input body part by running the M-thing let bodyPart,remainingVitalForce = runM bodyPartM vitalForce // transform the body part using the function let transformedBodyPart = f bodyPart // return the transformed part and remaining force (transformedBodyPart, remainingVitalForce) // wrap the inner function in the "M" wrapper M becomeAlive

let map f bodyPartM = // the inner one-argument function let becomeAlive vitalForce = // get the input body part by running the M-thing let bodyPart,remainingVitalForce = runM bodyPartM vitalForce // transform the body part using the function let transformedBodyPart = f bodyPart // return the transformed part and remaining force (transformedBodyPart, remainingVitalForce) // wrap the inner function in the "M" wrapper M becomeAlive

map : ('a -> 'b ) -> // The input is a normal function. ( M<'a> -> M<'b> ) // The output is a function in the // world of M-things.

let deadLeftBrokenArm = DeadLeftBrokenArm "Victor" let leftBrokenArmM = makeLiveLeftBrokenArm deadLeftBrokenArm let leftHealedArmM = // map the healing function to the world of M-things let healBrokenArmM = map healBrokenArm // use it! healBrokenArmM leftBrokenArmM // return type is M<LiveLeftHealedArm> // run the M<LiveLeftHealedArm> with some vital force let liveLeftHealedArm, remainingAfterLeftArm = runM leftHealedArmM vf

Demo – Broken Arm

let deadLeftBrokenArm = DeadLeftBrokenArm "Victor" let leftBrokenArmM = makeLiveLeftBrokenArm deadLeftBrokenArm let leftHealedArmM = // map the healing function to the world of M-things let healBrokenArmM = map healBrokenArm // use it! healBrokenArmM leftBrokenArmM // return type is M<LiveLeftHealedArm> // run the M<LiveLeftHealedArm> with some vital force let liveLeftHealedArm, remainingAfterLeftArm = runM leftHealedArmM vf

Demo – Broken Arm

let deadLeftBrokenArm = DeadLeftBrokenArm "Victor" let leftBrokenArmM = makeLiveLeftBrokenArm deadLeftBrokenArm let leftHealedArmM = // map the healing function to the world of M-things let healBrokenArmM = map healBrokenArm // use it! healBrokenArmM leftBrokenArmM // return type is M<LiveLeftHealedArm> // run the M<LiveLeftHealedArm> with some vital force let liveLeftHealedArm, remainingAfterLeftArm = runM leftHealedArmM vf

Demo – Broken Arm

// output // liveLeftHealedArm : LiveLeftHealedArm = // LiveLeftHealedArm ("Victor",{units = 1}) // remainingAfterLeftArm : VitalForce = // {units = 9}

The importance of map

The "map" pattern for elevated worlds

map

Elevated World

Normal World

a b

Elevated World

Normal World

E<a> E<b>

A function in the world of normal things

where "elevated world" is Option, List, Async, etc

The "map" pattern for elevated worlds

map

Elevated World

Normal World

a b

Elevated World

Normal World

E<a> E<b>

A function in the world of E-things

where "elevated world" is Option, List, Async, etc

The importance of map

World of normal values

int string bool

World of Lists

List<int> List<string> List<bool>

The importance of map

World of normal values

int string bool

World of Lists

List<int> List<string> List<bool>

The importance of map

World of normal values

int string bool

World of Lists

List<int> List<string> List<bool>

let addTwo_L inputList = let outputList = new List() foreach element in inputList do let newElement = addTwo element outputList.Add(newElement)

How not to code with lists

Let’s say you have some ints wrapped in an List, and

you want to add 2 to each element:

let addTwo x = x + 2

let addTwo_L inputList = let outputList = new List() foreach element in inputList do let newElement = addTwo element outputList.Add(newElement)

How not to code with lists

Let’s say you have some ints wrapped in an List, and

you want to add 2 to each element:

let addTwo x = x + 2

let addTwo_L inputList = let outputList = new List() foreach element in inputList do let newElement = addTwo element outputList.Add(newElement)

How not to code with lists

Let’s say you have some ints wrapped in an List, and

you want to add 2 to each element:

let addTwo x = x + 2

How not to code with lists

addTwo

World of normal values

World of Lists

How to code with lists

addTwo_L

World of normal values

World of Lists

How to code with lists

T -> U

List<T> -> List<U>

List.map

World of normal values

World of Lists

Linq.Select

How to code with lists

addTwo

addTwo_L [1;2] |>

1 |> // 3

// [3;4]

World of normal values

World of Lists

// map works with "addTwo" let addTwo_L = List.map addTwo // List<int> -> List<int> addTwo_L [1;2] // List<int> = [3; 4] [1;2] |> List.map addOne // List<int> = [3; 4] // map works with "healBrokenArm" let healBrokenArm_L = List.map healBrokenArm // List<LiveLeftBrokenArm> -> List<LiveLeftHealedArm>

Same applies for any generic type: Option, Task, etc

Technique 4:

Combining two live parts

Combining two parts

Dead Lower Arm

Dead Upper Arm

Live Whole Arm

What we've got What we want

Combining two parts

Live Arm Live Lower Arm ArmSurgery

Live Whole Arm

Live Upper Arm

We have this function!

Live Arm

...and we want one of these! How can we get it?

Combining two parts

Dead Lower Arm

We have these...

Dead Upper Arm

Live Arm

Combining two parts

Dead Lower Arm Dead Upper Arm Dead Arm

Create

ArmSurgery

Live Arm

Combining two parts

Dead Lower Arm Dead Upper Arm Dead Arm

Create

No. Only works on live arms

ArmSurgery

Create

ArmSurgery

Combining two parts

Dead Lower Arm Dead Upper Arm

Live Lower Arm Live Upper Arm Live Arm

Create

Create

ArmSurgery

No. We can't make live things directly, only M-type things

Combining two parts

Dead Lower Arm Dead Upper Arm

Live Lower Arm Live Upper Arm Live Arm

Create

Create

ArmSurgery

Combining two parts

Dead Lower Arm Dead Upper Arm

M<LiveLowerArm> M<LiveUpperArm> M<LiveArm>

Create

No. "ArmSurgery" doesn't work on M-type things

Create

ArmSurgeryM

Combining two parts

Dead Lower Arm Dead Upper Arm

M<LiveLowerArm> M<LiveUpperArm> M<LiveArm>

Create

We need a special "ArmSurgeryM" that works on M-type things

Combining two parts

map2

ArmSurgery Live Lower Arm Live Upper Arm Live Arm

ArmSurgeryM M<LiveLowerArm> M<LiveUpperArm> M<LiveArm>

World of things

World of M<_> things

Param1 -> Param2 -> Result

map2

A 2-param function in the world of things

The "map2" pattern for M-things

A 2-param function in the world of M<thing>s

World of things

World of M<_> things

Param1 -> Param2 -> Result

M<Param1> -> M<Param2> -> M<Result>

map2

The "map2" pattern for M-things

A 2-param function in the world of E<thing>s

World of things

World of E<_> things

Param1 -> Param2 -> Result

E<Param1> -> E<Param2> -> E<Result>

map2

The "map2" pattern for elevated worlds

Applies to any generic type: Option, Task, etc

Technique 5:

Combining live and dead parts

Combining mismatched parts

Empty Head Dead Brain

What we've got

Live Head

What we want

Combining mismatched parts

Live Head Live Brain HeadSurgery Empty Head

Combining function alive not alive

Create

HeadSurgery

Combining mismatched parts

Dead Brain Empty Head

Live Brain Empty Head Live Head

Copy

Create

HeadSurgery

Combining mismatched parts

Dead Brain Empty Head

Live Brain Empty Head Live Head

Copy

No. We can't make live things directly, only M-type things

Create

HeadSurgeryM

Combining mismatched parts

Dead Brain Empty Head

M<Live Brain> M<Empty Head> M<Live Head>

Create

HeadSurgeryM

Combining mismatched parts

Dead Brain Empty Head

M<Live Brain> M<Empty Head>

So what goes here?

M<Live Head>

This is not a live thing

Combining mismatched parts

return

Anything

M<Anything>

Create

HeadSurgeryM

Combining mismatched parts

Dead Brain

M<Live Brain> M<Empty Head> M<Live Head>

return

Empty Head

Create

HeadSurgeryM

Combining mismatched parts

Dead Brain

M<Live Brain> M<Empty Head> M<Live Head>

return

Empty Head

Both are M-things now

Create

HeadSurgeryM

Combining mismatched parts

Dead Brain

M<Live Brain> M<Empty Head> M<Live Head>

map2

Empty Head

Live Head Live Brain HeadSurgery Empty Head

return

"return" for M-things

return

Normal World

a

World of M<_> things

A value in the world of normal things

"return" for M-things

return

Normal World

a

World of M<_> things

M<a>

A value in the world of M-things

"return" for all elevated worlds

return

Normal World

a

Elevated World

E<a>

A value in the world of normal things

A value in the world of E-things

Technique 6:

Chaining M-generating functions

Chaining functions

Beating Heart Dead Heart

What we want What we've got

Chaining functions

Beating Heart Live Heart Dead Heart

Creating a beating heart is a two-step process

Chaining functions

Dead Heart M<Live Heart> Live Heart M<Beating Heart>

We have an M-generating function

We have another M-generating function

Dead Heart M<Live Heart>

Live Heart M<Beating Heart>

Chaining functions

Output type doesn't match input type

Dead Heart M<Live Heart>

Live Heart M<Beating Heart>

Chaining functions

Dead Heart M<Live Heart>

M<Live Heart> M<Beating Heart>

Chaining functions

If we could change this type to M<Live Heart>, it would work!

M<Beating Heart> M<Live Heart> makeBeatingHeartM

M<Beating Heart> Live Heart makeBeatingHeart

Chaining functions

This is what we’ve got: an M-generating function

This is what we want: an M-thing only function

M<Beating Heart> M<Live Heart> makeBeatingHeartM

M<Beating Heart> Live Heart makeBeatingHeart

Chaining functions

bind

"bind" converts an M-generating function into a M-thing only function

"bind" for M-things

bind

World of M<_> things

Normal World

a

M<b>

World of M<_> things

Normal World

M<a> M<b>

an M-generating function (diagonal)

"bind" for M-things

bind

World of M<_> things

Normal World

a

M<b>

World of M<_> things

Normal World

M<a> M<b>

a pure M-thing function (horizontal)

Show me the code

Beating Heart and "bind"

let makeLiveHeart deadHeart = let becomeAlive vitalForce = // snipped (liveHeart, remainingVitalForce) M becomeAlive // signature // makeLiveHeart : DeadHeart -> M<LiveHeart>

Demo: Chaining

let makeBeatingHeart liveHeart = let becomeAlive vitalForce = // snipped (beatingHeart, remainingVitalForce) M becomeAlive // signature // makeBeatingHeart : LiveHeart -> M<BeatingHeart>

Demo: Chaining

let beatingHeartM = // Convert "diagonal" to "horizontal" let makeBeatingHeartM = bind makeBeatingHeart

Demo: Chaining

let beatingHeartM = // Convert "diagonal" to "horizontal" let makeBeatingHeartM = bind makeBeatingHeart

// flow the data through each function DeadHeart "Anne" // DeadHeart |> makeLiveHeart // output = M<LiveHeart> |> makeBeatingHeartM // output = M<BeatingHeart>

Demo: Chaining

Q: Where did the vital force tracking go?

A: We are silently threading data through the code.

But no globals, no mutables!

// run the M<BeatingHeart> with some vital force let beatingHeart, remainingFromHeart = runM beatingHeartM vf // val beatingHeart : BeatingHeart = // BeatingHeart ( // LiveHeart ("Anne",{units = 1}), // {units = 1} ) // // val remainingFromHeart : VitalForce = // {units = 8} // TWO units used up!

Demo: Chaining

Proof that we are silently threading the vital force through the code!

The importance of bind

"bind" for all elevated worlds

bind

Elevated World

Normal World

a

E<b>

Elevated World

Normal World

E<a> E<b>

where "elevated world" is Option, List, Async, etc

"bind" for all elevated worlds

bind

Elevated World

Normal World

a

E<b>

Elevated World

Normal World

E<a> E<b>

where "elevated world" is Option, List, Async, etc

The importance of bind

World of normal values

int string bool

World of Lists

List<int> List<string> List<bool>

"Diagonal" functions

The importance of bind

World of normal values

int string bool

World of Lists

List<int> List<string> List<bool>

Bind

"SelectMany“ in C#

The importance of bind

World of normal values

int string bool

World of Lists

List<int> List<string> List<bool>

Bind

The importance of bind

World of normal values

int string bool

World of Lists

List<int> List<string> List<bool>

Bind

The importance of bind

World of normal values

int string bool

World of Lists

List<int> List<string> List<bool>

“Horizontal" functions

Technique 7:

Lifting arbitrary functions

Making "map3", "map4", "map5"

on the fly

type LiveBody = { leftLeg: LiveLeftLeg rightLeg : LiveLeftLeg leftArm : LiveLeftHealedArm rightArm : LiveRightArm head : LiveHead heart : BeatingHeart }

Defining the whole body

val createBody : leftLeg :LiveLeftLeg -> rightLeg :LiveLeftLeg -> leftArm :LiveLeftHealedArm -> rightArm :LiveRightArm -> head :LiveHead -> beatingHeart :BeatingHeart -> LiveBody // final result

Creating the whole body

Do we need a "mapSix" function?

Introducing "apply"

apply World of M<_> things

M<(a->b)>

World of M<_> things

Introducing "apply"

apply World of M<_> things

M<(a->b)>

World of M<_> things

M<a> M<b>

Introducing "apply"

apply World of M<_> things

M<(a->b)>

World of M<_> things

M<a> M<b>

apply M<(a->b->c)> M<a> M<b->c>

Introducing "apply"

apply World of M<_> things

M<(a->b)>

World of M<_> things

M<a> M<b>

apply M<(a->b->c)> M<a> M<b->c>

apply M<(a->b->c->d)> M<a> M<b->c->d>

Using "apply" to make "map3"

apply M<(a->b->c->d)> M<a> M<b->c->d>

Using "apply" to make "map3"

apply M<(b->c->d)> M<b> M<c->d>

apply M<(a->b->c->d)> M<a> M<b->c->d>

Using "apply" to make "map3"

apply M<(b->c->d)> M<b> M<c->d>

M<c->d> apply

M<c> M<d>

apply M<(a->b->c->d)> M<a> M<b->c->d>

Using "apply" to make "map3"

a->b->c->Result a b c Result

Using "apply" to make "map3"

M<(a->b->c->d)>

a->b->c->Result a b c Result

return

Using "apply" to make "map3"

apply M<(a->b->c->d)> M<a>

a->b->c->Result a b c Result

return create

Using "apply" to make "map3"

apply M<(a->b->c->d)> M<a> M<b>

a->b->c->Result a b c Result

return create create

apply

Using "apply" to make "map3"

apply M<(a->b->c->d)> M<a> M<b> M<c>

a->b->c->Result a b c Result

return create create create

apply apply

Using "apply" to make "map3"

apply M<(a->b->c->d)> M<a> M<b> M<c> M<Result>

a->b->c->Result a b c Result

return create create create

apply apply

Show me the code

Whole body and "apply"

// create the body in the "normal" world let createBody leftLeg rightLeg leftArm rightArm head heart = { leftLeg = leftLeg rightLeg = rightLeg leftArm = leftArm rightArm = rightArm head = head heart = heart }

Demo: Whole body

// <*> means "apply" let bodyM = returnM createBody <*> leftLegM <*> rightLegM <*> leftHealedArmM <*> rightArmM <*> headM <*> beatingHeartM // output is M<LiveBody>

Demo: Whole body

M-Things from earlier

Output is still a potential thing. We're "programming"!

// Lightning strikes! It's alive! let liveBody, remainingFromBody = runM bodyM vf // val liveBody : LiveBody = // {leftLeg = LiveLeftLeg ("Boris",{units = 1}) // rightLeg = LiveLeftLeg ("Boris",{units = 1}) // leftArm = LiveLeftArm ("Victor",{units = 1}) // rightArm = {lowerArm = LiveRightLowerArm // ("Tom",{units = 1}) // upperArm = LiveRightUpperArm // ("Jerry",{units = 1}) } // head = {brain = LiveBrain // ("Abby Normal",{units = 1}) // emptyHead = EmptyHead "Yorick"} // heart = BeatingHeart ( // LiveHeart ("Anne",{units = 1}), // {units = 1})} // val remainingFromBody : VitalForce = {units = 2}

Demo: Whole body

The state is automatically kept up-to-date

Is your brain hurting now?

Do we still have two problems?

Live part B

Vital force

Become alive B!

Remaining vital force

Dead part B

Live part A

Vital force

Become alive A!

Remaining vital force

Dead part A

Connect the force between two steps using "bind" or "apply"

Live part B

Vital force

Become alive B!

Remaining vital force

Dead part B

Live part A

Vital force

Become alive A!

Remaining vital force

Dead part A

Combine two outputs using "map2"

A Functional Toolbox

map

return bind

map2

apply

The Functional Toolbox

• "map"

– Lifts functions into the elevated world

• "return"

– Lifts values into the elevated world

• "apply"

– Lets you combine elevated values

– "map2" is a just a specialized "apply“

• "bind"

– Converts “diagonal” functions into horizontal ones

The Functional Toolbox

• "map"

– (with a sensible implementation) is a Functor

• "return" and "apply"

– (with a sensible implementation) is an Applicative

• "return" and "bind"

– (with a sensible implementation) is a Monad

The State monad

The state is threaded through the

code "invisibly"

let beatingHeartM = DeadHeart "Anne" |> makeLiveHeart |> makeBeatingHeartM // TWO units of force used up

State monad

Where is the "vital force" tracking variable?

let bodyM = returnM createBody <*> leftLegM <*> rightLegM <*> leftHealedArmM <*> rightArmM <*> headM <*> beatingHeartM // EIGHT units of force used up

State monad

Where is the "vital force" variable?

We are silently threading the vital force through the code...

...which allows us to focus on the design instead

Using Dr Frankenfunctor's

techniques in the real world

Is this too academic? Too abstract to be useful?

Scenario: Update user information

• Input is {userId, name, email}

• Step 1: Validate input

– Could fail if name is blank, etc

• Step 2: Canonicalize input

– Trim blanks, lowercase email, etc

• Step 3: Fetch existing record from db

– Could fail if record is missing

• Step 4: Update record in db

Validate

Generates a possible error

Validate Canonicalize

Generates a possible error Always succeeds

Validate Canonicalize DbFetch

Generates a possible error Generates a possible error Always succeeds

Validate Canonicalize DbFetch DbUpdate

Generates a possible error Generates a possible error Always succeeds Doesn't return

How can we glue these mismatched functions together?

World of normal things

"lift" from this world

World of two-track things

to this world

World of normal things

World of two-track things

bind map apply

map

Converting everything to two-track

bind

map

Converting everything to two-track

bind

map

tee map

Converting everything to two-track

Validate Canonicalize DbFetch DbUpdate

Now we *can* glue these together easily!

map bind tee, then map

Summary • We've seen a toolkit of useful techniques

– Don’t expect to understand them all straight away.

• How to wrap a function into a type

– A.k.a. a "computation" or "effect“

• How to use "map", "apply" and "bind"

– Monads are not that scary

– You can work with effects before running them!

• How to thread state "invisibly" through code

– Without using any globals or mutables!

Thanks!

@ScottWlaschin

fsharpforfunandprofit.com/monadster

Contact me

Slides and video here

Let us know if you need help with F#