gooey 0.0.0.0 → 0.1.0.0

raw patch · 2 files changed

+21/−24 lines, 2 filesdep −hashabledep ~renderablePVP ok

version bump matches the API change (PVP)

Dependencies removed: hashable

Dependency ranges changed: renderable

API changes (from Hackage documentation)

Files

• gooey.cabal +3/−4
• src/Control/GUI.hs +18/−20

@@ -10,7 +10,7 @@ -- PVP summary:      +-+------- breaking API changes --                   | | +----- non-breaking API additions --                   | | | +--- code changes with no API change-version:             0.0.0.0+version:             0.1.0.0  -- A short (one-line) description of the package. synopsis:            Graphical user interfaces that are renderable,@@ -63,9 +63,8 @@   -- Other library packages from which modules are imported.   build-depends:       base >=4.8 && <4.9,                        varying >= 0.1.4 && < 0.2,-                       renderable >= 0.0.0.2,-                       transformers >= 0.4 && < 0.5,-                       hashable >= 1.2 && < 1.3+                       renderable >= 0.1.0.0,+                       transformers >= 0.4 && < 0.5    -- Directories containing source files.   hs-source-dirs:      src

@@ -13,6 +13,8 @@  {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE FlexibleContexts #-}+{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE MultiParamTypeClasses #-} module Control.GUI (     -- * Definition     UX(..),@@ -30,8 +32,8 @@  import Control.Varying import Control.Monad.IO.Class+import Control.Arrow (first) import Data.Renderable-import Data.Hashable import Data.Monoid  --------------------------------------------------------------------------------@@ -46,7 +48,7 @@  -- | A UX is a functor by applying a function to the contained event's value. instance Functor (UX a) where-    fmap f (UX a b) = UX a $ (fmap f b)+    fmap f (UX a b) = UX a $ fmap f b  -- | A UX is an applicative if its left datatype is a monoid. It replies to -- 'pure' with an empty left value while the right value is the argument@@ -59,12 +61,7 @@ -- | A UX is renderable if its left value is also renderable. It inherits all -- Renderable type variables from its left value and simply renders that -- value.-instance Renderable a => Renderable (UX a b) where-    type RenderMonad (UX a b) = RenderMonad a-    type RenderRsrc (UX a b) = RenderRsrc a-    type RenderTfrm (UX a b) = RenderTfrm a-    nameOf (UX ui _) = nameOf ui-    cache rz rs (UX ui _) = cache rz rs ui+instance Composite a m r t => Composite (UX a b) m r t where     composite (UX ui _) = composite ui  -- | A GUI is a UX that varies over some domain. What this means is that a@@ -122,7 +119,7 @@ -- | Creates a new GUI displaying an interface that eventually produces a value. -- The type used to represent the user interface must have a 'Decomposable' -- instance, that way the resulting GUI\'s discrete values can be rendered.-gui :: (Monad m, Decomposable a m r t)+gui :: (Monad m, Composite a m r t)     => Var m i a     -- ^ The stream of a changing user interface.     -> Var m i (Event b)@@ -132,11 +129,11 @@     -> (a -> b -> c)     -- ^ The merging function that combines the interface's final value with the     -- value produced by the event stream.-    -> GUI m i [Element m r t] c+    -> GUI m i [(t, Element m r t)] c gui v ve f = GUI $ Var $ \i -> do     (a, v')  <- runVar v i     (e, ve') <- runVar ve i-    let ui = decompose a+    let ui = composite a     case e of         NoEvent -> return (UX ui NoEvent, runGUI $ gui v' ve' f)         Event b -> return (UX ui (Event $ f a b), pure $ UX [] $ Event $ f a b)@@ -148,18 +145,19 @@ -- same domain it\'s possible to tween GUIs. -------------------------------------------------------------------------------- -- | Transforms a GUI.-transformGUI :: (Monad m, Monad (RenderMonad t), Show t, Show (RenderTfrm t),-                 Hashable t, Hashable (RenderTfrm t), Monoid (RenderTfrm t),-                 Renderable t)-             => Var m i (RenderTfrm t)-             -- ^ The stream of a changing transformation.-             -> GUI m i t b-             -- ^ The GUI to transform.-             -> GUI m i [Element (RenderMonad t) (RenderRsrc t) (RenderTfrm t)] b+--transformGUI :: (Monad m, Monoid t, Composite a m r t)+--             => Var m i t+--             -- ^ The stream of a changing transformation.+--             -> GUI m i a b+--             -- ^ The GUI to transform.+--             -> GUI m i a b+transformGUI :: (Monad m, Monoid t)+             => Var m i t -> GUI m i [(t, d)] b -> GUI m i [(t, d)] b transformGUI vt g = GUI $ Var $ \i -> do     (UX ui e, v) <- runVar (runGUI g) i     (t, vt') <- runVar vt i-    return (UX [Element (t,ui)] e, runGUI $ transformGUI vt' $ GUI v)+    let ui' = map (first (mappend t)) ui+    return (UX ui' e, runGUI $ transformGUI vt' $ GUI v) -------------------------------------------------------------------------------- -- $combination -- Combining two GUIs creates a new GUI.