Comments (5)
In fact, I don't see what mtl
can do otherwise then making a mtl-2.3
(i.e .breaking change) as transformers in Control.Monad.List
and Control.Monad.Error
are removed, and I think it's easier to just remove them from mtl
as well.
from mtl.
Revision is not enough.
[ 1 of 22] Compiling Control.Monad.Cont.Class ( Control/Monad/Cont/Class.hs, dist/build/Control/Monad/Cont/Class.o )
Control/Monad/Cont/Class.hs:58:1: error:
Could not load module ‘Control.Monad.Trans.Error’
It is a member of the hidden package ‘transformers-0.5.6.2’.
from mtl.
I'll use the following patch to see how my packages break:
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:
from mtl.
Removing Control.Monad.List
is a great idea. It doesn't define a class anyways, and ties with this broken transformer should be broken.
For Control.Monad.Error
we should check first whether there are any important bits of documentation that are not present in ExceptT
.
from mtl.
Compatibility is in master, but a release has not yet been made. Closing in favour of #86 (MTL 2.3 tracking issue)
from mtl.
Related Issues (20)
- README inaccurately mentions Control.Monad.Error Control.Monad.Except HOT 2
- "Since" information for `MonadFail` instances missing (haddock, CHANGELOG)
- Add release dates to CHANGELOG HOT 1
- mtl current master is Safe-inferred (but actually may not be) HOT 9
- Changelog for mtl-2.3 doesn't mention removal of re-export of several modules
- mtl 3.0 planning HOT 12
- `mtl-2.3` dropped `ExceptT` HOT 15
- `mtl-2.3` needs a migration guide for removal of re-exports HOT 3
- Redundant constraint Monoid w in GHC 9.4 build HOT 1
- Tag for `mtl-2.3` HOT 7
- FYI: A paper on how Hackage packages use `mtl`.
- Why not use rank 2 polymorphism for `callCC` HOT 2
- Make MonadCont instance for ContT polykinded HOT 2
- how can i help with a 2.3.1 release or the like? HOT 1
- Build error against transformers-0.6 with GHC-9.0 HOT 13
- Conversions between lazy and strict StateT
- LiftingState
- Request: Export runWriterT from Writer.CPS HOT 1
- How to combine two different `r` `MonadReaders` ? HOT 1
- Windows CI Fails
Recommend Projects
-
React
A declarative, efficient, and flexible JavaScript library for building user interfaces.
-
Vue.js
🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.
-
Typescript
TypeScript is a superset of JavaScript that compiles to clean JavaScript output.
-
TensorFlow
An Open Source Machine Learning Framework for Everyone
-
Django
The Web framework for perfectionists with deadlines.
-
Laravel
A PHP framework for web artisans
-
D3
Bring data to life with SVG, Canvas and HTML. 📊📈🎉
-
Recommend Topics
-
javascript
JavaScript (JS) is a lightweight interpreted programming language with first-class functions.
-
web
Some thing interesting about web. New door for the world.
-
server
A server is a program made to process requests and deliver data to clients.
-
Machine learning
Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.
-
Visualization
Some thing interesting about visualization, use data art
-
Game
Some thing interesting about game, make everyone happy.
Recommend Org
-
Facebook
We are working to build community through open source technology. NB: members must have two-factor auth.
-
Microsoft
Open source projects and samples from Microsoft.
-
Google
Google ❤️ Open Source for everyone.
-
Alibaba
Alibaba Open Source for everyone
-
D3
Data-Driven Documents codes.
-
Tencent
China tencent open source team.
from mtl.