The Power of Composition

Ad

Ad

Ad

Ad

Ad

Ad

Ad

Ad

Ad

Ad

Ad

Ad

The Power Of Composition
@ScottWlaschin
fsharpforfunandprofit.com
^ for beginners in FP

The Power Of Composition
• The philosophy of composition
• Functional programming principles
– Functions and how to compos...

PREREQUISITES

How to learn functional programming
• Have a "beginner's mind"
• Forget everything you know about object-
oriented program...

The "Are you ready to learn FP?" test
• What is a class?
• What is a method?
• What is a for-loop?
• What is inheritance?
...

Answers!
• What is a class?
– Correct answer: "I don't know"
• What is a method?
– Correct answer: "No idea"
• What is a f...

THE PHILOSOPHY OF
COMPOSITION

Prerequisites for
understanding composition
• You must have been a child at some point
• You must have played with Lego
• ...

Lego
Philosophy

Lego Philosophy
1. All pieces are designed to be connected
2. Connect two pieces together and get
another "piece" that can...

All pieces are designed to be connected

Connect two pieces together and
get another "piece" that can still be connected

The pieces are reusable in different contexts

Make big things from small things in the same way

Wooden RailwayTrack Philosophy
1. All pieces are designed to be connected
2. Connect two pieces together and get
another "...

All pieces are designed to be connected

Connect two pieces together and get
another "piece" that can still be connected
You can keep adding and adding.

The pieces are reusable in different contexts

Make big things from small things in the same way

Unix Philosophy
• Write programs that do one thing well.
– To do a new job, build afresh rather than complicate
old progra...

THE PRINCIPLES OF
FUNCTIONAL PROGRAMMING

Core principles of FP
Function
Types are not classes
Functions are things
Composition everywhere

Core FP principle:
Functions are things
Function

Functions as things
The Tunnel of
Transformation
Function
apple -> banana
A function is a thing which
transforms inputs to...

A function is a standalone thing,
not attached to a class
It can be used for inputs and outputs
of other functions

input
A function can be an output
A function is a standalone thing

output
A function can be an input
A function is a standalone thing

input output
A function can be a parameter
A function is a standalone thing

Core FP 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!
Where did the banana go?...

Function composition
New Function
apple -> cherry
A Very Important Point: For composition to work properly:
• Data must be...

let add1 x = x + 1
let double x = x + x
let add1_double = add1 >> double
let x = add1_double 5 // 12
Composition
DoubleAdd1

let add1_double_square =
add1 >> double >> square
let x = add1_double_square 5 // 144
Composition
DoubleAdd1 Square

Piping

add1 5 // = 6
double (add1 5) // = 12
square (double (add1 5)) // = 144

5 |> add1 // = 6
5 |> add1 |> double // = 12
5 |> add1 |> double |> square // = 144
add1 double square5 6 12 144

Building big things from functions
It's compositions all the way up

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

Http
Response
Http
Request

• "monoids"
– for combining strings, lists, etc.
• "monads"
– for composing functions with effects
• CategoryTheory
– or, ...

Core FP principle:
Types are not classes

So, what is a type then?
A type is a just a name
for a set of things
Set of
valid inputs
Set of
valid outputs
Function

Set of
valid inputs
Set of
valid outputs
Function
1
2
3
4
5
6
This is type
"integer"
A type is a just a name
for a set of ...

Set of
valid inputs
Set of
valid outputs
Function
This is type
"string"
"abc"
"but"
"cobol"
"double"
"end"
"float"
A type ...

Set of
valid inputs
Set of
valid outputs
Function
This is type
"Person"
Donna Roy
Javier Mendoza
Nathan Logan
Shawna Ingra...

Set of
valid inputs
Set of
valid outputs
Function
This is type
"Fruit"
A type is a just a name
for a set of things

Set of
valid inputs
Set of
valid outputs
Function
This is a type of
Fruit->Fruit functions
A type is a just a name
for a s...

Composition everywhere:
Types can be composed too

Algebraic type system

New types are built from smaller types by:
Composing with “AND”
Composing with “OR”

