diff -Nru haskell-mtl-2.0.1.0/Control/Monad/Cont/Class.hs haskell-mtl-2.1.2/Control/Monad/Cont/Class.hs --- haskell-mtl-2.0.1.0/Control/Monad/Cont/Class.hs 2010-11-07 11:41:11.000000000 +0000 +++ haskell-mtl-2.1.2/Control/Monad/Cont/Class.hs 2012-06-23 03:10:36.000000000 +0000 @@ -69,7 +69,7 @@ import Control.Monad import Data.Monoid -class (Monad m) => MonadCont m where +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. @@ -99,16 +99,16 @@ instance (Error e, MonadCont m) => MonadCont (ErrorT e m) where callCC = Error.liftCallCC callCC -instance (MonadCont m) => MonadCont (IdentityT m) where +instance MonadCont m => MonadCont (IdentityT m) where callCC = Identity.liftCallCC callCC -instance (MonadCont m) => MonadCont (ListT m) where +instance MonadCont m => MonadCont (ListT m) where callCC = List.liftCallCC callCC -instance (MonadCont m) => MonadCont (MaybeT m) where +instance MonadCont m => MonadCont (MaybeT m) where callCC = Maybe.liftCallCC callCC -instance (MonadCont m) => MonadCont (ReaderT r m) where +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 @@ -117,10 +117,10 @@ 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 +instance MonadCont m => MonadCont (LazyState.StateT s m) where callCC = LazyState.liftCallCC' callCC -instance (MonadCont m) => MonadCont (StrictState.StateT s m) where +instance MonadCont m => MonadCont (StrictState.StateT s m) where callCC = StrictState.liftCallCC' callCC instance (Monoid w, MonadCont m) => MonadCont (LazyWriter.WriterT w m) where diff -Nru haskell-mtl-2.0.1.0/Control/Monad/Error/Class.hs haskell-mtl-2.1.2/Control/Monad/Error/Class.hs --- haskell-mtl-2.0.1.0/Control/Monad/Error/Class.hs 2010-11-07 11:41:11.000000000 +0000 +++ haskell-mtl-2.1.2/Control/Monad/Error/Class.hs 2012-06-23 03:10:36.000000000 +0000 @@ -5,6 +5,7 @@ Copyright : (c) Michael Weber 2001, (c) Jeff Newbern 2003-2006, (c) Andriy Palamarchuk 2006 + (c) Edward Kmett 2012 License : BSD-style (see the file LICENSE) Maintainer : libraries@haskell.org @@ -52,10 +53,11 @@ import Control.Monad.Trans.Writer.Strict as StrictWriter import Control.Monad.Trans.Class (lift) -import Control.Exception (IOException) +import Control.Exception (IOException, catch, ioError) import Control.Monad import Control.Monad.Instances () import Data.Monoid +import Prelude (Either(..), (.), IO) {- | The strategy of combining computations that can throw exceptions @@ -95,7 +97,7 @@ -- --------------------------------------------------------------------------- -- Our parameterizable error monad -instance (Error e) => MonadError e (Either e) where +instance Error e => MonadError e (Either e) where throwError = Left Left l `catchError` h = h l Right r `catchError` _ = Right r @@ -110,19 +112,19 @@ -- All of these instances need UndecidableInstances, -- because they do not satisfy the coverage condition. -instance (MonadError e m) => MonadError e (IdentityT m) where +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 +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 +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 +instance MonadError e m => MonadError e (ReaderT r m) where throwError = lift . throwError catchError = Reader.liftCatch catchError @@ -134,11 +136,11 @@ throwError = lift . throwError catchError = StrictRWS.liftCatch catchError -instance (MonadError e m) => MonadError e (LazyState.StateT s m) where +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 +instance MonadError e m => MonadError e (StrictState.StateT s m) where throwError = lift . throwError catchError = StrictState.liftCatch catchError diff -Nru haskell-mtl-2.0.1.0/Control/Monad/Reader/Class.hs haskell-mtl-2.1.2/Control/Monad/Reader/Class.hs --- haskell-mtl-2.0.1.0/Control/Monad/Reader/Class.hs 2010-11-07 11:41:11.000000000 +0000 +++ haskell-mtl-2.1.2/Control/Monad/Reader/Class.hs 2012-06-23 03:10:36.000000000 +0000 @@ -48,9 +48,9 @@ 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 qualified Control.Monad.Trans.Reader as ReaderT (ask, local, reader) +import qualified Control.Monad.Trans.RWS.Lazy as LazyRWS (RWST, ask, local, reader) +import qualified Control.Monad.Trans.RWS.Strict as StrictRWS (RWST, ask, local, reader) import Control.Monad.Trans.State.Lazy as Lazy import Control.Monad.Trans.State.Strict as Strict import Control.Monad.Trans.Writer.Lazy as Lazy @@ -67,22 +67,27 @@ -- | 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 +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. + 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. + reader :: (r -> a) -- ^ The selector function to apply to the environment. + -> m a + reader f = do + r <- ask + return (f r) + -- | Retrieves a function of the current environment. -asks :: (MonadReader r m) - => (r -> a) -- ^ The selector function to apply to the 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) +asks = reader -- ---------------------------------------------------------------------------- -- The partially applied function type is a simple reader monad @@ -90,18 +95,22 @@ instance MonadReader r ((->) r) where ask = id local f m = m . f + reader = id -instance (Monad m) => MonadReader r (ReaderT r m) where +instance Monad m => MonadReader r (ReaderT r m) where ask = ReaderT.ask local = ReaderT.local + reader = ReaderT.reader instance (Monad m, Monoid w) => MonadReader r (LazyRWS.RWST r w s m) where ask = LazyRWS.ask local = LazyRWS.local + reader = LazyRWS.reader instance (Monad m, Monoid w) => MonadReader r (StrictRWS.RWST r w s m) where ask = StrictRWS.ask local = StrictRWS.local + reader = StrictRWS.reader -- --------------------------------------------------------------------------- -- Instances for other mtl transformers @@ -109,38 +118,47 @@ -- All of these instances need UndecidableInstances, -- because they do not satisfy the coverage condition. -instance (MonadReader r' m) => MonadReader r' (ContT r m) where +instance MonadReader r' m => MonadReader r' (ContT r m) where ask = lift ask local = Cont.liftLocal ask local + reader = lift . reader instance (Error e, MonadReader r m) => MonadReader r (ErrorT e m) where ask = lift ask local = mapErrorT . local + reader = lift . reader -instance (MonadReader r m) => MonadReader r (IdentityT m) where +instance MonadReader r m => MonadReader r (IdentityT m) where ask = lift ask local = mapIdentityT . local + reader = lift . reader -instance (MonadReader r m) => MonadReader r (ListT m) where +instance MonadReader r m => MonadReader r (ListT m) where ask = lift ask local = mapListT . local + reader = lift . reader -instance (MonadReader r m) => MonadReader r (MaybeT m) where +instance MonadReader r m => MonadReader r (MaybeT m) where ask = lift ask local = mapMaybeT . local + reader = lift . reader -instance (MonadReader r m) => MonadReader r (Lazy.StateT s m) where +instance MonadReader r m => MonadReader r (Lazy.StateT s m) where ask = lift ask local = Lazy.mapStateT . local + reader = lift . reader -instance (MonadReader r m) => MonadReader r (Strict.StateT s m) where +instance MonadReader r m => MonadReader r (Strict.StateT s m) where ask = lift ask local = Strict.mapStateT . local + reader = lift . reader instance (Monoid w, MonadReader r m) => MonadReader r (Lazy.WriterT w m) where ask = lift ask local = Lazy.mapWriterT . local + reader = lift . reader instance (Monoid w, MonadReader r m) => MonadReader r (Strict.WriterT w m) where ask = lift ask local = Strict.mapWriterT . local + reader = lift . reader diff -Nru haskell-mtl-2.0.1.0/Control/Monad/Reader.hs haskell-mtl-2.1.2/Control/Monad/Reader.hs --- haskell-mtl-2.0.1.0/Control/Monad/Reader.hs 2010-11-07 11:41:11.000000000 +0000 +++ haskell-mtl-2.1.2/Control/Monad/Reader.hs 2012-06-23 03:10:36.000000000 +0000 @@ -41,7 +41,6 @@ asks, -- * The Reader monad Reader, - reader, runReader, mapReader, withReader, @@ -65,7 +64,7 @@ import Control.Monad.Reader.Class import Control.Monad.Trans.Reader ( - Reader, reader, runReader, mapReader, withReader, + Reader, runReader, mapReader, withReader, ReaderT(..), mapReaderT, withReaderT) import Control.Monad.Trans diff -Nru haskell-mtl-2.0.1.0/Control/Monad/RWS/Class.hs haskell-mtl-2.1.2/Control/Monad/RWS/Class.hs --- haskell-mtl-2.0.1.0/Control/Monad/RWS/Class.hs 2010-11-07 11:41:11.000000000 +0000 +++ haskell-mtl-2.1.2/Control/Monad/RWS/Class.hs 2012-06-23 03:10:36.000000000 +0000 @@ -31,6 +31,7 @@ import Control.Monad.State.Class import Control.Monad.Writer.Class +import Control.Monad.Trans.Class import Control.Monad.Trans.Error(Error, ErrorT) import Control.Monad.Trans.Maybe(MaybeT) import Control.Monad.Trans.Identity(IdentityT) @@ -43,6 +44,7 @@ => 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) --------------------------------------------------------------------------- @@ -50,7 +52,7 @@ -- -- 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) +instance MonadRWS r w s m => MonadRWS r w s (IdentityT m) +instance MonadRWS r w s m => MonadRWS r w s (MaybeT m) diff -Nru haskell-mtl-2.0.1.0/Control/Monad/State/Class.hs haskell-mtl-2.1.2/Control/Monad/State/Class.hs --- haskell-mtl-2.0.1.0/Control/Monad/State/Class.hs 2010-11-07 11:41:11.000000000 +0000 +++ haskell-mtl-2.1.2/Control/Monad/State/Class.hs 2012-06-23 03:10:36.000000000 +0000 @@ -33,10 +33,10 @@ 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 qualified Control.Monad.Trans.RWS.Lazy as LazyRWS (RWST, get, put, state) +import qualified Control.Monad.Trans.RWS.Strict as StrictRWS (RWST, get, put, state) +import qualified Control.Monad.Trans.State.Lazy as Lazy (StateT, get, put, state) +import qualified Control.Monad.Trans.State.Strict as Strict (StateT, get, put, state) import Control.Monad.Trans.Writer.Lazy as Lazy import Control.Monad.Trans.Writer.Strict as Strict @@ -46,11 +46,23 @@ -- --------------------------------------------------------------------------- -class (Monad m) => MonadState s m | m -> s where +-- | Minimal definition is either both of @get@ and @put@ or just @state@ +class Monad m => MonadState s m | m -> s where -- | Return the state from the internals of the monad. get :: m s + get = state (\s -> (s, s)) + -- | Replace the state inside the monad. put :: s -> m () + put s = state (\_ -> ((), s)) + + -- | Embed a simple state action into the monad. + state :: (s -> (a, s)) -> m a + state f = do + s <- get + let ~(a, s') = f s + put s' + return a -- | Monadic state transformer. -- @@ -63,35 +75,35 @@ -- 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) +modify :: MonadState s m => (s -> s) -> m () +modify f = state (\s -> ((), f s)) -- | Gets specific component of the state, using a projection function -- supplied. - -gets :: (MonadState s m) => (s -> a) -> m a +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 +instance Monad m => MonadState s (Lazy.StateT s m) where get = Lazy.get put = Lazy.put + state = Lazy.state -instance (Monad m) => MonadState s (Strict.StateT s m) where +instance Monad m => MonadState s (Strict.StateT s m) where get = Strict.get put = Strict.put + state = Strict.state instance (Monad m, Monoid w) => MonadState s (LazyRWS.RWST r w s m) where get = LazyRWS.get put = LazyRWS.put + state = LazyRWS.state instance (Monad m, Monoid w) => MonadState s (StrictRWS.RWST r w s m) where get = StrictRWS.get put = StrictRWS.put + state = StrictRWS.state -- --------------------------------------------------------------------------- -- Instances for other mtl transformers @@ -99,34 +111,42 @@ -- All of these instances need UndecidableInstances, -- because they do not satisfy the coverage condition. -instance (MonadState s m) => MonadState s (ContT r m) where +instance MonadState s m => MonadState s (ContT r m) where get = lift get put = lift . put + state = lift . state instance (Error e, MonadState s m) => MonadState s (ErrorT e m) where get = lift get put = lift . put + state = lift . state -instance (MonadState s m) => MonadState s (IdentityT m) where +instance MonadState s m => MonadState s (IdentityT m) where get = lift get put = lift . put + state = lift . state -instance (MonadState s m) => MonadState s (ListT m) where +instance MonadState s m => MonadState s (ListT m) where get = lift get put = lift . put + state = lift . state -instance (MonadState s m) => MonadState s (MaybeT m) where +instance MonadState s m => MonadState s (MaybeT m) where get = lift get put = lift . put + state = lift . state -instance (MonadState s m) => MonadState s (ReaderT r m) where +instance MonadState s m => MonadState s (ReaderT r m) where get = lift get put = lift . put + state = lift . state instance (Monoid w, MonadState s m) => MonadState s (Lazy.WriterT w m) where get = lift get put = lift . put + state = lift . state instance (Monoid w, MonadState s m) => MonadState s (Strict.WriterT w m) where get = lift get put = lift . put + state = lift . state diff -Nru haskell-mtl-2.0.1.0/Control/Monad/State/Lazy.hs haskell-mtl-2.1.2/Control/Monad/State/Lazy.hs --- haskell-mtl-2.0.1.0/Control/Monad/State/Lazy.hs 2010-11-07 11:41:11.000000000 +0000 +++ haskell-mtl-2.1.2/Control/Monad/State/Lazy.hs 2012-06-23 03:10:36.000000000 +0000 @@ -25,7 +25,6 @@ gets, -- * The State monad State, - state, runState, evalState, execState, @@ -48,7 +47,7 @@ import Control.Monad.Trans import Control.Monad.Trans.State.Lazy - (State, state, runState, evalState, execState, mapState, withState, + (State, runState, evalState, execState, mapState, withState, StateT(..), evalStateT, execStateT, mapStateT, withStateT) import Control.Monad diff -Nru haskell-mtl-2.0.1.0/Control/Monad/State/Strict.hs haskell-mtl-2.1.2/Control/Monad/State/Strict.hs --- haskell-mtl-2.0.1.0/Control/Monad/State/Strict.hs 2010-11-07 11:41:11.000000000 +0000 +++ haskell-mtl-2.1.2/Control/Monad/State/Strict.hs 2012-06-23 03:10:36.000000000 +0000 @@ -25,7 +25,6 @@ gets, -- * The State monad State, - state, runState, evalState, execState, @@ -48,7 +47,7 @@ import Control.Monad.Trans import Control.Monad.Trans.State.Strict - (State, state, runState, evalState, execState, mapState, withState, + (State, runState, evalState, execState, mapState, withState, StateT(..), evalStateT, execStateT, mapStateT, withStateT) import Control.Monad diff -Nru haskell-mtl-2.0.1.0/Control/Monad/Writer/Class.hs haskell-mtl-2.1.2/Control/Monad/Writer/Class.hs --- haskell-mtl-2.0.1.0/Control/Monad/Writer/Class.hs 2010-11-07 11:41:11.000000000 +0000 +++ haskell-mtl-2.1.2/Control/Monad/Writer/Class.hs 2012-06-23 03:10:36.000000000 +0000 @@ -31,15 +31,15 @@ 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) + RWST, writer, tell, listen, pass) import qualified Control.Monad.Trans.RWS.Strict as StrictRWS ( - RWST, tell, listen, pass) + RWST, writer, 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) + WriterT, writer, tell, listen, pass) import qualified Control.Monad.Trans.Writer.Strict as Strict ( - WriterT, tell, listen, pass) + WriterT, writer, tell, listen, pass) import Control.Monad.Trans.Class (lift) import Control.Monad @@ -58,8 +58,16 @@ -- the written object. class (Monoid w, Monad m) => MonadWriter w m | m -> w where + -- | @'writer' (a,w)@ embeds a simple writer action. + writer :: (a,w) -> m a + writer ~(a, w) = do + tell w + return a + -- | @'tell' w@ is an action that produces the output @w@. tell :: w -> m () + tell w = writer ((),w) + -- | @'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) @@ -72,7 +80,7 @@ -- 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 :: MonadWriter w m => (w -> b) -> m a -> m (a, b) listens f m = do ~(a, w) <- listen m return (a, f w) @@ -82,27 +90,31 @@ -- unchanged. -- -- * @'censor' f m = 'pass' ('liftM' (\\x -> (x,f)) m)@ -censor :: (MonadWriter w m) => (w -> w) -> m a -> m a +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 + writer = Lazy.writer tell = Lazy.tell listen = Lazy.listen pass = Lazy.pass instance (Monoid w, Monad m) => MonadWriter w (Strict.WriterT w m) where + writer = Strict.writer tell = Strict.tell listen = Strict.listen pass = Strict.pass instance (Monoid w, Monad m) => MonadWriter w (LazyRWS.RWST r w s m) where + writer = LazyRWS.writer tell = LazyRWS.tell listen = LazyRWS.listen pass = LazyRWS.pass instance (Monoid w, Monad m) => MonadWriter w (StrictRWS.RWST r w s m) where + writer = StrictRWS.writer tell = StrictRWS.tell listen = StrictRWS.listen pass = StrictRWS.pass @@ -114,31 +126,37 @@ -- because they do not satisfy the coverage condition. instance (Error e, MonadWriter w m) => MonadWriter w (ErrorT e m) where + writer = lift . writer tell = lift . tell listen = Error.liftListen listen pass = Error.liftPass pass -instance (MonadWriter w m) => MonadWriter w (IdentityT m) where +instance MonadWriter w m => MonadWriter w (IdentityT m) where + writer = lift . writer tell = lift . tell listen = Identity.mapIdentityT listen pass = Identity.mapIdentityT pass -instance (MonadWriter w m) => MonadWriter w (MaybeT m) where +instance MonadWriter w m => MonadWriter w (MaybeT m) where + writer = lift . writer tell = lift . tell listen = Maybe.liftListen listen pass = Maybe.liftPass pass -instance (MonadWriter w m) => MonadWriter w (ReaderT r m) where +instance MonadWriter w m => MonadWriter w (ReaderT r m) where + writer = lift . writer tell = lift . tell listen = mapReaderT listen pass = mapReaderT pass -instance (MonadWriter w m) => MonadWriter w (Lazy.StateT s m) where +instance MonadWriter w m => MonadWriter w (Lazy.StateT s m) where + writer = lift . writer tell = lift . tell listen = Lazy.liftListen listen pass = Lazy.liftPass pass -instance (MonadWriter w m) => MonadWriter w (Strict.StateT s m) where +instance MonadWriter w m => MonadWriter w (Strict.StateT s m) where + writer = lift . writer tell = lift . tell listen = Strict.liftListen listen pass = Strict.liftPass pass diff -Nru haskell-mtl-2.0.1.0/Control/Monad/Writer/Lazy.hs haskell-mtl-2.1.2/Control/Monad/Writer/Lazy.hs --- haskell-mtl-2.0.1.0/Control/Monad/Writer/Lazy.hs 2010-11-07 11:41:11.000000000 +0000 +++ haskell-mtl-2.1.2/Control/Monad/Writer/Lazy.hs 2012-06-23 03:10:36.000000000 +0000 @@ -24,7 +24,6 @@ censor, -- * The Writer monad Writer, - writer, runWriter, execWriter, mapWriter, @@ -42,7 +41,7 @@ import Control.Monad.Trans import Control.Monad.Trans.Writer.Lazy ( - Writer, writer, runWriter, execWriter, mapWriter, + Writer, runWriter, execWriter, mapWriter, WriterT(..), execWriterT, mapWriterT) import Control.Monad diff -Nru haskell-mtl-2.0.1.0/Control/Monad/Writer/Strict.hs haskell-mtl-2.1.2/Control/Monad/Writer/Strict.hs --- haskell-mtl-2.0.1.0/Control/Monad/Writer/Strict.hs 2010-11-07 11:41:11.000000000 +0000 +++ haskell-mtl-2.1.2/Control/Monad/Writer/Strict.hs 2012-06-23 03:10:36.000000000 +0000 @@ -24,7 +24,6 @@ censor, -- * The Writer monad Writer, - writer, runWriter, execWriter, mapWriter, @@ -42,7 +41,7 @@ import Control.Monad.Trans import Control.Monad.Trans.Writer.Strict ( - Writer, writer, runWriter, execWriter, mapWriter, + Writer, runWriter, execWriter, mapWriter, WriterT(..), execWriterT, mapWriterT) import Control.Monad diff -Nru haskell-mtl-2.0.1.0/debian/changelog haskell-mtl-2.1.2/debian/changelog --- haskell-mtl-2.0.1.0/debian/changelog 2012-02-04 12:27:25.000000000 +0000 +++ haskell-mtl-2.1.2/debian/changelog 2014-06-13 23:03:09.000000000 +0000 @@ -1,3 +1,45 @@ +haskell-mtl (2.1.2-4ubuntu1) precise; urgency=medium + + * Backport to precise. + + -- Marcus Hoffmann Sat, 14 Jun 2014 01:03:09 +0200 + +haskell-mtl (2.1.2-4) unstable; urgency=low + + * Fix Vcs-Darcs url: http://darcs.debian.org/ instead of + http://darcs.debian.org/darcs/ + * Move Haskell blurb to the end of the description, reduces the impact + of #708703 + + -- Joachim Breitner Sat, 25 May 2013 23:52:32 +0200 + +haskell-mtl (2.1.2-3) unstable; urgency=low + + * Enable compat level 9 + * Use substvars for Haskell description blurbs + + -- Joachim Breitner Fri, 24 May 2013 12:51:28 +0200 + +haskell-mtl (2.1.2-2) experimental; urgency=low + + * Bump standards version, no change + + -- Joachim Breitner Sun, 14 Oct 2012 12:01:35 +0200 + +haskell-mtl (2.1.2-1) experimental; urgency=low + + * New upstream release + * Depend on haskell-devscripts (>= 0.8.13), to ensure it is built + against experimental + + -- Joachim Breitner Mon, 08 Oct 2012 23:26:05 +0200 + +haskell-mtl (2.1.1-1) unstable; urgency=low + + * New upstream release + + -- Joachim Breitner Fri, 25 May 2012 09:41:45 +0200 + haskell-mtl (2.0.1.0-3) unstable; urgency=low * Sourceful upload to rebuild documentation package diff -Nru haskell-mtl-2.0.1.0/debian/compat haskell-mtl-2.1.2/debian/compat --- haskell-mtl-2.0.1.0/debian/compat 2011-03-04 04:51:58.000000000 +0000 +++ haskell-mtl-2.1.2/debian/compat 2014-06-13 23:03:09.000000000 +0000 @@ -1 +1 @@ -7 +9 diff -Nru haskell-mtl-2.0.1.0/debian/control haskell-mtl-2.1.2/debian/control --- haskell-mtl-2.0.1.0/debian/control 2011-03-04 04:59:16.000000000 +0000 +++ haskell-mtl-2.1.2/debian/control 2014-06-13 23:03:09.000000000 +0000 @@ -3,20 +3,20 @@ Priority: extra Maintainer: Debian Haskell Group Uploaders: Joachim Breitner -Standards-Version: 3.9.1 +Standards-Version: 3.9.4 Build-Depends: - debhelper (>= 7), - haskell-devscripts (>= 0.7), + debhelper (>= 9), + haskell-devscripts (>= 0.8.15), ghc, ghc-doc, ghc-prof, - libghc-transformers-dev (>= 0.2), - libghc-transformers-dev (<< 0.3), + libghc-transformers-dev (>= 0.3), + libghc-transformers-dev (<< 0.4), libghc-transformers-prof, libghc-transformers-doc, cdbs Homepage: http://hackage.haskell.org/package/mtl -Vcs-Darcs: http://darcs.debian.org/darcs/pkg-haskell/haskell-mtl +Vcs-Darcs: http://darcs.debian.org/pkg-haskell/haskell-mtl Vcs-Browser: http://darcs.debian.org/cgi-bin/darcsweb.cgi?r=pkg-haskell/haskell-mtl Package: libghc-mtl-dev @@ -28,14 +28,13 @@ Suggests: ${haskell:Suggests} Recommends: ${haskell:Recommends} Provides: ${haskell:Provides} -Description: Haskell monad transformer library for GHC - This package provides a library for the Haskell programming language. - See http://www.haskell.org/ for more information on Haskell. - . +Description: Haskell monad transformer library for GHC${haskell:ShortBlurb} MTL is a monad transformer library, inspired by the paper "Functional Programming with Overloading and Higher-Order Polymorphism", by Mark P Jones (), Advanced School of Functional Programming, 1995. + . + ${haskell:Blurb} Package: libghc-mtl-prof Architecture: any @@ -45,15 +44,13 @@ Suggests: ${haskell:Suggests} Recommends: ${haskell:Recommends} Provides: ${haskell:Provides} -Description: Haskell monad transformer library for GHC; profiling libraries - This package provides a library for the Haskell programming language, - compiled for profiling. - See http://www.haskell.org/ for more information on Haskell. - . +Description: Haskell monad transformer library for GHC${haskell:ShortBlurb} MTL is a monad transformer library, inspired by the paper "Functional Programming with Overloading and Higher-Order Polymorphism", by Mark P Jones (), Advanced School of Functional Programming, 1995. + . + ${haskell:Blurb} Package: libghc-mtl-doc Section: doc @@ -61,12 +58,10 @@ Depends: ${haskell:Depends}, ${misc:Depends} Suggests: ${haskell:Suggests} Recommends: ${haskell:Recommends} -Description: Haskell monad transformer library for GHC; documentation - This package provides the documentation for a library for the Haskell - programming language. - See http://www.haskell.org/ for more information on Haskell. - . +Description: Haskell monad transformer library for GHC${haskell:ShortBlurb} MTL is a monad transformer library, inspired by the paper "Functional Programming with Overloading and Higher-Order Polymorphism", by Mark P Jones (), Advanced School of Functional Programming, 1995. + . + ${haskell:Blurb} diff -Nru haskell-mtl-2.0.1.0/mtl.cabal haskell-mtl-2.1.2/mtl.cabal --- haskell-mtl-2.0.1.0/mtl.cabal 2010-11-07 11:41:11.000000000 +0000 +++ haskell-mtl-2.1.2/mtl.cabal 2012-06-23 03:10:36.000000000 +0000 @@ -1,12 +1,14 @@ name: mtl -version: 2.0.1.0 +version: 2.1.2 cabal-version: >= 1.6 license: BSD3 license-file: LICENSE author: Andy Gill -maintainer: libraries@haskell.org +maintainer: Edward Kmett category: Control synopsis: Monad classes, using functional dependencies +homepage: http://github.com/ekmett/mtl +bug-reports: http://github.com/ekmett/mtl/issues description: Monad classes using functional dependencies, with instances for various monad transformers, inspired by the paper @@ -15,6 +17,10 @@ (). build-type: Simple +source-repository head + type: git + location: git://github.com/ekmett/mtl.git + Library exposed-modules: Control.Monad.Cont @@ -38,8 +44,9 @@ Control.Monad.Writer.Class Control.Monad.Writer.Lazy Control.Monad.Writer.Strict - build-depends: base < 6, transformers == 0.2.* + build-depends: base < 6, transformers == 0.3.* extensions: MultiParamTypeClasses FunctionalDependencies FlexibleInstances + ghc-options: -Wall -fno-warn-unused-imports