What is the difference between Final Tagless and Free Monads from the Software Design point of view? What is Hierarchical Free Monads approach? How to build real applications in Haskell? This talk was given on FPure 2019, Kazan.

1. Final Tagless vs Free Monad
FPure, Kazan, 2019
1
Alexander Granin
graninas@gmail.com
Twitter: @graninas

2. Plan
● About me
● A Mysterious Software Design
● Final Tagless vs Free Monad
● To Whom It May Concern
● Links
2

3. About me
Developer Haskell, C++, C#, Python
Worked for Kaspersky Lab, 2GIS, Juspay, Restaumatic, Enecuum
Researcher Functional Programming in C++
Writer Book “Functional Design and Architecture”
Conferences FPConf, C++ Russia, C++ Siberia, Dev2Dev
Meetups LambdaNsk, FProgSpb, DevDay, TechTalks, ...
3

4. A Mysterious Software Design
4

5. cartesianclosedcomicro-che.info/ccc/28
Why academia vs engineering battles
are rarely interesting
People familiar with theory
Haskellers Painstream developers
5

6. cartesianclosedcomicro-che.info/ccc/28
Why academia vs engineering battles
are rarely interesting
People familiar with theory
Haskellers Painstream developers
People working on real problems
Software engineers Mathskellers
Why engineering vs academia battles
are rarely useful
6

7. Inversion of Control
Why? How? When?
7

8. Inversion of Control
Why?
Complexity reducing
Abstraction
Separation of concerns
Low coupling
Effects control
Testability
Maintainability
How? When?
8

9. Inversion of Control
Why?
Complexity reducing
Abstraction
Separation of concerns
Low coupling
Effects control
Testability
Maintainability
How?
Final Tagless
Free Monad
Service Handle Pattern
ReaderT Pattern
...
When?
9

10. Inversion of Control
Why?
Complexity reducing
Abstraction
Separation of concerns
Low coupling
Effects control
Testability
Maintainability
How?
Final Tagless
Free Monad
Service Handle Pattern
ReaderT Pattern
...
When?
Big applications
Complex domain
Long lifecycle
Team development
Sirius Business™
10

11. Free Monad
11

12. data Meteor = Meteor
{ _size :: Int
, _mass :: Int
}
App
State
12

13. data Meteor = Meteor
{ _size :: Int
, _mass :: Int
}
data Region
= NorthEast
| NorthWest
| SouthEast
| SouthWest
App
State
13

14. data Meteor = Meteor
{ _size :: Int
, _mass :: Int
}
data Region
= NorthEast
| NorthWest
| SouthEast
| SouthWest
type Meteors = StateVar (Set Meteor)
type Catalogue = Map Region Meteors
App
State
14

15. data Meteor = Meteor
{ _size :: Int
, _mass :: Int
}
data Region
= NorthEast
| NorthWest
| SouthEast
| SouthWest
type Meteors = StateVar (Set Meteor)
type Catalogue = Map Region Meteors
data AppState = AppState
{ _catalogue :: Catalogue
, _totalMeteors :: StateVar Int
, _channel :: StateVar (Set Meteor)
}
App
State
15

16. initState :: StateL AppState
initState = do
StateL
App
State
16

17. initState :: StateL AppState
initState = do
ne <- newVarIO Set.empty
nw <- newVarIO Set.empty
se <- newVarIO Set.empty
sw <- newVarIO Set.empty
let catalogue = Map.fromList
[ (NorthEast, ne)
, (NorthWest, nw)
, (SouthEast, se)
, (SouthWest, sw)
]
StateL
App
State
17

18. initState :: StateL AppState
initState = do
ne <- newVarIO Set.empty
nw <- newVarIO Set.empty
se <- newVarIO Set.empty
sw <- newVarIO Set.empty
let catalogue = Map.fromList
[ (NorthEast, ne)
, (NorthWest, nw)
, (SouthEast, se)
, (SouthWest, sw)
]
published <- newVarIO Set.empty
total <- newVarIO 0
pure $ AppState catalogue total published
StateL
App
State
18

19. getRandomMeteor :: Region -> RandomL Meteor
getRandomMeteor region = do
size <- getRandomInt (1, 100)
mass <- getRandomInt (size, size * 100)
pure $ Meteor size mass region
RandomLStateL
App
State
19

20. getRandomMeteor :: Region -> RandomL Meteor
getRandomMeteor region = do
size <- getRandomInt (1, 100)
mass <- getRandomInt (size, size * 100)
pure $ Meteor size mass region
publishMeteor :: AppState -> Meteor -> StateL ()
publishMeteor st meteor
= modifyVar (_channel st) $ Set.insert meteor
RandomLStateL
App
State
Business
Logic
20

21. getRandomMeteor :: Region -> RandomL Meteor
getRandomMeteor region = do
size <- getRandomInt (1, 100)
mass <- getRandomInt (size, size * 100)
pure $ Meteor size mass region
publishMeteor :: AppState -> Meteor -> StateL ()
publishMeteor st meteor
= modifyVar (_channel st) $ Set.insert meteor
meteorShower :: AppState -> Region -> LangL ()
meteorShower st region = do
meteor <- evalRandom $ getRandomMeteor region
atomically $ publishMeteor st meteor
logInfo $ "New meteor discovered: " <> show meteor
LoggerL
LangL
RandomLStateL
App
State
Business
Logic
21

22. meteorsMonitoring :: AppL ()
meteorsMonitoring = do
st <- atomically $ initState
LoggerL
LangL
RandomLStateL
AppL
App
State
Business
Logic
22

23. meteorsMonitoring :: AppL ()
meteorsMonitoring = do
st <- atomically $ initState
process $ forever $ meteorShower st NorthEast
process $ forever $ meteorShower st NorthWest
process $ forever $ meteorShower st SouthEast
process $ forever $ meteorShower st SouthWest
process $ forever $ meteorCounter st
LoggerL
LangL
RandomLStateL
ProcessL
AppL
App
State
Business
Logic
23

24. meteorsMonitoring :: AppConfig -> AppL ()
meteorsMonitoring cfg = do
st <- atomically $ initState cfg
process $ forever $ meteorShower st NorthEast
process $ forever $ meteorShower st NorthWest
process $ forever $ meteorShower st SouthEast
process $ forever $ meteorShower st SouthWest
process $ forever $ meteorCounter st
LoggerL
LangL
RandomLStateL
ProcessL
AppL
App
State
Business
Logic
App
Configs
Application
24

25. meteorsMonitoring :: AppConfig -> AppL ()
meteorsMonitoring cfg = do
st <- atomically $ initState cfg
process $ forever $ meteorShower st NorthEast
process $ forever $ meteorShower st NorthWest
process $ forever $ meteorShower st SouthEast
process $ forever $ meteorShower st SouthWest
process $ forever $ meteorCounter st
main :: IO ()
main = do
loggerRt <- createLoggerRuntime loggerCfg
appRt <- createAppRuntime loggerRt
startApp appRt $ meteorsMonitoring appCfg
LoggerL
LangL
RandomLStateL
ProcessL
AppL
Runtime, Interpreters, Configs, Environment
Application
App
State
Business
Logic
App
Configs
25

26. Implementation
Effects, Subsystems & Services
(abstracted as Free eDSLs)
Domain & Business Logic
LoggerL
LangL
RandomLStateL
ProcessL
AppL
Runtime, Interpreters, Configs, Environment
Application
App
State
Business
Logic
App
Configs
26

27. The Only Thing That Matters
LoggerL
LangL
RandomLStateL
ProcessL
AppL
Runtime, Interpreters, Configs, Environment
Application
App
State
Business
Logic
App
Configs
27

28. Free Monad vs Final Tagless
28

29. Free Monad vs Final Tagless
Language definition
29

30. data LoggerF next where
LogMessage :: LogLevel -> Message
-> (() -> next) -> LoggerF next
makeFunctorInstance ''LoggerF
type LoggerL = F LoggerF
class Monad m => LoggerL m where
logMessage :: LogLevel -> Message -> m ()
30

31. data LoggerF next where
LogMessage :: LogLevel -> Message
-> (() -> next) -> LoggerF next
makeFunctorInstance ''LoggerF
type LoggerL = F LoggerF
data RandomF next where
GetRandomInt :: (Int, Int) -> (Int -> next)
-> RandomF next
makeFunctorInstance ''RandomF
type RandomL = F RandomF
class Monad m => LoggerL m where
logMessage :: LogLevel -> Message -> m ()
class Monad m => RandomL m where
getRandomInt :: (Int, Int) -> m Int
31

