I'm releasing the mvc library for model-view-controller (MVC) programming in Haskell. I initially designed this library with games and user interfaces in mind, but the larger goal of this library is to provide a mathematically inspired framework for general-purpose component sharing in Haskell.
This library differs in a significant way from other MVC libraries: this API statically enforces in the types that the Model is pure, but with very little loss in power. Using mvc you can refactor many types of concurrent applications into a substantial and pure Model that interfaces with carefully constrained Views and Controllers.
When you purify your Model this way, you can:
record and replay bugs reproducibly,
do property-based testing (ala
QuickCheck) to uncover corner cases, and:prove formal properties about your
Modelusing equational reasoning.
The first half of this post walks through two examples reproduced from the mvc documentation and the second half of this post describes the architecture that enables you to embed large and non-trivial business logic in an entirely pure Model. This post will use a side-by-side mix of theoretical terminology alongside plain English. Even if you don't understand the theoretical half of this post you should still derive benefit from the non-technical half and use that as a bridge towards understanding the underlying theory.
Examples
The mvc library uses four types to represent everything:
The
Modelis a pure streaming transformation from inputs to outputsThe
Viewhandles all outputs from theModelThe
Controllersupplies all inputs to theModelThe
Managedtype extends other types with logic for acquiring or releasing resources
There are no other concepts you have to learn. The API is extraordinarily small (4 types, and 8 primitive functions associated with those types).
However, as we extend our application the types will never grow more complex. In fact, the mvc library statically forbids you from increasing the complexity of your types, because the library only provides a single run function of the following type:
runMVC
:: s -- Initial state
-> Model s a b -- Program logic
-> Managed (View b, Controller a) -- Impure output and input
-> IO s -- Returns final stateThere is no other way to consume Models, Views, and Controllers, so runMVC forces you to consolidate all your Views into a single View and consolidate all your Controllers into a single Controller. This creates a single entry point and a single exit point for your Model. Equally important, you cannot mix your Model logic with your View or Controller logic. The mvc library enforces MVC best practices using the type system.
This first minimal example illustrates these basic concepts:
import MVC
import qualified MVC.Prelude as MVC
import qualified Pipes.Prelude as Pipes
external :: Managed (View String, Controller String)
external = do
c1 <- MVC.stdinLines
c2 <- MVC.tick 1
return (MVC.stdoutLines, c1 <> fmap show c2)
model :: Model () String String
model = asPipe (Pipes.takeWhile (/= "quit"))
main :: IO ()
main = runMVC () model externalThe key components are:
A
Controllerthat interleaves lines from standard input with periodic ticksA
Viewthat writes lines to standard outputA pure
Model, which forwards lines until it detects the string"quit"A
Managedtype, which abstracts over resource acquisition and release
The Model only has a single streaming entry point (the Controller) and a single streaming exit point (the View).
However, this interface is deceptively simple and can model very complex logic. For example, here's a more elaborate example using the sdl library that displays a white rectangle between every two mouse clicks:
import Control.Monad (join)
import Graphics.UI.SDL as SDL
import Lens.Family.Stock (_Left, _Right) -- `lens-family-core`
import MVC
import MVC.Prelude
import qualified Pipes.Prelude as Pipes
data Done = Done deriving (Eq, Show)
sdl :: Managed (View (Either Rect Done), Controller Event)
sdl = join $ managed $ \k ->
withInit [InitVideo, InitEventthread] $ do
surface <- setVideoMode 640 480 32 [SWSurface]
white <- mapRGB (surfaceGetPixelFormat surface) 255 255 255
let done :: View Done
done = asSink (\Done -> SDL.quit)
drawRect :: View Rect
drawRect = asSink $ \rect -> do
_ <- fillRect surface (Just rect) white
SDL.flip surface
totalOut :: View (Either Rect Done)
totalOut = handles _Left drawRect <> handles _Right done
k $ do
totalIn <- producer Single (lift waitEvent >~ cat)
return (totalOut, totalIn)
pipe :: Monad m => Pipe Event (Either Rect Done) m ()
pipe = do
Pipes.takeWhile (/= Quit)
>-> (click >~ rectangle >~ Pipes.map Left)
yield (Right Done)
rectangle :: Monad m => Consumer' (Int, Int) m Rect
rectangle = do
(x1, y1) <- await
(x2, y2) <- await
let x = min x1 x2
y = min y1 y2
w = abs (x1 - x2)
h = abs (y1 - y2)
return (Rect x y w h)
click :: Monad m => Consumer' Event m (Int, Int)
click = do
e <- await
case e of
MouseButtonDown x y ButtonLeft ->
return (fromIntegral x, fromIntegral y)
_ -> click
main :: IO ()
main = runMVC () (asPipe pipe) sdlCompile and run this program, which will open up a window, and begin clicking to paint white rectangles to the screen:
Here we package the effectful and concurrent components that we need from the sdl into a self-contained package containing a single View and Controller. Our pure logic is contained entirely within a pure Pipe, meaning that we can feed synthetic input to our program:
>>> let leftClick (x, y) = MouseButtonDown x y ButtonLeft
>>> Pipes.toList $
... each [leftClick (10, 10), leftClick (15, 16), Quit]
... >-> pipe
[Left (Rect {rectX = 10, rectY = 10, rectW = 5, rectH = 6}),Right
Done]... or even QuickCheck our program logic! We can verify that our program generates exactly one rectangle for every two clicks:
>>> import Test.QuickCheck
>>> quickCheck $ \xs ->
... length (Pipes.toList (each (map leftClick xs) >-> pipe))
... == length xs `div` 2
+++ OK, passed 100 tests.These kinds of tests would be impossible to run if we settled for anything less than complete separation of impurity and concurrency from our program's logic.
However, this total separation might seem unrealistic. What happens if we don't have exactly one View or exactly one Controller?
Monoids - Part 1
Views and Controllers are Monoids, meaning that we can combine any number of Views into a single View, and likewise combine any number of Controllers into a single Controller, by using mconcat (short for "Monoid concatenation") from Data.Monoid:
-- Combine a list of `Monoid`s into a single `Monoid`
mconcat :: Monoid m => [m] -> mWhen we specialize the type of mconcat to View or Controller we get the following two specialized functions:
-- Combining `View`s sequences their effects
mconcat :: [View a] -> View a
-- Combining `Controller`s interleaves their events
mconcat :: [Controller a] -> Controller aIn other words, we can can combine a list of any number of Views into a single View and combine a list of any number of Controllers into a single Controller. We get several benefits for free as a result of this design.
First, combinability centralizes our View logic and Controller logic into a single expression that we feed to runMVC. We can therefore identify all inputs and outputs to our system simply by tracing all sub-expressions that feed into this larger expression. Contrast this with a typical mature code base where locating all relevant inputs and outputs for the system is non-trivial because they are typically not packaged into a single self-contained term.
Second, combinability promotes reuse. If we find ourselves repeatedly using the same set of inputs or outputs we can bundle them into a new derived component that we can share with others.
Third, combinable inputs and outputs are the reason our Model can afford to have a single entry point and a single exit point. This beats having to write callback spaghetti code where we cannot easily reason about our application's control flow.
This is an example of a scalable architecture. The Monoid type class lets us indefinitely grow our inputs and outputs without ever increasing the number of concepts, abstractions or types.
To be more specific, this scalable architecture is a special case of the category design pattern. When combinable components are morphisms in a category, we can connect as many components as we please yet still end up back where we started. In this case the operative category is a monoid, where Views or Controllers are morphisms, (<>) is the composition operator and mempty is the identity morphism.
Functors - Part 1
However, the Monoid type class only lets us combine Views and Controllers that have the same type. For example, suppose we have a Controller for key presses, and a separate Controller for mouse events:
keys :: Controller KeyEvent
clicks :: Controller MouseEventIf we try to combine these using (<>) (an infix operator for mappend), we will get a type error because their types do not match:
keys <> clicks -- TYPE ERROR!keys and clicks don't stream the same event type, so how do we reconcile their different types? We use functors!
fmap Left keys
:: Controller (Either KeyEvent MouseEvent)
fmap Right clicks
:: Controller (Either KeyEvent MouseEvent)
fmap Left keys <> fmap Right clicks
:: Controller (Either KeyEvent MouseEvent)The functor design pattern specifies that when we have an impedance mismatch between components, we unify them to agree on a common component framework. Here, we unify both of our Controller output types using Either.
Using theoretical terminology, when we have morphisms in diverse categories, we use functors to transform these morphisms to agree on a common category. In this case keys is a morphism in the Controller KeyEvent monoid and clicks is a morphism in the Controller MouseEvent monoid. We use fmap to transform both monoids to agree on the Controller (Either KeyEvent MouseEvent) monoid.
However, in this case fmap is behaving as a functor in a different sense than we are normally accustomed to. We're already familiar with the following functor laws for fmap:
fmap (f . g) = fmap f . fmap g
fmap id = idHowever, right now we're not interested in transformations from functions to functions. Instead, we're interested in transformations from monoids to monoids, so we're going to invoke a different set of functor laws for our Controllers:
fmap f (c1 <> c2) = fmap f c1 <> fmap f c2
fmap f mempty = memptyIn other words, fmap f correctly translates monoid operations from one type of Controller to another. This functor between monoids is the operative functor when we transform Controllers to agree on a common type.
Functors - Part 2
We can use the same functor design pattern to unify different types of Views as well. For example, let's assume that we have two separate Views, one that logs Strings to a file, and another that displays video Frames to a screen:
logLines :: View String
frames :: View FrameAgain, we cannot naively combine these using mappend/(<>) because the types don't match:
logLines <> frames -- TYPE ERROR!However, View does not implement Functor, so how do we unify the types this time?
We still use functors! However, this time we will be using the handles function from mvc, which has the following type:
handles :: Traversal' a b -> View b -> View aThis lets us use Traversals to specify which outgoing values each View should handle:
import Lens.Family.Stock (_Left, _Right)
-- _Left :: Traversal' (Either a b) a
-- _Right :: Traversal' (Either a b) b
handles _Left logLines
:: View (Either String Frames)
handles _Right frames
:: View (Either String Frames)
handles _Left logLines <> handles _Right frames
:: view (Either String Frames)This reads a little like English: logLines handles _Left values, and frames handles _Right values.
Like the previous example, handles is a functor in two ways. The first functor maps traversal composition to function composition:
handles (t1 . t2) = handles t1 . handles t2
handles id = idThe second functor maps monoid operations from one View to another:
handles t (v1 <> v2) = handles t v1 <> handles t v2
handles t mempty = memptyThis latter functor between View monoids is the operative functor when we are unifying Views to agree on a common type.
Applicatives
Alright, but we don't typically work with unadorned Views or Controllers. If you look at the utility section of mvc you will see that most Views or Controllers are Managed, meaning that they must acquire or release some sort of resource before they can begin streaming values in or out. For example, any View or Controller that interacts with a file must initially acquire the file and release the file when done:
fromFile :: FilePath -> Managed (Controller String)
toFile :: FilePath -> Managed (View String)Uh oh... We have a problem! runMVC doesn't accept separate Managed Views and Managed Controllers. runMVC only accepts a combined View and Controller that share the same Managed logic:
runMVC
:: s
-> Model s a b
-> Managed (View b, Controller a) -- What do we do?
-> IO srunMVC is written this way because some Views and Controllers must acquire and release the same resource. Does this mean that I need to provide a new run function that accepts separate Managed Views and Managed Controllers?
No! Fortunately, Managed implements the Applicative type class and we can use Applicatives to combined two Managed resources into a single Managed resource:
import Control.Applicative (liftA2)
liftA2 (,)
:: Applicative f => f a -> f b -> f (a, b)
-- Specialize `liftA2` to `Managed`
liftA2 (,)
:: Managed a -> Managed b -> Managed (a, b)
toFile "output.txt"
:: Managed (View String)
fromFile "input.txt"
:: Managed (Controller String)
liftA2 (,) (toFile "output.txt") (fromFile "input.txt")
:: Managed (View String, Controller String)I can fuse my two Managed resources into a single Managed resource! This is another example of scalable design. We don't complicate our run function by adding special cases for every permutation of Managed Views and Controllers. Instead, we make Managed layers laterally combinable, which prevents proliferation of functions, types, and concepts.
Monoids - Part 2
Managed implements the Monoid type class, too! Specifically, we can wrap any type that implements Monoid with Managed and we will get back a new derived Monoid:
instance Monoid r => Monoid (Managed r) where
mempty = pure mempty
mappend = liftA2 mappendThis means that if I have two Managed Views, I can combine them into a single Managed View using the same Monoid operations as before:
view1 :: Managed (View A)
view2 :: Managed (View A)
viewBoth :: Managed (View A)
viewBoth = view1 <> view2The same is true for Controllers:
controller1 :: Managed (Controller A)
controller2 :: Managed (Controller A)
controllerBoth :: Managed (Controller A)
controllerBoth = controller1 <> controller2In fact, this trick works for any Applicative, not just Managed. Applicatives let you extend arbitrary Monoids with new features while still preserving their Monoid interface. There is no limit to how many Applicative extensions you can layer this way.
Conclusion
The documentation for the mvc library is full of theoretical examples like these showing how to architect applications using scalable abstractions inspired by category theory.
The mvc library has certain limitations. Specifically, I did not design the library to handle changing numbers of inputs and outputs over time. This is not because of a deficiency in category theory. Rather, I wanted to introduce this simpler API as a stepping stone towards understanding more general abstractions later on that I will release as separate libraries.
The other reason I'm releasing the mvc library is to test the waters for an upcoming book I will write about architecting programs using category theory. I plan to write one section of the book around an application structured using this mvc style.
Links: