free 0.2.3 → 1.8.0

raw patch · 5 files changed

+226/−31 lines, 5 filesdep +comonads-fddep +mtldep ~comonad-transformersPVP ok

version bump matches the API change (PVP)

Dependencies added: comonads-fd, mtl

Dependency ranges changed: comonad-transformers

API changes (from Hackage documentation)

Files

• Control/Comonad/Cofree.hs +29/−13
• Control/Comonad/Cofree/Class.hs +71/−0
• Control/Monad/Free.hs +54/−14
• Control/Monad/Free/Class.hs +64/−0
• free.cabal +8/−4

@@ -1,4 +1,8 @@-{-# LANGUAGE CPP, FlexibleContexts, FlexibleInstances, UndecidableInstances #-}+{-# LANGUAGE CPP+           , FlexibleContexts+           , FlexibleInstances+           , UndecidableInstances+           , MultiParamTypeClasses #-} ----------------------------------------------------------------------------- -- | -- Module      :  Control.Comonad.Cofree@@ -7,15 +11,15 @@ -- -- Maintainer  :  Edward Kmett <ekmett@gmail.com> -- Stability   :  provisional--- Portability :  portable+-- Portability :  MPTCs, fundeps ----- Haskell 98 cofree comonads+-- Cofree comonads -- ---------------------------------------------------------------------------- module Control.Comonad.Cofree   ( Cofree(..)   , section-  , outCofree+  , unwrap   , coiter   , unfold   ) where@@ -23,6 +27,10 @@ import Control.Applicative import Control.Comonad import Control.Comonad.Trans.Class+import Control.Comonad.Cofree.Class+import Control.Comonad.Env.Class+import Control.Comonad.Store.Class+import Control.Comonad.Traced.Class import Data.Functor.Bind import Data.Distributive import Data.Foldable@@ -40,9 +48,6 @@  data Cofree f a = a :< f (Cofree f a) -outCofree :: Cofree f a -> f (Cofree f a)-outCofree (_ :< as) = as- coiter :: Functor f => (a -> f a) -> a -> Cofree f a coiter psi a = a :< (coiter psi <$> psi a) @@ -50,16 +55,19 @@ unfold f c = case f c of    (x, d) -> x :< fmap (unfold f) d +instance Functor f => ComonadCofree f (Cofree f) where+  unwrap (_ :< as) = as+ instance Distributive f => Distributive (Cofree f) where-  distribute w = fmap extract w :< fmap distribute (distribute (fmap outCofree w))+  distribute w = fmap extract w :< fmap distribute (collect unwrap w)  instance Functor f => Functor (Cofree f) where   fmap f (a :< as) = f a :< fmap (fmap f) as   b <$ (_ :< as) = b :< fmap (b <$) as  instance Functor f => Extend (Cofree f) where-  extend f w = f w :< fmap (extend f) (outCofree w)-  duplicate w = w :< fmap duplicate (outCofree w)+  extend f w = f w :< fmap (extend f) (unwrap w)+  duplicate w = w :< fmap duplicate (unwrap w)  instance Functor f => Comonad (Cofree f) where   extract (a :< _) = a@@ -114,9 +122,7 @@ instance Traversable1 f => Traversable1 (Cofree f) where   traverse1 f (a :< as) = (:<) <$> f a <.> traverse1 (traverse1 f) as - #ifdef GHC_TYPEABLE- instance (Typeable1 f) => Typeable1 (Cofree f) where   typeOf1 dfa = mkTyConApp cofreeTyCon [typeOf1 (f dfa)]     where@@ -150,5 +156,15 @@ cofreeDataType :: DataType cofreeDataType = mkDataType "Control.Comonad.Cofree.Cofree" [cofreeConstr] {-# NOINLINE cofreeDataType #-}- #endif++instance ComonadEnv e w => ComonadEnv e (Cofree w) where+  ask = ask . lower++instance ComonadStore s w => ComonadStore s (Cofree w) where+  pos (_ :< as) = pos as+  peek s (_ :< as) = extract (peek s as)+++instance ComonadTraced m w => ComonadTraced m (Cofree w) where+  trace m = trace m . lower

@@ -0,0 +1,71 @@+{-# LANGUAGE MultiParamTypeClasses+           , FunctionalDependencies+           , FlexibleInstances+           , UndecidableInstances #-}+-----------------------------------------------------------------------------+-- |+-- Module      :  Control.Comonad.Cofree.Class+-- Copyright   :  (C) 2008-2011 Edward Kmett+-- License     :  BSD-style (see the file LICENSE)+--+-- Maintainer  :  Edward Kmett <ekmett@gmail.com>+-- Stability   :  experimental+-- Portability :  fundeps, MPTCs+----------------------------------------------------------------------------+module Control.Comonad.Cofree.Class +  ( ComonadCofree(..)+  ) where++import Control.Applicative+import Control.Comonad+import qualified Control.Comonad.Trans.Env.Strict as Strict+import qualified Control.Comonad.Trans.Store.Strict as Strict+import qualified Control.Comonad.Trans.Discont.Strict as Strict+import qualified Control.Comonad.Trans.Env.Lazy as Lazy+import qualified Control.Comonad.Trans.Store.Lazy as Lazy+import qualified Control.Comonad.Trans.Discont.Lazy as Lazy+import qualified Control.Comonad.Trans.Traced as Simple+import qualified Control.Comonad.Trans.Traced.Memo as Memo+import qualified Control.Comonad.Trans.Store.Memo as Memo+import qualified Control.Comonad.Trans.Discont.Memo as Memo+import Control.Comonad.Trans.Identity +import Data.Monoid+import Data.Semigroup++class (Functor f, Comonad w) => ComonadCofree f w | w -> f where+  unwrap :: w a -> f (w a)++instance ComonadCofree f w => ComonadCofree f (IdentityT w) where+  unwrap = fmap IdentityT . unwrap . runIdentityT+  +instance ComonadCofree f w => ComonadCofree f (Strict.EnvT e w) where+  unwrap (Strict.EnvT e wa) = Strict.EnvT e <$> unwrap wa++instance ComonadCofree f w => ComonadCofree f (Lazy.EnvT e w) where+  unwrap (Lazy.EnvT e wa) = Lazy.EnvT e <$> unwrap wa++instance ComonadCofree f w => ComonadCofree f (Strict.StoreT s w) where+  unwrap (Strict.StoreT wsa s) = flip Strict.StoreT s <$> unwrap wsa++instance ComonadCofree f w => ComonadCofree f (Lazy.StoreT s w) where+  unwrap (Lazy.StoreT wsa s) = flip Lazy.StoreT s <$> unwrap wsa++instance ComonadCofree f w => ComonadCofree f (Memo.StoreT s w) where+  unwrap w = flip Memo.storeT s <$> unwrap wsa+    where (wsa, s) = Memo.runStoreT w++instance (ComonadCofree f w, Semigroup m, Monoid m) => ComonadCofree f (Simple.TracedT m w) where+  unwrap (Simple.TracedT wma) = Simple.TracedT <$> unwrap wma++instance (ComonadCofree f w, Semigroup m, Monoid m) => ComonadCofree f (Memo.TracedT m w) where+  unwrap = fmap Memo.tracedT . unwrap . Memo.runTracedT++instance ComonadCofree f w => ComonadCofree f (Strict.DiscontT k w) where+  unwrap (Strict.DiscontT f ws) = Strict.DiscontT f <$> unwrap ws++instance ComonadCofree f w => ComonadCofree f (Lazy.DiscontT k w) where+  unwrap (Lazy.DiscontT f ws) = Lazy.DiscontT f <$> unwrap ws++instance ComonadCofree f w => ComonadCofree f (Memo.DiscontT k w) where+  unwrap w = Memo.discontT f <$> unwrap wa+    where (f, wa) = Memo.runDiscontT w

@@ -1,26 +1,37 @@-{-# LANGUAGE FlexibleContexts, FlexibleInstances, UndecidableInstances #-}+{-# LANGUAGE FlexibleContexts+           , FlexibleInstances+           , UndecidableInstances+	   , MultiParamTypeClasses #-} ----------------------------------------------------------------------------- -- | -- Module      :  Control.Monad.Free--- Copyright   :  (C) 2008-2011 Edward Kmett,+-- Copyright   :  (C) 2008-2011 Edward Kmett -- License     :  BSD-style (see the file LICENSE) -- -- Maintainer  :  Edward Kmett <ekmett@gmail.com> -- Stability   :  provisional--- Portability :  portable+-- Portability :  MPTCs, fundeps ----- Haskell 98 free monads+-- Free monads -- ---------------------------------------------------------------------------- module Control.Monad.Free-  ( Free(..)+  ( MonadFree(..)+  , Free(..)   , retract+  , liftF   , iter   ) where  import Control.Applicative import Control.Monad (liftM, MonadPlus(..)) import Control.Monad.Trans.Class+import Control.Monad.Free.Class+import Control.Monad.Reader.Class+import Control.Monad.Writer.Class+import Control.Monad.State.Class+import Control.Monad.Error.Class+import Control.Monad.Cont.Class import Data.Functor.Bind import Data.Foldable import Data.Traversable@@ -29,10 +40,6 @@  data Free f a = Pure a | Free (f (Free f a)) -iter :: Functor f => (f a -> a) -> Free f a -> a-iter _ (Pure a) = a-iter phi (Free m) = phi (iter phi <$> m)- instance (Eq (f (Free f a)), Eq a) => Eq (Free f a) where   Pure a == Pure b = a == b   Free fa == Free fb = fa == fb@@ -95,11 +102,6 @@ instance MonadTrans Free where   lift = Free . liftM Pure --- | retract . lift = id-retract :: Monad f => Free f a -> f a-retract (Pure a) = return a-retract (Free as) = as >>= retract- instance Foldable f => Foldable (Free f) where   foldMap f (Pure a) = f a   foldMap f (Free fa) = foldMap (foldMap f) fa@@ -115,3 +117,41 @@ instance Traversable1 f => Traversable1 (Free f) where   traverse1 f (Pure a) = Pure <$> f a   traverse1 f (Free fa) = Free <$> traverse1 (traverse1 f) fa++instance (Functor m, MonadWriter e m) => MonadWriter e (Free m) where+  tell = lift . tell+  listen = lift . listen . retract+  pass = lift . pass . retract+  +instance (Functor m, MonadReader e m) => MonadReader e (Free m) where+  ask = lift ask+  local f = lift . local f . retract+  +instance (Functor m, MonadState s m) => MonadState s (Free m) where+  get = lift get+  put s = lift (put s)++instance (Functor m, MonadError e m) => MonadError e (Free m) where+  throwError = lift . throwError+  catchError as f = lift (catchError (retract as) (retract . f))++instance (Functor m, MonadCont m) => MonadCont (Free m) where+  callCC f = lift (callCC (retract . f . liftM lift))++liftF :: Functor f => f a -> Free f a+liftF = Free . fmap Pure++instance Functor f => MonadFree f (Free f) where+  wrap = Free++-- | +--+-- > retract . lift = id+-- > retract . liftF = id+retract :: Monad f => Free f a -> f a+retract (Pure a) = return a+retract (Free as) = as >>= retract++iter :: Functor f => (f a -> a) -> Free f a -> a+iter _ (Pure a) = a+iter phi (Free m) = phi (iter phi <$> m)

@@ -0,0 +1,64 @@+{-# LANGUAGE MultiParamTypeClasses, FunctionalDependencies, FlexibleInstances, UndecidableInstances #-}+-----------------------------------------------------------------------------+-- |+-- Module      :  Control.Monad.Free.Class+-- Copyright   :  (C) 2008-2011 Edward Kmett+-- License     :  BSD-style (see the file LICENSE)+--+-- Maintainer  :  Edward Kmett <ekmett@gmail.com>+-- Stability   :  experimental+-- Portability :  non-portable (fundeps, MPTCs)+----------------------------------------------------------------------------+module Control.Monad.Free.Class +  ( MonadFree(..)+  ) where++import Control.Applicative+import Control.Monad.Trans.Reader+import qualified Control.Monad.Trans.State.Strict as Strict+import qualified Control.Monad.Trans.State.Lazy as Lazy+import qualified Control.Monad.Trans.Writer.Strict as Strict+import qualified Control.Monad.Trans.Writer.Lazy as Lazy+import qualified Control.Monad.Trans.RWS.Strict as Strict+import qualified Control.Monad.Trans.RWS.Lazy as Lazy+import Control.Monad.Trans.Maybe+import Control.Monad.Trans.List+import Control.Monad.Trans.Error+import Control.Monad.Trans.Identity +import Data.Monoid++class Monad m => MonadFree f m | m -> f where+  wrap :: f (m a) -> m a++instance (Functor f, MonadFree f m) => MonadFree f (ReaderT e m) where+  wrap fm = ReaderT $ \e -> wrap $ flip runReaderT e <$> fm++instance (Functor f, MonadFree f m) => MonadFree f (Lazy.StateT s m) where+  wrap fm = Lazy.StateT $ \s -> wrap $ flip Lazy.runStateT s <$> fm++instance (Functor f, MonadFree f m) => MonadFree f (Strict.StateT s m) where+  wrap fm = Strict.StateT $ \s -> wrap $ flip Strict.runStateT s <$> fm++instance (Functor f, MonadFree f m, Monoid w) => MonadFree f (Lazy.WriterT w m) where+  wrap = Lazy.WriterT . wrap . fmap Lazy.runWriterT++instance (Functor f, MonadFree f m, Monoid w) => MonadFree f (Strict.WriterT w m) where+  wrap = Strict.WriterT . wrap . fmap Strict.runWriterT++instance (Functor f, MonadFree f m, Monoid w) => MonadFree f (Strict.RWST r w s m) where+  wrap fm = Strict.RWST $ \r s -> wrap $ fmap (\m -> Strict.runRWST m r s) fm++instance (Functor f, MonadFree f m, Monoid w) => MonadFree f (Lazy.RWST r w s m) where+  wrap fm = Lazy.RWST $ \r s -> wrap $ fmap (\m -> Lazy.runRWST m r s) fm++instance (Functor f, MonadFree f m) => MonadFree f (MaybeT m) where+  wrap = MaybeT . wrap . fmap runMaybeT++instance (Functor f, MonadFree f m) => MonadFree f (IdentityT m) where+  wrap = IdentityT . wrap . fmap runIdentityT ++instance (Functor f, MonadFree f m) => MonadFree f (ListT m) where+  wrap = ListT . wrap . fmap runListT++instance (Functor f, MonadFree f m, Error e) => MonadFree f (ErrorT e m) where+  wrap = ErrorT . wrap . fmap runErrorT

@@ -1,6 +1,6 @@ name:          free category:      Control, Monads-version:       0.2.3+version:       1.8.0 license:       BSD3 cabal-version: >= 1.6 license-file:  LICENSE@@ -9,8 +9,8 @@ stability:     provisional homepage:      git://github.com/ekmett/free/ copyright:     Copyright (C) 2008-2011 Edward A. Kmett-synopsis:      Haskell 98 monads for free-description:   Haskell 98 monads for free+synopsis:      Monads for free+description:   Monads for free build-type:    Simple  source-repository head@@ -22,9 +22,11 @@     base >= 4 && < 4.4,     distributive >= 0.2 && < 0.3,     transformers >= 0.2.0 && <= 0.3,+    mtl >= 2.0.1.0 && < 2.1,     semigroupoids >= 1.2.2 && <= 1.3,     comonad >= 1.1 && < 1.2,-    comonad-transformers >= 1.6.3 && < 1.7,+    comonad-transformers >= 1.8 && < 1.9,+    comonads-fd >= 1.8 && < 1.9,     semigroups >= 0.5 && < 0.6    if impl(ghc)@@ -34,6 +36,8 @@    exposed-modules:     Control.Monad.Free+    Control.Monad.Free.Class     Control.Comonad.Cofree+    Control.Comonad.Cofree.Class    ghc-options:      -Wall