Compatibility with transformers 0.6 about mtl HOT 5 CLOSED

commit df51a5eafc09aa730c915376df154ff2a84f4625
Author: Oleg Grenrus <[email protected]>
Date:   Tue Jul 27 16:58:13 2021 +0300

    Quick 'n' dirty transformers-0.6 compat

diff --git a/Control/Monad/Cont/Class.hs b/Control/Monad/Cont/Class.hs
index 16de1f4..8bca8b4 100644
--- a/Control/Monad/Cont/Class.hs
+++ b/Control/Monad/Cont/Class.hs
@@ -55,10 +55,8 @@ module 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.Except as Except
 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
@@ -68,6 +66,11 @@ import Control.Monad.Trans.State.Strict as StrictState
 import Control.Monad.Trans.Writer.Lazy as LazyWriter
 import Control.Monad.Trans.Writer.Strict as StrictWriter
 
+#if !MIN_VERSION_transformers(0,6,0)
+import Control.Monad.Trans.Error as Error
+import Control.Monad.Trans.List as List
+#endif
+
 import Control.Monad
 import Data.Monoid
 
@@ -101,8 +104,6 @@ instance MonadCont (ContT r m) where
 -- ---------------------------------------------------------------------------
 -- Instances for other mtl transformers
 
-instance (Error e, MonadCont m) => MonadCont (ErrorT e m) where
-    callCC = Error.liftCallCC callCC
 
 {- | @since 2.2 -}
 instance MonadCont m => MonadCont (ExceptT e m) where
@@ -111,9 +112,14 @@ instance MonadCont m => MonadCont (ExceptT e m) where
 instance MonadCont m => MonadCont (IdentityT m) where
     callCC = Identity.liftCallCC callCC
 
+#if !MIN_VERSION_transformers(0,6,0)
 instance MonadCont m => MonadCont (ListT m) where
     callCC = List.liftCallCC callCC
 
+instance (Error e, MonadCont m) => MonadCont (ErrorT e m) where
+    callCC = Error.liftCallCC callCC
+#endif
+
 instance MonadCont m => MonadCont (MaybeT m) where
     callCC = Maybe.liftCallCC callCC
 
