Ce diaporama a bien été signalé.
Nous utilisons votre profil LinkedIn et vos données d’activité pour vous proposer des publicités personnalisées et pertinentes. Vous pouvez changer vos préférences de publicités à tout moment.
Functional Design Patterns
(NDC London 2014)
@ScottWlaschin
fsharpforfunandprofit.com
Functional Design Patterns
@ScottWlaschin
fsharpforfunandprofit.com
X
Functional Design Patterns
@ScottWlaschin
fsharpforfunandprofit.com
HOW I GOT HERE
Me
I
Making fun of Enterprise OO
is like shooting fish in a barrel
I but...
I but...
Making fun of Enterprise OO
is like shooting IMarineVertebrates
in an AbstractBarrelProxyFactory
Inspired by @sjk...
I
This is what happens when you dabble too
much in functional programming
https://www.flickr.com/photos/37511372@N08/5488671752/
Haskell programmers
F#/OCaml programmers
Visual Basic programmers
L...
FP DESIGN PATTERNS
• Single Responsibility Principle
• Open/Closed principle
• Dependency Inversion
Principle
• Interface Segregation
Princip...
• Single Responsibility Principle
• Open/Closed principle
• Dependency Inversion
Principle
• Interface Segregation
Princip...
• Single Responsibility Principle
• Open/Closed principle
• Dependency Inversion
Principle
• Interface Segregation
Princip...
Functional patterns
• Apomorphisms
• Dynamorphisms
• Chronomorphisms
• Zygohistomorphic prepromorphisms
Functional patterns
• Core Principles of FP design
– Functions, types, composition
• Functions as parameters
– Functions a...
This talk
A whirlwind tour of many sights
Don't worry if you don't understand everything
(SOME) CORE PRINCIPLES OF
FUNCTIONAL PROGRAMMING
Important to understand!
Core principles of FP
Function
Types are not classes
Functions are things
Composition everywhere
Core principle:
Functions are things
Function
Functions as things
The Tunnel of
Transformation
Function
apple -> banana
A function is a standalone thing,
not attached t...
Functions as things
let z = 1
int-> int->int
1
let add x y = x + y
Functions as inputs and outputs
let useFn f = (f 1) + 2
let add x = (fun y -> x + y)
int->(int->int)
int
int
let transform...
Core principle:
Composition everywhere
Function composition
Function 1
apple -> banana
Function 2
banana -> cherry
Function composition
>>
Function 1
apple -> banana
Function 2
banana -> cherry
Function composition
New Function
apple -> cherry
Can't tell it was built from
smaller functions!
Design paradigm:
Functions all the way down
“Functions in the small,
objects in the large”
Low-level operation
ToUpper
stringstring
Low-level operation
Service
AddressValidator
A “Service” is just like a microservice
but without the "micro" in front
Vali...
Service
Use-case
UpdateProfileData
ChangeProfile
Result
ChangeProfile
Request
Service Service
Use-case
Web application
Http
Response
Http
Request
Use-case Use-case
Core principle:
Types are not classes
X
Types are not classes
Set of
valid inputs
Set of
valid outputs
So what is a type?
Types separate data from behavior
Lists Lists
List.map
List.collect
List.filter
List.etc
Types can be composed too
“algebraic types"
Product types
× = Alice, Jan 12th
Bob, Feb 2nd
Carol, Mar 3rd
Set of people Set of dates
type Birthday = Person * Date
Sum types
Set of Cash values
Set of Cheque values
Set of CreditCard
values
+
+
type PaymentMethod =
| Cash
| Cheque of Che...
Design principle:
Strive for totality
twelveDividedBy(x)
input x maps to 12/x
…
3
2
1
0
…
Domain (int) Codomain (int)
…
4
6
12
…
Totality
int TwelveDividedBy(in...
twelveDividedBy(x)
input x maps to 12/x
…
3
2
1
0
…
Domain (int) Codomain (int)
…
4
6
12
…
Totality
int TwelveDividedBy(in...
twelveDividedBy(x)
input x maps to 12/x
…
3
2
1
0
…
Domain (int) Codomain (int)
…
4
6
12
…
Totality
int TwelveDividedBy(in...
twelveDividedBy(x)
input x maps to 12/x
…
3
2
1
-1
…
NonZeroInteger int
…
4
6
12
…
Totality
int TwelveDividedBy(int input)...
twelveDividedBy(x)
input x maps to 12/x
…
3
2
1
0
-1
…
int Option<Int>
…
Some 4
Some 6
Some 12
None
…
Totality
int TwelveD...
Design principle:
Use static types for domain
modelling and documentation
Static types only!
Sorry Clojure and JS
develope...
Big topic! Not enough time today !
More on DDD and designing with types at
fsharpforfunandprofit.com/ddd
FUNCTIONS AS
PARAMETERS
Guideline:
Parameterize all the things
Parameterize all the things
let printList() =
for i in [1..10] do
printfn "the number is %i" i
Parameterize all the things
It's second nature to parameterize the data input:
let printList aList =
for i in aList do
pri...
Parameterize all the things
let printList anAction aList =
for i in aList do
anAction i
FPers would parameterize the actio...
Parameterize all the things
public static int Product(int n)
{
int product = 1;
for (int i = 1; i <= n; i++)
{
product *= ...
public static int Product(int n)
{
int product = 1;
for (int i = 1; i <= n; i++)
{
product *= i;
}
return product;
}
publi...
Parameterize all the things
let product n =
let initialValue = 1
let action productSoFar x = productSoFar * x
[1..n] |> Li...
Tip:
Function types are "interfaces"
Function types are interfaces
interface IBunchOfStuff
{
int DoSomething(int x);
string DoSomethingElse(int x);
void DoAThi...
Function types are interfaces
interface IBunchOfStuff
{
int DoSomething(int x);
}
An interface with one method is a just a...
Strategy pattern
class MyClass
{
public MyClass(IBunchOfStuff strategy) {..}
int DoSomethingWithStuff(int x)
{
return _str...
Strategy pattern
int int
int->int
int->int
let DoSomethingWithStuff strategy x =
strategy x
Functional strategy pattern:
I...
Decorator pattern using function parameter:
let isEven x = (x % 2 = 0) // int -> bool
isEvenint bool
loggerint bool
let lo...
Decorator pattern using function parameter:
let isEven x = (x % 2 = 0) // int -> bool
isEvenint bool
loggerint bool
let is...
Decorator pattern using function composition:
let isEven x = (x % 2 = 0) // int -> bool
isEvenint bool
isEvenint boollogin...
Bad news:
Composition patterns
only work for functions that
have one parameter! 
Good news!
Every function is a
one parameter function 
Writing functions in different ways
let add x y = x + y
let add = (fun x y -> x + y)
let add x = (fun y -> x + y)
int-> in...
let three = 1 + 2
let three = (+) 1 2
let three = ((+) 1) 2
"+" is a two parameter function
let three = 1 + 2
let three = (+) 1 2
let three = ((+) 1) 2
let add1 = (+) 1
let three = add1 2
No, "+" is a one param fun...
Pattern:
Partial application
let name = "Scott"
printfn "Hello, my name is %s" name
let name = "Scott"
(printfn "Hello, my name is %s") name
let name =...
Pattern:
Use partial application when
working with lists
let names = ["Alice"; "Bob"; "Scott"]
names |> List.iter hello
let hello = printfn "Hello, my name is %s"
let add1 = (+) 1...
Pattern:
Use partial application to do
dependency injection
type GetCustomer = CustomerId -> Customer
let getCustomerFromDatabase connection
(customerId:CustomerId) =
// from connect...
type GetCustomer = CustomerId -> Customer
let getCustomerFromMemory dict (customerId:CustomerId) =
dict.Get(customerId)
ty...
Pattern:
The Hollywood principle*:
continuations
Continuations
int Divide(int top, int bottom)
{
if (bottom == 0)
{
throw new InvalidOperationException("div by 0");
}
else...
Continuations
void Divide(int top, int bottom,
Action ifZero, Action<int> ifSuccess)
{
if (bottom == 0)
{
ifZero();
}
else...
Continuations
let divide ifZero ifSuccess top bottom =
if (bottom=0)
then ifZero()
else ifSuccess (top/bottom)
F# version
...
Continuations
let divide ifZero ifSuccess top bottom =
if (bottom=0)
then ifZero()
else ifSuccess (top/bottom)
let ifZero1...
let divide ifZero ifSuccess top bottom =
if (bottom=0)
then ifZero()
else ifSuccess (top/bottom)
Continuations
let ifZero2...
let divide ifZero ifSuccess top bottom =
if (bottom=0)
then ifZero()
else ifSuccess (top/bottom)
Continuations
let ifZero3...
Pattern:
Chaining callbacks with
continuations
Pyramid of doom: null testing example
Let example input =
let x = doSomething input
if x <> null then
let y = doSomethingE...
Pyramid of doom: async example
let taskExample input =
let taskX = startTask input
taskX.WhenFinished (fun x ->
let taskY ...
Pyramid of doom: null example
let example input =
let x = doSomething input
if x <> null then
let y = doSomethingElse x
if...
Pyramid of doom: option example
let example input =
let x = doSomething input
if x.IsSome then
let y = doSomethingElse (x....
Pyramid of doom: option example
let example input =
let x = doSomething input
if x.IsSome then
let y = doSomethingElse (x....
Pyramid of doom: option example
let example input =
let x = doSomething input
if x.IsSome then
let y = doSomethingElse (x....
Pyramid of doom: option example
let example input =
let x = doSomething input
if x.IsSome then
// do something with x.Valu...
if opt.IsSome then
//do something with opt.Value
else
None
let ifSomeDo f opt =
if opt.IsSome then
f opt.Value
else
None
let example input =
doSomething input
|> ifSomeDo doSomethingElse
|> ifSomeDo doAThirdThing
|> ifSomeDo (fun z -> Some z)
...
MONADS
A switch analogy
Some
None
Input ->
Connecting switches
on Some
Bypass on None
Connecting switches
Connecting switches
Composing switches
>> >>
Composing one-track functions is fine...
Composing switches
>> >>
... and composing two-track functions is fine...
Composing switches
 
... but composing switches is not allowed!
How to combine the
mismatched functions?
“Bind” is the answer!
Bind all the things!
Composing switches
Two-track input Two-track input
One-track input Two-track input


Building an adapter block
Two-track input
Slot for switch function
Two-track output
Building an adapter block
Two-track input Two-track output
let bind nextFunction optionInput =
match optionInput with
| Some s -> nextFunction s
| None -> None
Building an adapter b...
let bind nextFunction optionInput =
match optionInput with
| Some s -> nextFunction s
| None -> None
Building an adapter b...
let bind nextFunction optionInput =
match optionInput with
| Some s -> nextFunction s
| None -> None
Building an adapter b...
let bind nextFunction optionInput =
match optionInput with
| Some s -> nextFunction s
| None -> None
Building an adapter b...
Pattern:
Use bind to chain options
Pyramid of doom: using bind
let bind f opt =
match opt with
| Some v -> f v
| None -> None
let example input =
let x = doS...
let example input =
doSomething input
|> bind doSomethingElse
|> bind doAThirdThing
|> bind (fun z -> Some z)
Pyramid of d...
Pattern:
Use bind to chain tasks
Connecting tasks
When task
completesWait Wait
Pyramid of doom: using bind for tasks
let taskBind f task =
task.WhenFinished (fun taskResult ->
f taskResult)
let taskExa...
Pyramid of doom: using bind for tasks
let taskBind f task =
task.WhenFinished (fun taskResult ->
f taskResult)
let taskExa...
Pattern:
Use bind to chain error handlers
Use case without error handling
string UpdateCustomerWithErrorHandling()
{
var request = receiveRequest();
validateRequest...
Use case with error handling
string UpdateCustomerWithErrorHandling()
{
var request = receiveRequest();
var isValidated = ...
Use case with error handling
string UpdateCustomerWithErrorHandling()
{
var request = receiveRequest();
var isValidated = ...
Use case with error handling
string UpdateCustomerWithErrorHandling()
{
var request = receiveRequest();
var isValidated = ...
Use case with error handling
string UpdateCustomerWithErrorHandling()
{
var request = receiveRequest();
var isValidated = ...
Use case with error handling
string UpdateCustomerWithErrorHandling()
{
var request = receiveRequest();
var isValidated = ...
A structure for managing errors
Request SuccessValidate
Failure
let validateInput input =
if input.name = "" then
Failure ...
Connecting switches
Validate UpdateDb SendEmail
Connecting switches
Validate UpdateDb SendEmail
Functional flow without error handling
let updateCustomer =
receiveRequest
|> validateRequest
|> canonicalizeEmail
|> upda...
let updateCustomerWithErrorHandling =
receiveRequest
|> validateRequest
|> canonicalizeEmail
|> updateDbFromRequest
|> sen...
MAPS
World of normal values
int string bool
World of options
int option string option bool option
World of options
World of normal values
int string bool
int option string option bool option

World of options
World of normal values
int option string option bool option

int string bool
let add42ToOption opt =
if opt.IsSome then
let newVal = add42 opt.Value
Some newVal
else
None
How not to code with options...
World of options
World of normal values
add42

World of options
World of normal values
add42
Lifting
World of options
World of normal values
T -> U
option<T> -> option<U>
Option.map
World of options
World of normal values
add42
add42ToOptionSome 1 |>
1 |> // 43
// Some 43
The right way to code with options
Let’s say you have an int wrapped in an Option, and
you want to add 42 to it:
let add42...
The right way to code with options
Let’s say you have an int wrapped in an Option, and
you want to add 42 to it:
let add42...
Lifting to lists
World of lists
World of normal values
T -> U
List<T> -> List<U>
List.map
The right way to code with wrapped types
[1;2;3] |> List.map add42
// [43;44;45]
Lifting to async
World of async
World of normal values
T -> U
async<T> -> async<U>
Async.map
Guideline:
Most wrapped generic types
have a “map”. Use it!
Guideline:
If you create your own generic type,
create a “map” for it.
MONOIDS
Mathematics
Ahead
Thinking like a mathematician
1 + 2 = 3
1 + (2 + 3) = (1 + 2) + 3
1 + 0 = 1
0 + 1 = 1
1 + 2 = 3
Some things
A way of combining
them
2 x 3 = 6
Some things
A way of combining
them
"a" + "b" = "ab"
Some things
A way of combining
them
concat([a],[b]) = [a; b]
Some things
A way of combining
them
1 + 2
1 + 2 + 3
1 + 2 + 3 + 4
Is an integer
Is an integer
A pairwise operation has
become an operation that
works on lists!
1 + (2 + 3) = (1 + 2) + 3
Order of combining doesn’t matter
1 + 2 + 3 + 4
(1 + 2) + (3 + 4)
((1 + 2) + 3) + 4
All the same
1 - (2 - 3) = (1 - 2) - 3
Order of combining does matter
1 + 0 = 1
0 + 1 = 1
A special kind of thing that when
you combine it with something, just
gives you back the original
some...
42 * 1 = 42
1 * 42 = 42
A special kind of thing that when
you combine it with something, just
gives you back the original
...
"" + "hello" = "hello"
"hello" + "" = "hello"
“Zero” for strings
The generalization
• You start with a bunch of things, and some way of
combining them two at a time.
• Rule 1 (Closure):Th...
• Rule 1 (Closure):The result of combining two
things is always another one of the things.
• Benefit: converts pairwise op...
1 * 2 * 3 * 4
[ 1; 2; 3; 4 ] |> List.reduce (*)
• Rule 1 (Closure):The result of combining two
things is always another on...
"a" + "b" + "c" + "d"
[ "a"; "b"; "c"; "d" ] |> List.reduce (+)
• Rule 1 (Closure):The result of combining two
things is a...
• Rule 2 (Associativity):When combining more
than two things, which pairwise combination
you do first doesn't matter.
• Be...
• Rule 2 (Associativity):When combining more
than two things, which pairwise combination
you do first doesn't matter.
• Be...
• Rule 2 (Associativity):When combining more
than two things, which pairwise combination
you do first doesn't matter.
• Be...
• Rule 2 (Associativity):When combining more
than two things, which pairwise combination
you do first doesn't matter.
• Be...
• Rule 2 (Associativity):When combining more
than two things, which pairwise combination
you do first doesn't matter.
• Be...
Issues with reduce
• How can I use reduce on an empty list?
• In a divide and conquer algorithm, what should I
do if one o...
• Rule 3 (Identity element):There is a special
thing called "zero" such that when you combine
any thing with "zero" you ge...
Pattern:
Simplifying aggregation code with monoids
type OrderLine = {Qty:int; Total:float}
let orderLines = [
{Qty=2; Total=19.98}
{Qty=1; Total= 1.99}
{Qty=3; Total= 3.99} ...
Pattern:
Convert non-monoids to monoids
Customer
+
Customer
+
Customer
Customer Stats
+
Customer Stats
+
Customer Stats
Reduce
Map
Not a monoid A monoid
Customer ...
Hadoop make me a sandwich
https://twitter.com/daviottenheimer
/status/532661754820829185
Guideline:
Convert expensive monoids
to cheap monoids
Log file (Mon)
+
Log File (Tue)
+
Log File (Wed)
=
Really big file
Summary (Mon)
+
Summary (Tue)
+
Summary (Wed)
Map
Strin...
Pattern:
Seeing monoids everywhere
Monoids in the real world
Metrics guideline:
Use counters rather than rates
Alternative metrics guideline:
Make sure your ...
Is function composition a monoid?
>>
Function 1
apple -> banana
Function 2
banana -> cherry
New Function
apple -> cherry
N...
Is function composition a monoid?
>>
Function 1
apple -> apple
Same thing
Function 2
apple -> apple
Function 3
apple -> ap...
Is function composition a monoid?
“Functions with same type of input and output”
Functions where the input and output are ...
Is function composition a monoid?
“Functions with same type of input and output”
“Endomorphisms”
Functions where the input...
let plus1 x = x + 1 // int->int
let times2 x = x * 2 // int->int
let subtract42 x = x – 42 // int->int
Reduce
plus1ThenTim...
Event sourcing
Any function containing an endomorphism can
be converted into a monoid!
Event application function:
Is an e...
apply event1 // State -> State
apply event2 // State -> State
apply event3 // State -> State
Reduce
applyAllEventsAtOnce /...
Monads vs. monoids?
Series combination
=+
Result is same
kind of thing
(Closure)
Series combination
+
Order not
important
(Associative) Monoid!
+( )
++( )
Parallel combination
=+
Same thing
(Closure)
Order not
important
(Associative)
Monoid!
Monad laws
• The Monad laws are just the monoid
definitions in diguise
– Closure, Associativity, Identity
• What happens i...
A monad is just a monoid in
the category of endofunctors!
A monad is just a monoid in
the category of endofunctors!
THANKS!
Prochain SlideShare
Chargement dans…5
×

Functional Programming Patterns (NDC London 2014)

156 928 vues

Publié le

(video of these slides available here http://fsharpforfunandprofit.com/fppatterns/)

In object-oriented development, we are all familiar with design patterns such as the Strategy pattern and Decorator pattern, and design principles such as SOLID.

The functional programming community has design patterns and principles as well.

This talk will provide an overview of some of these, and present some demonstrations of FP design in practice.

Publié dans : Logiciels

Functional Programming Patterns (NDC London 2014)

  1. 1. Functional Design Patterns (NDC London 2014) @ScottWlaschin fsharpforfunandprofit.com
  2. 2. Functional Design Patterns @ScottWlaschin fsharpforfunandprofit.com X
  3. 3. Functional Design Patterns @ScottWlaschin fsharpforfunandprofit.com
  4. 4. HOW I GOT HERE
  5. 5. Me
  6. 6. I
  7. 7. Making fun of Enterprise OO is like shooting fish in a barrel I but...
  8. 8. I but... Making fun of Enterprise OO is like shooting IMarineVertebrates in an AbstractBarrelProxyFactory Inspired by @sjkilleen
  9. 9. I
  10. 10. This is what happens when you dabble too much in functional programming
  11. 11. https://www.flickr.com/photos/37511372@N08/5488671752/ Haskell programmers F#/OCaml programmers Visual Basic programmers Lisp programmers
  12. 12. FP DESIGN PATTERNS
  13. 13. • Single Responsibility Principle • Open/Closed principle • Dependency Inversion Principle • Interface Segregation Principle • Factory pattern • Strategy pattern • Decorator pattern • Visitor pattern OO pattern/principle
  14. 14. • Single Responsibility Principle • Open/Closed principle • Dependency Inversion Principle • Interface Segregation Principle • Factory pattern • Strategy pattern • Decorator pattern • Visitor pattern OO pattern/principle Borg response
  15. 15. • Single Responsibility Principle • Open/Closed principle • Dependency Inversion Principle • Interface Segregation Principle • Factory pattern • Strategy pattern • Decorator pattern • Visitor pattern • Functions • Functions • Functions, also • Functions • You will be assimilated! • Functions again • Functions • Resistance is futile! OO pattern/principle FP equivalent Seriously, FP patterns are different
  16. 16. Functional patterns • Apomorphisms • Dynamorphisms • Chronomorphisms • Zygohistomorphic prepromorphisms
  17. 17. Functional patterns • Core Principles of FP design – Functions, types, composition • Functions as parameters – Functions as interfaces – Partial application & dependency injection – Continuations, chaining & the pyramid of doom • Monads – Error handling, Async • Maps – Dealing with wrapped data – Functors • Monoids – Aggregating data and operations
  18. 18. This talk A whirlwind tour of many sights Don't worry if you don't understand everything
  19. 19. (SOME) CORE PRINCIPLES OF FUNCTIONAL PROGRAMMING Important to understand!
  20. 20. Core principles of FP Function Types are not classes Functions are things Composition everywhere
  21. 21. Core principle: Functions are things Function
  22. 22. Functions as things The Tunnel of Transformation Function apple -> banana A function is a standalone thing, not attached to a class
  23. 23. Functions as things let z = 1 int-> int->int 1 let add x y = x + y
  24. 24. Functions as inputs and outputs let useFn f = (f 1) + 2 let add x = (fun y -> x + y) int->(int->int) int int let transformInt f x = (f x) + 1 int int int->int Function as output Int ->int Function as input Function as parameterint->int (int->int)->int int->int
  25. 25. Core principle: Composition everywhere
  26. 26. Function composition Function 1 apple -> banana Function 2 banana -> cherry
  27. 27. Function composition >> Function 1 apple -> banana Function 2 banana -> cherry
  28. 28. Function composition New Function apple -> cherry Can't tell it was built from smaller functions!
  29. 29. Design paradigm: Functions all the way down
  30. 30. “Functions in the small, objects in the large”
  31. 31. Low-level operation ToUpper stringstring
  32. 32. Low-level operation Service AddressValidator A “Service” is just like a microservice but without the "micro" in front Validation Result Address Low-level operation Low-level operation
  33. 33. Service Use-case UpdateProfileData ChangeProfile Result ChangeProfile Request Service Service
  34. 34. Use-case Web application Http Response Http Request Use-case Use-case
  35. 35. Core principle: Types are not classes
  36. 36. X
  37. 37. Types are not classes Set of valid inputs Set of valid outputs So what is a type?
  38. 38. Types separate data from behavior Lists Lists List.map List.collect List.filter List.etc
  39. 39. Types can be composed too “algebraic types"
  40. 40. Product types × = Alice, Jan 12th Bob, Feb 2nd Carol, Mar 3rd Set of people Set of dates type Birthday = Person * Date
  41. 41. Sum types Set of Cash values Set of Cheque values Set of CreditCard values + + type PaymentMethod = | Cash | Cheque of ChequeNumber | Card of CardType * CardNumber
  42. 42. Design principle: Strive for totality
  43. 43. twelveDividedBy(x) input x maps to 12/x … 3 2 1 0 … Domain (int) Codomain (int) … 4 6 12 … Totality int TwelveDividedBy(int input) { switch (input) { case 3: return 4; case 2: return 6; case 1: return 12; case 0: return ??; } }
  44. 44. twelveDividedBy(x) input x maps to 12/x … 3 2 1 0 … Domain (int) Codomain (int) … 4 6 12 … Totality int TwelveDividedBy(int input) { switch (input) { case 3: return 4; case 2: return 6; case 1: return 12; case 0: return ??; } } What happens here?
  45. 45. twelveDividedBy(x) input x maps to 12/x … 3 2 1 0 … Domain (int) Codomain (int) … 4 6 12 … Totality int TwelveDividedBy(int input) { switch (input) { case 3: return 4; case 2: return 6; case 1: return 12; case 0: throw InvalidArgException; } } int -> int This type signature is a lie! You tell me you can handle 0, and then you complain about it?
  46. 46. twelveDividedBy(x) input x maps to 12/x … 3 2 1 -1 … NonZeroInteger int … 4 6 12 … Totality int TwelveDividedBy(int input) { switch (input) { case 3: return 4; case 2: return 6; case 1: return 12; case -1: return -12; } } Constrain the input 0 doesn’t have to be handled NonZeroInteger -> int 0 is missing Types are documentation
  47. 47. twelveDividedBy(x) input x maps to 12/x … 3 2 1 0 -1 … int Option<Int> … Some 4 Some 6 Some 12 None … Totality int TwelveDividedBy(int input) { switch (input) { case 3: return Some 4; case 2: return Some 6; case 1: return Some 12; case 0: return None; } } Extend the output 0 is valid input int -> int option Types are documentation
  48. 48. Design principle: Use static types for domain modelling and documentation Static types only! Sorry Clojure and JS developers 
  49. 49. Big topic! Not enough time today ! More on DDD and designing with types at fsharpforfunandprofit.com/ddd
  50. 50. FUNCTIONS AS PARAMETERS
  51. 51. Guideline: Parameterize all the things
  52. 52. Parameterize all the things let printList() = for i in [1..10] do printfn "the number is %i" i
  53. 53. Parameterize all the things It's second nature to parameterize the data input: let printList aList = for i in aList do printfn "the number is %i" i
  54. 54. Parameterize all the things let printList anAction aList = for i in aList do anAction i FPers would parameterize the action as well: We've decoupled the behavior from the data. Any list, any action!
  55. 55. Parameterize all the things public static int Product(int n) { int product = 1; for (int i = 1; i <= n; i++) { product *= i; } return product; } public static int Sum(int n) { int sum = 0; for (int i = 1; i <= n; i++) { sum += i; } return sum; }
  56. 56. public static int Product(int n) { int product = 1; for (int i = 1; i <= n; i++) { product *= i; } return product; } public static int Sum(int n) { int sum = 0; for (int i = 1; i <= n; i++) { sum += i; } return sum; } Parameterize all the things
  57. 57. Parameterize all the things let product n = let initialValue = 1 let action productSoFar x = productSoFar * x [1..n] |> List.fold action initialValue let sum n = let initialValue = 0 let action sumSoFar x = sumSoFar+x [1..n] |> List.fold action initialValue Lots of collection functions like this: "fold", "map", "reduce", "collect", etc.
  58. 58. Tip: Function types are "interfaces"
  59. 59. Function types are interfaces interface IBunchOfStuff { int DoSomething(int x); string DoSomethingElse(int x); void DoAThirdThing(string x); } Let's take the Single Responsibility Principle and the Interface Segregation Principle to the extreme... Every interface should have only one method!
  60. 60. Function types are interfaces interface IBunchOfStuff { int DoSomething(int x); } An interface with one method is a just a function type type IBunchOfStuff: int -> int Any function with that type is compatible with it let add2 x = x + 2 // int -> int let times3 x = x * 3 // int -> int
  61. 61. Strategy pattern class MyClass { public MyClass(IBunchOfStuff strategy) {..} int DoSomethingWithStuff(int x) { return _strategy.DoSomething(x) } } Object-oriented strategy pattern:
  62. 62. Strategy pattern int int int->int int->int let DoSomethingWithStuff strategy x = strategy x Functional strategy pattern: IBunchOfStuff as parameter
  63. 63. Decorator pattern using function parameter: let isEven x = (x % 2 = 0) // int -> bool isEvenint bool loggerint bool let logger f input = let output = f input // then log input and output // return output
  64. 64. Decorator pattern using function parameter: let isEven x = (x % 2 = 0) // int -> bool isEvenint bool loggerint bool let isEvenWithLogging = logger isEven // int -> bool Substitutable for original isEven
  65. 65. Decorator pattern using function composition: let isEven x = (x % 2 = 0) // int -> bool isEvenint bool isEvenint boollogint int logbool bool let isEvenWithLogging = log >> isEven >> log // int -> bool Substitutable for original isEven Composition!
  66. 66. Bad news: Composition patterns only work for functions that have one parameter! 
  67. 67. Good news! Every function is a one parameter function 
  68. 68. Writing functions in different ways let add x y = x + y let add = (fun x y -> x + y) let add x = (fun y -> x + y) int-> int->int int-> int->int int-> (int->int) Normal (Two parameters)
  69. 69. let three = 1 + 2 let three = (+) 1 2 let three = ((+) 1) 2 "+" is a two parameter function
  70. 70. let three = 1 + 2 let three = (+) 1 2 let three = ((+) 1) 2 let add1 = (+) 1 let three = add1 2 No, "+" is a one param function!
  71. 71. Pattern: Partial application
  72. 72. let name = "Scott" printfn "Hello, my name is %s" name let name = "Scott" (printfn "Hello, my name is %s") name let name = "Scott" let hello = (printfn "Hello, my name is %s") hello name Can reuse "hello" in many places now!
  73. 73. Pattern: Use partial application when working with lists
  74. 74. let names = ["Alice"; "Bob"; "Scott"] names |> List.iter hello let hello = printfn "Hello, my name is %s" let add1 = (+) 1 let equals2 = (=) 2 [1..100] |> List.map add1 |> List.filter equals2
  75. 75. Pattern: Use partial application to do dependency injection
  76. 76. type GetCustomer = CustomerId -> Customer let getCustomerFromDatabase connection (customerId:CustomerId) = // from connection // select customer // where customerId = customerId type of getCustomerFromDatabase = DbConnection -> CustomerId -> Customer let getCustomer1 = getCustomerFromDatabase myConnection // getCustomer1 : CustomerId -> Customer Persistence ignorant This function requires a connection  The partially applied function does NOT require a connection – it's baked in! 
  77. 77. type GetCustomer = CustomerId -> Customer let getCustomerFromMemory dict (customerId:CustomerId) = dict.Get(customerId) type of getCustomerFromMemory = Dictionary<Id,Customer> -> CustomerId -> Customer let getCustomer2 = getCustomerFromMemory dict // getCustomer2 : CustomerId -> Customer This function requires a dictionary  The partially applied function does NOT require a dictionary – it's baked in! 
  78. 78. Pattern: The Hollywood principle*: continuations
  79. 79. Continuations int Divide(int top, int bottom) { if (bottom == 0) { throw new InvalidOperationException("div by 0"); } else { return top/bottom; } } Method has decided to throw an exception (who put it in charge?)
  80. 80. Continuations void Divide(int top, int bottom, Action ifZero, Action<int> ifSuccess) { if (bottom == 0) { ifZero(); } else { ifSuccess( top/bottom ); } } Let the caller decide what happens what happens next?
  81. 81. Continuations let divide ifZero ifSuccess top bottom = if (bottom=0) then ifZero() else ifSuccess (top/bottom) F# version Four parameters is a lot though! Wouldn't it be nice if we could somehow "bake in" the two behaviour functions....
  82. 82. Continuations let divide ifZero ifSuccess top bottom = if (bottom=0) then ifZero() else ifSuccess (top/bottom) let ifZero1 () = printfn "bad" let ifSuccess1 x = printfn "good %i" x let divide1 = divide ifZero1 ifSuccess1 //test let good1 = divide1 6 3 let bad1 = divide1 6 0 setup the functions to: print a message Partially apply the continuations Use it like a normal function – only two parameters
  83. 83. let divide ifZero ifSuccess top bottom = if (bottom=0) then ifZero() else ifSuccess (top/bottom) Continuations let ifZero2() = None let ifSuccess2 x = Some x let divide2 = divide ifZero2 ifSuccess2 //test let good2 = divide2 6 3 let bad2 = divide2 6 0 setup the functions to: return an Option Use it like a normal function – only two parameters Partially apply the continuations
  84. 84. let divide ifZero ifSuccess top bottom = if (bottom=0) then ifZero() else ifSuccess (top/bottom) Continuations let ifZero3() = failwith "div by 0" let ifSuccess3 x = x let divide3 = divide ifZero3 ifSuccess3 //test let good3 = divide3 6 3 let bad3 = divide3 6 0 setup the functions to: throw an exception Use it like a normal function – only two parameters Partially apply the continuations
  85. 85. Pattern: Chaining callbacks with continuations
  86. 86. Pyramid of doom: null testing example Let example input = let x = doSomething input if x <> null then let y = doSomethingElse x if y <> null then let z = doAThirdThing y if z <> null then let result = z result else null else null else null I know you could do early returns, but bear with me...
  87. 87. Pyramid of doom: async example let taskExample input = let taskX = startTask input taskX.WhenFinished (fun x -> let taskY = startAnotherTask x taskY.WhenFinished (fun y -> let taskZ = startThirdTask y taskZ.WhenFinished (fun z -> z // final result
  88. 88. Pyramid of doom: null example let example input = let x = doSomething input if x <> null then let y = doSomethingElse x if y <> null then let z = doAThirdThing y if z <> null then let result = z result else null else null else null Nulls are a code smell: replace with Option!
  89. 89. Pyramid of doom: option example let example input = let x = doSomething input if x.IsSome then let y = doSomethingElse (x.Value) if y.IsSome then let z = doAThirdThing (y.Value) if z.IsSome then let result = z.Value Some result else None else None else None Much more elegant, yes? No! This is fugly! But there is a pattern we can exploit...
  90. 90. Pyramid of doom: option example let example input = let x = doSomething input if x.IsSome then let y = doSomethingElse (x.Value) if y.IsSome then let z = doAThirdThing (y.Value) if z.IsSome then // do something with z.Value // in this block else None else None else None
  91. 91. Pyramid of doom: option example let example input = let x = doSomething input if x.IsSome then let y = doSomethingElse (x.Value) if y.IsSome then // do something with y.Value // in this block else None else None
  92. 92. Pyramid of doom: option example let example input = let x = doSomething input if x.IsSome then // do something with x.Value // in this block else None Can you see the pattern?
  93. 93. if opt.IsSome then //do something with opt.Value else None
  94. 94. let ifSomeDo f opt = if opt.IsSome then f opt.Value else None
  95. 95. let example input = doSomething input |> ifSomeDo doSomethingElse |> ifSomeDo doAThirdThing |> ifSomeDo (fun z -> Some z) let ifSomeDo f opt = if opt.IsSome then f opt.Value else None
  96. 96. MONADS
  97. 97. A switch analogy Some None Input ->
  98. 98. Connecting switches on Some Bypass on None
  99. 99. Connecting switches
  100. 100. Connecting switches
  101. 101. Composing switches >> >> Composing one-track functions is fine...
  102. 102. Composing switches >> >> ... and composing two-track functions is fine...
  103. 103. Composing switches   ... but composing switches is not allowed!
  104. 104. How to combine the mismatched functions?
  105. 105. “Bind” is the answer! Bind all the things!
  106. 106. Composing switches Two-track input Two-track input One-track input Two-track input  
  107. 107. Building an adapter block Two-track input Slot for switch function Two-track output
  108. 108. Building an adapter block Two-track input Two-track output
  109. 109. let bind nextFunction optionInput = match optionInput with | Some s -> nextFunction s | None -> None Building an adapter block Two-track input Two-track output
  110. 110. let bind nextFunction optionInput = match optionInput with | Some s -> nextFunction s | None -> None Building an adapter block Two-track input Two-track output
  111. 111. let bind nextFunction optionInput = match optionInput with | Some s -> nextFunction s | None -> None Building an adapter block Two-track input Two-track output
  112. 112. let bind nextFunction optionInput = match optionInput with | Some s -> nextFunction s | None -> None Building an adapter block Two-track input Two-track output
  113. 113. Pattern: Use bind to chain options
  114. 114. Pyramid of doom: using bind let bind f opt = match opt with | Some v -> f v | None -> None let example input = let x = doSomething input if x.IsSome then let y = doSomethingElse (x.Value) if y.IsSome then let z = doAThirdThing (y.Value) if z.IsSome then let result = z.Value Some result else None else None else None
  115. 115. let example input = doSomething input |> bind doSomethingElse |> bind doAThirdThing |> bind (fun z -> Some z) Pyramid of doom: using bind Let bind f opt = match opt with | Some v -> f v | None -> None No pyramids! Code is linear and clear. This pattern is called “monadic bind”
  116. 116. Pattern: Use bind to chain tasks
  117. 117. Connecting tasks When task completesWait Wait
  118. 118. Pyramid of doom: using bind for tasks let taskBind f task = task.WhenFinished (fun taskResult -> f taskResult) let taskExample input = let taskX = startTask input taskX.WhenFinished (fun x -> let taskY = startAnotherTask x taskY.WhenFinished (fun y -> let taskZ = startThirdTask y taskZ.WhenFinished (fun z -> z // final result a.k.a “promise” “future”
  119. 119. Pyramid of doom: using bind for tasks let taskBind f task = task.WhenFinished (fun taskResult -> f taskResult) let taskExample input = startTask input |> taskBind startAnotherTask |> taskBind startThirdTask |> taskBind (fun z -> z) This pattern is also a “monadic bind”
  120. 120. Pattern: Use bind to chain error handlers
  121. 121. Use case without error handling string UpdateCustomerWithErrorHandling() { var request = receiveRequest(); validateRequest(request); canonicalizeEmail(request); db.updateDbFromRequest(request); smtpServer.sendEmail(request.Email) return "OK"; }
  122. 122. Use case with error handling string UpdateCustomerWithErrorHandling() { var request = receiveRequest(); var isValidated = validateRequest(request); if (!isValidated) { return "Request is not valid" } canonicalizeEmail(request); db.updateDbFromRequest(request); smtpServer.sendEmail(request.Email) return "OK"; }
  123. 123. Use case with error handling string UpdateCustomerWithErrorHandling() { var request = receiveRequest(); var isValidated = validateRequest(request); if (!isValidated) { return "Request is not valid" } canonicalizeEmail(request); var result = db.updateDbFromRequest(request); if (!result) { return "Customer record not found" } smtpServer.sendEmail(request.Email) return "OK"; }
  124. 124. Use case with error handling string UpdateCustomerWithErrorHandling() { var request = receiveRequest(); var isValidated = validateRequest(request); if (!isValidated) { return "Request is not valid" } canonicalizeEmail(request); try { var result = db.updateDbFromRequest(request); if (!result) { return "Customer record not found" } } catch { return "DB error: Customer record not updated" } smtpServer.sendEmail(request.Email) return "OK"; }
  125. 125. Use case with error handling string UpdateCustomerWithErrorHandling() { var request = receiveRequest(); var isValidated = validateRequest(request); if (!isValidated) { return "Request is not valid" } canonicalizeEmail(request); try { var result = db.updateDbFromRequest(request); if (!result) { return "Customer record not found" } } catch { return "DB error: Customer record not updated" } if (!smtpServer.sendEmail(request.Email)) { log.Error "Customer email not sent" } return "OK"; }
  126. 126. Use case with error handling string UpdateCustomerWithErrorHandling() { var request = receiveRequest(); var isValidated = validateRequest(request); if (!isValidated) { return "Request is not valid" } canonicalizeEmail(request); try { var result = db.updateDbFromRequest(request); if (!result) { return "Customer record not found" } } catch { return "DB error: Customer record not updated" } if (!smtpServer.sendEmail(request.Email)) { log.Error "Customer email not sent" } return "OK"; }
  127. 127. A structure for managing errors Request SuccessValidate Failure let validateInput input = if input.name = "" then Failure "Name must not be blank" else if input.email = "" then Failure "Email must not be blank" else Success input // happy path
  128. 128. Connecting switches Validate UpdateDb SendEmail
  129. 129. Connecting switches Validate UpdateDb SendEmail
  130. 130. Functional flow without error handling let updateCustomer = receiveRequest |> validateRequest |> canonicalizeEmail |> updateDbFromRequest |> sendEmail |> returnMessage Before One track
  131. 131. let updateCustomerWithErrorHandling = receiveRequest |> validateRequest |> canonicalizeEmail |> updateDbFromRequest |> sendEmail |> returnMessage Functional flow with error handling After See my talk on Friday or fsharpforfunandprofit.com/rop Two track
  132. 132. MAPS
  133. 133. World of normal values int string bool World of options int option string option bool option
  134. 134. World of options World of normal values int string bool int option string option bool option 
  135. 135. World of options World of normal values int option string option bool option  int string bool
  136. 136. let add42ToOption opt = if opt.IsSome then let newVal = add42 opt.Value Some newVal else None How not to code with options Let’s say you have an int wrapped in an Option, and you want to add 42 to it: let add42 x = x + 42 
  137. 137. World of options World of normal values add42 
  138. 138. World of options World of normal values add42
  139. 139. Lifting World of options World of normal values T -> U option<T> -> option<U> Option.map
  140. 140. World of options World of normal values add42 add42ToOptionSome 1 |> 1 |> // 43 // Some 43
  141. 141. The right way to code with options Let’s say you have an int wrapped in an Option, and you want to add 42 to it: let add42 x = x + 42 1 |> add42 // 43 let add42ToOption = Option.map add42 Some 1 |> add42ToOption // Some 43 
  142. 142. The right way to code with options Let’s say you have an int wrapped in an Option, and you want to add 42 to it: let add42 x = x + 42 1 |> add42 // 43 Some 1 |> Option.map add42 // Some 43 
  143. 143. Lifting to lists World of lists World of normal values T -> U List<T> -> List<U> List.map
  144. 144. The right way to code with wrapped types [1;2;3] |> List.map add42 // [43;44;45]
  145. 145. Lifting to async World of async World of normal values T -> U async<T> -> async<U> Async.map
  146. 146. Guideline: Most wrapped generic types have a “map”. Use it!
  147. 147. Guideline: If you create your own generic type, create a “map” for it.
  148. 148. MONOIDS
  149. 149. Mathematics Ahead
  150. 150. Thinking like a mathematician 1 + 2 = 3 1 + (2 + 3) = (1 + 2) + 3 1 + 0 = 1 0 + 1 = 1
  151. 151. 1 + 2 = 3 Some things A way of combining them
  152. 152. 2 x 3 = 6 Some things A way of combining them
  153. 153. "a" + "b" = "ab" Some things A way of combining them
  154. 154. concat([a],[b]) = [a; b] Some things A way of combining them
  155. 155. 1 + 2 1 + 2 + 3 1 + 2 + 3 + 4 Is an integer Is an integer A pairwise operation has become an operation that works on lists!
  156. 156. 1 + (2 + 3) = (1 + 2) + 3 Order of combining doesn’t matter 1 + 2 + 3 + 4 (1 + 2) + (3 + 4) ((1 + 2) + 3) + 4 All the same
  157. 157. 1 - (2 - 3) = (1 - 2) - 3 Order of combining does matter
  158. 158. 1 + 0 = 1 0 + 1 = 1 A special kind of thing that when you combine it with something, just gives you back the original something
  159. 159. 42 * 1 = 42 1 * 42 = 42 A special kind of thing that when you combine it with something, just gives you back the original something
  160. 160. "" + "hello" = "hello" "hello" + "" = "hello" “Zero” for strings
  161. 161. The generalization • You start with a bunch of things, and some way of combining them two at a time. • Rule 1 (Closure):The result of combining two things is always another one of the things. • Rule 2 (Associativity):When combining more than two things, which pairwise combination you do first doesn't matter. • Rule 3 (Identity element):There is a special thing called "zero" such that when you combine any thing with "zero" you get the original thing back. A monoid!
  162. 162. • Rule 1 (Closure):The result of combining two things is always another one of the things. • Benefit: converts pairwise operations into operations that work on lists. 1 + 2 + 3 + 4 [ 1; 2; 3; 4 ] |> List.reduce (+)
  163. 163. 1 * 2 * 3 * 4 [ 1; 2; 3; 4 ] |> List.reduce (*) • Rule 1 (Closure):The result of combining two things is always another one of the things. • Benefit: converts pairwise operations into operations that work on lists.
  164. 164. "a" + "b" + "c" + "d" [ "a"; "b"; "c"; "d" ] |> List.reduce (+) • Rule 1 (Closure):The result of combining two things is always another one of the things. • Benefit: converts pairwise operations into operations that work on lists.
  165. 165. • Rule 2 (Associativity):When combining more than two things, which pairwise combination you do first doesn't matter. • Benefit: Divide and conquer, parallelization, and incremental accumulation. 1 + 2 + 3 + 4
  166. 166. • Rule 2 (Associativity):When combining more than two things, which pairwise combination you do first doesn't matter. • Benefit: Divide and conquer, parallelization, and incremental accumulation. (1 + 2) (3 + 4) 3 + 7
  167. 167. • Rule 2 (Associativity):When combining more than two things, which pairwise combination you do first doesn't matter. • Benefit: Divide and conquer, parallelization, and incremental accumulation. (1 + 2 + 3)
  168. 168. • Rule 2 (Associativity):When combining more than two things, which pairwise combination you do first doesn't matter. • Benefit: Divide and conquer, parallelization, and incremental accumulation. (1 + 2 + 3) + 4
  169. 169. • Rule 2 (Associativity):When combining more than two things, which pairwise combination you do first doesn't matter. • Benefit: Divide and conquer, parallelization, and incremental accumulation. (6) + 4
  170. 170. Issues with reduce • How can I use reduce on an empty list? • In a divide and conquer algorithm, what should I do if one of the "divide" steps has nothing in it? • When using an incremental algorithm, what value should I start with when I have no data?
  171. 171. • Rule 3 (Identity element):There is a special thing called "zero" such that when you combine any thing with "zero" you get the original thing back. • Benefit: Initial value for empty or missing data
  172. 172. Pattern: Simplifying aggregation code with monoids
  173. 173. type OrderLine = {Qty:int; Total:float} let orderLines = [ {Qty=2; Total=19.98} {Qty=1; Total= 1.99} {Qty=3; Total= 3.99} ] let addPair line1 line2 = let newQty = line1.Qty + line2.Qty let newTotal = line1.Total + line2.Total {Qty=newQty; Total=newTotal} orderLines |> List.reduce addPair // {Qty=6; Total= 25.96} Any combination of monoids is also a monoid Write a pairwise combiner Profit!
  174. 174. Pattern: Convert non-monoids to monoids
  175. 175. Customer + Customer + Customer Customer Stats + Customer Stats + Customer Stats Reduce Map Not a monoid A monoid Customer Stats (Total)
  176. 176. Hadoop make me a sandwich https://twitter.com/daviottenheimer /status/532661754820829185
  177. 177. Guideline: Convert expensive monoids to cheap monoids
  178. 178. Log file (Mon) + Log File (Tue) + Log File (Wed) = Really big file Summary (Mon) + Summary (Tue) + Summary (Wed) Map Strings are monoids A monoid Much more efficient for incremental updates “Monoid homomorphism”
  179. 179. Pattern: Seeing monoids everywhere
  180. 180. Monoids in the real world Metrics guideline: Use counters rather than rates Alternative metrics guideline: Make sure your metrics are monoids • incremental updates • can handle missing data
  181. 181. Is function composition a monoid? >> Function 1 apple -> banana Function 2 banana -> cherry New Function apple -> cherry Not the same thing. Not a monoid 
  182. 182. Is function composition a monoid? >> Function 1 apple -> apple Same thing Function 2 apple -> apple Function 3 apple -> apple A monoid! 
  183. 183. Is function composition a monoid? “Functions with same type of input and output” Functions where the input and output are the same type are monoids! What shall we call these kinds of functions?
  184. 184. Is function composition a monoid? “Functions with same type of input and output” “Endomorphisms” Functions where the input and output are the same type are monoids! What shall we call these kinds of functions? All endomorphisms are monoids
  185. 185. let plus1 x = x + 1 // int->int let times2 x = x * 2 // int->int let subtract42 x = x – 42 // int->int Reduce plus1ThenTimes2ThenSubtract42 // int->int Endomorphisms Another endomorphism!
  186. 186. Event sourcing Any function containing an endomorphism can be converted into a monoid! Event application function: Is an endomorphism Event -> State -> State
  187. 187. apply event1 // State -> State apply event2 // State -> State apply event3 // State -> State Reduce applyAllEventsAtOnce // State -> State Endomorphism Another endomorphism! Partial application of event • incremental updates • can handle missing events
  188. 188. Monads vs. monoids?
  189. 189. Series combination =+ Result is same kind of thing (Closure)
  190. 190. Series combination + Order not important (Associative) Monoid! +( ) ++( )
  191. 191. Parallel combination =+ Same thing (Closure) Order not important (Associative) Monoid!
  192. 192. Monad laws • The Monad laws are just the monoid definitions in diguise – Closure, Associativity, Identity • What happens if you break the monad laws? – You go to jail – You lose monoid benefits such as aggregation
  193. 193. A monad is just a monoid in the category of endofunctors!
  194. 194. A monad is just a monoid in the category of endofunctors!
  195. 195. THANKS!

×