Dr Frankenfunctor and the Monadster

1. Dr Frankenfunctor and the Monadster @ScottWlaschin fsharpforfunandprofit.com/monadster

2. Warning This talk contains: – gruesome topics – strained analogies – discussion of monads Not suitable for sensitive people (seriously)

3. Functional programmers love composition...

4. A functionInput Output

5. function A function BCompose

6. function A function B

7. function A and B Easy!

8. ... But here is a challenge for function composition

9. function AInput Output function BInput Output 1 Output 2 function C Input 1 Output 1 Output 2Input 2 function D Input 1 Output Input 2

10. function AInput Output function BInput Output 1 Output 2 function D Input 1 Output Input 2 How to compose?

11. function AInput Output function BInput Output 1 Output 2 function D Input 1 Output Input 2 How to compose?

12. The answer: monads!

13. The spread of the monad • 1990 ACM Conference on LISP and Functional Programming First monad in captivity

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

15. The spread of the monad • 1990 ACM Conference on LISP and Functional Programming • 1991 Eugenio Moggi, "Notions of computation and monads" • 1992 PhilipWadler, "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

16. The spread of the monad • 1990 ACM Conference on LISP and Functional Programming • 1991 Eugenio Moggi, "Notions of computation and monads" • 1992 PhilipWadler, "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

17. 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 PhilipWadler, "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

18. The story of the Monadster

19. The creature was built from body parts of various shapes

20. The various parts were assembled into a whole

21. The body was animated in a single instant, using a bolt of lightning to create the vital force.

22. ...The Monadster The “mark of the lambda”

23. But how was it done? I have devoted many years of research into this matter...

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

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

26. Technique 1: Modelling with pure functions

27. Become alive! Vital force Dead part Live part Don't try this at home

28. Live body part Vital force Become alive! Remaining vital force Dead body part Two inputs

29. Live body part Vital force Become alive! Remaining vital force Dead body part Two outputs

30. Live body part Vital force Become alive! Remaining vital force Dead body part Less vital force available afterwards

31. Live body part Vital force Become alive! Remaining vital force Dead body part No globals, no mutation!

32. But now you have two problems...

33. 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?

34. 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?

35. Technique 2: Wrapping the "Become Alive" function Also, introducing schönfinkelling

36. Moses Schönfinkel invented schönfinkelling

37. Moses Schönfinkel invented schönfinkelling

38. Haskell Curry gave his name to currying

39. Input A Uncurried Function Input B Output C Curried Function Input A Intermediate Function Output CInput B What is currying? after currying Currying means that *every* function has one input

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

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

42. // 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

43. // "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

44. // removing the parens let three = add 1 2 Currying examples // returning a lambda with baked in "x" let add x = (fun y -> x + y)

45. Live part A Vital force Become alive! Remaining vital force Dead part A Currying "become alive!"

46. Become alive! Dead part A Vital force Live part A Currying "become alive!"

47. Become alive! Dead part A Vital force M<Live Part A> Live part A Wrapping the function "M" is for "Monadster"

48. Become alive! Dead part A Vital force M<Live Part A> Live part A Wrapping the function

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

50. M<Live Part A> Run Live part A Remaining vital force Running the function Vital force

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

52. Show me the code Left Leg

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

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

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

60. // 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

61. Technique 3: Transforming live parts

62. A Broken Arm Dead Broken Arm What we've got Live Healed Arm What we want

63. Healing a broken arm Live Healed ArmLive Broken Arm HealBrokenArm We have this function!

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

65. Create Dead Broken Arm Dead Healed Arm Live Healed Arm Healing a broken arm HealBrokenArm

66. Create Dead Broken Arm Dead Healed Arm Live Healed Arm  No. We can only heal live arms Healing a broken arm HealBrokenArm

67. Dead Broken Arm Live Healed ArmLive Broken Arm Create HealBrokenArm Healing a broken arm

68. Dead Broken Arm Live Healed ArmLive Broken Arm Create HealBrokenArm No. We can't create live things directly, only M-type things  Healing a broken arm 

69. Dead Broken Arm M<Live Healed Arm>M<Live Broken Arm> Create HealBrokenArm Healing a broken arm

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

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

72. Live Healed ArmLive 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

73. Live Healed ArmLive Broken Arm HealBrokenArm Healing a broken arm M<Live Healed Arm>M<Live Broken Arm> HealBrokenArmM map

74. "map" is generic for M-things NormalWorld a b

75. "map" is generic for M-things NormalWorld a b map

76. "map" is generic for M-things NormalWorld a b map World of M<_> things M<a> M A function in the world of M-things “lifting”