diff --git a/Control/Monad/Error.hs b/Control/Monad/Error.hs
deleted file mode 100644
index 9e6a1a4..0000000
--- a/Control/Monad/Error.hs
+++ /dev/null
@@ -1,151 +0,0 @@
-{-# LANGUAGE CPP #-}
-{- |
-Module      :  Control.Monad.Error
-Copyright   :  (c) Michael Weber <[email protected]> 2001,
-               (c) Jeff Newbern 2003-2006,
-               (c) Andriy Palamarchuk 2006
-License     :  BSD-style (see the file LICENSE)
-
-Maintainer  :  [email protected]
-Stability   :  experimental
-Portability :  non-portable (multi-parameter type classes)
-
-[Computation type:] Computations which may fail or throw exceptions.
-
-[Binding strategy:] Failure records information about the cause\/location
-of the failure. Failure values bypass the bound function,
-other values are used as inputs to the bound function.
-
-[Useful for:] Building computations from sequences of functions that may fail
-or using exception handling to structure error handling.
-
-[Zero and plus:] Zero is represented by an empty error and the plus operation
-executes its second argument if the first fails.
-
-[Example type:] @'Either' String a@
-
-The Error monad (also called the Exception monad).
--}
-
-{-
-  Rendered by Michael Weber <mailto:[email protected]>,
-  inspired by the Haskell Monad Template Library from
-    Andy Gill (<http://web.cecs.pdx.edu/~andy/>)
--}
-module Control.Monad.Error
-  {-# DEPRECATED "Use \"Control.Monad.Except\" instead" #-} (
-    -- * Monads with error handling
-    MonadError(..),
-    Error(..),
-    -- * The ErrorT monad transformer
-    ErrorT(ErrorT),
-    runErrorT,
-    mapErrorT,
-    module Control.Monad,
-    module Control.Monad.Fix,
-    module Control.Monad.Trans,
-    -- * Example 1: Custom Error Data Type
-    -- $customErrorExample
-
-    -- * Example 2: Using ErrorT Monad Transformer
-    -- $ErrorTExample
-  ) where
-
-import Control.Monad.Error.Class
-import Control.Monad.Trans
-import Control.Monad.Trans.Error (ErrorT(ErrorT), runErrorT, mapErrorT)
-
-import Control.Monad
-import Control.Monad.Fix
-
-#if defined(__GLASGOW_HASKELL__) && __GLASGOW_HASKELL__ < 707
-import Control.Monad.Instances ()
-#endif
-
-{- $customErrorExample
-Here is an example that demonstrates the use of a custom 'Error' data type with
-the 'throwError' and 'catchError' exception mechanism from 'MonadError'.
-The example throws an exception if the user enters an empty string
-or a string longer than 5 characters. Otherwise it prints length of the string.
-
->-- This is the type to represent length calculation error.
->data LengthError = EmptyString  -- Entered string was empty.
->          | StringTooLong Int   -- A string is longer than 5 characters.
->                                -- Records a length of the string.
->          | OtherError String   -- Other error, stores the problem description.
->
->-- We make LengthError an instance of the Error class
->-- to be able to throw it as an exception.
->instance Error LengthError where
->  noMsg    = OtherError "A String Error!"
->  strMsg s = OtherError s
->
->-- Converts LengthError to a readable message.
->instance Show LengthError where
->  show EmptyString = "The string was empty!"
->  show (StringTooLong len) =
->      "The length of the string (" ++ (show len) ++ ") is bigger than 5!"
->  show (OtherError msg) = msg
->
->-- For our monad type constructor, we use Either LengthError
->-- which represents failure using Left LengthError
->-- or a successful result of type a using Right a.
->type LengthMonad = Either LengthError
->
->main = do
->  putStrLn "Please enter a string:"
->  s <- getLine
->  reportResult (calculateLength s)
->
->-- Wraps length calculation to catch the errors.
->-- Returns either length of the string or an error.
->calculateLength :: String -> LengthMonad Int
->calculateLength s = (calculateLengthOrFail s) `catchError` Left
->
->-- Attempts to calculate length and throws an error if the provided string is
->-- empty or longer than 5 characters.
->-- The processing is done in Either monad.
->calculateLengthOrFail :: String -> LengthMonad Int
->calculateLengthOrFail [] = throwError EmptyString
->calculateLengthOrFail s | len > 5 = throwError (StringTooLong len)
->                        | otherwise = return len
->  where len = length s
->
->-- Prints result of the string length calculation.
->reportResult :: LengthMonad Int -> IO ()
->reportResult (Right len) = putStrLn ("The length of the string is " ++ (show len))
->reportResult (Left e) = putStrLn ("Length calculation failed with error: " ++ (show e))
--}
-
-{- $ErrorTExample
-@'ErrorT'@ monad transformer can be used to add error handling to another monad.
-Here is an example how to combine it with an @IO@ monad:
-
->import Control.Monad.Error
->
->-- An IO monad which can return String failure.
->-- It is convenient to define the monad type of the combined monad,
->-- especially if we combine more monad transformers.
->type LengthMonad = ErrorT String IO
->
->main = do
->  -- runErrorT removes the ErrorT wrapper
->  r <- runErrorT calculateLength
->  reportResult r
->
->-- Asks user for a non-empty string and returns its length.
->-- Throws an error if user enters an empty string.
->calculateLength :: LengthMonad Int
->calculateLength = do
->  -- all the IO operations have to be lifted to the IO monad in the monad stack
->  liftIO $ putStrLn "Please enter a non-empty string: "
->  s <- liftIO getLine
->  if null s
->    then throwError "The string was empty!"
->    else return $ length s
->
->-- Prints result of the string length calculation.
->reportResult :: Either String Int -> IO ()
->reportResult (Right len) = putStrLn ("The length of the string is " ++ (show len))
->reportResult (Left e) = putStrLn ("Length calculation failed with error: " ++ (show e))
--}
diff --git a/Control/Monad/Error/Class.hs b/Control/Monad/Error/Class.hs
index cc61776..ad70f4d 100644
--- a/Control/Monad/Error/Class.hs
+++ b/Control/Monad/Error/Class.hs
@@ -39,17 +39,13 @@ The Error monad (also called the Exception monad).
     Andy Gill (<http://web.cecs.pdx.edu/~andy/>)
 -}
 module Control.Monad.Error.Class (
-    Error(..),
     MonadError(..),
     liftEither,
   ) where
 
 import Control.Monad.Trans.Except (Except, ExceptT)
-import Control.Monad.Trans.Error (Error(..), ErrorT)
 import qualified Control.Monad.Trans.Except as ExceptT (throwE, catchE)
-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
@@ -59,6 +55,12 @@ import Control.Monad.Trans.State.Strict as StrictState
 import Control.Monad.Trans.Writer.Lazy as LazyWriter
 import Control.Monad.Trans.Writer.Strict as StrictWriter
 
+#if !MIN_VERSION_transformers(0,6,0)
+import Control.Monad.Trans.Error (Error(..), ErrorT)
+import Control.Monad.Trans.List as List
+import qualified Control.Monad.Trans.Error as ErrorT (throwError, catchError)
+#endif
+
 import Control.Monad.Trans.Class (lift)
 import Control.Exception (IOException, catch, ioError)
 import Control.Monad
@@ -136,9 +138,6 @@ instance MonadError e (Either e) where
     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
 
 {- | @since 2.2 -}
 instance Monad m => MonadError e (ExceptT e m) where
@@ -155,10 +154,16 @@ instance MonadError e m => MonadError e (IdentityT m) where
     throwError = lift . throwError
     catchError = Identity.liftCatch catchError
 
+#if !MIN_VERSION_transformers(0,6,0)
 instance MonadError e m => MonadError e (ListT m) where
     throwError = lift . throwError
     catchError = List.liftCatch catchError
 
+instance (Monad m, Error e) => MonadError e (ErrorT e m) where
+    throwError = ErrorT.throwError
+    catchError = ErrorT.catchError
+#endif
+
 instance MonadError e m => MonadError e (MaybeT m) where
     throwError = lift . throwError
     catchError = Maybe.liftCatch catchError
diff --git a/Control/Monad/List.hs b/Control/Monad/List.hs
deleted file mode 100644
index ff7a584..0000000
--- a/Control/Monad/List.hs
+++ /dev/null
@@ -1,25 +0,0 @@
------------------------------------------------------------------------------
--- |
--- Module      :  Control.Monad.List
--- Copyright   :  (c) Andy Gill 2001,
---                (c) Oregon Graduate Institute of Science and Technology, 2001
--- License     :  BSD-style (see the file LICENSE)
---
--- Maintainer  :  [email protected]
--- Stability   :  experimental
--- Portability :  portable
---
--- The List monad.
---
------------------------------------------------------------------------------
-
-module Control.Monad.List (
-    ListT(..),
-    mapListT,
-    module Control.Monad,
-    module Control.Monad.Trans,
-  ) where
-
-import Control.Monad
-import Control.Monad.Trans
-import Control.Monad.Trans.List
diff --git a/Control/Monad/RWS/Class.hs b/Control/Monad/RWS/Class.hs
index a6329ce..3e7f52d 100644
--- a/Control/Monad/RWS/Class.hs
+++ b/Control/Monad/RWS/Class.hs
@@ -1,3 +1,4 @@
+{-# LANGUAGE CPP #-}
 {-# LANGUAGE FlexibleInstances #-}
 {-# LANGUAGE FunctionalDependencies #-}
 {-# LANGUAGE MultiParamTypeClasses #-}
@@ -35,13 +36,16 @@ 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.Except(ExceptT)
 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)
 
+#if !MIN_VERSION_transformers(0,6,0)
+import Control.Monad.Trans.Error(Error, ErrorT)
+#endif
+
 import Data.Monoid
 
 class (Monoid w, MonadReader r m, MonadWriter w m, MonadState s m)
@@ -59,6 +63,9 @@ instance (Monoid w, Monad m) => MonadRWS r w s (Strict.RWST r w s m)
 
 -- | @since 2.2
 instance MonadRWS r w s m => MonadRWS r w s (ExceptT e m)
-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)
+
+#if !MIN_VERSION_transformers(0,6,0)
+instance (Error e, MonadRWS r w s m) => MonadRWS r w s (ErrorT e m)
+#endif
diff --git a/Control/Monad/Reader/Class.hs b/Control/Monad/Reader/Class.hs
index 60f8383..cd276ae 100644
--- a/Control/Monad/Reader/Class.hs
+++ b/Control/Monad/Reader/Class.hs
@@ -48,9 +48,7 @@ module Control.Monad.Reader.Class (
 
 import Control.Monad.Trans.Cont as Cont
 import Control.Monad.Trans.Except
-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, reader)
@@ -61,6 +59,11 @@ import Control.Monad.Trans.State.Strict as Strict
 import Control.Monad.Trans.Writer.Lazy as Lazy
 import Control.Monad.Trans.Writer.Strict as Strict
 
+#if !MIN_VERSION_transformers(0,6,0)
+import Control.Monad.Trans.Error
+import Control.Monad.Trans.List
+#endif
+
 import Control.Monad.Trans.Class (lift)
 import Control.Monad
 import Data.Monoid
@@ -132,11 +135,18 @@ instance MonadReader r' m => MonadReader r' (ContT r m) where
     local = Cont.liftLocal ask local
     reader = lift . reader
 
+#if !MIN_VERSION_transformers(0,6,0)
 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 (ListT m) where
+    ask   = lift ask
+    local = mapListT . local
+    reader = lift . reader
+#endif
+
 {- | @since 2.2 -}
 instance MonadReader r m => MonadReader r (ExceptT e m) where
     ask   = lift ask
@@ -148,11 +158,6 @@ instance MonadReader r m => MonadReader r (IdentityT m) where
     local = mapIdentityT . local
     reader = lift . reader
 
-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
     ask   = lift ask
     local = mapMaybeT . local
diff --git a/Control/Monad/State/Class.hs b/Control/Monad/State/Class.hs
index 65e5d14..4e20f93 100644
--- a/Control/Monad/State/Class.hs
+++ b/Control/Monad/State/Class.hs
@@ -33,10 +33,8 @@ module Control.Monad.State.Class (
   ) where
 
 import Control.Monad.Trans.Cont
-import Control.Monad.Trans.Error
 import Control.Monad.Trans.Except
 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, state)
@@ -46,6 +44,11 @@ import qualified Control.Monad.Trans.State.Strict as Strict (StateT, get, put, s
 import Control.Monad.Trans.Writer.Lazy as Lazy
 import Control.Monad.Trans.Writer.Strict as Strict
 
+#if !MIN_VERSION_transformers(0,6,0)
+import Control.Monad.Trans.Error
+import Control.Monad.Trans.List
+#endif
+
 import Control.Monad.Trans.Class (lift)
 import Control.Monad
 import Data.Monoid
@@ -134,27 +137,31 @@ instance MonadState s m => MonadState s (ContT r m) where
     put = lift . put
     state = lift . state
 
+#if !MIN_VERSION_transformers(0,6,0)
 instance (Error e, MonadState s m) => MonadState s (ErrorT e m) where
     get = lift get
     put = lift . put
     state = lift . state
 
--- | @since 2.2
-instance MonadState s m => MonadState s (ExceptT e m) where
+instance MonadState s m => MonadState s (ListT m) where
     get = lift get
     put = lift . put
     state = lift . state
+#endif
 
-instance MonadState s m => MonadState s (IdentityT m) where
+-- | @since 2.2
+instance MonadState s m => MonadState s (ExceptT e 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 (IdentityT m) where
     get = lift get
     put = lift . put
     state = lift . state
 
+
+
 instance MonadState s m => MonadState s (MaybeT m) where
     get = lift get
     put = lift . put
diff --git a/Control/Monad/Writer/Class.hs b/Control/Monad/Writer/Class.hs
index 2fc911f..89b2ba3 100644
--- a/Control/Monad/Writer/Class.hs
+++ b/Control/Monad/Writer/Class.hs
@@ -30,7 +30,6 @@ module Control.Monad.Writer.Class (
     censor,
   ) where
 
-import Control.Monad.Trans.Error as Error
 import Control.Monad.Trans.Except as Except
 import Control.Monad.Trans.Identity as Identity
 import Control.Monad.Trans.Maybe as Maybe
@@ -46,6 +45,10 @@ import qualified Control.Monad.Trans.Writer.Lazy as Lazy (
 import qualified Control.Monad.Trans.Writer.Strict as Strict (
         WriterT, writer, tell, listen, pass)
 
+#if !MIN_VERSION_transformers(0,6,0)
+import Control.Monad.Trans.Error as Error
+#endif
+
 import Control.Monad.Trans.Class (lift)
 import Control.Monad
 import Data.Monoid
@@ -144,11 +147,13 @@ instance (Monoid w, Monad m) => MonadWriter w (StrictRWS.RWST r w s m) where
 -- All of these instances need UndecidableInstances,
 -- because they do not satisfy the coverage condition.
 
+#if !MIN_VERSION_transformers(0,6,0)
 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
+#endif
 
 -- | @since 2.2
 instance MonadWriter w m => MonadWriter w (ExceptT e m) where
diff --git a/mtl.cabal b/mtl.cabal
index 7f11397..0b3d432 100644
--- a/mtl.cabal
+++ b/mtl.cabal
@@ -1,5 +1,5 @@
 name:         mtl
-version:      2.2.2
+version:      2.3
 cabal-version: >= 1.10
 license:      BSD3
 license-file: LICENSE
@@ -36,11 +36,9 @@ Library
   exposed-modules:
     Control.Monad.Cont
     Control.Monad.Cont.Class
-    Control.Monad.Error
     Control.Monad.Error.Class
     Control.Monad.Except
     Control.Monad.Identity
-    Control.Monad.List
     Control.Monad.RWS
     Control.Monad.RWS.Class
     Control.Monad.RWS.Lazy
@@ -56,7 +54,7 @@ Library
     Control.Monad.Writer.Class
     Control.Monad.Writer.Lazy
     Control.Monad.Writer.Strict
-  build-depends: base < 5, transformers >= 0.4 && <0.6
+  build-depends: base < 5, transformers >= 0.4 && <0.7
 
   default-language: Haskell2010
   other-extensions: