SLIDE 1
An Intuitive Guide to Combining Free Monad and Free Applicative
SLIDE 2 Who Am I?
- I'm Cameron
- Linkedin - https://www.linkedin.com/in/cameron-joannidis/
- Twitter - @CamJo89
- Consult across a range of areas and have built many big data and machine
learning systems
- Buzz Word Bingo
- Big Data
- Machine Learning
- Functional Programming
SLIDE 3 Agenda
- Abstracting effects from domain definitions
- Abstracting effects with Free Structures
- Combining Free and FreeAp
SLIDE 4 Before We Start
- I am not advocating that you should be using Free Monad and/or Free
Applicative over final tagless. Every team and project is different and both approaches are sufficiently powerful for most requirements
- I'm hoping to introduce you more generally to some more interesting things you
can do with Free Structures
- Source Code: https://github.com/camjo/presentations
SLIDE 5
A Basic Domain
SLIDE 6
A Basic Implementation
SLIDE 7
Capturing Failure
SLIDE 8
Capturing Async Effects
SLIDE 9
Combining Multiple Effects
SLIDE 10
What Happened to our Domain?
SLIDE 11
SLIDE 12 Problems
- Tightly couples implementation details to domain
- Can’t test domain logic in isolation of implementation
SLIDE 13
Final Tagless
SLIDE 14
Final Tagless Implementation
SLIDE 15
Free Monad
SLIDE 16
Operations as Data
SLIDE 17
Lifting Operations into Free Monad
SLIDE 18
Sequencing Operations
SLIDE 19
Our Program
SLIDE 20
Interpreting Program (Data)
SLIDE 21
Interpreting Program (Data)
SLIDE 22
Interpreting Program (Data)
SLIDE 23 Free (Monad) / FreeAp (Applicative)
- Encode domain as ADT
- Lift domain into Free structure
- Write logic as a Free program
- Create interpreters to interpret domain instructions with some effect
- Interpret Free program to produce output effect
SLIDE 24 Free (Monad) / FreeAp (Applicative)
- Encode domain as ADT
- Lift domain into Free structure
- Write logic as a Free program
- Create interpreters to interpret domain instructions with some effect
- Interpret Free program to produce output effect
SLIDE 25
Operations as Data
SLIDE 26
Our Domain as an ADT
SLIDE 27
Our Domain as an ADT
SLIDE 28 Free (Monad) / FreeAp (Applicative)
- Encode domain as ADT
- Lift domain into Free structure
- Write logic as a Free program
- Create interpreters to interpret domain instructions with some effect
- Interpret Free program to produce output effect
SLIDE 29
Lifting Operations into Free Monad
SLIDE 30
Lifting Operations into Free Monad
SLIDE 31
Lifting Operations into FreeAp
SLIDE 32
Lifting Operations into FreeAp
SLIDE 33 A Little Trick
- Lets us defer the choice of using a monad effect type or an applicative effect
type until we actually use it
- Can be extended to any Free structure in theory
SLIDE 34 Creating our Repo with ExecStrategy
Allows us to defer the choice of Free Monad vs. Free Applicative
SLIDE 35 Free (Monad) / FreeAp (Applicative)
- Encode domain as ADT
- Lift domain into Free structure
- Write logic as a Free program
- Create interpreters to interpret domain instructions with some effect
- Interpret Free program to produce output effect
SLIDE 36
FREE MONAD
DEPENDENT OPERATIONS E.G. SEQUENTIAL
SLIDE 37
Operations in Sequence
SLIDE 38 FREE APPLICATIVE
INDEPENDENT OPERATIONS E.G. PARALLELISM
SLIDE 39
Operations in Parallel
SLIDE 40 HOW DO WE COMBINE SEQUENTIAL AND PARALLEL OPERATIONS?
SLIDE 41
Instruction Set
SLIDE 42 Two Main Choices
- Parallel program of sequential steps
SLIDE 43
Parallel Program of Sequential Steps
SLIDE 44 Two Main Choices
- Parallel program of sequential steps
- Sequential program of parallel steps
SLIDE 45
Sequential Program of Parallel Steps
SLIDE 46 Lifting Operations into Program
- Free needs to wrap internal Operation with FreeAp
- FreeAp steps need to be wrapped in Free
SLIDE 47 Lifting a Free Applicative into the Free Monad
- Its as simple as the code below
- The other .asProgramStep definition is a tad more involved.
(See the code on Github for how to do it. )
SLIDE 48
Two (Simple) Domains
SLIDE 49 Lift Domain
- Handling the combination of multiple domains by making the domain functor
generic as F
SLIDE 50 Lift Domain
- Handling the combination of multiple domains by making the domain functor
generic as F
SLIDE 51
Writing Our Program
SLIDE 52
Program Structure
SLIDE 53
Writing Our Program (Another Way)
SLIDE 54
Program Structure
SLIDE 55 Free (Monad) / FreeAp (Applicative)
- Encode domain as ADT
- Lift domain into Free structure
- Write logic as a Free program
- Create interpreters to interpret domain instructions with some effect
- Interpret Free program to produce output effect
SLIDE 56
Interpreting an Operation
SLIDE 57 User Interpreter
We make it slow so that we can easily observe the difference in runtime between the sequential and parallel versions
SLIDE 58 Our Interpreter
We make it slow so that we can easily observe the difference in runtime between the sequential and parallel versions
SLIDE 59 Free (Monad) / FreeAp (Applicative)
- Encode domain as ADT
- Lift domain into Free structure
- Write logic as a Free program
- Create interpreters to interpret domain instructions with some effect
- Interpret Free program to produce output effect
SLIDE 60 Combining Our Domains
- Define our operations as a common instruction set
- Combine out interpreters to read this instruction set
SLIDE 61
Creating Program Instructions
SLIDE 62
Creating Program Instructions
SLIDE 63
Creating Program Instructions
SLIDE 64
Interpreting Program Instructions
SLIDE 65
Interpreting Program Instructions
SLIDE 66
Interpreting Program Instructions
SLIDE 67
Interpreting Program Instructions
SLIDE 68
Interpreting Program Instructions
SLIDE 69 Making it Parallel
- Our Free Monads operation type was FreeAp[F, ?]
- Provide a way to turn that into our output effect G in parallel (using Applicative)
SLIDE 70
Running the Program
SLIDE 71
Program 1
SLIDE 72
Program Results
SLIDE 73
Program 2
SLIDE 74
Program Results
SLIDE 75 Things to Note
- Target effect must have an applicative instance
- Default Task applicative instance runs sequentially left to right (i.e. not in parallel
- since it is also a monad)
- Need to explicitly import parallel applicative instance or create your own in
scope (See github code example for how)
- We can remove most usages of .asProgramStep with implicits
SLIDE 76 Freestyle - Removing the Boilerplate
- Freestyle (frees.io) uses macros to remove most of the boilerplate
- Defaults to using the Free[FreeAp[F, ?], A] approach that we used
- Several integrations and library abstractions out of the box
- Out of the box optimisations to reduce the overhead of using many domain
algebras
SLIDE 77 What We’ve Covered
- Why we abstract effects from domain
- Abstracting effects with Final Tagless or Free Structures
- Combining Free and FreeAp to introduce parallelism into our domain
- Freestyle to remove boilerplate
SLIDE 78
Thank You
Questions? @CamJo89