32. data LoggerF next where
LogMessage :: LogLevel -> Message
-> (() -> next) -> LoggerF next
makeFunctorInstance ''LoggerF
type LoggerL = F LoggerF
data RandomF next where
GetRandomInt :: (Int, Int) -> (Int -> next)
-> RandomF next
makeFunctorInstance ''RandomF
type RandomL = F RandomF
data LangF next where
EvalLogger :: LoggerL ()
-> (() -> next) -> LangF next
EvalRandom :: RandomL a
-> (a -> next) -> LangF next
makeFunctorInstance ''LangF
type LangL = F LangF
class Monad m => LoggerL m where
logMessage :: LogLevel -> Message -> m ()
class Monad m => RandomL m where
getRandomInt :: (Int, Int) -> m Int
-- <NOT NEEDED> --
32

33. data LoggerF next where
LogMessage :: LogLevel -> Message
-> (() -> next) -> LoggerF next
makeFunctorInstance ''LoggerF
type LoggerL = F LoggerF
data RandomF next where
GetRandomInt :: (Int, Int) -> (Int -> next)
-> RandomF next
makeFunctorInstance ''RandomF
type RandomL = F RandomF
data LangF next where
EvalLogger :: LoggerL ()
-> (() -> next) -> LangF next
EvalRandom :: RandomL a
-> (a -> next) -> LangF next
makeFunctorInstance ''LangF
type LangL = F LangF
class Monad m => LoggerL m where
logMessage :: LogLevel -> Message -> m ()
class Monad m => RandomL m where
getRandomInt :: (Int, Int) -> m Int
-- <NOT NEEDED> --
Boilerplate??!
33

34. data LoggerF next where
LogMessage :: LogLevel -> Message
-> (() -> next) -> LoggerF next
makeFunctorInstance ''LoggerF
type LoggerL = F LoggerF
data RandomF next where
GetRandomInt :: (Int, Int) -> (Int -> next)
-> RandomF next
makeFunctorInstance ''RandomF
type RandomL = F RandomF
data LangF next where
EvalLogger :: LoggerL ()
-> (() -> next) -> LangF next
EvalRandom :: RandomL a
-> (a -> next) -> LangF next
makeFunctorInstance ''LangF
type LangL = F LangF
class Monad m => LoggerL m where
logMessage :: LogLevel -> Message -> m ()
class Monad m => RandomL m where
getRandomInt :: (Int, Int) -> m Int
-- <NOT NEEDED> --
Functors don’t compose?!!
Boilerplate??!
34

35. data LoggerF next where
LogMessage :: LogLevel -> Message
-> (() -> next) -> LoggerF next
makeFunctorInstance ''LoggerF
type LoggerL = F LoggerF
data RandomF next where
GetRandomInt :: (Int, Int) -> (Int -> next)
-> RandomF next
makeFunctorInstance ''RandomF
type RandomL = F RandomF
data LangF next where
EvalLogger :: LoggerL ()
-> (() -> next) -> LangF next
EvalRandom :: RandomL a
-> (a -> next) -> LangF next
makeFunctorInstance ''LangF
type LangL = F LangF
class Monad m => LoggerL m where
logMessage :: LogLevel -> Message -> m ()
class Monad m => RandomL m where
getRandomInt :: (Int, Int) -> m Int
-- <NOT NEEDED> --
Functors don’t compose?!!
Boilerplate??!
Too complicated!??
35

36. The Only Thing That Matters
LoggerL
LangL
RandomLStateL
ProcessL
AppL
Runtime, Interpreters, Configs, Environment
Application
App
State
Business
Logic
App
Configs
36

37. 37

38. Free Monad vs Final Tagless
Interpreters definition
38

39. interpretRandomF :: RandomF a -> IO a
interpretRandomF (GetRandomInt r n) = ...
runRandomL :: RandomL a -> IO a
runRandomL = foldF interpretRandomF
instance RandomL (ReaderT CoreRuntime m) where
getRandomInt range = liftIO $ randomRIO range
39

