Maintainable Software Architecture in Haskell (with Polysemy)

Maintainable Software Architeture
in Haskell (with Polysemy)
© Pawel Szulc, @EncodePanda, paul.szulc@gmail.com 1

maintain [ meyn-teyn ]
verb (used with object)
1. to keep in existence
2. to keep in an appropriate condition, operation, or force; keep
unimpaired:
3. to keep in a speciﬁed state, position, etc.

unimpaired:

unimpaired:
... in Haskell?

"Socialism Haskell is a system
language which heroically
overcomes difﬁculties unknown in
any other system language"

Emphasis on what, less focus on
why?

Maintainable Software Architeture
in Haskell

Our plan for today
1. Coding Dojo / Hack day
2. Real world example
• problem
• approach
• consequences
• Polysemy

Does writing code sucks?

Why writing code sucks (sometimes)?

Coding Kata: Write a sorting
algorithm

"As a Billing System user I want to
generate an invoice for a given
account based on its current
system use"

Functions and their nature
1. Manipulate data (f :: Input -> Output)
2. Interact with an outside world

doStuff :: Int -> Int
doStuff i = i + 1
Why this function is soooo good?
• easy to test
• you will be notiﬁed if its behavior changes

It's easy to maintain function if it
only manipulates data.

-- | take an Int (i) and UUID (uuid) as parameters
-- | fetch existing Int under given uuid from MongoDB
-- | (if does not exist, default to zero)
-- | add them, store the result, return result as text
doStuff :: UUID -> Int -> IO String
doStuff uuid i = do
maybeOld <- fetch uuid
let
oldI = maybe 0 id maybeOld
newI = oldI + i
persist uuid newI
pure ("New value: " ++ (show newI))

doStuff uuid i = do
let
newI = oldI + i
persist uuid newI

It's easy to test and maintain
function if it only manipulates data.
Can we change "interactions with
the outside world" into data?

doStuff uuid i = do
let
newI = oldI + i
persist uuid newI

Let's start with something simple

-- | take Int, return +1 as text
doStuff :: Int -> String
doStuff i = "New value: " ++ (show $ i + 1)

prop_returns_plus1 :: Property
prop_returns_plus1 = property do
-- given
i <- Gen.int
-- when
let res = doStuff i
-- then
res === "New value: " ++ (show $ i + 1)

module Main where
main :: IO ()
main = putStrLn $ doStuff 10

-- | take Int, store it, return +1 as text

data Storage = Persist UUID Int
doStuff :: UUID -> Int -> (Storage, String)
doStuff uuid i =
( Persist uuid newI
, "New value: " ++ (show newI)
)
where
newI = i + 1

doStuff uuid i =
( Persist uuid newI
)
where
newI = i + 1

prop_returns_plus1 = property $ do
-- given
i <- Gen.int
uuid <- genUUID
-- when
let result = doStuff uuid i
-- then
let expected = ( Persist uuid (i + 1)
, "New value: " ++ (show $ i + 1)
)
result === expected

-- given
i <- Gen.int
uuid <- genUUID
-- when
-- then
, "New value: " ++ (show $ i + 1)
)
result === expected

interpret :: (Storage, String) -> IO String

type InMemStorage = M.Map UUID Int
interpret ::
IORef InMemStorage
-> (Storage, String)
-> IO String
interpret ioRef (Persist uuid pi, i) = do
modifyIORef ioRef (M.insert uuid pi)
return i

interpret ::
IORef InMemStorage
-> IO String
return i

main :: IO ()
main = do
ioRef <- newIORef M.empty
uuid <- nextRandom
res <- interpret ioRef (doStuff uuid 10)
putStrLn res

doStuff uuid i =
( Persist uuid newI
)
where
newI = i + 1

-- | take Int, store it once, story it twice, return +1 as text
doStuff uuid i =
( Persist uuid newI
)
where
newI = i + 1

doStuff :: UUID -> Int -> ([Storage], String)
doStuff uuid i =
( [(Persist uuid newI)]
)
where
newI = i + 1

