Dr Frankenfunctor and the Monadster
-
Upload
scott-wlaschin -
Category
Technology
-
view
10.210 -
download
0
Transcript of Dr Frankenfunctor and the Monadster
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#