Example: pairs, tuples, records
FruitSalad = One each of and and
Compose with “AND”
type FruitSalad = {
Apple: AppleVariet...

Snack = or or
Compose with “OR”
type Snack =
| Apple of AppleVariety
| Banana of BananaVariety
| Cherry of CherryVariety

Real world example
of type composition

Example of some requirements:
We accept three forms of payment:
Cash, Check, or Card.
For Cash we don't need any extra inf...

interface IPaymentMethod
{..}
class Cash() : IPaymentMethod
{..}
class Check(int checkNo): IPaymentMethod
{..}
class Card(...

type CheckNumber = int
type CardNumber = string
In F# you would probably implement by composing
types, like this:

type CheckNumber = ...
type CardNumber = …
type CardType = Visa | Mastercard
type CreditCardInfo = {
CardType : CardType
C...

type CheckNumber = ...
type CardNumber = ...
type CardType = ...
type CreditCardInfo = ...
type PaymentMethod =
| Cash
| C...

type CheckNumber = ...
type CardNumber = ...
type CardType = ...
type CreditCardInfo = ...
type PaymentMethod =
| Cash
| C...

type CheckNumber = ...
type CardNumber = ...
type CardType = ...
type CreditCardInfo = ...
type PaymentMethod =
| Cash
| C...

FP design principle:
Types are executable documentation

type Deal = Deck –› (Deck * Card)
type PickupCard = (Hand * Card) –› Hand
Types are executable documentation
type Suit = C...

Types are executable documentation
type CardType =Visa | Mastercard
type CardNumber = CardNumber of string
type CheckNumbe...

A big topic and not enough time  
More on DDD and designing with types at
fsharpforfunandprofit.com/ddd

BASIC COMPOSITION:
THINK OF A NUMBER

Think of a number
• Think of a number.
• Add one to it.
• Square it.
• Subtract one.
• Divide by the number you first thou...

Think of a number
AddOne
SquareItSubtractOne
DivideByTheNumberYouThoughtOf
SubtractTheNumberYouThoughtOf
TheNumberYouThoug...

let thinkOfANumber numberYouThoughtOf =
// define a function for each step
let addOne x = x + 1
let squareIt x = x * x
let...

IT'S NOT ALWAYSTHIS
EASY…

function A function BCompose

function A function B

function A and B
Easy!

... But here is a challenge

function AInput Output
function BInput
Output 1
Output 2
function C
Input 1 Output
Input 2

function AInput Output
function BInput
Output 1
Output 2
Challenge: How can
we compose these?

function AInput Output
function C
Input 1 Output
Input 2
Challenge: How can
we compose these?

COMPOSING MULTIPLE INPUTS:
ROMAN NUMERALS

To Roman Numerals
• Task: convert an integer to Roman Numerals
• V = 5, X = 10, C = 100 etc

To Roman Numerals
• Use the "tally" approach
– Start with N copies of "I"
– Replace five "I"s with a "V"
– Replace two "V"...

The Replace function
oldValue outputString
newValue
inputString
Replace

Uh-oh! Composition problem
Replace I / V Replace V / X Replace X / L 

Bad news:
Composition patterns
only work for functions that
have one parameter! 

Good news!
Every function can be turned into
a one parameter function 

Haskell Curry
We named this technique after him

Input A
Uncurried
Function
Input B
Output C
Curried
Function
Input A
Intermediate
Function
Output CInput B
What is curryin...

Replace
Before currying
let replace oldValue newValue inputStr =
inputStr.Replace(oldValue,newValue)

Replace
Old New
Old
New
After currying
let replace oldValue newValue =
fun inputStr ->
inputStr.Replace(oldValue,newValue)

Partial Application
Replace ReplaceOldNew
Old New
Old
New
let replace_IIIII_V = replace "IIIII" "V"
// replace_IIIII_V is ...

To Roman Numerals
integer
etc
Replicate "I"
Replace_IIIII_V
Replace_VV_X
Replace_XXXXX_L

let toRomanNumerals number =
let replace_IIIII_V = replace "IIIII" "V"
let replace_VV_X = replace "VV" "X"
let replace_XXX...

Inline Partial Application
let add x y = x + y
let multiply x y = x * y
5
|> add 2
|> multiply 2
Piping
"inline" partial a...

Inline Partial Application
let add x y = x + y
let multiply x y = x * y
[1..10]
|> List.map (add 2)
|> List.map (multiply ...

let toRomanNumerals number =
String.replicate number "I"
|> replace "IIIII" "V"
|> replace "VV" "X"
|> replace "XXXXX" "L"...

let toRomanNumerals number =
String.replicate number "I"
|> replace "IIIII" "V"
|> replace "VV" "X"
|> replace "XXXXX" "L"...

functionInput Output
function
Input 1 Output
Input 2
Challenge: How can
we compose these?

COMPOSING MULTIPLE OUTPUTS:
FIZZBUZZ

FizzBuzz definition
• Write a program that prints the numbers
from 1 to 100
• But:
– For multiples of three print "Fizz" i...

let fizzBuzz max =
for n in [1..max] do
if (isDivisibleBy n 15) then
printfn "FizzBuzz"
else if (isDivisibleBy n 3) then
p...

Pipeline implementation
Handle 3 case
Handle 5 case
number
Answer
Handle 15 case
Handle remaining

number Handle case
Carbonated
(e.g. "Fizz", "Buzz")
Uncarbonated
(e.g. 2, 7, 13)

Uncarbonated
Carbonated
Input ->

type CarbonationResult =
| Uncarbonated of int // unprocessed
| Carbonated of string // "Fizz", Buzz", etc
FizzBuzz core
l...

12 |> carbonate 3 "Fizz" // Carbonated "Fizz"
10 |> carbonate 3 "Fizz" // Uncarbonated 10
10 |> carbonate 5 "Buzz" // Carb...

If Uncarbonated
If Carbonated
bypass
How to we compose them?

How do we compose these?

>> >>
Composing one-track functions is fine...

>> >>
... and composing two-track functions is fine...

 
... but composing points/switches is not allowed!

let fizzbuzz n =
let result15 = n |> carbonate 15 "FizzBuzz"
match result15 with
| Carbonated str ->
str
| Uncarbonated n ...

let fizzbuzz n =
let result15 = n |> carbonate 15 "FizzBuzz"
match result15 with
| Carbonated str ->
str
| Uncarbonated n ...

let fizzbuzz n =
let result15 = n |> carbonate 15 "FizzBuzz"
match result15 with
| Carbonated str ->
str
| Uncarbonated n ...

let fizzbuzz n =
let result15 = n |> carbonate 15 "FizzBuzz"
match result15 with
| Carbonated str ->
str
| Uncarbonated n ...

if Carbonated
// return the string
if Uncarbonated then
// do something with the number

let ifUncarbonatedDo f result =
match result with
| Carbonated str ->
Carbonated str
| Uncarbonated n ->
f n

let fizzbuzz n =
n
|> carbonate 15 "FizzBuzz"
|> ifUncarbonatedDo (carbonate 3 "Fizz")
|> ifUncarbonatedDo (carbonate 5 "B...

MAKING LOOPS
COMPOSABLE

Another composition problem
List of
numbers
FizzBizz for one number


Solution: the "map" transformer
List input List outputFizzBizz for lists
FizzBizz for one number
List.map

// final version of FizzBuzz
let fizzbuzz100 =
[1..100]
|> List.map fizzBuzz
|> List.iter (printfn "%s") // I/O only at en...

THE M-WORD

Is there a general solution to
handling functions like this?

Yes! “Bind” is the answer!
Bind all the things!

Two-track input Two-track output
One-track input Two-track output



Two-track input Two-track output

Two-track input Two-track output

let bind nextFunction result =
match result with
| Uncarbonated n ->
nextFunction n
| Carbonated str ->
Carbonated str
Two...

let bind nextFunction result =
match result with
| Uncarbonated n ->
nextFunction n
| Carbonated str ->
Carbonated str
Two...

let bind nextFunction result =
match result with
| Uncarbonated n ->
nextFunction n
| Carbonated str ->
Carbonated str
Two...

let bind nextFunction result =
match result with
| Uncarbonated n ->
nextFunction n
| Carbonated str ->
Carbonated str
Two...

FP terminology
• A monad is
– A data type
– With an associated "bind" function
– (and some other stuff)
• A monadic functi...

Example:
Using bind to chain tasks

When task
completesWait Wait
a.k.a "promise", "future"

let taskExample input =
let taskX = startTask input
taskX.WhenFinished (fun x ->
let taskY = startAnotherTask x
taskY.When...

let bind f task =
task.WhenFinished (fun taskResult ->
f taskResult)
let taskExample input =
startTask input
|> bind start...

let ( >>= ) x f = x |> bind
let taskExample input =
startTask input
>>= startAnotherTask
>>= startThirdTask
>>= ...
Rewrit...

Example:
Composing error-generating functions

Example of scenario with errors
Name is blank
Email not valid
Validate request
Canonicalize email
Fetch existing user reco...

Validate
Generates a possible error

Validate Canonicalize
Generates a possible error Always succeeds

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

Validate Canonicalize DbFetch DbUpdate
Generates a possible error Generates a possible errorAlways succeeds Doesn't return...

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* compose
them easily!
map bind tee, then map

KLEISLI COMPOSITION:
WEB SERVICE

=+
Result is
same kind of thing
Kleisli Composition

Async<HttpContext option>HttpContext
A "WebPart" (suave.io library)
See suave.io site for more

=>=>
Result is another
WebPart so you can repeat
WebPart Composition
Kleisli composition symbol

path "/hello" >=> OK "Hello" // a WebPart
Checks request path
(might fail)
Sets response

choose [
path "/hello" >=> OK "Hello"
path "/goodbye" >=> OK "Goodbye"
]
Picks first WebPart
that succeeds

GET >=> choose [
path "/hello" >=> OK "Hello"
path "/goodbye" >=> OK "Goodbye"
]
Only succeeds if
request is a GET

let app = choose [
GET >=> choose [
path "/hello" >=> OK "Hello"
path "/goodbye" >=> OK "Goodbye"
]
POST >=> choose [
path...

Http
Response
Http
Request
As I promised – no classes, no loops, etc!

Review
• The philosophy of composition
– Connectable, no adapters, reusable parts
• FP principles:
– Composable functions
...

Slides and video here
fsharpforfunandprofit.com/composition
Thank you!
"Domain modelling Made Functional" book
fsharpforfu...

Share Slideshare

LinkedIn
Facebook
Twitter

Embed

Size (px)

Show related Slideshows at end

WordPress Shortcode

Link

Share
Email

2024 Trend Updates: What Really Wor... by Search Engine Jou... 1042022 views
Storytelling For The Web: Integrate... by Chiara Aliotta 954721 views
Artificial Intelligence, Data and C... by OECD Directorate ... 880306 views
How to Leverage AI to Boost Employe... by SocialHRCamp 370586 views
2024 State of Marketing Report – by... by Marius Sescu 210442 views
Everything You Need To Know About C... by Expeed Software 229923 views

View on Slideshare

1 of 165 Ad

View on Slideshare

1 of 165 Ad