monads-fd 0.1.0.3 → 0.1.0.4

raw patch · 7 files changed

+560/−15 lines, 7 filesdep −mtldep ~basePVP: major bump suggested

API removals or changes: PVP suggests a major version bump

Dependencies removed: mtl

Dependency ranges changed: base

API changes (from Hackage documentation)

Files

• Control/Monad/Cont/Class.hs +76/−1
• Control/Monad/Error/Class.hs +113/−1
• Control/Monad/RWS/Class.hs +30/−4
• Control/Monad/Reader/Class.hs +104/−1
• Control/Monad/State/Class.hs +106/−1
• Control/Monad/Writer/Class.hs +119/−1
• monads-fd.cabal +12/−6

@@ -52,4 +52,79 @@     MonadCont(..),   ) where -import "mtl" Control.Monad.Cont.Class+import Control.Monad.Trans.Cont (ContT)+import qualified Control.Monad.Trans.Cont as ContT+import Control.Monad.Trans.Error as Error+import Control.Monad.Trans.Identity as Identity+import Control.Monad.Trans.List as List+import Control.Monad.Trans.Maybe as Maybe+import Control.Monad.Trans.Reader as Reader+import Control.Monad.Trans.RWS.Lazy as LazyRWS+import Control.Monad.Trans.RWS.Strict as StrictRWS+import Control.Monad.Trans.State.Lazy as LazyState+import Control.Monad.Trans.State.Strict as StrictState+import Control.Monad.Trans.Writer.Lazy as LazyWriter+import Control.Monad.Trans.Writer.Strict as StrictWriter++import Control.Monad+import Data.Monoid++class (Monad m) => MonadCont m where+    {- | @callCC@ (call-with-current-continuation)+    calls a function with the current continuation as its argument.+    Provides an escape continuation mechanism for use with Continuation monads.+    Escape continuations allow to abort the current computation and return+    a value immediately.+    They achieve a similar effect to 'Control.Monad.Error.throwError'+    and 'Control.Monad.Error.catchError'+    within an 'Control.Monad.Error.Error' monad.+    Advantage of this function over calling @return@ is that it makes+    the continuation explicit,+    allowing more flexibility and better control+    (see examples in "Control.Monad.Cont").++    The standard idiom used with @callCC@ is to provide a lambda-expression+    to name the continuation. Then calling the named continuation anywhere+    within its scope will escape from the computation,+    even if it is many layers deep within nested computations.+    -}+    callCC :: ((a -> m b) -> m a) -> m a++instance MonadCont (ContT r m) where+    callCC = ContT.callCC++-- ---------------------------------------------------------------------------+-- Instances for other mtl transformers++instance (Error e, MonadCont m) => MonadCont (ErrorT e m) where+    callCC = Error.liftCallCC callCC++instance (MonadCont m) => MonadCont (IdentityT m) where+    callCC = Identity.liftCallCC callCC++instance (MonadCont m) => MonadCont (ListT m) where+    callCC = List.liftCallCC callCC++instance (MonadCont m) => MonadCont (MaybeT m) where+    callCC = Maybe.liftCallCC callCC++instance (MonadCont m) => MonadCont (ReaderT r m) where+    callCC = Reader.liftCallCC callCC++instance (Monoid w, MonadCont m) => MonadCont (LazyRWS.RWST r w s m) where+    callCC = LazyRWS.liftCallCC' callCC++instance (Monoid w, MonadCont m) => MonadCont (StrictRWS.RWST r w s m) where+    callCC = StrictRWS.liftCallCC' callCC++instance (MonadCont m) => MonadCont (LazyState.StateT s m) where+    callCC = LazyState.liftCallCC' callCC++instance (MonadCont m) => MonadCont (StrictState.StateT s m) where+    callCC = StrictState.liftCallCC' callCC++instance (Monoid w, MonadCont m) => MonadCont (LazyWriter.WriterT w m) where+    callCC = LazyWriter.liftCallCC callCC++instance (Monoid w, MonadCont m) => MonadCont (StrictWriter.WriterT w m) where+    callCC = StrictWriter.liftCallCC callCC