40. interpretRandomF :: RandomF a -> IO a
interpretRandomF (GetRandomInt r n) = ...
runRandomL :: RandomL a -> IO a
runRandomL = foldF interpretRandomF
interpretLoggerF
:: HsLoggerHandle -> LoggerF a -> IO a
interpretLoggerF _ (LogMessage lvl msg n) = ...
runLoggerL
:: HsLoggerHandle -> L.LoggerL () -> IO ()
runLoggerL h = foldF (interpretLoggerF h)
instance RandomL (ReaderT CoreRuntime m) where
getRandomInt range = liftIO $ randomRIO range
instance LoggerL (ReaderT CoreRuntime m) where
logMessage lvl msg = blaBla
40

41. interpretRandomF :: RandomF a -> IO a
interpretRandomF (GetRandomInt r n) = ...
runRandomL :: RandomL a -> IO a
runRandomL = foldF interpretRandomF
interpretLoggerF
:: HsLoggerHandle -> LoggerF a -> IO a
interpretLoggerF _ (LogMessage lvl msg n) = ...
runLoggerL
:: HsLoggerHandle -> L.LoggerL () -> IO ()
runLoggerL h = foldF (interpretLoggerF h)
interpretLangF :: CoreRuntime -> LangF a -> IO a
interpretLangF coreRt (EvalLogger l n) = ...
interpretLangF coreRt (EvalRandom r n) = ...
runLangL :: CoreRuntime -> LangL a -> IO a
runLangL coreRt = foldF (interpretLangF coreRt)
instance RandomL (ReaderT CoreRuntime m) where
getRandomInt range = liftIO $ randomRIO range
instance LoggerL (ReaderT CoreRuntime m) where
logMessage lvl msg = blaBla
-- <NOT NEEDED> --
41

42. interpretRandomF :: RandomF a -> IO a
interpretRandomF (GetRandomInt r n) = ...
runRandomL :: RandomL a -> IO a
runRandomL = foldF interpretRandomF
interpretLoggerF
:: HsLoggerHandle -> LoggerF a -> IO a
interpretLoggerF _ (LogMessage lvl msg n) = ...
runLoggerL
:: HsLoggerHandle -> L.LoggerL () -> IO ()
runLoggerL h = foldF (interpretLoggerF h)
interpretLangF :: CoreRuntime -> LangF a -> IO a
interpretLangF coreRt (EvalLogger l n) = ...
interpretLangF coreRt (EvalRandom r n) = ...
runLangL :: CoreRuntime -> LangL a -> IO a
runLangL coreRt = foldF (interpretLangF coreRt)
instance RandomL (ReaderT CoreRuntime m) where
getRandomInt range = liftIO $ randomRIO range
instance LoggerL (ReaderT CoreRuntime m) where
logMessage lvl msg = blaBla
-- <NOT NEEDED> --
Boilerplate??!
42

43. interpretRandomF :: RandomF a -> IO a
interpretRandomF (GetRandomInt r n) = ...
runRandomL :: RandomL a -> IO a
runRandomL = foldF interpretRandomF
interpretLoggerF
:: HsLoggerHandle -> LoggerF a -> IO a
interpretLoggerF _ (LogMessage lvl msg n) = ...
runLoggerL
:: HsLoggerHandle -> L.LoggerL () -> IO ()
runLoggerL h = foldF (interpretLoggerF h)
interpretLangF :: CoreRuntime -> LangF a -> IO a
interpretLangF coreRt (EvalLogger l n) = ...
interpretLangF coreRt (EvalRandom r n) = ...
runLangL :: CoreRuntime -> LangL a -> IO a
runLangL coreRt = foldF (interpretLangF coreRt)
instance RandomL (ReaderT CoreRuntime m) where
getRandomInt range = liftIO $ randomRIO range
instance LoggerL (ReaderT CoreRuntime m) where
logMessage lvl msg = blaBla
-- <NOT NEEDED> --
Boilerplate??!
Interpreters don’t compose?!!
43

44. interpretRandomF :: RandomF a -> IO a
interpretRandomF (GetRandomInt r n) = ...
runRandomL :: RandomL a -> IO a
runRandomL = foldF interpretRandomF
interpretLoggerF
:: HsLoggerHandle -> LoggerF a -> IO a
interpretLoggerF _ (LogMessage lvl msg n) = ...
runLoggerL
:: HsLoggerHandle -> L.LoggerL () -> IO ()
runLoggerL h = foldF (interpretLoggerF h)
interpretLangF :: CoreRuntime -> LangF a -> IO a
interpretLangF coreRt (EvalLogger l n) = ...
interpretLangF coreRt (EvalRandom r n) = ...
runLangL :: CoreRuntime -> LangL a -> IO a
runLangL coreRt = foldF (interpretLangF coreRt)
instance RandomL (ReaderT CoreRuntime m) where
getRandomInt range = liftIO $ randomRIO range
instance LoggerL (ReaderT CoreRuntime m) where
logMessage lvl msg = blaBla
-- <NOT NEEDED> --
Boilerplate??!
Interpreters don’t compose?!!
Slow??!!
44

45. 45

46. 46

47. 47

48. Church Encoded Free
faster than Final Tagless.
48

49. FT FreeM ChurchM
10 0.155 0.155 0.167
100 0.16 0.16 0.16
1000 0.161 0.176 0.15
10000 0.166 1.448 0.17
100000 0.31 ∞ 0.276
1000000 1.618 ∞ 1.464
10000000 14.781 ∞ 14.528
20000000 35.751 ∞ 29.888
30000000 53.655 ∞ 46.489
FT FreeM ChurchM
10 0.165 0.168 0.162
100 0.166 0.17 0.165
1000 0.17 0.161 0.163
10000 0.174 0.757 0.18
100000 0.258 ∞ 0.307
1000000 1.357 ∞ 1.236
10000000 11.459 ∞ hang
Use logs, log total
Use delays, factor = 0
Use logs, log total
No delays
49

50. Free Monad vs Final Tagless
Business Logic
50

51. getRandomMeteor
:: Region -> RandomL Meteor
getRandomMeteor
:: RandomL m => Region -> m Meteor
51

52. getRandomMeteor
:: Region -> RandomL Meteor
publishMeteor
:: AppState -> Meteor -> StateL ()
getRandomMeteor
:: RandomL m => Region -> m Meteor
publishMeteor
:: AppState -> Meteor -> STM ()
52

53. getRandomMeteor
:: Region -> RandomL Meteor
publishMeteor
:: AppState -> Meteor -> StateL ()
meteorShower
:: AppState -> Region -> LangL ()
getRandomMeteor
:: RandomL m => Region -> m Meteor
publishMeteor
:: AppState -> Meteor -> STM ()
meteorShower
:: (MonadUnliftIO m, LoggerL m, RandomL m)
=> AppState -> Region -> m ()
53

54. getRandomMeteor
:: Region -> RandomL Meteor
publishMeteor
:: AppState -> Meteor -> StateL ()
meteorShower
:: AppState -> Region -> LangL ()
meteorsMonitoring
:: AppConfig -> AppL ()
getRandomMeteor
:: RandomL m => Region -> m Meteor
publishMeteor
:: AppState -> Meteor -> STM ()
meteorShower
:: (MonadUnliftIO m, LoggerL m, RandomL m)
=> AppState -> Region -> m ()
meteorsMonitoring
:: (MonadUnliftIO m, ControlFlowL m,
LoggerL m, RandomL m)
=> AppConfig -> m ()
54

55. getRandomMeteor
:: RandomL m => Region -> m Meteor
publishMeteor
:: AppState -> Meteor -> STM ()
meteorShower
:: (MonadUnliftIO m, LoggerL m, RandomL m)
=> AppState -> Region -> m ()
meteorsMonitoring
:: (MonadUnliftIO m, ControlFlowL m,
LoggerL m, RandomL m)
=> AppConfig -> m ()
55
Boilerplate.

56. getRandomMeteor
:: RandomL m => Region -> m Meteor
publishMeteor
:: AppState -> Meteor -> STM ()
meteorShower
:: (MonadUnliftIO m, LoggerL m, RandomL m)
=> AppState -> Region -> m ()
meteorsMonitoring
:: (MonadUnliftIO m, ControlFlowL m,
LoggerL m, RandomL m)
=> AppConfig -> m ()
Boilerplate.
Maintenance nightmare.
56