interpret ::
IORef InMemStorage
-> IO String
return i

interpret ::
IORef InMemStorage
-> ([Storage], String)
-> IO String
interpret ioRef (actions, i) = do
traverse perform actions
return i
where
perform (Persist uuid pi) =

interpret ::
IORef InMemStorage
-> IO String
return i
where

-- given
i <- Gen.int
uuid <- genUUID
-- when
-- then
, "New value: " ++ (show $ i + 1)
)
result === expected

-- given
i <- Gen.int
uuid <- genUUID
-- when
-- then
let expected = ( [Persist uuid (i + 1)]
, "New value: " ++ (show $ i + 1)
)
result === expected

main :: IO ()
main = do
ioRef <- newIORef M.empty
uuid <- nextRandom
res <- interpret ioRef (doStuff uuid 10)
putStrLn res

doStuff uuid i =
( [(Persist uuid newI)]
)
where
newI = i + 1

doStuff uuid i =
( [ (Persist uuid newI)
, (Persist uuid newI)
]
)
where
newI = i + 1

-- given
i <- Gen.int
uuid <- genUUID
-- when
-- then
let expected = ( [Persist uuid (i + 1)]
, "New value: " ++ (show $ i + 1)
)
result === expected

-- given
i <- Gen.int
uuid <- genUUID
-- when
-- then
let expected = ( [ Persist uuid (i + 1)
, Persist uuid (i + 1)]
, "New value: " ++ (show $ i + 1)
)
result === expected

interpret :: ([Storage], String) -> IO String

sthElse :: UUID -> Int -> ([Storage], Int)
interpret :: ([Storage], String) -> IO String

sthElse :: UUID -> Int -> ([Storage], Int)
interpret :: ([Storage], a) -> IO a

interpret ::
IORef InMemStorage
-> IO String
return i
where

interpret ::
IORef InMemStorage
-> ([Storage], a)
-> IO a
return i
where

data Storage k =
Persist UUID Int
deriving stock (Eq, Show)
doStuff uuid i =
, (Persist uuid newI)]
)
where
newI = i + 1

data Storage k =
Persist UUID Int
doStuff uuid i =
, (Persist uuid newI)]
)
where
newI = i + 1

data Storage k =
Done k
| Persist UUID Int
doStuff :: UUID -> Int -> [Storage String]
doStuff uuid i =
[ (Persist uuid newI)
, (Done $ "New value: " ++ (show newI))]
where
newI = i + 1

data Storage k =
Done k
| Persist UUID Int
doStuff uuid i =
where
newI = i + 1

interpret ::
IORef InMemStorage
-> ([Storage], a)
-> IO a
return i
where

interpret ::
IORef InMemStorage
-> [Storage a]
-> IO a
interpret ioRef actions = do
traverse perform (init actions)
value (last actions)
where
value (Done a) = pure a
value _ = fail "failed"

interpret ::
IORef InMemStorage
-> [Storage a]
-> IO a
where

data Storage k =
Done k
| Persist UUID Int
doStuff uuid i =
, (Done $ "New value: " ++ (show newI))
]
where
newI = i + 1

data Storage k =
Done k
| Persist UUID Int (Storage k)
doStuff uuid i =
]
where
newI = i + 1

data Storage k =
Done k
doStuff uuid i =
]
where
newI = i + 1

data Storage k =
Done k
doStuff :: UUID -> Int -> Storage String
doStuff uuid i =
(Persist uuid newI
(Persist uuid newI
(Done $ "New value: " ++ (show newI))
))
where
newI = i + 1

data Storage k =
Done k
doStuff uuid i =
(Persist uuid newI
(Persist uuid newI
))
where
newI = i + 1

interpret :: IORef InMemStorage -> Storage a -> IO a
interpret ioRef (Done a) = pure a
interpret ioRef (Persist uuid i next) =
modifyIORef ioRef (M.insert uuid i) *>
interpret ioRef next