77. Show me the code Broken Arm and "map"

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

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

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

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

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

86. 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}

87. The importance of map

88. The "map" pattern for elevated worlds map ElevatedWorld NormalWorld a b ElevatedWorld Normal World E<a> E A function in the world of normal things where "elevated world" is Option, List, Async, etc

89. The "map" pattern for elevated worlds map ElevatedWorld NormalWorld a b ElevatedWorld Normal World E<a> E A function in the world of E-things where "elevated world" is Option, List, Async, etc

90. The importance of map World of normal values int string bool World of Lists List<int> List<string> List<bool>

91. The importance of map World of normal values int string bool World of Lists List<int> List<string> List<bool>

92. The importance of map World of normal values int string bool World of Lists List<int> List<string> List<bool>

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

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

95. 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 

96. How not to code with lists addTwo  World of normal values World of Lists

97. How to code with lists addTwo_L World of normal values World of Lists

98. How to code with lists T -> U List<T> -> List List.map World of normal values World of Lists Linq.Select

99. How to code with lists addTwo addTwo_L[1;2] |> 1 |> // 3 // [3;4] World of normal values World of Lists

100. // 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

101. Technique 4: Combining two live parts

102. Combining two parts Dead Lower Arm Dead Upper Arm Live Whole Arm What we've got What we want

103. Combining two parts Live ArmLive Lower Arm ArmSurgery Live Whole Arm Live Upper Arm We have this function!

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

105. Live Arm Combining two parts Dead Lower Arm Dead Upper Arm Dead Arm Create ArmSurgery

106. Live Arm Combining two parts Dead Lower Arm Dead Upper Arm Dead Arm Create  No. Only works on live arms ArmSurgery

107. Create ArmSurgery Combining two parts Dead Lower Arm Dead Upper Arm Live Lower Arm Live Upper Arm Live Arm Create

108. 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

109. 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 

110. 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  

111. Combining two parts map2 ArmSurgeryLive Lower Arm Live Upper Arm Live Arm ArmSurgeryMM<LiveLowerArm> M<LiveUpperArm> M<LiveArm>

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

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

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

115. Technique 5: Combining live and dead parts

116. Combining mismatched parts Empty HeadDead Brain What we've got Live Head What we want

117. Combining mismatched parts Live HeadLive Brain HeadSurgeryEmpty Head Combining function alive not alive

118. Create HeadSurgery Combining mismatched parts Dead Brain Empty Head Live Brain Empty Head Live Head Copy

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

120. Create HeadSurgeryM  Combining mismatched parts Dead Brain Empty Head M<Live Brain> M<Empty Head> M<Live Head>

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

122. Combining mismatched parts return Anything M<Anything>

123. Create HeadSurgeryM  Combining mismatched parts Dead Brain M<Live Brain> M<Empty Head> M<Live Head> return Empty Head

124. Create HeadSurgeryM  Combining mismatched parts Dead Brain M<Live Brain> M<Empty Head> M<Live Head> return Empty Head Both are M-things now

125. Create HeadSurgeryM  Combining mismatched parts Dead Brain M<Live Brain> M<Empty Head> M<Live Head> map2 Empty Head Live HeadLive Brain HeadSurgeryEmpty Head return

126. "return" for M-things return NormalWorld a World of M<_> things A value in the world of normal things

127. "return" for M-things return NormalWorld a World of M<_> things M<a> A value in the world of M-things

128. "return" for all elevated worlds return NormalWorld a ElevatedWorld E<a> A value in the world of normal things A value in the world of E-things

129. Technique 6: Chaining M-generating functions

130. Chaining functions Beating HeartDead Heart What we wantWhat we've got

131. Chaining functions Beating HeartLive HeartDead Heart Creating a beating heart is a two-step process

132. Chaining functions Dead Heart M<Live Heart> Live Heart M<Beating Heart> We have an M-generating function We have another M-generating function

133. Dead Heart M<Live Heart> Live Heart M<Beating Heart>   Chaining functions Output type doesn't match input type

134. Dead Heart M<Live Heart> Live Heart M<Beating Heart> Chaining functions 

135. 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! 

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

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

138. "bind" for M-things bind World of M<_> things Normal World a M World of M<_> things Normal World M<a> M an M-generating function (diagonal)

139. "bind" for M-things bind World of M<_> things Normal World a M World of M<_> things Normal World M<a> M a pure M-thing function (horizontal)

140. Show me the code Beating Heart and "bind"

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

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

143. let beatingHeartM = // Convert "diagonal" to "horizontal" let makeBeatingHeartM = bind makeBeatingHeart Demo: Chaining

144. 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!

145. // 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!

146. The importance of bind

147. "bind" for all elevated worlds bind Elevated World Normal World a E Elevated World Normal World E<a> E where "elevated world" is Option, List, Async, etc

148. "bind" for all elevated worlds bind Elevated World Normal World a E Elevated World Normal World E<a> E where "elevated world" is Option, List, Async, etc

149. The importance of bind World of normal values int string bool World of Lists List<int> List<string> List<bool> "Diagonal" functions

150. The importance of bind World of normal values int string bool World of Lists List<int> List<string> List<bool> Bind "SelectMany“ in C#

151. The importance of bind World of normal values int string bool World of Lists List<int> List<string> List<bool> Bind

152. The importance of bind World of normal values int string bool World of Lists List<int> List<string> List<bool> Bind

153. The importance of bind World of normal values int string bool World of Lists List<int> List<string> List<bool> “Horizontal" functions

154. Technique 7: Lifting arbitrary functions Making "map3", "map4", "map5" on the fly

155. type LiveBody = { leftLeg: LiveLeftLeg rightLeg : LiveLeftLeg leftArm : LiveLeftHealedArm rightArm : LiveRightArm head : LiveHead heart : BeatingHeart } Defining the whole body

156. 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?

157. Introducing "apply" apply World of M<_> things M<(a->b)> World of M<_> things

158. Introducing "apply" apply World of M<_> things M<(a->b)> World of M<_> things M<a> M

159. Introducing "apply" apply World of M<_> things M<(a->b)> World of M<_> things M<a> M apply M<(a->b->c)> M<a> M<b->c>

160. Introducing "apply" apply World of M<_> things M<(a->b)> World of M<_> things M<a> M apply M<(a->b->c)> M<a> M<b->c> apply M<(a->b->c->d)> M<a> M<b->c->d>

161. Using "apply" to make "map3" apply M<(a->b->c->d)> M<a> M<b->c->d>

162. Using "apply" to make "map3" apply M<(b->c->d)> M M<c->d> apply M<(a->b->c->d)> M<a> M<b->c->d>

163. Using "apply" to make "map3" apply M<(b->c->d)> M M<c->d> M<c->d> apply M<c> M<d> apply M<(a->b->c->d)> M<a> M<b->c->d>

164. Using "apply" to make "map3" a->b->c->Result a b c Result

165. Using "apply" to make "map3" M<(a->b->c->d)> a->b->c->Result a b c Result return

166. Using "apply" to make "map3" apply M<(a->b->c->d)> M<a> a->b->c->Result a b c Result return create

167. Using "apply" to make "map3" apply M<(a->b->c->d)> M<a> M a->b->c->Result a b c Result return create create apply

168. Using "apply" to make "map3" apply M<(a->b->c->d)> M<a> M M<c> a->b->c->Result a b c Result return create create create apply apply

169. Using "apply" to make "map3" apply M<(a->b->c->d)> M<a> M M<c> M<Result> a->b->c->Result a b c Result return create create create apply apply

170. Show me the code Whole body and "apply"

171. // 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

172. // <*> 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"!

173. // 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

174. Is your brain hurting now?

175. Do we still have two problems?

176. 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"

177. 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"

178. A FunctionalToolbox

179. map return bind map2 apply

180. The FunctionalToolbox • "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

181. The FunctionalToolbox • "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

182. The State monad The state is threaded through the code "invisibly"

183. let beatingHeartM = DeadHeart "Anne" |> makeLiveHeart |> makeBeatingHeartM // TWO units of force used up State monad Where is the "vital force" tracking variable?

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

185. Using Dr Frankenfunctor's techniques in the real world Is this too academic? Too abstract to be useful?

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

187. Validate Generates a possible error

188. Validate Canonicalize Generates a possible error Always succeeds

189. Validate Canonicalize DbFetch Generates a possible error Generates a possible errorAlways succeeds

190. Validate Canonicalize DbFetch DbUpdate Generates a possible error Generates a possible errorAlways succeeds Doesn't return How can we glue these mismatched functions together?

191. World of normal things "lift" from this world World of two-track things to this world

192. World of normal things World of two-track things bindmap apply

193. map Converting everything to two-track

194. bind map Converting everything to two-track

195. bind map tee map Converting everything to two-track

196. Validate Canonicalize DbFetch DbUpdate Now we *can* glue these together easily! map bind tee, then map

197. 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!

198. Thanks! @ScottWlaschin fsharpforfunandprofit.com/monadster Contact me Slides and video here Let us know if you need help with F#

Dr Frankenfunctor and the Monadster

Scott Wlaschin

Dr Frankenfunctor and the Monadster