The Power of Composition

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 compose them
– Types and how to compose them
• Composition in practice
– Two simple examples
– FizzBuzz gone carbonated
– A web service

How to learn functional programming
• Have a "beginner's mind"
• Forget everything you know about object-
oriented programming
– No loops!
– No variables!
– No objects!

The "Are you ready to learn FP?" test
• What is a class?
• What is a method?
• What is a for-loop?
• What is inheritance?
You *must* pass
this test before
continuing!

Answers!
• What is a class?
– Correct answer: "I don't know"
• What is a method?
– Correct answer: "No idea"
• What is a for-loop?
– Correct answer: "I couldn't tell you"
• What is inheritance?
– Correct answer: "Search me"

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

Lego Philosophy
1. All pieces are designed to be connected
2. Connect two pieces together and get
another "piece" that can still be connected
3. The pieces are reusable in many contexts

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
3. The pieces are reusable in many contexts

Connect two pieces together and get
You can keep adding and adding.

Unix Philosophy
• Write programs that do one thing well.
– To do a new job, build afresh rather than complicate
old programs by adding new "features".
• Write programs to work together.
– Expect the output of every program to become the
input to another, as yet unknown, program.
• Write programs to handle text streams, because
that is a universal interface.
All pieces are designed to be connected
The pieces are reusable
You don't need to create a special adapter to make connections.

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 outputs

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

input output
A function can be a parameter

Core FP principle:
Composition everywhere

Function composition
Function 1
apple -> banana
Function 2
banana -> cherry

>>
Function 1
apple -> banana
Function 2
banana -> cherry

New Function
apple -> cherry
Can't tell it was built
from smaller functions!
Where did the banana go?
(abstraction)

New Function
apple -> cherry
A Very Important Point: For composition to work properly:
• Data must be immutable
• Functions must be self-contained, with no strings attached:
no side-effects, no I/O, no globals, etc

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

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
Validation
Result
Address
Low-level operation Low-level operation

Service
Use-case
UpdateProfileData
ChangeProfile
Result
ChangeProfile
Request
Service Service

Use-case
Web application
Http
Response
Http
Request
Use-case Use-case

• "monoids"
– for combining strings, lists, etc.
• "monads"
– for composing functions with effects
• CategoryTheory
– or, "Composition Theory"
More kinds of composition
for functional programmers…

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"
for a set of things

Set of
valid inputs
Set of
valid outputs
Function
This is type
"string"
"abc"
"but"
"cobol"
"double"
"end"
"float"
for a set of things

Set of
valid inputs
Set of
valid outputs
Function
This is type
"Person"
Donna Roy
Javier Mendoza
Nathan Logan
Shawna Ingram
Abel Ortiz
Lena Robbins
GordonWood
for a set of things

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

Set of
valid inputs
Set of
valid outputs
Function
This is a type of
Fruit->Fruit functions
for a set of things

Composition everywhere:
Types can be composed too

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: AppleVariety
Banana: BananaVariety
Cherry: CherryVariety
}

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 information
For Checks we need a check number
For Cards we need a card type and card number

interface IPaymentMethod
{..}
class Cash() : IPaymentMethod
{..}
class Check(int checkNo): IPaymentMethod
{..}
class Card(string cardType, string cardNo) : IPaymentMethod
{..}
In OO design you would probably implement it as an
interface and a set of subclasses, like this:

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
CardNumber : CardNumber
}

type CardNumber = ...
type CardType = ...
type CreditCardInfo = ...
type PaymentMethod =
| Cash
| Check of CheckNumber
| Card of CreditCardInfo

type CardType = ...
| Cash
type PaymentAmount = decimal
type Currency = EUR | USD

type CardType = ...
| Cash
type PaymentAmount = decimal
type Currency = EUR | USD
type Payment = {
Amount : PaymentAmount
Currency: Currency
Method: PaymentMethod }

FP design principle:
Types are executable documentation

type Deal = Deck –› (Deck * Card)
type PickupCard = (Hand * Card) –› Hand
type Suit = Club | Diamond | Spade | Heart
type Rank = Two | Three | Four | Five | Six | Seven | Eight
| Nine |Ten | Jack | Queen | King | Ace
type Card = Suit * Rank
type Hand = Card list
type Deck = Card list
type Player = {Name:string; Hand:Hand}
type Game = {Deck:Deck; Players: Player list}
The domain on one screen!

type CardType =Visa | Mastercard
type CardNumber = CardNumber of string
type CheckNumber = CheckNumber of int
| Cash
| Card of CardType * CardNumber

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 thought of.
• Subtract the number you first thought of.
• The answer is TWO!