data Storage k =
Done k
doStuff uuid i =
(Persist uuid newI
(Persist uuid newI
))
where
newI = i + 1

data Storage k =
Done k

data Storage k =
Done k
deriving stock (Functor, Eq, Show)

data Storage k =
Done k
deriving stock (Functor, Eq, Show)
instance Applicative Storage where
pure a = Done a
(<*>) func (Done a) =
fmap (f -> f a) func
(<*>) func (Persist uuid i next) =
Persist uuid i (func <*> next)

doStuff uuid i =
(Persist uuid newI
(Persist uuid newI
))
where
newI = i + 1

doStuff uuid i =
Persist uuid newI (Done ()) *>
where
newI = i + 1

doStuff uuid i =
where
newI = i + 1

doStuff uuid i =
persist uuid newI *>
persist uuid newI *>
where
newI = i + 1
persist :: UUID -> Int -> Storage ()
persist uuid i = Persist uuid i (Done ())

-- | take Int, fetch existing Int (if does not exist, default to zero)
doStuff uuid i =
fetch uuid *>
persist ...
data Storage k =
Done k
| Fetch UUID ...
deriving stock (Functor)
fetch :: UUID -> Storage (Maybe Int)

doStuff uuid i =
fetch uuid *>
persist ...
data Storage k =
Done k
| Fetch UUID ...

data Storage k =
Done k

data Storage k =
Done k
| Fetch UUID (Maybe Int -> Storage k)

data Storage k =
Done k
fetch uuid = Fetch uuid (mi -> Done mi)

data Storage k =
Done k
fetch uuid = Fetch uuid pure

"Sequentially compose two actions,
passing any value produced by the
ﬁrst as an argument to the second."

??? :: m a -> (a -> m b) -> m b

>>= :: m a -> (a -> m b) -> m b

instance Monad Storage where
(Done a) >>= f = f a
(Persist uuid i next) >>= f =
Persist uuid i (next >>= f)
(Fetch uuid nextFunc) >>= f =
Fetch uuid (mi -> (nextFunc mi) >>= f)

-- | take Int, fetch existing Int
-- | add them,
-- | store the result,
-- | return result as text
doStuff uuid i = do
let
newI = oldI + i
persist uuid newI

-- | add them,
doStuff uuid i = do
let
newI = oldI + i
persist uuid newI

(modifyIORef ioRef (M.insert uuid i)) *> (interpret ioRef next)
interpret ioRef (Fetch uuid nextFunc) = do
inmem <- readIORef ioRef
let maybeI = M.lookup uuid inmem
interpret ioRef (nextFunc maybeI)

prop_fetch_add_store_return :: Property
prop_fetch_add_store_return = property $ do
-- given
i <- Gen.int
uuid <- genUUID
initial <- Gen.int
ioRef <- evalIO $ newIORef $ M.singleton uuid initial
-- when
res <- evalIO $ interpret ioRef (doStuff uuid i)
-- then
inmem <- evalIO $ readIORef ioRef
res === "New value: " ++ show (i + initial)
M.toList inmem === [(uuid, i + initial)]

doStuff uuid i = do
let
newI = oldI + i
persist uuid newI

data Storage k =
Done k
instance Applicative Storage where
pure a = Done a
(<*>) func (Done a) = fmap (f -> f a) func
(<*>) func (Persist uuid i next) = Persist uuid i (func <*> next)
instance Monad Storage where
(Done a) >>= f = f a
(Persist uuid i next) >>= f = Persist uuid i (next >>= f)
(Fetch uuid nextFunc) >>= f = Fetch uuid (mi -> (nextFunc mi) >>= f)

data Storage k =
Done k

data Storage k =
Persist UUID Int k
| Fetch UUID (Maybe Int -> k)
data Free (f:: * -> *) (k :: *) =
Pure k |
Impure (f (Free f k))