57. getRandomMeteor
:: RandomL m => Region -> m Meteor
publishMeteor
:: AppState -> Meteor -> STM ()
meteorShower
:: (MonadUnliftIO m, LoggerL m, RandomL m,
HasCoreRuntime m)
=> AppState -> Region -> m ()
meteorsMonitoring
:: (MonadUnliftIO m, ControlFlowL m,
LoggerL m, RandomL m, HasCoreRuntime m)
=> AppConfig -> m ()
Maintenance nightmare.
Boilerplate.
Implementation details.
57

58. getRandomMeteor
:: (MonadUnliftIO m, RandomL m)
=> Region -> m Meteor
publishMeteor
:: AppState -> Meteor -> STM ()
meteorShower
:: (MonadUnliftIO m, LoggerL m, RandomL m,
HasCoreRuntime m)
=> AppState -> Region -> m ()
meteorsMonitoring
:: (MonadUnliftIO m, ControlFlowL m,
LoggerL m, RandomL m, HasCoreRuntime m)
=> AppConfig -> m ()
Maintenance nightmare.
Boilerplate.
Illusion of control.
Implementation details.
58

59. getRandomMeteor
:: Region -> AppEff Meteor
publishMeteor
:: AppState -> Meteor -> STM ()
meteorShower
:: AppState -> Region -> AppEff ()
meteorsMonitoring
:: AppConfig -> AppEff ()
type Eff =
( MonadUnliftIO m
, ControlFlowL m
, LoggerL m
, RandomL m
)
newtype AppEff a = AppT
{ unAppT :: ReaderT CoreRuntime Eff a
}
deriving (Functor, Applicative, Monad)
59

60. LoggerL
RandomL
MonadUnliftIO
ControlFlowL
STMDatabaseL
UnpredictedRandomEffect
LaunchRockets
LoggerL
LangL
RandomLStateL
ProcessL
AppL
Runtime, Interpreters, Configs, Environment
Application
App
State
Business
Logic
App
Configs
Runtime
DatabaseL
IOL
Business
Logic
App State
App Configs
60

61. 61
Effect system != Layering.

62. 62
Effect system != Layering.
Effect systems is an exceptionally bad idea which could
only have originated in academia.

63. To Whom It May Concern
63

64. Functors of free monads aren’t composable.
64

65. Functors of free monads aren’t composable.
Interpreters of free monads aren’t composable.
65

66. Functors of free monads aren’t composable.
Interpreters of free monads aren’t composable.
Free monads aren’t composable.
66

67. Functors of free monads aren’t composable.
Interpreters of free monads aren’t composable.
Free monads aren’t composable.
Free monads are slow.
67

68. Functors of free monads aren’t composable.
Interpreters of free monads aren’t composable.
Free monads aren’t composable.
Free monads are slow.
Essentially, Free Monads are equivalent to Final Tagles.
68

69. Functors of free monads aren’t composable.
Interpreters of free monads aren’t composable.
Free monads aren’t composable.
Free monads are slow.
Essentially, Free Monads are equivalent to Final Tagles.
This paper says it’s impossible.
69

70. Functors of free monads aren’t composable.
Interpreters of free monads aren’t composable.
Free monads aren’t composable.
Free monads are slow.
Essentially, Free Monads are equivalent to Final Tagles.
This paper says it’s impossible.
This paper says it’s bad.
70

71. Functors of free monads aren’t composable.
Interpreters of free monads aren’t composable.
Free monads aren’t composable.
Free monads are slow.
Essentially, Free Monads are equivalent to Final Tagles.
This paper says it’s impossible.
This paper says it’s bad.
You haven’t read the X’s paper, how dare you?!
71

72. Software development is not “Math”.
Software development is “Physics”.
In here, experiment is the only measure of truth.
72

73. Links
Code Hydra framework
My book Functional Design and Architecture
Book’s Patreon Patreon/functional_design_and_architecture
My other talks https://graninas.com/talks-eng
My poetry ;) https://graninas.com/creations/#poetry
73

74. Free monads are powerful and fast.
FPure, Kazan, 2019
74
Alexander Granin
graninas@gmail.com
Twitter: @graninas