Think of a number
AddOne
SquareItSubtractOne
DivideByTheNumberYouThoughtOf
SubtractTheNumberYouThoughtOf
TheNumberYouThoughtOf
Answer

let thinkOfANumber numberYouThoughtOf =
// define a function for each step
let addOne x = x + 1
let squareIt x = x * x
let subtractOne x = x - 1
let divideByTheNumberYouThoughtOf x = x / numberYouThoughtOf
let subtractTheNumberYouThoughtOf x = x - numberYouThoughtOf
// then combine them using piping
numberYouThoughtOf
|> addOne
|> squareIt
|> subtractOne
|> divideByTheNumberYouThoughtOf
|> subtractTheNumberYouThoughtOf

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

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

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"s with a "X"
– Replace five "X"s with a "L"
– Replace two "L"s with a "C"
– Replace five "C"s with a "D"
– Replace two "D"s with a "M"

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 currying?
after currying
Currying means that *every* function can be converted
to a series of one input functions

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 a function
let replace_VV_X = replace "VV" "X"
// replace_VV_X is a function
Only 2 parameters
passed in

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_XXXXX_L = replace "XXXXX" "L"
let replace_LL_C = replace "LL" "C"
let replace_CCCCC_D = replace "CCCCC" "D"
let replace_DD_M = replace "DD" "M"
String.replicate number "I"
|> replace_IIIII_V
|> replace_VV_X
|> replace_XXXXX_L
|> replace_LL_C
|> replace_CCCCC_D
|> replace_DD_M

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

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

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" instead
– For multiples of five print "Buzz" instead
– For multiples of both three and five print
"FizzBuzz" instead.

let fizzBuzz max =
for n in [1..max] do
if (isDivisibleBy n 15) then
printfn "FizzBuzz"
else if (isDivisibleBy n 3) then
printfn "Fizz"
else if (isDivisibleBy n 5) then
printfn "Buzz"
else
printfn "%i" n
let isDivisibleBy n divisor = (n % divisor) = 0
A simple implementation

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
let carbonate divisor label n =
if (isDivisibleBy n divisor) then
Carbonated label
else
Uncarbonated n
Idea from http://weblog.raganwald.com/2007/01/dont-overthink-fizzbuzz.html

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

If Uncarbonated
If Carbonated
bypass
How to we compose them?

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

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

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

let fizzbuzz n =
match result15 with
| Carbonated str ->
str
| Uncarbonated n ->
match result3 with
| Carbonated str ->
str
| Uncarbonated n ->

let fizzbuzz n =
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

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

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

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

FP terminology
• A monad is
– A data type
– With an associated "bind" function
– (and some other stuff)
• A monadic function is
– A switch/points function
– "bind" is used to compose them

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.WhenFinished (fun y ->
let taskZ = startThirdTask y
taskZ.WhenFinished (fun z ->
etc

let bind f task =
task.WhenFinished (fun taskResult ->
f taskResult)
startTask input
|> bind startAnotherTask
|> bind startThirdTask
|> bind ...
Rewritten using bind:

let ( >>= ) x f = x |> bind
startTask input
>>= startAnotherTask
>>= startThirdTask
>>= ...
Rewritten using >>=
A common symbol for "bind"

Example:
Composing error-generating functions

Example of scenario with errors
Name is blank
Email not valid
Validate request
Canonicalize email
Fetch existing user record
Update existing user record
User not found
Db error
Authorization error
Timeout

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
How can we glue these
mismatched functions together?

map
Converting everything to two-track

bind
map

bind
map
tee map

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 [
]
Only succeeds if
request is a GET

let app = choose [
GET >=> choose [
]
POST >=> choose [
path "/hello" >=> OK "Hello POST"
path "/goodbye" >=> OK "Goodbye POST"
]
]
startWebServer defaultConfig app
A complete web app

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
– Composable types
• Basic composition
– Composition with ">>"
– Piping with "|>"
• Using partial application to help composition
• Monads and monadic functions
– Composition using "bind" / ">>="
– Kleisli composition using ">=>"

Slides and video here
fsharpforfunandprofit.com/composition
Thank you!
"Domain modelling Made Functional" book
fsharpforfunandprofit.com/books
@ScottWlaschin Me on twitter
fsharpforfunandprofit.com/videos

The Power of Composition

More Related Content

What's hot

Similar to The Power of Composition

More from Scott Wlaschin

Recently uploaded

The Power of Composition