data Storage k =
Persist UUID Int k
data Free (f:: * -> *) (k :: *) =
Pure k |
Impure (f (Free f k))
persist :: UUID -> Int -> Free Storage ()
persist uuid i = Impure (Persist uuid i (Pure ()))
fetch :: UUID -> Free Storage (Maybe Int)
fetch uuid = Impure (Fetch uuid (mi -> Pure mi))

instance Functor f => Functor (Free f) where
fmap f (Pure k) = Pure $ f k
fmap f (Impure c) = Impure (fmap (fmap f) c)
instance Functor f => Applicative (Free f) where
pure a = Pure a
(<*>) func (Pure a) = fmap (f -> f a) func
(<*>) func (Impure c) = Impure (fmap (f -> func <*> f) c)
instance Functor f => Monad (Free f) where
Pure k >>= f = f k
Impure c >>= f = Impure $ fmap (x -> x >>= f) c

data Storage k =
Persist UUID Int k

doStuff uuid i = do
let
newI = oldI + i
persist uuid newI

doStuff :: UUID -> Int -> Free Storage String
doStuff uuid i = do
let
newI = oldI + i
persist uuid newI

interpretFree ::
Monad m
=> (forall x. f x -> m x)
-> Free f a
-> m a
interpretFree _ (Pure a) = pure a
interpretFree f (Impure c) = f c >>= interpretFree f

interpretFree ::
Monad m
-> Free f a
-> m a
interpret ioRef (Persist uuid i k) = do
modifyIORef ioRef (M.insert uuid i)
pure k
interpret ioRef (Fetch uuid kFunc) = do
pure $ kFunc maybeI

interpretFree ::
Monad m
-> Free f a
-> m a
pure k
pure $ kFunc maybeI

interpretFree :: (f x -> m x) -> Free f a -> m a

-- given
i <- Gen.int
uuid <- genUUID
initial <- Gen.int
-- when
-- then

-- given
i <- Gen.int
uuid <- genUUID
initial <- Gen.int
-- when
res <- evalIO $ interpretFree (interpret ioRef) (doStuff uuid i)
-- then

Free Monads?

"As a Billing System user I want to
generate an invoice for a given
account based on its current
system use"

To generate invoice for account account_id
1. fetch proﬁle from CRM
2. fetch CDRs from FTP
3. generate invoice number
4. total = sum cdrs
5. glue together

https://github.com/polysemy-research/polysemy

Sem r a.
program :: Sem '[Console, (Random Int)] Int

Sem r a.

Sem r a___
___
.________________________________________^

Sem r a.

Sem r a________________________
________________________
.________________________^

Sem r a.

Sem r aprogram ::
Member Console r
=> Member (Random Int) r
=> Sem r Int
.

Sem r aprogram ::
Member Console r
=> Sem r Int
.________^

Sem r aprogram ::
Member Console r <|
=> Member (Random Int) r <|
=> Sem r Int |
.________^_____________________|

program ::
Member Console r
=> Sem r Int
data Console m a where
PrintLine :: String -> Console m ()
ReadLine :: Console m String
makeSem ''Console
printLine :: Member Console r => String -> Sem r ()
readLine :: Member Console r => Sem r String

program ::
Member Console r
=> Sem r Int
makeSem ''Console

program ::
Member Console r
=> Sem r Int
data Random v m a where
NextRandom :: Random v m v
makeSem ''Random
nextRandom :: Member (Random v) r => Sem r v

program ::
Member Console r
=> Sem r Int
makeSem ''Random

-- cheatsheet
program ::
Member Console r
=> Sem r Int
program = do
printLine "Insert your number:"
i1 <- readLine
i2 <- nextRandom
pure (read i1 + i2)

-- cheatsheet
program ::
Member Console r
=> Sem r Int
program = do
i1 <- readLine
i2 <- nextRandom
pure (read i1 + i2)

program ::
Member Console r
=> Sem r Int
program = do
i1 <- readLine
i2 <- nextRandom
pure (read i1 + i2)
-- Sem r a ~> IO a ?

