gabriella439 / haskell-mvc-library

Model-view-controller

MVC v1.1.7

Use the mvc library to distill concurrent programs into pure and single-threaded programs using the Model-View-Controller pattern. The mvc library makes pervasive purity practical.

mvc is guided by a single overarching design principle: application architectures inspired by category theory scale in the large because they reduce complexity and prevent proliferation of concepts. Use mvc if you wish to learn how to practically apply theory to tame large applications.

Quick start

• Install the Haskell Platform
• cabal install mvc
• Read the documentation in the MVC module and the MVC.Prelude module

Optionally begin from this program skeleton:

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 external

Features

• Determinism: Perform property-based testing on your model (like QuickCheck)

• Purity: Move a substantial amount of your application logic into pure code

• Semantics: Equationally reason about your concurrency-free and pure core

• Best practices: Statically enforce decoupling

• Concise API: Only four types, and 8 primitive functions

• Elegant semantics: Use practical category theory

• Extensive Documentation: The haddocks contain extensive tips and idioms

Development Status

The API is stable because I do not plan to generalize the API further. Any future generalizations will be released as separate libraries. The goal of this library is to serve as a stepping stone towards understanding more sophisticated and general application architectures, so I wish to preserve its simplicity for pedagogical reasons.

Future development will focus on building an ecosystem of pre-built Views and Controllers that applications can use, with a focus on tools useful for user interfaces and games.

How to contribute

• Build derived libraries

• Write mvc tutorials

License (BSD 3-clause)

Copyright (c) 2014 Gabriella Gonzalez All rights reserved.

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

• Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.

• Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

• Neither the name of Gabriella Gonzalez nor the names of other contributors may be used to endorse or promote products derived from this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

haskell-mvc-library's Issues

Version discrepancies

Cabal file: Version: 1.0.3
Readme: Version: 1.0.2
Release Tags: Version 1.0.1

Add `MonadIO` instance for the `Managed` type

Fix License to 2014

`Managed (Controller a)` is probably old style

See https://github.com/Gabriel439/Haskell-MVC-Library/blob/cae798b5bbee77533713a1e951fa1defd94cf4a0/src/MVC.hs#L123

Several places in the comments mention Managed (Controller a) or Managed (View b) instead of the new style Managed (View b, Controller a). Does this need a cleanup or am I mistaken?

Example in MVC.Prelude does not do anything when run (OS X El Capitan)

Cool library! However I can't get the example in MVC.Prelude (with SDL and drawing rectangles) to run on my machine. It builds, but when I run it it just sits there, consuming 1 core but otherwise doing nothing until I kill it (the window doesn't even pop up). The other example (the simple one from MVC base) works fine, so I suspect it's something to do with SDL.

When I add some debug printing for SDL events (via 'Pipes.chain print'), I see that SDL only gets 1 or 2 events and then stops (a MouseMotion event, and sometimes a window focus event). I've seen this sort of thing when trying to use the sdl2 library with the threaded RTS, but this one doesn't work even when single-threaded. I did try converting the example from SDL to the sdl2 library (which I assume is more modern...?), and surprisingly it worked perfectly (with the single-threaded RTS)!

Beyond this I don't know what could be wrong, sorry. If you have any debug suggestions I'd be happy to dig into it some more.

Versions: I have sdl (1.2.15) and sdl2 (2.0.4) installed using Homebrew.

Modify handles to process all targets

From edvo on /r/haskell:

Changing handles to handle all targets of the traversal also gives a much simpler implementation:

handles :: Traversal' a b -> View b -> View a
handles k (AsSink send_) = AsSink $ void . k (\x -> x <$ send_ x)

consumer has a delay effect

There is a delay effect when using consumer. Code to reproduce:

import           Control.Applicative
import           MVC
import qualified MVC.Prelude as MVC
import qualified Pipes.Prelude as Pipes

main :: IO ()
main = runMVC () (asPipe $ Pipes.takeWhile (/="q") >-> cat) ((,) <$> MVC.consumer Pipes.print <*> MVC.stdinLines)

which gives:
*Main> :main
1
2
"1"
3
"2"

"3"
q
*Main>

Sequencing Controllers

I wanted to sequence 2 controllers so that the second ran after the first was completely drained (to be able to send finalizer signals down the shute etc). I found myself digging into the core library to do it, by tweaking the Input <|>

sequenced :: Controller a -> Controller a -> Controller a
sequenced (AsInput c0) (AsInput c1) = AsInput (Input $ do
        r0 <- recv c0
        case r0 of
            Nothing -> recv c1
            Just a  -> return (Just a))

And this worked pretty well with applicative style:

test1 = runMVC () (asPipe cat)
 ((,) <$>
  pure (contramap show MVC.stdoutLines) <*>
  (sequenced <$>
   MVC.producer Single (each ['a'..'d']) <*>
   MVC.producer Single (each ['1'..'4'])))

Is there any other way to sequence Controllers? Or, alternatively, is there a way to lift the hood of the library a little whilst still preventing Controllers from being consumed elsewhere (which I fully appreciate and support)?

View composition using prisms doesn't work

See https://gist.github.com/bosu/53f2f5fdddd23ae486b8.

Changing "works" to "doesnt_work" at line 30 reproduces the bug for me (I get empty output).

Using ghc 7.10.1 with reasonably recent NixOS version.

Add `ManagedT`

Could allow an alternative definition of runMVC like this

runMVCT :: MonadIO m => s -> Model s a b -> Managed (ViewT m b, Controller a) -> m s

ViewT could be nice to have too

Add `asGetter`

It would have this type:

asGetter :: (Producer a (State s) () -> Producer b (State s) ()) -> Model s a b

This would allow users to take advantage of pipes-parse abstractions.

Update upper bounds of dependencies

Two dependency upper bounds are currently out of date:

• foldl: the bound is < 1.2, the current version on Hackage is 1.2.0
• transformers: the bound is < 0.5.0.0, the current version on Hackage is 0.5.2.0