control-monad-free 0.4 → 0.5

raw patch · 6 files changed

+39/−18 lines, 6 filesdep +transformersdep ~basesetup-changedPVP ok

version bump matches the API change (PVP)

Dependencies added: transformers

Dependency ranges changed: base

API changes (from Hackage documentation)

Files

• Control/Monad/Free.hs +13/−4
• Control/Monad/Free/Improve.hs +1/−0
• Control/Monad/Free/Zip.hs +13/−8
• Setup.hs +2/−0
• Setup.lhs +0/−3
• control-monad-free.cabal +10/−3

@@ -7,9 +7,9 @@    module Control.Monad, -- * Free Monads    MonadFree(..),-   Free(..),+   Free(..), isPure, isImpure,    foldFree, foldFreeM,-   evalFree, mapFree,+   evalFree, mapFree, mapFreeM, -- * Free Monad Transformers    FreeT(..),    foldFreeT, foldFreeT', mapFreeT,@@ -56,6 +56,9 @@     Pure a    >>= f = f a     Impure fa >>= f = Impure (fmap (>>= f) fa) +isPure Pure{} = True; isPure _ = False+isImpure = not . isPure+ foldFree :: Functor f => (a -> b) -> (f b -> b) -> Free f a -> b foldFree pure _    (Pure   x) = pure x foldFree pure imp  (Impure x) = imp (fmap (foldFree pure imp) x)@@ -69,9 +72,11 @@ evalFree _ i (Impure x) = i x  mapFree :: (Functor f, Functor g) => (forall a. f a -> g a) -> Free f a -> Free g a-mapFree eta (Pure a)   = Pure a-mapFree eta (Impure x) = Impure (fmap (mapFree eta) (eta x))+mapFree eta = foldFree Pure (Impure . eta) +mapFreeM :: (Traversable f, Functor g, Monad m) => (forall a. f a -> m(g a)) -> Free f a -> m(Free g a)+mapFreeM eta = foldFreeM (return . Pure) (liftM Impure . eta)+ -- * Monad Transformer --   (built upon Luke Palmer control-monad-free hackage package) newtype FreeT f m a = FreeT { unFreeT :: m (Either a (f (FreeT f m a))) }@@ -94,6 +99,10 @@         case r of              Left  x  -> unFreeT $ f x              Right xc -> return . Right $ fmap (>>= f) xc++instance (Functor f, Monad m) => MonadFree f (FreeT f m) where+    wrap = FreeT . return . Right+    free = lift . unFreeT  instance (Functor f) => MonadTrans (FreeT f) where     lift = FreeT . liftM Left

@@ -11,6 +11,7 @@ {-# LANGUAGE Rank2Types #-} {-# LANGUAGE FlexibleContexts, FlexibleInstances #-} {-# LANGUAGE MultiParamTypeClasses #-}+{-# LANGUAGE OverlappingInstances #-}  module Control.Monad.Free.Improve (    C(..), rep, improve

@@ -1,21 +1,26 @@+{-# LANGUAGE CPP #-} module Control.Monad.Free.Zip (zipFree, zipFree_) where  import Control.Monad.Free+import Control.Monad.Trans+#ifdef TRANSFORMERS+import Control.Monad.Trans.State+#else import Control.Monad.State+#endif import Data.Foldable import Data.Traversable as T -zipFree :: (Traversable f, Eq (f ()), Monad m) => (a -> b -> m c) -> Free f a -> Free f b -> m (Free f c)-zipFree f (Pure a) (Pure b) = Pure `liftM` f a b+zipFree :: (Traversable f, Eq (f ()), Monad m) => (Free f a -> Free f b -> m (Free f c))+                                                -> Free f a -> Free f b -> m (Free f c) zipFree f m1@(Impure a) m2@(Impure b)-      | fmap (const ()) a == fmap (const ()) b = Impure `liftM` unsafeZipWithG (zipFree f) a b-zipFree _ _ _ = fail "zipFree: not the same structure"+      | fmap (const ()) a == fmap (const ()) b = Impure `liftM` unsafeZipWithG f a b+zipFree _ _ _ = fail "zipFree: structure mistmatch" -zipFree_ :: (Traversable f, Eq (f ()), Monad m) => (a -> b -> m ()) -> Free f a -> Free f b -> m ()-zipFree_ f (Pure a) (Pure b) = f a b+zipFree_ :: (Traversable f, Eq (f ()), Monad m) => (Free f a -> Free f b -> m ()) -> Free f a -> Free f b -> m () zipFree_ f m1@(Impure a) m2@(Impure b)-      | fmap (const ()) a == fmap (const ()) b = zipWithM_ (zipFree_ f) (toList a) (toList b)-zipFree_ _ _ _ = fail "zipFree: not the same structure"+      | fmap (const ()) a == fmap (const ()) b = zipWithM_ f (toList a) (toList b)+zipFree_ _ _ _ = fail "zipFree_: structure mismatch"   unsafeZipWithG :: (Traversable t1, Traversable t2, Monad m) => (a -> b -> m c) ->  t1 a -> t2 b -> m(t2 c)

@@ -0,0 +1,2 @@+import Distribution.Simple+main = defaultMain

@@ -1,3 +0,0 @@-#!/usr/bin/env runhaskell-> import Distribution.Simple-> main = defaultMain

@@ -1,5 +1,5 @@ name: control-monad-free-version: 0.4+version: 0.5 Cabal-Version:  >= 1.2.3 build-type: Simple license: PublicDomain@@ -18,11 +18,18 @@ category: Control, Monads stability: experimental +Flag transformers+   default: True  Library   buildable: True-  build-depends: base, mtl-  extensions:  StandaloneDeriving, Rank2Types, MultiParamTypeClasses, FlexibleInstances, FlexibleContexts, UndecidableInstances+  build-depends: base >= 2 && < 5+  if flag(transformers)+     build-depends: transformers+     cpp-options: -DTRANSFORMERS+  else+     build-depends: mtl+  extensions:  StandaloneDeriving, Rank2Types, MultiParamTypeClasses, FlexibleInstances, FlexibleContexts, UndecidableInstances, OverlappingInstances   exposed-modules:      Control.Monad.Free      Control.Monad.Free.Zip