monads-tf 0.0.0.1 → 0.1.0.0
raw patch · 5 files changed
+79/−6 lines, 5 filesdep ~basedep ~transformersPVP ok
version bump matches the API change (PVP)
Dependency ranges changed: base, transformers
API changes (from Hackage documentation)
- Control.Monad.Cont.Class: instance (Monad m) => MonadCont (ContT r m)
- Control.Monad.Cont.Class: instance (MonadCont m) => MonadCont (IdentityT m)
- Control.Monad.Cont.Class: instance (MonadCont m) => MonadCont (ListT m)
- Control.Monad.Cont.Class: instance (MonadCont m) => MonadCont (MaybeT m)
- Control.Monad.Cont.Class: instance (MonadCont m) => MonadCont (ReaderT r m)
- Control.Monad.Cont.Class: instance (MonadCont m) => MonadCont (StateT s m)
- Control.Monad.Error.Class: instance (Error e) => MonadError (Either e)
- Control.Monad.Error.Class: instance (MonadError m) => MonadError (IdentityT m)
- Control.Monad.Error.Class: instance (MonadError m) => MonadError (ListT m)
- Control.Monad.Error.Class: instance (MonadError m) => MonadError (MaybeT m)
- Control.Monad.Error.Class: instance (MonadError m) => MonadError (ReaderT r m)
- Control.Monad.Error.Class: instance (MonadError m) => MonadError (StateT s m)
- Control.Monad.RWS.Class: instance (MonadRWS m) => MonadRWS (IdentityT m)
- Control.Monad.RWS.Class: instance (MonadRWS m) => MonadRWS (MaybeT m)
- Control.Monad.Reader.Class: instance (Monad m) => MonadReader (ReaderT r m)
- Control.Monad.Reader.Class: instance (MonadReader m) => MonadReader (ContT r m)
- Control.Monad.Reader.Class: instance (MonadReader m) => MonadReader (IdentityT m)
- Control.Monad.Reader.Class: instance (MonadReader m) => MonadReader (ListT m)
- Control.Monad.Reader.Class: instance (MonadReader m) => MonadReader (MaybeT m)
- Control.Monad.Reader.Class: instance (MonadReader m) => MonadReader (StateT s m)
- Control.Monad.State.Class: instance (Monad m) => MonadState (StateT s m)
- Control.Monad.State.Class: instance (MonadState m) => MonadState (ContT r m)
- Control.Monad.State.Class: instance (MonadState m) => MonadState (IdentityT m)
- Control.Monad.State.Class: instance (MonadState m) => MonadState (ListT m)
- Control.Monad.State.Class: instance (MonadState m) => MonadState (MaybeT m)
- Control.Monad.State.Class: instance (MonadState m) => MonadState (ReaderT r m)
- Control.Monad.Writer.Class: instance (MonadWriter m) => MonadWriter (IdentityT m)
- Control.Monad.Writer.Class: instance (MonadWriter m) => MonadWriter (MaybeT m)
- Control.Monad.Writer.Class: instance (MonadWriter m) => MonadWriter (ReaderT r m)
- Control.Monad.Writer.Class: instance (MonadWriter m) => MonadWriter (StateT s m)
+ Control.Monad.Cont.Class: instance MonadCont (ContT r m)
+ Control.Monad.Cont.Class: instance MonadCont m => MonadCont (IdentityT m)
+ Control.Monad.Cont.Class: instance MonadCont m => MonadCont (ListT m)
+ Control.Monad.Cont.Class: instance MonadCont m => MonadCont (MaybeT m)
+ Control.Monad.Cont.Class: instance MonadCont m => MonadCont (ReaderT r m)
+ Control.Monad.Cont.Class: instance MonadCont m => MonadCont (StateT s m)
+ Control.Monad.Error.Class: instance Error e => MonadError (Either e)
+ Control.Monad.Error.Class: instance MonadError m => MonadError (IdentityT m)
+ Control.Monad.Error.Class: instance MonadError m => MonadError (ListT m)
+ Control.Monad.Error.Class: instance MonadError m => MonadError (MaybeT m)
+ Control.Monad.Error.Class: instance MonadError m => MonadError (ReaderT r m)
+ Control.Monad.Error.Class: instance MonadError m => MonadError (StateT s m)
+ Control.Monad.RWS.Class: instance MonadRWS m => MonadRWS (IdentityT m)
+ Control.Monad.RWS.Class: instance MonadRWS m => MonadRWS (MaybeT m)
+ Control.Monad.Reader.Class: instance Monad m => MonadReader (ReaderT r m)
+ Control.Monad.Reader.Class: instance MonadReader m => MonadReader (ContT r m)
+ Control.Monad.Reader.Class: instance MonadReader m => MonadReader (IdentityT m)
+ Control.Monad.Reader.Class: instance MonadReader m => MonadReader (ListT m)
+ Control.Monad.Reader.Class: instance MonadReader m => MonadReader (MaybeT m)
+ Control.Monad.Reader.Class: instance MonadReader m => MonadReader (StateT s m)
+ Control.Monad.State.Class: instance Monad m => MonadState (StateT s m)
+ Control.Monad.State.Class: instance MonadState m => MonadState (ContT r m)
+ Control.Monad.State.Class: instance MonadState m => MonadState (IdentityT m)
+ Control.Monad.State.Class: instance MonadState m => MonadState (ListT m)
+ Control.Monad.State.Class: instance MonadState m => MonadState (MaybeT m)
+ Control.Monad.State.Class: instance MonadState m => MonadState (ReaderT r m)
+ Control.Monad.Writer.Class: instance MonadWriter m => MonadWriter (IdentityT m)
+ Control.Monad.Writer.Class: instance MonadWriter m => MonadWriter (MaybeT m)
+ Control.Monad.Writer.Class: instance MonadWriter m => MonadWriter (ReaderT r m)
+ Control.Monad.Writer.Class: instance MonadWriter m => MonadWriter (StateT s m)
- Control.Monad.Cont: callCC :: (MonadCont m) => ((a -> m b) -> m a) -> m a
+ Control.Monad.Cont: callCC :: MonadCont m => ((a -> m b) -> m a) -> m a
- Control.Monad.Cont: class (Monad m) => MonadCont m
+ Control.Monad.Cont: class Monad m => MonadCont m
- Control.Monad.Cont.Class: callCC :: (MonadCont m) => ((a -> m b) -> m a) -> m a
+ Control.Monad.Cont.Class: callCC :: MonadCont m => ((a -> m b) -> m a) -> m a
- Control.Monad.Cont.Class: class (Monad m) => MonadCont m
+ Control.Monad.Cont.Class: class Monad m => MonadCont m
- Control.Monad.Error: catchError :: (MonadError m) => m a -> (ErrorType m -> m a) -> m a
+ Control.Monad.Error: catchError :: MonadError m => m a -> (ErrorType m -> m a) -> m a
- Control.Monad.Error: class (Monad m) => MonadError m where { type family ErrorType m; }
+ Control.Monad.Error: class Monad m => MonadError m where { type family ErrorType m; }
- Control.Monad.Error: throwError :: (MonadError m) => ErrorType m -> m a
+ Control.Monad.Error: throwError :: MonadError m => ErrorType m -> m a
- Control.Monad.Error.Class: catchError :: (MonadError m) => m a -> (ErrorType m -> m a) -> m a
+ Control.Monad.Error.Class: catchError :: MonadError m => m a -> (ErrorType m -> m a) -> m a
- Control.Monad.Error.Class: class (Monad m) => MonadError m where { type family ErrorType m; }
+ Control.Monad.Error.Class: class Monad m => MonadError m where { type family ErrorType m; }
- Control.Monad.Error.Class: noMsg :: (Error a) => a
+ Control.Monad.Error.Class: noMsg :: Error a => a
- Control.Monad.Error.Class: strMsg :: (Error a) => String -> a
+ Control.Monad.Error.Class: strMsg :: Error a => String -> a
- Control.Monad.Error.Class: throwError :: (MonadError m) => ErrorType m -> m a
+ Control.Monad.Error.Class: throwError :: MonadError m => ErrorType m -> m a
- Control.Monad.RWS.Lazy: evalRWST :: (Monad m) => RWST r w s m a -> r -> s -> m (a, w)
+ Control.Monad.RWS.Lazy: evalRWST :: Monad m => RWST r w s m a -> r -> s -> m (a, w)
- Control.Monad.RWS.Lazy: execRWST :: (Monad m) => RWST r w s m a -> r -> s -> m (s, w)
+ Control.Monad.RWS.Lazy: execRWST :: Monad m => RWST r w s m a -> r -> s -> m (s, w)
- Control.Monad.RWS.Strict: evalRWST :: (Monad m) => RWST r w s m a -> r -> s -> m (a, w)
+ Control.Monad.RWS.Strict: evalRWST :: Monad m => RWST r w s m a -> r -> s -> m (a, w)
- Control.Monad.RWS.Strict: execRWST :: (Monad m) => RWST r w s m a -> r -> s -> m (s, w)
+ Control.Monad.RWS.Strict: execRWST :: Monad m => RWST r w s m a -> r -> s -> m (s, w)
- Control.Monad.Reader: ask :: (MonadReader m) => m (EnvType m)
+ Control.Monad.Reader: ask :: MonadReader m => m (EnvType m)
- Control.Monad.Reader: asks :: (MonadReader m) => (EnvType m -> a) -> m a
+ Control.Monad.Reader: asks :: MonadReader m => (EnvType m -> a) -> m a
- Control.Monad.Reader: class (Monad m) => MonadReader m where { type family EnvType m; }
+ Control.Monad.Reader: class Monad m => MonadReader m where { type family EnvType m; }
- Control.Monad.Reader: local :: (MonadReader m) => (EnvType m -> EnvType m) -> m a -> m a
+ Control.Monad.Reader: local :: MonadReader m => (EnvType m -> EnvType m) -> m a -> m a
- Control.Monad.Reader.Class: ask :: (MonadReader m) => m (EnvType m)
+ Control.Monad.Reader.Class: ask :: MonadReader m => m (EnvType m)
- Control.Monad.Reader.Class: asks :: (MonadReader m) => (EnvType m -> a) -> m a
+ Control.Monad.Reader.Class: asks :: MonadReader m => (EnvType m -> a) -> m a
- Control.Monad.Reader.Class: class (Monad m) => MonadReader m where { type family EnvType m; }
+ Control.Monad.Reader.Class: class Monad m => MonadReader m where { type family EnvType m; }
- Control.Monad.Reader.Class: local :: (MonadReader m) => (EnvType m -> EnvType m) -> m a -> m a
+ Control.Monad.Reader.Class: local :: MonadReader m => (EnvType m -> EnvType m) -> m a -> m a
- Control.Monad.State.Class: class (Monad m) => MonadState m where { type family StateType m; }
+ Control.Monad.State.Class: class Monad m => MonadState m where { type family StateType m; }
- Control.Monad.State.Class: get :: (MonadState m) => m (StateType m)
+ Control.Monad.State.Class: get :: MonadState m => m (StateType m)
- Control.Monad.State.Class: gets :: (MonadState m) => (StateType m -> a) -> m a
+ Control.Monad.State.Class: gets :: MonadState m => (StateType m -> a) -> m a
- Control.Monad.State.Class: modify :: (MonadState m) => (StateType m -> StateType m) -> m ()
+ Control.Monad.State.Class: modify :: MonadState m => (StateType m -> StateType m) -> m ()
- Control.Monad.State.Class: put :: (MonadState m) => StateType m -> m ()
+ Control.Monad.State.Class: put :: MonadState m => StateType m -> m ()
- Control.Monad.State.Lazy: class (Monad m) => MonadState m where { type family StateType m; }
+ Control.Monad.State.Lazy: class Monad m => MonadState m where { type family StateType m; }
- Control.Monad.State.Lazy: evalStateT :: (Monad m) => StateT s m a -> s -> m a
+ Control.Monad.State.Lazy: evalStateT :: Monad m => StateT s m a -> s -> m a
- Control.Monad.State.Lazy: execStateT :: (Monad m) => StateT s m a -> s -> m s
+ Control.Monad.State.Lazy: execStateT :: Monad m => StateT s m a -> s -> m s
- Control.Monad.State.Lazy: get :: (MonadState m) => m (StateType m)
+ Control.Monad.State.Lazy: get :: MonadState m => m (StateType m)
- Control.Monad.State.Lazy: gets :: (MonadState m) => (StateType m -> a) -> m a
+ Control.Monad.State.Lazy: gets :: MonadState m => (StateType m -> a) -> m a
- Control.Monad.State.Lazy: modify :: (MonadState m) => (StateType m -> StateType m) -> m ()
+ Control.Monad.State.Lazy: modify :: MonadState m => (StateType m -> StateType m) -> m ()
- Control.Monad.State.Lazy: put :: (MonadState m) => StateType m -> m ()
+ Control.Monad.State.Lazy: put :: MonadState m => StateType m -> m ()
- Control.Monad.State.Strict: class (Monad m) => MonadState m where { type family StateType m; }
+ Control.Monad.State.Strict: class Monad m => MonadState m where { type family StateType m; }
- Control.Monad.State.Strict: evalStateT :: (Monad m) => StateT s m a -> s -> m a
+ Control.Monad.State.Strict: evalStateT :: Monad m => StateT s m a -> s -> m a
- Control.Monad.State.Strict: execStateT :: (Monad m) => StateT s m a -> s -> m s
+ Control.Monad.State.Strict: execStateT :: Monad m => StateT s m a -> s -> m s
- Control.Monad.State.Strict: get :: (MonadState m) => m (StateType m)
+ Control.Monad.State.Strict: get :: MonadState m => m (StateType m)
- Control.Monad.State.Strict: gets :: (MonadState m) => (StateType m -> a) -> m a
+ Control.Monad.State.Strict: gets :: MonadState m => (StateType m -> a) -> m a
- Control.Monad.State.Strict: modify :: (MonadState m) => (StateType m -> StateType m) -> m ()
+ Control.Monad.State.Strict: modify :: MonadState m => (StateType m -> StateType m) -> m ()
- Control.Monad.State.Strict: put :: (MonadState m) => StateType m -> m ()
+ Control.Monad.State.Strict: put :: MonadState m => StateType m -> m ()
- Control.Monad.Writer.Class: censor :: (MonadWriter m) => (WriterType m -> WriterType m) -> m a -> m a
+ Control.Monad.Writer.Class: censor :: MonadWriter m => (WriterType m -> WriterType m) -> m a -> m a
- Control.Monad.Writer.Class: listen :: (MonadWriter m) => m a -> m (a, WriterType m)
+ Control.Monad.Writer.Class: listen :: MonadWriter m => m a -> m (a, WriterType m)
- Control.Monad.Writer.Class: listens :: (MonadWriter m) => (WriterType m -> b) -> m a -> m (a, b)
+ Control.Monad.Writer.Class: listens :: MonadWriter m => (WriterType m -> b) -> m a -> m (a, b)
- Control.Monad.Writer.Class: pass :: (MonadWriter m) => m (a, WriterType m -> WriterType m) -> m a
+ Control.Monad.Writer.Class: pass :: MonadWriter m => m (a, WriterType m -> WriterType m) -> m a
- Control.Monad.Writer.Class: tell :: (MonadWriter m) => WriterType m -> m ()
+ Control.Monad.Writer.Class: tell :: MonadWriter m => WriterType m -> m ()
- Control.Monad.Writer.Lazy: censor :: (MonadWriter m) => (WriterType m -> WriterType m) -> m a -> m a
+ Control.Monad.Writer.Lazy: censor :: MonadWriter m => (WriterType m -> WriterType m) -> m a -> m a
- Control.Monad.Writer.Lazy: execWriterT :: (Monad m) => WriterT w m a -> m w
+ Control.Monad.Writer.Lazy: execWriterT :: Monad m => WriterT w m a -> m w
- Control.Monad.Writer.Lazy: listen :: (MonadWriter m) => m a -> m (a, WriterType m)
+ Control.Monad.Writer.Lazy: listen :: MonadWriter m => m a -> m (a, WriterType m)
- Control.Monad.Writer.Lazy: listens :: (MonadWriter m) => (WriterType m -> b) -> m a -> m (a, b)
+ Control.Monad.Writer.Lazy: listens :: MonadWriter m => (WriterType m -> b) -> m a -> m (a, b)
- Control.Monad.Writer.Lazy: pass :: (MonadWriter m) => m (a, WriterType m -> WriterType m) -> m a
+ Control.Monad.Writer.Lazy: pass :: MonadWriter m => m (a, WriterType m -> WriterType m) -> m a
- Control.Monad.Writer.Lazy: tell :: (MonadWriter m) => WriterType m -> m ()
+ Control.Monad.Writer.Lazy: tell :: MonadWriter m => WriterType m -> m ()
- Control.Monad.Writer.Strict: censor :: (MonadWriter m) => (WriterType m -> WriterType m) -> m a -> m a
+ Control.Monad.Writer.Strict: censor :: MonadWriter m => (WriterType m -> WriterType m) -> m a -> m a
- Control.Monad.Writer.Strict: execWriterT :: (Monad m) => WriterT w m a -> m w
+ Control.Monad.Writer.Strict: execWriterT :: Monad m => WriterT w m a -> m w
- Control.Monad.Writer.Strict: listen :: (MonadWriter m) => m a -> m (a, WriterType m)
+ Control.Monad.Writer.Strict: listen :: MonadWriter m => m a -> m (a, WriterType m)
- Control.Monad.Writer.Strict: listens :: (MonadWriter m) => (WriterType m -> b) -> m a -> m (a, b)
+ Control.Monad.Writer.Strict: listens :: MonadWriter m => (WriterType m -> b) -> m a -> m (a, b)
- Control.Monad.Writer.Strict: pass :: (MonadWriter m) => m (a, WriterType m -> WriterType m) -> m a
+ Control.Monad.Writer.Strict: pass :: MonadWriter m => m (a, WriterType m -> WriterType m) -> m a
- Control.Monad.Writer.Strict: tell :: (MonadWriter m) => WriterType m -> m ()
+ Control.Monad.Writer.Strict: tell :: MonadWriter m => WriterType m -> m ()
Files
- Control/Monad/Cont/Class.hs +1/−1
- Control/Monad/Identity.hs +39/−0
- Control/Monad/Reader/Class.hs +0/−1
- Control/Monad/Trans.hs +34/−0
- monads-tf.cabal +5/−4
Control/Monad/Cont/Class.hs view
@@ -90,7 +90,7 @@ -} callCC :: ((a -> m b) -> m a) -> m a -instance (Monad m) => MonadCont (ContT r m) where+instance MonadCont (ContT r m) where callCC = ContT.callCC -- ---------------------------------------------------------------------------
+ Control/Monad/Identity.hs view
@@ -0,0 +1,39 @@+{- |+Module : Control.Monad.Identity+Copyright : (c) Andy Gill 2001,+ (c) Oregon Graduate Institute of Science and Technology 2001,+ (c) Jeff Newbern 2003-2006,+ (c) Andriy Palamarchuk 2006+License : BSD-style (see the file libraries/base/LICENSE)++Maintainer : libraries@haskell.org+Stability : experimental+Portability : portable++[Computation type:] Simple function application.++[Binding strategy:] The bound function is applied to the input value.+@'Identity' x >>= f == 'Identity' (f x)@++[Useful for:] Monads can be derived from monad transformers applied to the+'Identity' monad.++[Zero and plus:] None.++[Example type:] @'Identity' a@++The @Identity@ monad is a monad that does not embody any computational strategy.+It simply applies the bound function to its input without any modification.+Computationally, there is no reason to use the @Identity@ monad+instead of the much simpler act of simply applying functions to their arguments.+The purpose of the @Identity@ monad is its fundamental role in the theory+of monad transformers.+Any monad transformer applied to the @Identity@ monad yields a non-transformer+version of that monad.+-}++module Control.Monad.Identity (+ module Data.Functor.Identity+ ) where++import Data.Functor.Identity
Control/Monad/Reader/Class.hs view
@@ -1,4 +1,3 @@-{-# LANGUAGE TypeFamilies #-} {- | Module : Control.Monad.Reader.Class Copyright : (c) Andy Gill 2001,
+ Control/Monad/Trans.hs view
@@ -0,0 +1,34 @@+-----------------------------------------------------------------------------+-- |+-- Module : Control.Monad.Trans+-- Copyright : (c) Andy Gill 2001,+-- (c) Oregon Graduate Institute of Science and Technology, 2001+-- License : BSD-style (see the file libraries/base/LICENSE)+--+-- Maintainer : libraries@haskell.org+-- Stability : experimental+-- Portability : portable+--+-- Classes for monad transformers.+--+-- A monad transformer makes new monad out of an existing monad, such+-- that computations of the old monad may be embedded in the new one.+-- To construct a monad with a desired set of features, one typically+-- starts with a base monad, such as @Identity@, @[]@ or 'IO', and+-- applies a sequence of monad transformers.+--+-- Most monad transformer modules include the special case of applying the+-- transformer to @Identity@. For example, @State s@ is an abbreviation+-- for @StateT s Identity@.+--+-- Each monad transformer also comes with an operation @run@/XXX/ to+-- unwrap the transformer, exposing a computation of the inner monad.+-----------------------------------------------------------------------------++module Control.Monad.Trans (+ module Control.Monad.Trans.Class,+ module Control.Monad.IO.Class+ ) where++import Control.Monad.IO.Class+import Control.Monad.Trans.Class
monads-tf.cabal view
@@ -1,8 +1,7 @@ name: monads-tf-version: 0.0.0.1+version: 0.1.0.0 license: BSD3 license-file: LICENSE-cabal-version: >= 1.2.3 author: Andy Gill maintainer: Ross Paterson <ross@soi.city.ac.uk> category: Control@@ -15,13 +14,14 @@ (<http://web.cecs.pdx.edu/~mpj/pubs/springschool.html>). . This package is almost a compatible replacement for the @mtl-tf@ package.- Client packages will need to depend on this one and on @transformers@. build-type: Simple+cabal-version: >= 1.2.3 exposed-modules: Control.Monad.Cont Control.Monad.Cont.Class Control.Monad.Error Control.Monad.Error.Class+ Control.Monad.Identity Control.Monad.List Control.Monad.RWS Control.Monad.RWS.Class@@ -33,11 +33,12 @@ Control.Monad.State.Class Control.Monad.State.Lazy Control.Monad.State.Strict+ Control.Monad.Trans Control.Monad.Writer Control.Monad.Writer.Class Control.Monad.Writer.Lazy Control.Monad.Writer.Strict-build-depends: base, transformers >= 0.1.4.0+build-depends: base < 6, transformers >= 0.2 extensions: FlexibleContexts TypeFamilies