control-monad-free 0.6.1 → 0.6.2

raw patch · 5 files changed

+47/−36 lines, 5 filesdep −prelude-extrasdep ~basesetup-changedPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

Dependencies removed: prelude-extras

Dependency ranges changed: base

API changes (from Hackage documentation)

Files

• Control/Monad/Free.hs +24/−19
• Control/Monad/Free/Improve.hs +0/−1
• Control/Monad/Free/Zip.hs +17/−8
• Setup.hs +0/−2
• control-monad-free.cabal +6/−6

@@ -4,9 +4,11 @@ {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE DeriveGeneric, DeriveDataTypeable #-} {-# LANGUAGE FlexibleInstances, FlexibleContexts, UndecidableInstances #-}+{-# OPTIONS -Wno-name-shadowing #-}  module Control.Monad.Free (    module Control.Monad,+   module Control.Monad.Fail, -- * Free Monads    MonadFree(..),    Free(..), isPure, isImpure,@@ -24,14 +26,16 @@   ) where  import Control.Applicative-import Control.Monad+import Control.Monad hiding (fail)+import Control.Monad.Fail import Control.Monad.Trans.Class import Control.Monad.IO.Class+import Data.Bifunctor import Data.Foldable+import Data.Functor.Classes import Data.Traversable as T import Data.Typeable (Typeable) import GHC.Generics (Generic)-import Prelude.Extras  -- | This type class generalizes over encodings of Free Monads. class (Functor f, Monad m) => MonadFree f m where@@ -44,26 +48,29 @@  data Free f a = Impure (f (Free f a)) | Pure a deriving (Generic, Typeable) -instance (Eq1 f) => Eq1 (Free f) where (==#) = (==)-instance (Eq a, Eq1 f) => Eq (Free f a) where- Pure a == Pure b = a == b- Impure a == Impure b = a ==# b- _ == _ = False+instance (Eq1 f) => Eq1 (Free f) where+ liftEq (==) (Pure a) (Pure b) = a == b+ liftEq (==) (Impure a) (Impure b) = liftEq (liftEq (==)) a b+ liftEq _ _ _ = False+instance (Eq a, Eq1 f) => Eq (Free f a) where (==) = eq1 -instance Ord1 f => Ord1 (Free f) where compare1 = compare+instance Ord1 f => Ord1 (Free f) where+  liftCompare _ Impure{} Pure{} = LT+  liftCompare _ Pure{} Impure{} = GT+  liftCompare compare (Pure   a) (Pure   b) = compare a b+  liftCompare compare (Impure a) (Impure b) = liftCompare (liftCompare compare) a b instance (Ord a, Ord1 f) => Ord (Free f a) where-  compare Impure{} Pure{} = LT-  compare Pure{} Impure{} = GT-  compare (Pure   a) (Pure   b) = compare a b-  compare (Impure a) (Impure b) = compare1 a b+  compare = compare1  instance (Show a, Show1 f) => Show (Free f a) where   showsPrec p (Pure   a) = showParen (p > 0) $ ("Pure "   ++) . showsPrec  11 a-  showsPrec p (Impure a) = showParen (p > 0) $ ("Impure " ++) . showsPrec1 11 a+  showsPrec p (Impure a) = showParen (p > 0) $ ("Impure " ++) . liftShowsPrec showsPrec showList 11 a  instance Functor f => Functor (Free f) where-    fmap f (Pure a)    = Pure   (f a)-    fmap f (Impure fa) = Impure (fmap (fmap f) fa)+  fmap f = go where+    go (Pure    a) = Pure (f a)+    go (Impure fa) = Impure (fmap go fa)+  {-# INLINE fmap #-}  instance (Functor f, Foldable f) => Foldable (Free f) where     foldMap f (Pure a)    = f a@@ -84,6 +91,7 @@   Impure f <*> x = Impure (fmap (<*> x) f)  +isPure, isImpure :: Free f a -> Bool isPure Pure{} = True; isPure _ = False isImpure = not . isPure @@ -130,11 +138,8 @@       f' (Left  x) = Left  <$> f x       f' (Right x) = Right <$> (traverse.traverse) f x -editEither l r = either (Left . l) (Right . r)-conj f = FreeT . f . unFreeT- instance (Functor f, Functor m) => Functor (FreeT f m) where-    fmap f = conj $ fmap (editEither f ((fmap.fmap) f))+    fmap f = FreeT . fmap (bimap f ((fmap.fmap) f)) . unFreeT  instance (Functor f, Functor a, Monad a) => Applicative (FreeT f a) where     pure = FreeT . return . Left

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

@@ -6,20 +6,29 @@ import Control.Monad.Trans.State import Data.Foldable import Data.Traversable as T+import Prelude hiding (fail) -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 f a b+zipFree+  :: (Traversable f, Eq (f ()), MonadFail m)+  => (Free f a -> Free f b -> m (Free f c))+  -> Free f a+  -> Free f b+  -> m (Free f c)+zipFree f (Impure a) (Impure b)+  | fmap (const ()) a == fmap (const ()) b = Impure `liftM` unsafeZipWithG f a b zipFree _ _ _ = fail "zipFree: structure mistmatch" -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_ f (toList a) (toList b)+zipFree_+  :: (Traversable f, Eq (f ()), MonadFail m)+  => (Free f a -> Free f b -> m ()) -> Free f a -> Free f b -> m ()+zipFree_ f (Impure a) (Impure b)+  | 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)+unsafeZipWithG+  :: (Traversable t1, Traversable t2, Monad m, MonadFail m)+  => (a -> b -> m c) -> t1 a -> t2 b -> m (t2 c) unsafeZipWithG f t1 t2  = evalStateT (T.mapM zipG' t2) (toList t1)        where zipG' y = do (x:xx) <- get                           put xx

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

@@ -1,6 +1,6 @@ name: control-monad-free-version: 0.6.1-Cabal-Version:  >= 1.6+version: 0.6.2+Cabal-Version:  >= 1.24 build-type: Simple license: PublicDomain author: Luke Palmer, Pepe Iborra@@ -16,8 +16,7 @@   synopsis: Free monads and monad transformers category: Control, Monads-stability: experimental-tested-with: GHC >= 6.8+stability: stable  source-repository head   type:     git@@ -25,8 +24,9 @@  Library   buildable: True-  build-depends: base >= 2 && < 5, transformers, prelude-extras-  extensions:  StandaloneDeriving, Rank2Types, MultiParamTypeClasses, FlexibleInstances, FlexibleContexts, UndecidableInstances, OverlappingInstances+  build-depends: base >= 4.9 && < 5, transformers+  default-language: Haskell2010+  default-extensions:  StandaloneDeriving, Rank2Types, MultiParamTypeClasses, FlexibleInstances, FlexibleContexts, UndecidableInstances   exposed-modules:      Control.Monad.Free      Control.Monad.Free.Zip