run :: Sem '[] a -> a
runM :: Monad m
=> Sem '[Embed m] a -> m a
-- Sem '[Embed IO] a -> IO a
program ::
Member Console r
=> Sem r Int
-- Sem '[Console, Random Int] Int

run :: Sem '[] a -> a
runM :: Monad m
program ::
Member Console r
=> Sem r Int

What we need is an interpreter

runConsoleIO ::
Member (Embed IO) r
=> Sem (Console ': r) a -> Sem r a
runConsoleIO = interpret $ case
PrintLine line -> putStrLn line
ReadLine -> getLine

runConsoleIO ::
Member (Embed IO) r
ReadLine -> getLine

-- embed :: Member (Embed m) r => m a -> Sem r a
runConsoleIO ::
Member (Embed IO) r
ReadLine -> getLine

-- embed :: Member (Embed m) r => m a -> Sem r a
runConsoleIO ::
Member (Embed IO) r
PrintLine line -> embed $ putStrLn line
ReadLine -> embed $ getLine

runRandomIO ::
Member (Embed IO) r
=> Sem (Random Int ': r) a -> Sem r a
runRandomIO = interpret $ case
NextRandom -> embed randomIO

main :: IO ()
main = execute >>= putStrLn.show
where
execute = program
& runConsoleIO
& runRandomIO
& runM

main :: IO ()
where
execute = program -- Sem '[Console, Random Int ] Int
& runConsoleIO
& runRandomIO
& runM

main :: IO ()
where
& runConsoleIO -- Sem '[ , Random Int, Embed IO] Int
& runRandomIO
& runM

main :: IO ()
where
& runRandomIO -- Sem '[ , Embed IO] Int
& runM

main :: IO ()
where
& runRandomIO -- Sem '[ , Embed IO] Int
& runM -- IO Int

data Invoice = Invoice
{ invoiceNumber :: InvoiceNumber
, fullName :: FullName
, deliveryAddress :: Address
, total :: Cent
}

newtype InvoiceNumber = InvoiceNumber { unInvoiceNumber :: Text }
deriving (Show, Eq)
data Address = Address
{ street :: Text
, house :: Text
, num :: Text
, city :: Text
, country :: Text
}
data FullName = FullName
{ first :: Text
, last :: Text
}

data Invoice = Invoice
{ invoiceNumber :: InvoiceNumber
, fullName :: FullName
, deliveryAddress :: Address
, total :: Cent
}

data CallType = Voice | Sms
newtype Duration = Duration { unDuration :: Int }
deriving stock (Show, Eq)
deriving newtype (Num)
data Cdr = Cdr
{ uuid :: UUID
, accountId :: AccountId
, callType :: CallType
, callDuration :: Duration
}

data Plan = Plan
{ voiceCost :: Cent
, smsCost :: Cent
}
data Profile = Profile
{ firstName :: Text
, lastName :: Text
, address :: Address
, plan :: Plan
}

mkInvoice ::
InvoiceNumber
-> Profile
-> [Cdr]
-> Invoice
mkInvoice invNum Profile {..} cdrs = Invoice
{ invoiceNumber = invNum
, fullName = FullName firstName lastName
, deliveryAddress= address
, total = foldr cost zeroCents cdrs
}
where
cost (Cdr _ _ Voice (Duration duration)) acc = acc + (voiceCost plan * duration)
cost (Cdr _ _ Sms (Duration amount)) acc = acc + (smsCost plan * amount)

mkInvoice ::
InvoiceNumber
-> Profile
-> [Cdr]
-> Invoice
mkInvoice = ...

import Polysemy
data Crm m a where
GetProfile :: AccountId -> Crm m Profile
makeSem ''Crm

import Polysemy
data CdrStore m a where
FetchCdrs :: AccountId -> CdrStore m [Cdr]
makeSem ''CdrStore

import Polysemy
data InvoiceStore m a where
GenNextInvoiceNumber :: AccountId -> InvoiceStore m InvoiceNumber
makeSem ''InvoiceStore

import Polysemy

import Polysemy
StoreInvoice :: AccountId -> Invoice -> InvoiceStore m ()

generateInvoice ::
Member CdrStore r
=> Member Crm r
=> Member InvoiceStore r
=> AccountId
-> Sem r Invoice
generateInvoice accId = do
invNumber <- genNextInvoiceNumber accId
profile <- getProfile accId
cdrs <- fetchCdrs accId
let invoice = mkInvoice invNumber profile cdrs
storeInvoice accId invoice
return invoice

data Crm m a where
GetProfile :: AccountId -> Crm m Profile
type CrmMap = M.Map AccountId Profile
runCrm ::
Member (State CrmMap) r
=> Sem (Crm ': r) a
-> Sem r a
runCrm = interpret $ case
GetProfile accountId -> gets (m -> m M.! accountId)

data CdrStore m a where
FetchCdrs :: AccountId -> CdrStore m [Cdr]
type CdrMap = M.Map AccountId [Cdr]
runCdrStore ::
Member (State CdrMap) r
=> Sem (CdrStore ': r) a
-> Sem r a
runCdrStore = interpret $ case
FetchCdrs accountId -> gets (m -> m M.! accountId)

StoreInvoice :: AccountId -> Invoice -> InvoiceStore m ()
type InvoiceMap = M.Map (AccountId, InvoiceNumber) Invoice
runInvoiceStore ::
Member (State InvoiceMap) r
=> Member (Embed IO) r
=> Sem (InvoiceStore ': r) a
-> Sem r a
runInvoiceStore = interpret $ case
StoreInvoice accountId invoice ->
modify (M.insert (accountId, invoiceNumber invoice) invoice)
GenNextInvoiceNumber accountId ->
embed $ fmap (InvoiceNumber . toText) nextRandom

main :: IO ()
main = execute
where
accountId = AccountId 1000
execute = generateInvoice accountId
& runCrm
& runCdrStore
& runInvoiceStore
& evalState @CrmMap (M.singleton accountId profile)
& evalState @CdrMap (M.singleton accountId (cdrs accountId))
& evalState @InvoiceMap M.empty
& runM

main :: IO ()
main = execute
where
& runCrm
& runCdrStore
& runInvoiceStore
& runM

profile :: Profile
profile = Profile "John" "Smith" address plan
where
address =
Address "Backer Street" "221b" "2" "London" "United Kingdom"
plan = Plan 10 1

main :: IO ()
main = execute
where
& runCrm
& runCdrStore
& runInvoiceStore
& runM

cdrs :: AccountId -> [Cdr]
cdrs accountId =
[ cdr "8abbe08f-4b64-4263-b000-13f3ff77a0c6" Voice 10
, cdr "bed067b0-3e79-429d-8b96-d1f2c96e79ba" Sms 1
, cdr "d4bea3d9-a2a7-44cc-8a8d-301051860761" Voice 30
]

main :: IO ()
main = execute
where
& runCrm
& runCdrStore
& runInvoiceStore
& runM

main :: IO ()
main = execute >>= putStrLn.prettyPrint
where
& runCrm
& runCdrStore
& runInvoiceStore
& runM
prettyPrint = unpack.toStrict.encodePretty

{
"fullName": {
"first": "John",
"last": "Smith"
},
"deliveryAddress": {
"country": "United Kingdom",
"num": "2",
"street": "Backer Street",
"house": "221b",
"city": "London"
},
"invoiceNumber": "136172ef-95cb-4714-924a-4d3f9c5e5fd6",
"total": 401
}

Maintainable?

Thank You!Pawel Szulc
twitter: @EncodePanda
email: paul.szulc@gmail.com

Maintainable Software Architecture in Haskell (with Polysemy)

More Related Content

Similar to Maintainable Software Architecture in Haskell (with Polysemy)

More from Pawel Szulc

Recently uploaded

Maintainable Software Architecture in Haskell (with Polysemy)