@@ -1,3 +1,5 @@+{-# LANGUAGE UndecidableInstances #-}+ {- | Module      :  Control.Monad.Error.Class Copyright   :  (c) Michael Weber <michael.weber@post.rwth-aachen.de> 2001,@@ -36,4 +38,114 @@     MonadError(..),   ) where -import "mtl" Control.Monad.Error.Class+import Control.Monad.Trans.Error (Error(..), ErrorT)+import qualified Control.Monad.Trans.Error as ErrorT (throwError, catchError)+import Control.Monad.Trans.Identity as Identity+import Control.Monad.Trans.List as List+import Control.Monad.Trans.Maybe as Maybe+import Control.Monad.Trans.Reader as Reader+import Control.Monad.Trans.RWS.Lazy as LazyRWS+import Control.Monad.Trans.RWS.Strict as StrictRWS+import Control.Monad.Trans.State.Lazy as LazyState+import Control.Monad.Trans.State.Strict as StrictState+import Control.Monad.Trans.Writer.Lazy as LazyWriter+import Control.Monad.Trans.Writer.Strict as StrictWriter++import Control.Monad.Trans.Class (lift)+import Control.Exception (IOException)+import Control.Monad+import Control.Monad.Instances ()+import Data.Monoid++{- |+The strategy of combining computations that can throw exceptions+by bypassing bound functions+from the point an exception is thrown to the point that it is handled.++Is parameterized over the type of error information and+the monad type constructor.+It is common to use @'Data.Either' String@ as the monad type constructor+for an error monad in which error descriptions take the form of strings.+In that case and many other common cases the resulting monad is already defined+as an instance of the 'MonadError' class.+You can also define your own error type and\/or use a monad type constructor+other than @'Either' 'String'@ or @'Either' 'IOError'@.+In these cases you will have to explicitly define instances of the 'Error'+and\/or 'MonadError' classes.+-}+class (Monad m) => MonadError e m | m -> e where+    -- | Is used within a monadic computation to begin exception processing.+    throwError :: e -> m a++    {- |+    A handler function to handle previous errors and return to normal execution.+    A common idiom is:++    > do { action1; action2; action3 } `catchError` handler++    where the @action@ functions can call 'throwError'.+    Note that @handler@ and the do-block must have the same return type.+    -}+    catchError :: m a -> (e -> m a) -> m a++instance MonadError IOException IO where+    throwError = ioError+    catchError = catch++-- ---------------------------------------------------------------------------+-- Our parameterizable error monad++instance (Error e) => MonadError e (Either e) where+    throwError             = Left+    Left  l `catchError` h = h l+    Right r `catchError` _ = Right r++instance (Monad m, Error e) => MonadError e (ErrorT e m) where+    throwError = ErrorT.throwError+    catchError = ErrorT.catchError++-- ---------------------------------------------------------------------------+-- Instances for other mtl transformers+--+-- All of these instances need UndecidableInstances,+-- because they do not satisfy the coverage condition.++instance (MonadError e m) => MonadError e (IdentityT m) where+    throwError = lift . throwError+    catchError = Identity.liftCatch catchError++instance (MonadError e m) => MonadError e (ListT m) where+    throwError = lift . throwError+    catchError = List.liftCatch catchError++instance (MonadError e m) => MonadError e (MaybeT m) where+    throwError = lift . throwError+    catchError = Maybe.liftCatch catchError++instance (MonadError e m) => MonadError e (ReaderT r m) where+    throwError = lift . throwError+    catchError = Reader.liftCatch catchError++instance (Monoid w, MonadError e m) => MonadError e (LazyRWS.RWST r w s m) where+    throwError = lift . throwError+    catchError = LazyRWS.liftCatch catchError++instance (Monoid w, MonadError e m) => MonadError e (StrictRWS.RWST r w s m) where+    throwError = lift . throwError+    catchError = StrictRWS.liftCatch catchError++instance (MonadError e m) => MonadError e (LazyState.StateT s m) where+    throwError = lift . throwError+    catchError = LazyState.liftCatch catchError++instance (MonadError e m) => MonadError e (StrictState.StateT s m) where+    throwError = lift . throwError+    catchError = StrictState.liftCatch catchError++instance (Monoid w, MonadError e m) => MonadError e (LazyWriter.WriterT w m) where+    throwError = lift . throwError+    catchError = LazyWriter.liftCatch catchError++instance (Monoid w, MonadError e m) => MonadError e (StrictWriter.WriterT w m) where+    throwError = lift . throwError+    catchError = StrictWriter.liftCatch catchError

@@ -1,3 +1,6 @@+{-# LANGUAGE UndecidableInstances #-}+-- Search for UndecidableInstances to see why this is needed+ ----------------------------------------------------------------------------- -- | -- Module      :  Control.Monad.RWS.Class@@ -25,7 +28,30 @@     module Control.Monad.Writer.Class,   ) where -import "mtl" Control.Monad.RWS.Class-import "mtl" Control.Monad.Reader.Class-import "mtl" Control.Monad.State.Class-import "mtl" Control.Monad.Writer.Class+import Control.Monad.Reader.Class+import Control.Monad.State.Class+import Control.Monad.Writer.Class++import Control.Monad.Trans.Error(Error, ErrorT)+import Control.Monad.Trans.Maybe(MaybeT)+import Control.Monad.Trans.Identity(IdentityT)+import Control.Monad.Trans.RWS.Lazy as Lazy (RWST)+import qualified Control.Monad.Trans.RWS.Strict as Strict (RWST)++import Data.Monoid++class (Monoid w, MonadReader r m, MonadWriter w m, MonadState s m)+   => MonadRWS r w s m | m -> r, m -> w, m -> s++instance (Monoid w, Monad m) => MonadRWS r w s (Lazy.RWST r w s m)+instance (Monoid w, Monad m) => MonadRWS r w s (Strict.RWST r w s m)+ +---------------------------------------------------------------------------+-- Instances for other mtl transformers+--+-- All of these instances need UndecidableInstances,+-- because they do not satisfy the coverage condition.+ +instance (Error e, MonadRWS r w s m) => MonadRWS r w s (ErrorT e m)+instance (MonadRWS r w s m) => MonadRWS r w s (IdentityT m)+instance (MonadRWS r w s m) => MonadRWS r w s (MaybeT m)

@@ -1,3 +1,5 @@+{-# LANGUAGE UndecidableInstances #-}+-- Search for UndecidableInstances to see why this is needed {- | Module      :  Control.Monad.Reader.Class Copyright   :  (c) Andy Gill 2001,@@ -41,4 +43,105 @@     asks,     ) where -import "mtl" Control.Monad.Reader.Class+import Control.Monad.Trans.Cont as Cont+import Control.Monad.Trans.Error+import Control.Monad.Trans.Identity+import Control.Monad.Trans.List+import Control.Monad.Trans.Maybe+import Control.Monad.Trans.Reader (ReaderT)+import qualified Control.Monad.Trans.Reader as ReaderT (ask, local)+import qualified Control.Monad.Trans.RWS.Lazy as LazyRWS (RWST, ask, local)+import qualified Control.Monad.Trans.RWS.Strict as StrictRWS (RWST, ask, local)+import Control.Monad.Trans.State.Lazy as Lazy+import Control.Monad.Trans.State.Strict as Strict+import Control.Monad.Trans.Writer.Lazy as Lazy+import Control.Monad.Trans.Writer.Strict as Strict++import Control.Monad.Trans.Class (lift)+import Control.Monad+import Data.Monoid++-- ----------------------------------------------------------------------------+-- class MonadReader+--  asks for the internal (non-mutable) state.++-- | See examples in "Control.Monad.Reader".+-- Note, the partially applied function type @(->) r@ is a simple reader monad.+-- See the @instance@ declaration below.+class (Monad m) => MonadReader r m | m -> r where+    -- | Retrieves the monad environment.+    ask   :: m r++    -- | Executes a computation in a modified environment.+    local :: (r -> r)	-- ^ The function to modify the environment.+          -> m a	-- ^ @Reader@ to run in the modified environment.+          -> m a++-- | Retrieves a function of the current environment.+asks :: (MonadReader r m)+    => (r -> a)		-- ^ The selector function to apply to the environment.+    -> m a+asks f = do+    r <- ask+    return (f r)++-- ----------------------------------------------------------------------------+-- The partially applied function type is a simple reader monad++instance MonadReader r ((->) r) where+    ask       = id+    local f m = m . f++instance (Monad m) => MonadReader r (ReaderT r m) where+    ask = ReaderT.ask+    local = ReaderT.local++instance (Monad m, Monoid w) => MonadReader r (LazyRWS.RWST r w s m) where+    ask = LazyRWS.ask+    local = LazyRWS.local++instance (Monad m, Monoid w) => MonadReader r (StrictRWS.RWST r w s m) where+    ask = StrictRWS.ask+    local = StrictRWS.local++-- ---------------------------------------------------------------------------+-- Instances for other mtl transformers+--+-- All of these instances need UndecidableInstances,+-- because they do not satisfy the coverage condition.++instance (MonadReader r' m) => MonadReader r' (ContT r m) where+    ask   = lift ask+    local = Cont.liftLocal ask local++instance (Error e, MonadReader r m) => MonadReader r (ErrorT e m) where+    ask   = lift ask+    local = mapErrorT . local++instance (MonadReader r m) => MonadReader r (IdentityT m) where+    ask   = lift ask+    local = mapIdentityT . local++instance (MonadReader r m) => MonadReader r (ListT m) where+    ask   = lift ask+    local = mapListT . local++instance (MonadReader r m) => MonadReader r (MaybeT m) where+    ask   = lift ask+    local = mapMaybeT . local++instance (MonadReader r m) => MonadReader r (Lazy.StateT s m) where+    ask   = lift ask+    local = Lazy.mapStateT . local++instance (MonadReader r m) => MonadReader r (Strict.StateT s m) where+    ask   = lift ask+    local = Strict.mapStateT . local++instance (Monoid w, MonadReader r m) => MonadReader r (Lazy.WriterT w m) where+    ask   = lift ask+    local = Lazy.mapWriterT . local++instance (Monoid w, MonadReader r m) => MonadReader r (Strict.WriterT w m) where+    ask   = lift ask+    local = Strict.mapWriterT . local

@@ -1,3 +1,6 @@+{-# LANGUAGE UndecidableInstances #-}+-- Search for UndecidableInstances to see why this is needed+ ----------------------------------------------------------------------------- -- | -- Module      :  Control.Monad.State.Class@@ -25,4 +28,106 @@     gets,   ) where -import "mtl" Control.Monad.State.Class+import Control.Monad.Trans.Cont+import Control.Monad.Trans.Error+import Control.Monad.Trans.Identity+import Control.Monad.Trans.List+import Control.Monad.Trans.Maybe+import Control.Monad.Trans.Reader+import qualified Control.Monad.Trans.RWS.Lazy as LazyRWS (RWST, get, put)+import qualified Control.Monad.Trans.RWS.Strict as StrictRWS (RWST, get, put)+import qualified Control.Monad.Trans.State.Lazy as Lazy (StateT, get, put)+import qualified Control.Monad.Trans.State.Strict as Strict (StateT, get, put)+import Control.Monad.Trans.Writer.Lazy as Lazy+import Control.Monad.Trans.Writer.Strict as Strict++import Control.Monad.Trans.Class (lift)+import Control.Monad+import Data.Monoid++-- ---------------------------------------------------------------------------++class (Monad m) => MonadState s m | m -> s where+    -- | Return the state from the internals of the monad.+    get :: m s+    -- | Replace the state inside the monad.+    put :: s -> m ()++-- | Monadic state transformer.+--+--      Maps an old state to a new state inside a state monad.+--      The old state is thrown away.+--+-- >      Main> :t modify ((+1) :: Int -> Int)+-- >      modify (...) :: (MonadState Int a) => a ()+--+--    This says that @modify (+1)@ acts over any+--    Monad that is a member of the @MonadState@ class,+--    with an @Int@ state.++modify :: (MonadState s m) => (s -> s) -> m ()+modify f = do+    s <- get+    put (f s)++-- | Gets specific component of the state, using a projection function+-- supplied.++gets :: (MonadState s m) => (s -> a) -> m a+gets f = do+    s <- get+    return (f s)++instance (Monad m) => MonadState s (Lazy.StateT s m) where+    get = Lazy.get+    put = Lazy.put++instance (Monad m) => MonadState s (Strict.StateT s m) where+    get = Strict.get+    put = Strict.put++instance (Monad m, Monoid w) => MonadState s (LazyRWS.RWST r w s m) where+    get = LazyRWS.get+    put = LazyRWS.put++instance (Monad m, Monoid w) => MonadState s (StrictRWS.RWST r w s m) where+    get = StrictRWS.get+    put = StrictRWS.put++-- ---------------------------------------------------------------------------+-- Instances for other mtl transformers+--+-- All of these instances need UndecidableInstances,+-- because they do not satisfy the coverage condition.++instance (MonadState s m) => MonadState s (ContT r m) where+    get = lift get+    put = lift . put++instance (Error e, MonadState s m) => MonadState s (ErrorT e m) where+    get = lift get+    put = lift . put++instance (MonadState s m) => MonadState s (IdentityT m) where+    get = lift get+    put = lift . put++instance (MonadState s m) => MonadState s (ListT m) where+    get = lift get+    put = lift . put++instance (MonadState s m) => MonadState s (MaybeT m) where+    get = lift get+    put = lift . put++instance (MonadState s m) => MonadState s (ReaderT r m) where+    get = lift get+    put = lift . put++instance (Monoid w, MonadState s m) => MonadState s (Lazy.WriterT w m) where+    get = lift get+    put = lift . put++instance (Monoid w, MonadState s m) => MonadState s (Strict.WriterT w m) where+    get = lift get+    put = lift . put

@@ -1,3 +1,6 @@+{-# LANGUAGE UndecidableInstances #-}+-- Search for UndecidableInstances to see why this is needed+ ----------------------------------------------------------------------------- -- | -- Module      :  Control.Monad.Writer.Class@@ -24,4 +27,119 @@     censor,   ) where -import "mtl" Control.Monad.Writer.Class+import Control.Monad.Trans.Error as Error+import Control.Monad.Trans.Identity as Identity+import Control.Monad.Trans.Maybe as Maybe+import Control.Monad.Trans.Reader+import qualified Control.Monad.Trans.RWS.Lazy as LazyRWS (+        RWST, tell, listen, pass)+import qualified Control.Monad.Trans.RWS.Strict as StrictRWS (+        RWST, tell, listen, pass)+import Control.Monad.Trans.State.Lazy as Lazy+import Control.Monad.Trans.State.Strict as Strict+import qualified Control.Monad.Trans.Writer.Lazy as Lazy (+        WriterT, tell, listen, pass)+import qualified Control.Monad.Trans.Writer.Strict as Strict (+        WriterT, tell, listen, pass)++import Control.Monad.Trans.Class (lift)+import Control.Monad+import Data.Monoid++-- ---------------------------------------------------------------------------+-- MonadWriter class+--+-- tell is like tell on the MUD's it shouts to monad+-- what you want to be heard. The monad carries this 'packet'+-- upwards, merging it if needed (hence the Monoid requirement).+--+-- listen listens to a monad acting, and returns what the monad "said".+--+-- pass lets you provide a writer transformer which changes internals of+-- the written object.++class (Monoid w, Monad m) => MonadWriter w m | m -> w where+    -- | @'tell' w@ is an action that produces the output @w@.+    tell   :: w -> m ()+    -- | @'listen' m@ is an action that executes the action @m@ and adds+    -- its output to the value of the computation.+    listen :: m a -> m (a, w)+    -- | @'pass' m@ is an action that executes the action @m@, which+    -- returns a value and a function, and returns the value, applying+    -- the function to the output.+    pass   :: m (a, w -> w) -> m a++-- | @'listens' f m@ is an action that executes the action @m@ and adds+-- the result of applying @f@ to the output to the value of the computation.+--+-- * @'listens' f m = 'liftM' (id *** f) ('listen' m)@+listens :: (MonadWriter w m) => (w -> b) -> m a -> m (a, b)+listens f m = do+    ~(a, w) <- listen m+    return (a, f w)++-- | @'censor' f m@ is an action that executes the action @m@ and+-- applies the function @f@ to its output, leaving the return value+-- unchanged.+--+-- * @'censor' f m = 'pass' ('liftM' (\\x -> (x,f)) m)@+censor :: (MonadWriter w m) => (w -> w) -> m a -> m a+censor f m = pass $ do+    a <- m+    return (a, f)++instance (Monoid w, Monad m) => MonadWriter w (Lazy.WriterT w m) where+    tell   = Lazy.tell+    listen = Lazy.listen+    pass   = Lazy.pass++instance (Monoid w, Monad m) => MonadWriter w (Strict.WriterT w m) where+    tell   = Strict.tell+    listen = Strict.listen+    pass   = Strict.pass++instance (Monoid w, Monad m) => MonadWriter w (LazyRWS.RWST r w s m) where+    tell   = LazyRWS.tell+    listen = LazyRWS.listen+    pass   = LazyRWS.pass++instance (Monoid w, Monad m) => MonadWriter w (StrictRWS.RWST r w s m) where+    tell   = StrictRWS.tell+    listen = StrictRWS.listen+    pass   = StrictRWS.pass++-- ---------------------------------------------------------------------------+-- Instances for other mtl transformers+--+-- All of these instances need UndecidableInstances,+-- because they do not satisfy the coverage condition.++instance (Error e, MonadWriter w m) => MonadWriter w (ErrorT e m) where+    tell   = lift . tell+    listen = Error.liftListen listen+    pass   = Error.liftPass pass++instance (MonadWriter w m) => MonadWriter w (IdentityT m) where+    tell   = lift . tell+    listen = Identity.mapIdentityT listen+    pass   = Identity.mapIdentityT pass++instance (MonadWriter w m) => MonadWriter w (MaybeT m) where+    tell   = lift . tell+    listen = Maybe.liftListen listen+    pass   = Maybe.liftPass pass++instance (MonadWriter w m) => MonadWriter w (ReaderT r m) where+    tell   = lift . tell+    listen = mapReaderT listen+    pass   = mapReaderT pass++instance (MonadWriter w m) => MonadWriter w (Lazy.StateT s m) where+    tell   = lift . tell+    listen = Lazy.liftListen listen+    pass   = Lazy.liftPass pass++instance (MonadWriter w m) => MonadWriter w (Strict.StateT s m) where+    tell   = lift . tell+    listen = Strict.liftListen listen+    pass   = Strict.liftPass pass

@@ -1,5 +1,5 @@ name:         monads-fd-version:      0.1.0.3+version:      0.1.0.4 cabal-version: >= 1.6 license:      BSD3 license-file: LICENSE@@ -8,9 +8,13 @@ category:     Control synopsis:     Monad classes, using functional dependencies description:-    Now that @mtl@ has been upgraded to depend on @transformers@,-    this package is a backwards compatibility stub re-exporting the-    @mtl@ package.+    Monad classes using functional dependencies, with instances+    for various monad transformers, inspired by the paper+    /Functional Programming with Overloading and Higher-Order Polymorphism/,+    by Mark P Jones, in /Advanced School of Functional Programming/, 1995+    (<http://web.cecs.pdx.edu/~mpj/pubs/springschool.html>).+    .+    This package is almost a compatible replacement for the @mtl@ package. build-type: Simple  Library@@ -36,6 +40,8 @@     Control.Monad.Writer.Class     Control.Monad.Writer.Lazy     Control.Monad.Writer.Strict-  build-depends: base < 6, transformers == 0.2.*, mtl == 2.*+  build-depends: base < 6, transformers == 0.2.*   extensions:-    PackageImports+    MultiParamTypeClasses+    FunctionalDependencies+    FlexibleInstances