deriving-trans 0.5.2.0 → 0.6.0.0

raw patch · 6 files changed

+336/−186 lines, 6 filesdep +resourcetdep ~exceptionsdep ~mtldep ~transformersPVP ok

version bump matches the API change (PVP)

Dependencies added: resourcet

Dependency ranges changed: exceptions, mtl, transformers

API changes (from Hackage documentation)

Files

• CHANGELOG.md +15/−0
• deriving-trans.cabal +17/−5
• src/Control/Monad/Accum/OrphanInstances.hs +10/−0
• src/Control/Monad/Select/OrphanInstances.hs +12/−0
• src/Control/Monad/Trans/Compose.hs +221/−138
• src/Control/Monad/Trans/Elevator.hs +61/−43

@@ -1,5 +1,20 @@ # Revision history for deriving-trans +## 0.6.0.0 *23 Jan 2023*++* Update dependencies:+  - transformers `>= 0.6`+  - exceptions `>= 0.4` (optional)+  - mtl `>= 2.3` (optional)+  - primitive (optional)+  - resourcet `>= 1.2` (optional)+  - unliftio (optional)+* Add `MonadAccum` and `MonadSelect` instances to `Elevator` and `ComposeT`.+* Add "base-case" instances for `AccumT` and `SelectT`.+* Add "base-case" instances for the CPS versions of `WriterT` and `RWST`.+* Remove `Monad m` constraint from "base-case" instance for `ContT`.+* Add `MonadResource` instances to `Elevator` and `ComposeT` including a `ResourceT` "base-case" instance.+ ## 0.5.2.0 *17 Jan 2023*  * Add optional dependency `primitive`.

@@ -1,6 +1,6 @@ cabal-version: 3.0 name: deriving-trans-version: 0.5.2.0+version: 0.6.0.0 synopsis: Derive instances for monad transformer stacks description:   Implementing instances for monad transformer stacks can be tedious.@@ -40,6 +40,11 @@   description:     Implement instances for `PrimMonad`. +flag resourcet+  default: True+  description:+    Implement instances for `MonadResource`.+ flag unliftio   default: True   description:@@ -52,22 +57,27 @@     Control.Monad.Trans.Compose.Stack     Control.Monad.Trans.Compose.Transparent     Control.Monad.Trans.Elevator-  --other-modules:   build-depends:     , base < 5     , monad-control     , monad-control-identity-    , transformers+    , transformers >= 0.6     , transformers-base   if flag(exceptions)     build-depends:-      , exceptions+      , exceptions >= 0.4   if flag(mtl)+    other-modules:+      Control.Monad.Accum.OrphanInstances+      Control.Monad.Select.OrphanInstances     build-depends:-      , mtl+      , mtl >= 2.3   if flag(primitive)     build-depends:       , primitive+  if flag(resourcet)+    build-depends:+      , resourcet >= 1.2   if flag(unliftio)     build-depends:       , unliftio-core@@ -88,6 +98,7 @@     FlexibleInstances     FunctionalDependencies     GeneralizedNewtypeDeriving+    ImportQualifiedPost     MultiParamTypeClasses     NamedFieldPuns     OverloadedStrings@@ -101,3 +112,4 @@   ghc-options:     -Wall     -Wunused-packages+    -Wredundant-constraints

@@ -0,0 +1,10 @@+{-# OPTIONS_GHC -fno-warn-orphans #-}++module Control.Monad.Accum.OrphanInstances where++import Control.Monad.Accum+import qualified Control.Monad.Trans.Accum as T++instance (Monoid w, Monad m) => MonadAccum w (T.AccumT w m) where+  look = T.look+  add = T.add

@@ -0,0 +1,12 @@+{-# OPTIONS_GHC -fno-warn-orphans #-}++module Control.Monad.Select.OrphanInstances where++import Control.Monad.Select+import Control.Monad.Trans.Control.Identity+import qualified Control.Monad.Trans.Select as T+import Data.Functor.Identity++instance MonadBaseControlIdentity Identity m => MonadSelect r (T.SelectT r m) where+  select f = T.SelectT $ \ k -> liftBaseWithIdentity $ \runInIdentity ->+    Identity $ f $ runIdentity . runInIdentity . k

@@ -14,34 +14,47 @@ import Data.Kind  #if defined(VERSION_exceptions)-import Control.Monad.Catch-import qualified Control.Monad.Catch.Pure as T+import Control.Monad.Catch qualified as Exceptions+import Control.Monad.Catch.Pure qualified as Exceptions.T #endif  #if defined(VERSION_mtl)-import Control.Monad.Cont.Class-import Control.Monad.Error.Class-import Control.Monad.Reader.Class-import Control.Monad.RWS.Class (MonadRWS)-import Control.Monad.State.Class-import qualified Control.Monad.Trans.Cont as T-import qualified Control.Monad.Trans.Except as T-import qualified Control.Monad.Trans.RWS.Lazy as LT-import qualified Control.Monad.Trans.RWS.Strict as ST-import qualified Control.Monad.Trans.Reader as T-import qualified Control.Monad.Trans.State.Lazy as LT-import qualified Control.Monad.Trans.State.Strict as ST-import qualified Control.Monad.Trans.Writer.Lazy as LT-import qualified Control.Monad.Trans.Writer.Strict as ST-import Control.Monad.Writer.Class+import Control.Monad.Accum qualified as Mtl+import Control.Monad.Accum.OrphanInstances qualified as Mtl ()+import Control.Monad.Cont.Class qualified as Mtl+import Control.Monad.Error.Class qualified as Mtl+import Control.Monad.Reader.Class qualified as Mtl+import Control.Monad.RWS.Class qualified as Mtl (MonadRWS)+import Control.Monad.Select qualified as Mtl+import Control.Monad.Select.OrphanInstances qualified as Mtl ()+import Control.Monad.State.Class qualified as Mtl+import Control.Monad.Trans.Accum qualified as Mtl.T+import Control.Monad.Trans.Cont qualified as Mtl.T+import Control.Monad.Trans.Except qualified as Mtl.T+import Control.Monad.Trans.RWS.CPS qualified as Mtl.CPST+import Control.Monad.Trans.RWS.Lazy qualified as Mtl.LT+import Control.Monad.Trans.RWS.Strict qualified as Mtl.ST+import Control.Monad.Trans.Reader qualified as Mtl.T+import Control.Monad.Trans.Select qualified as Mtl.T+import Control.Monad.Trans.State.Lazy qualified as Mtl.LT+import Control.Monad.Trans.State.Strict qualified as Mtl.ST+import Control.Monad.Trans.Writer.CPS qualified as Mtl.CPST+import Control.Monad.Trans.Writer.Lazy qualified as Mtl.LT+import Control.Monad.Trans.Writer.Strict qualified as Mtl.ST+import Control.Monad.Writer.Class qualified as Mtl+import Data.Functor.Identity qualified as Mtl #endif  #if defined(VERSION_primitive)-import Control.Monad.Primitive+import Control.Monad.Primitive qualified as Primitive #endif +#if defined(VERSION_resourcet)+import Control.Monad.Trans.Resource qualified as ResourceT+#endif+ #if defined(VERSION_unliftio_core)-import Control.Monad.IO.Unlift+import Control.Monad.IO.Unlift qualified as UnliftIO #endif  -- * 'ComposeT'@@ -72,48 +85,44 @@ newtype ComposeT t1 t2 m a = ComposeT { deComposeT :: t1 (t2 m) a }   deriving newtype (Applicative, Functor, Monad) -instance (forall m. Monad m => Monad (t2 m), MonadTrans t1, MonadTrans t2) => MonadTrans (ComposeT t1 t2) where+instance (MonadTrans t1, MonadTrans t2) => MonadTrans (ComposeT t1 t2) where   lift = ComposeT . lift . lift -instance (forall m. Monad m => Monad (t2 m), MonadTransControl t1, MonadTransControl t2) => MonadTransControl (ComposeT t1 t2) where+instance (MonadTransControl t1, MonadTransControl t2) => MonadTransControl (ComposeT t1 t2) where   type StT (ComposeT t1 t2) a = StT t2 (StT t1 a)   liftWith f = defaultLiftWith2 ComposeT deComposeT $ \ x -> f x   restoreT = defaultRestoreT2 ComposeT -instance (forall m. Monad m => Monad (t2 m), MonadTransControlIdentity t1, MonadTransControlIdentity t2) => MonadTransControlIdentity (ComposeT t1 t2) where+instance (MonadTransControlIdentity t1, MonadTransControlIdentity t2) => MonadTransControlIdentity (ComposeT t1 t2) where   liftWithIdentity inner = ComposeT $ liftWithIdentity $ \ runId1 ->     liftWithIdentity $ \ runId2 -> inner $ runId2 . runId1 . deComposeT  -- | Elevated to @m@. deriving via Elevator (ComposeT t1 t2) m   instance-    ( Monad (t1 (t2 m))+    ( MonadIO m     , MonadTrans (ComposeT t1 t2)-    , MonadIO m     ) => MonadIO (ComposeT t1 t2 m)  -- | Elevated to @m@. deriving via Elevator (ComposeT t1 t2) m   instance-    ( Monad (t1 (t2 m))+    ( MonadBase b m     , MonadTrans (ComposeT t1 t2)-    , MonadBase b m     ) => MonadBase b (ComposeT t1 t2 m)  -- | Elevated to @m@. deriving via Elevator (ComposeT t1 t2) m   instance-    ( Monad (t1 (t2 m))+    ( MonadBaseControl b m     , MonadTransControl (ComposeT t1 t2)-    , MonadBaseControl b m     ) => MonadBaseControl b (ComposeT t1 t2 m)  -- | Elevated to @m@. deriving via Elevator (ComposeT t1 t2) m   instance-    ( Monad (t1 (t2 m))+    ( MonadBaseControlIdentity b m     , MonadTransControlIdentity (ComposeT t1 t2)-    , MonadBaseControlIdentity b m     ) => MonadBaseControlIdentity b (ComposeT t1 t2 m)  #if defined(VERSION_exceptions)@@ -121,31 +130,29 @@ -- Elevated to @(t2 m)@. deriving via Elevator t1 (t2 (m :: Type -> Type))   instance {-# OVERLAPPABLE #-}-    ( Monad (t1 (t2 m))+    ( Exceptions.MonadThrow (t2 m)     , MonadTrans t1-    , MonadThrow (t2 m)-    ) => MonadThrow (ComposeT t1 t2 m)+    ) => Exceptions.MonadThrow (ComposeT t1 t2 m) --- | Set by 'T.CatchT'.-deriving via T.CatchT (t2 (m :: Type -> Type))+-- | Set by 'Exceptions.T.CatchT'.+deriving via Exceptions.T.CatchT (t2 (m :: Type -> Type))   instance     ( Monad (t2 m)-    ) => MonadThrow (ComposeT T.CatchT t2 m)+    ) => Exceptions.MonadThrow (ComposeT Exceptions.T.CatchT t2 m)  -- | /OVERLAPPABLE/. -- Elevated to @(t2 m)@. deriving via Elevator t1 (t2 (m :: Type -> Type))   instance {-# OVERLAPPABLE #-}-    ( Monad (t1 (t2 m))+    ( Exceptions.MonadCatch (t2 m)     , MonadTransControl t1-    , MonadCatch (t2 m)-    ) => MonadCatch (ComposeT t1 t2 m)+    ) => Exceptions.MonadCatch (ComposeT t1 t2 m) --- | Set by 'T.CatchT'.-deriving via T.CatchT (t2 (m :: Type -> Type))+-- | Set by 'Exceptions.T.CatchT'.+deriving via Exceptions.T.CatchT (t2 (m :: Type -> Type))   instance     ( Monad (t2 m)-    ) => MonadCatch (ComposeT T.CatchT t2 m)+    ) => Exceptions.MonadCatch (ComposeT Exceptions.T.CatchT t2 m) #endif  #if defined(VERSION_mtl)@@ -153,177 +160,253 @@ -- Elevated to @(t2 m)@. deriving via Elevator t1 (t2 (m :: Type -> Type))   instance {-# OVERLAPPABLE #-}-    ( Monad (t1 (t2 m))-    , MonadTransControl t1-    , MonadCont (t2 m)-    ) => MonadCont (ComposeT t1 t2 m)+    ( Mtl.MonadAccum w (t2 m)+    , MonadTrans t1+    ) => Mtl.MonadAccum w (ComposeT t1 t2 m) --- | Set by 'T.ContT'.-deriving via T.ContT r (t2 (m :: Type -> Type))+-- | Set by 'Mtl.T.AccumT'.+deriving via Mtl.T.AccumT w (t2 (m :: Type -> Type))   instance-    ( Monad (t2 m)-    ) => MonadCont (ComposeT (T.ContT r) t2 m)+    ( Monoid w+    , Monad (t2 m)+    ) => Mtl.MonadAccum w (ComposeT (Mtl.T.AccumT w) t2 m)  -- | /OVERLAPPABLE/. -- Elevated to @(t2 m)@. deriving via Elevator t1 (t2 (m :: Type -> Type))   instance {-# OVERLAPPABLE #-}-    ( Monad (t1 (t2 m))+    ( Mtl.MonadCont (t2 m)     , MonadTransControl t1-    , MonadError e (t2 m)-    ) => MonadError e (ComposeT t1 t2 m)+    ) => Mtl.MonadCont (ComposeT t1 t2 m) --- | Set by 'T.ExceptT'.-deriving via T.ExceptT e (t2 (m :: Type -> Type))+-- | Set by 'Mtl.T.ContT'.+deriving via Mtl.T.ContT r (t2 (m :: Type -> Type))+  instance Mtl.MonadCont (ComposeT (Mtl.T.ContT r) t2 m)++-- | /OVERLAPPABLE/.+-- Elevated to @(t2 m)@.+deriving via Elevator t1 (t2 (m :: Type -> Type))+  instance {-# OVERLAPPABLE #-}+    ( Mtl.MonadError e (t2 m)+    , MonadTransControl t1+    ) => Mtl.MonadError e (ComposeT t1 t2 m)++-- | Set by 'Mtl.T.ExceptT'.+deriving via Mtl.T.ExceptT e (t2 (m :: Type -> Type))   instance     ( Monad (t2 m)-    ) => MonadError e (ComposeT (T.ExceptT e) t2 m)+    ) => Mtl.MonadError e (ComposeT (Mtl.T.ExceptT e) t2 m)  -- | /OVERLAPPABLE/. -- Elevated to @(t2 m)@. deriving via Elevator t1 (t2 (m :: Type -> Type))   instance {-# OVERLAPPABLE #-}-    ( Monad (t1 (t2 m))+    ( Mtl.MonadReader r (t2 m)     , MonadTransControl t1-    , MonadReader r (t2 m)-    ) => MonadReader r (ComposeT t1 t2 m)+    ) => Mtl.MonadReader r (ComposeT t1 t2 m) --- | Set by 'T.ReaderT'.-deriving via T.ReaderT r (t2 (m :: Type -> Type))+-- | Set by 'Mtl.T.ReaderT'.+deriving via Mtl.T.ReaderT r (t2 (m :: Type -> Type))   instance     ( Monad (t2 m)-    ) => MonadReader r (ComposeT (T.ReaderT r) t2 m)+    ) => Mtl.MonadReader r (ComposeT (Mtl.T.ReaderT r) t2 m) --- | Set by 'LT.RWST'.-deriving via LT.RWST r w s (t2 (m :: Type -> Type))+-- | Set by 'Mtl.CPST.RWST'.+deriving via Mtl.CPST.RWST r w s (t2 (m :: Type -> Type))   instance-    ( Monad (t2 m)-    , Monoid w-    ) => MonadReader r (ComposeT (LT.RWST r w s) t2 m)+    ( Monoid w+    , Monad (t2 m)+    ) => Mtl.MonadReader r (ComposeT (Mtl.CPST.RWST r w s) t2 m) --- | Set by 'ST.RWST'.-deriving via ST.RWST r w s (t2 (m :: Type -> Type))+-- | Set by 'Mtl.LT.RWST'.+deriving via Mtl.LT.RWST r w s (t2 (m :: Type -> Type))   instance-    ( Monad (t2 m)-    , Monoid w-    ) => MonadReader r (ComposeT (ST.RWST r w s) t2 m)+    ( Monoid w+    , Monad (t2 m)+    ) => Mtl.MonadReader r (ComposeT (Mtl.LT.RWST r w s) t2 m) +-- | Set by 'Mtl.ST.RWST'.+deriving via Mtl.ST.RWST r w s (t2 (m :: Type -> Type))+  instance+    ( Monoid w+    , Monad (t2 m)+    ) => Mtl.MonadReader r (ComposeT (Mtl.ST.RWST r w s) t2 m)+ -- | /OVERLAPPABLE/. -- Elevated to @(t2 m)@. deriving via Elevator t1 (t2 (m :: Type -> Type))   instance {-# OVERLAPPABLE #-}-    ( Monad (t1 (t2 m))+    ( Mtl.MonadRWS r w s (t2 m)     , MonadTransControl t1-    , MonadRWS r w s (t2 m)-    ) => MonadRWS r w s (ComposeT t1 t2 m)+    ) => Mtl.MonadRWS r w s (ComposeT t1 t2 m) --- | Set by 'LT.RWST'.-deriving via LT.RWST r w s (t2 (m :: Type -> Type))+-- | Set by 'Mtl.CPST.RWST'.+deriving via Mtl.CPST.RWST r w s (t2 (m :: Type -> Type))   instance-    ( Monad (t2 m)-    , Monoid w-    ) => MonadRWS r w s (ComposeT (LT.RWST r w s) t2 m)+    ( Monoid w+    , Monad (t2 m)+    ) => Mtl.MonadRWS r w s (ComposeT (Mtl.CPST.RWST r w s) t2 m) --- | Set by 'ST.RWST'.-deriving via ST.RWST r w s (t2 (m :: Type -> Type))+-- | Set by 'Mtl.LT.RWST'.+deriving via Mtl.LT.RWST r w s (t2 (m :: Type -> Type))   instance-    ( Monad (t2 m)-    , Monoid w-    ) => MonadRWS r w s (ComposeT (ST.RWST r w s) t2 m)+    ( Monoid w+    , Monad (t2 m)+    ) => Mtl.MonadRWS r w s (ComposeT (Mtl.LT.RWST r w s) t2 m) +-- | Set by 'Mtl.ST.RWST'.+deriving via Mtl.ST.RWST r w s (t2 (m :: Type -> Type))+  instance+    ( Monoid w+    , Monad (t2 m)+    ) => Mtl.MonadRWS r w s (ComposeT (Mtl.ST.RWST r w s) t2 m)+ -- | /OVERLAPPABLE/. -- Elevated to @(t2 m)@. deriving via Elevator t1 (t2 (m :: Type -> Type))   instance {-# OVERLAPPABLE #-}-    ( Monad (t1 (t2 m))+    ( Mtl.MonadSelect r (t2 m)     , MonadTrans t1-    , MonadState s (t2 m)-    ) => MonadState s (ComposeT t1 t2 m)+    ) => Mtl.MonadSelect r (ComposeT t1 t2 m) --- | Set by 'LT.StateT'.-deriving via LT.StateT s (t2 (m :: Type -> Type))+-- | Set by 'Mtl.T.SelectT'.+deriving via Mtl.T.SelectT r (t2 (m :: Type -> Type))   instance-    ( Monad (t2 m)-    ) => MonadState s (ComposeT (LT.StateT s) t2 m)+    ( MonadBaseControlIdentity Mtl.Identity (t2 m)+    ) => Mtl.MonadSelect r (ComposeT (Mtl.T.SelectT r) t2 m) --- | Set by 'ST.StateT'.-deriving via ST.StateT s (t2 (m :: Type -> Type))+-- | /OVERLAPPABLE/.+-- Elevated to @(t2 m)@.+deriving via Elevator t1 (t2 (m :: Type -> Type))+  instance {-# OVERLAPPABLE #-}+    ( Mtl.MonadState s (t2 m)+    , MonadTrans t1+    ) => Mtl.MonadState s (ComposeT t1 t2 m)++-- | Set by 'Mtl.LT.StateT'.+deriving via Mtl.LT.StateT s (t2 (m :: Type -> Type))   instance     ( Monad (t2 m)-    ) => MonadState s (ComposeT (ST.StateT s) t2 m)+    ) => Mtl.MonadState s (ComposeT (Mtl.LT.StateT s) t2 m) --- | Set by 'LT.RWST'.-deriving via LT.RWST r w s (t2 (m :: Type -> Type))+-- | Set by 'Mtl.ST.StateT'.+deriving via Mtl.ST.StateT s (t2 (m :: Type -> Type))   instance     ( Monad (t2 m)-    , Monoid w-    ) => MonadState s (ComposeT (LT.RWST r w s) t2 m)+    ) => Mtl.MonadState s (ComposeT (Mtl.ST.StateT s) t2 m) --- | Set by 'ST.RWST'.-deriving via ST.RWST r w s (t2 (m :: Type -> Type))+-- | Set by 'Mtl.CPST.RWST'.+deriving via Mtl.CPST.RWST r w s (t2 (m :: Type -> Type))   instance-    ( Monad (t2 m)-    , Monoid w-    ) => MonadState s (ComposeT (ST.RWST r w s) t2 m)+    ( Monoid w+    , Monad (t2 m)+    ) => Mtl.MonadState s (ComposeT (Mtl.CPST.RWST r w s) t2 m) +-- | Set by 'Mtl.LT.RWST'.+deriving via Mtl.LT.RWST r w s (t2 (m :: Type -> Type))+  instance+    ( Monoid w+    , Monad (t2 m)+    ) => Mtl.MonadState s (ComposeT (Mtl.LT.RWST r w s) t2 m)++-- | Set by 'Mtl.ST.RWST'.+deriving via Mtl.ST.RWST r w s (t2 (m :: Type -> Type))+  instance+    ( Monoid w+    , Monad (t2 m)+    ) => Mtl.MonadState s (ComposeT (Mtl.ST.RWST r w s) t2 m)+ -- | /OVERLAPPABLE/. -- Elevated to @(t2 m)@. deriving via Elevator t1 (t2 (m :: Type -> Type))   instance {-# OVERLAPPABLE #-}-    ( Monad (t1 (t2 m))+    ( Mtl.MonadWriter w (t2 m)     , MonadTransControl t1-    , MonadWriter w (t2 m)-    ) => MonadWriter w (ComposeT t1 t2 m)+    ) => Mtl.MonadWriter w (ComposeT t1 t2 m) --- | Set by 'LT.WriterT'.-deriving via LT.WriterT w (t2 (m :: Type -> Type))+-- | Set by 'Mtl.CPST.WriterT'.+deriving via Mtl.CPST.WriterT w (t2 (m :: Type -> Type))   instance-    ( Monad (t2 m)-    , Monoid w-    ) => MonadWriter w (ComposeT (LT.WriterT w) t2 m)+    ( Monoid w+    , Monad (t2 m)+    ) => Mtl.MonadWriter w (ComposeT (Mtl.CPST.WriterT w) t2 m) --- | Set by 'ST.WriterT'.-deriving via ST.WriterT w (t2 (m :: Type -> Type))+-- | Set by 'Mtl.LT.WriterT'.+deriving via Mtl.LT.WriterT w (t2 (m :: Type -> Type))   instance-    ( Monad (t2 m)-    , Monoid w-    ) => MonadWriter w (ComposeT (ST.WriterT w) t2 m)+    ( Monoid w+    , Monad (t2 m)+    ) => Mtl.MonadWriter w (ComposeT (Mtl.LT.WriterT w) t2 m) --- | Set by 'LT.RWST'.-deriving via LT.RWST r w s (t2 (m :: Type -> Type))+-- | Set by 'Mtl.ST.WriterT'.+deriving via Mtl.ST.WriterT w (t2 (m :: Type -> Type))   instance-    ( Monad (t2 m)-    , Monoid w-    ) => MonadWriter w (ComposeT (LT.RWST r w s) t2 m)+    ( Monoid w+    , Monad (t2 m)+    ) => Mtl.MonadWriter w (ComposeT (Mtl.ST.WriterT w) t2 m) --- | Set by 'ST.RWST'.-deriving via ST.RWST r w s (t2 (m :: Type -> Type))+-- | Set by 'Mtl.CPST.RWST'.+deriving via Mtl.CPST.RWST r w s (t2 (m :: Type -> Type))   instance-    ( Monad (t2 m)-    , Monoid w-    ) => MonadWriter w (ComposeT (ST.RWST r w s) t2 m)+    ( Monoid w+    , Monad (t2 m)+    ) => Mtl.MonadWriter w (ComposeT (Mtl.CPST.RWST r w s) t2 m)++-- | Set by 'Mtl.LT.RWST'.+deriving via Mtl.LT.RWST r w s (t2 (m :: Type -> Type))+  instance+    ( Monoid w+    , Monad (t2 m)+    ) => Mtl.MonadWriter w (ComposeT (Mtl.LT.RWST r w s) t2 m)++-- | Set by 'Mtl.ST.RWST'.+deriving via Mtl.ST.RWST r w s (t2 (m :: Type -> Type))+  instance+    ( Monoid w+    , Monad (t2 m)+    ) => Mtl.MonadWriter w (ComposeT (Mtl.ST.RWST r w s) t2 m) #endif  #if defined(VERSION_primitive) -- | Elevated to @m@. deriving via Elevator (ComposeT t1 t2) m   instance-    ( Monad (t1 (t2 m))+    ( Primitive.PrimMonad m     , MonadTrans (ComposeT t1 t2)-    , PrimMonad m     ) =>-    PrimMonad (ComposeT t1 t2 m)+    Primitive.PrimMonad (ComposeT t1 t2 m) #endif +#if defined(VERSION_resourcet)+-- TODO: `MonadIO m` and `MonadTrans t2` should not be required for this instance+-- | /OVERLAPPABLE/.+-- Elevated to @(t2 m)@.+deriving via Elevator t1 (t2 (m :: Type -> Type))+  instance {-# OVERLAPPABLE #-}+    ( ResourceT.MonadResource (t2 m)+    , MonadTrans t1+    , MonadIO m+    , MonadTrans t2+    ) => ResourceT.MonadResource (ComposeT t1 t2 m)++-- TODO: `MonadIO m` and `MonadTrans t2` should not be required for this instance+-- | Set by 'ResourceT.ResourceT'.+deriving via ResourceT.ResourceT (t2 (m :: Type -> Type))+  instance+    ( MonadIO (t2 m)+    , MonadIO m+    , MonadTrans t2+    ) => ResourceT.MonadResource (ComposeT ResourceT.ResourceT t2 m)+#endif+ #if defined(VERSION_unliftio_core) -- | Elevated to @m@. deriving via Elevator (ComposeT t1 t2) m   instance-    ( Monad (t1 (t2 m))+    ( UnliftIO.MonadUnliftIO m     , MonadTransControlIdentity (ComposeT t1 t2)-    , MonadUnliftIO m     ) =>-    MonadUnliftIO (ComposeT t1 t2 m)+    UnliftIO.MonadUnliftIO (ComposeT t1 t2 m) #endif  @@ -423,7 +506,7 @@ -- Create a monad transformer stack and wrap it using a newtype. -- -- @--- type AppStackT = t'Control.Monad.Trans.Compose.Transparent.TransparentT' t'Control.Monad.Trans.Compose.Infix..|>' 'T.ReaderT' 'Bool' t'Control.Monad.Trans.Compose.Infix..|>' CustomT t'Control.Monad.Trans.Compose.Infix..|>' 'T.ReaderT' 'Char' t'Control.Monad.Trans.Compose.Infix..|>' 'LT.StateT' 'Int'+-- type AppStackT = t'Control.Monad.Trans.Compose.Transparent.TransparentT' t'Control.Monad.Trans.Compose.Infix..|>' 'Control.Monad.Trans.Reader.ReaderT' 'Bool' t'Control.Monad.Trans.Compose.Infix..|>' CustomT t'Control.Monad.Trans.Compose.Infix..|>' 'Control.Monad.Trans.Reader.ReaderT' 'Char' t'Control.Monad.Trans.Compose.Infix..|>' 'Control.Monad.Trans.State.Lazy.StateT' 'Int' -- newtype AppT m a = AppT { unAppT :: AppStackT m a } --   deriving newtype ('Functor', 'Applicative', 'Monad') -- @@@ -464,15 +547,15 @@ --     'Control.Monad.Trans.Compose.Infix../>' runStateT' --     $ unAppT appTma --  where---   runReaderT' :: 'Control.Monad.Reader.Class.MonadReader' 'Bool' m => 'T.ReaderT' 'Char' m a -> m a+--   runReaderT' :: 'Control.Monad.Reader.Class.MonadReader' 'Bool' m => 'Control.Monad.Trans.Reader.ReaderT' 'Char' m a -> m a --   runReaderT' tma = do --     bool <- 'Control.Monad.Reader.Class.ask' --     let char = if bool then \'Y\' else \'N\'---     'T.runReaderT' tma char+--     'Control.Monad.Trans.Reader.runReaderT' tma char -----   runStateT' :: 'Control.Monad.Reader.Class.MonadReader' 'Char' m => 'LT.StateT' 'Int' m a -> m (a, 'Int')+--   runStateT' :: 'Control.Monad.Reader.Class.MonadReader' 'Char' m => 'Control.Monad.Trans.State.Lazy.StateT' 'Int' m a -> m (a, 'Int') --   runStateT' tma = do --     char <- 'Control.Monad.Reader.Class.ask' --     let num = 'fromEnum' char---     'LT.runStateT' tma num+--     'Control.Monad.Trans.State.Lazy.runStateT' tma num -- @

@@ -16,24 +16,30 @@ import Data.Kind  #if defined(VERSION_exceptions)-import Control.Monad.Catch+import Control.Monad.Catch qualified as Exceptions #endif  #if defined(VERSION_mtl)-import Control.Monad.Cont.Class-import Control.Monad.Error.Class-import Control.Monad.Reader.Class-import Control.Monad.RWS.Class (MonadRWS)-import Control.Monad.State.Class-import Control.Monad.Writer.Class+import Control.Monad.Accum qualified as Mtl+import Control.Monad.Cont.Class qualified as Mtl+import Control.Monad.Error.Class qualified as Mtl+import Control.Monad.Reader.Class qualified as Mtl+import Control.Monad.RWS.Class qualified as Mtl (MonadRWS)+import Control.Monad.Select qualified as Mtl+import Control.Monad.State.Class qualified as Mtl+import Control.Monad.Writer.Class qualified as Mtl #endif  #if defined(VERSION_primitive)-import Control.Monad.Primitive+import Control.Monad.Primitive qualified as Primitive #endif +#if defined(VERSION_resourcet)+import Control.Monad.Trans.Resource qualified as ResourceT+#endif+ #if defined(VERSION_unliftio_core)-import Control.Monad.IO.Unlift+import Control.Monad.IO.Unlift qualified as UnliftIO #endif  -- * 'Elevator'@@ -63,82 +69,94 @@   deriving newtype (Applicative, Functor, Monad)   deriving newtype (MonadTrans, MonadTransControl, MonadTransControlIdentity) -instance (Monad (t m), MonadTrans t, MonadBase b m) => MonadBase b (Elevator t m) where+instance (MonadBase b m, MonadTrans t) => MonadBase b (Elevator t m) where   liftBase = lift . liftBase -instance (Monad (t m), MonadTransControl t, MonadBaseControl b m) => MonadBaseControl b (Elevator t m) where+instance (MonadBaseControl b m, MonadTransControl t) => MonadBaseControl b (Elevator t m) where   type StM (Elevator t m) a = StM m (StT t a)   liftBaseWith f = liftWith $ \ runT -> liftBaseWith $ \ runInBase -> f $ runInBase . runT   restoreM = restoreT . restoreM -instance (Monad (t m), MonadTransControlIdentity t, MonadBaseControlIdentity b m) => MonadBaseControlIdentity b (Elevator t m) where+instance (MonadBaseControlIdentity b m, MonadTransControlIdentity t) => MonadBaseControlIdentity b (Elevator t m) where   liftBaseWithIdentity = defaultLiftBaseWithIdentity -instance (Monad (t m), MonadTransControl t, Monad m, Alternative m) => Alternative (Elevator t m) where+instance (Alternative m, Monad m, MonadTransControl t) => Alternative (Elevator t m) where   empty = lift empty   (<|>) x y = (restoreT . pure =<<) $ liftWith $ \ runT -> runT x <|> runT y -instance (Monad (t m), MonadTrans t, MonadFail m) => MonadFail (Elevator t m) where+instance (MonadFail m, MonadTrans t) => MonadFail (Elevator t m) where   fail = lift . fail -instance (Monad (t m), MonadTransControlIdentity t, MonadFix m) => MonadFix (Elevator t m) where+instance (MonadFix m, MonadTransControlIdentity t) => MonadFix (Elevator t m) where   mfix f = liftWithIdentity $ \ runT -> mfix $ \ x -> runT $ f x -instance (Monad (t m), MonadTrans t, MonadIO m) => MonadIO (Elevator t m) where+instance (MonadIO m, MonadTrans t) => MonadIO (Elevator t m) where   liftIO = lift . liftIO -instance (Monad (t m), MonadTransControl t, MonadPlus m) => MonadPlus (Elevator t m)+instance (MonadPlus m, MonadTransControl t) => MonadPlus (Elevator t m) -instance (Monad (t m), MonadTransControlIdentity t, MonadZip m) => MonadZip (Elevator t m) where+instance (MonadZip m, MonadTransControlIdentity t) => MonadZip (Elevator t m) where   mzip x y = liftWithIdentity $ \ runT ->     mzip (runT x) (runT y)  #if defined(VERSION_exceptions)-instance (Monad (t m), MonadTrans t, MonadThrow m) => MonadThrow (Elevator t m) where-  throwM = lift . throwM+instance (Exceptions.MonadThrow m, MonadTrans t) => Exceptions.MonadThrow (Elevator t m) where+  throwM = lift . Exceptions.throwM -instance (Monad (t m), MonadTransControl t, MonadCatch m) => MonadCatch (Elevator t m) where+instance (Exceptions.MonadCatch m, MonadTransControl t) => Exceptions.MonadCatch (Elevator t m) where   catch throwing catching = (restoreT . pure =<<) $ liftWith $ \ runT ->-    catch (runT throwing) (runT . catching)+    Exceptions.catch (runT throwing) (runT . catching) #endif  #if defined(VERSION_mtl)-instance (Monad (t m), MonadTransControl t, MonadCont m) => MonadCont (Elevator t m) where+instance (Mtl.MonadAccum w m, MonadTrans t) => Mtl.MonadAccum w (Elevator t m) where+  look = lift Mtl.look+  add = lift . Mtl.add++instance (Mtl.MonadCont m, MonadTransControl t) => Mtl.MonadCont (Elevator t m) where   callCC f = (restoreT . pure =<<) $ liftWith $ \ runT ->-    callCC $ \ c -> runT $ f $ \ a -> restoreT $ c =<< runT (pure a)+    Mtl.callCC $ \ c -> runT $ f $ \ a -> restoreT $ c =<< runT (pure a) -instance (Monad (t m), MonadTransControl t, MonadError e m) => MonadError e (Elevator t m) where-  throwError = lift . throwError+instance (Mtl.MonadError e m, MonadTransControl t) => Mtl.MonadError e (Elevator t m) where+  throwError = lift . Mtl.throwError   catchError throwing catching = (restoreT . pure =<<) $ liftWith $ \ runT ->-    catchError (runT throwing) (runT . catching)+    Mtl.catchError (runT throwing) (runT . catching) -instance (Monad (t m), MonadTransControl t, MonadReader r m) => MonadReader r (Elevator t m) where-  ask = lift ask+instance (Mtl.MonadReader r m, MonadTransControl t) => Mtl.MonadReader r (Elevator t m) where+  ask = lift Mtl.ask   local f tma = (restoreT . pure =<<) $ liftWith $ \ runT ->-    local f $ runT tma+    Mtl.local f $ runT tma -instance (Monad (t m), MonadTransControl t, MonadRWS r w s m) => MonadRWS r w s (Elevator t m)+instance (Mtl.MonadRWS r w s m, MonadTransControl t) => Mtl.MonadRWS r w s (Elevator t m) -instance (Monad (t m), MonadTrans t, MonadState s m) => MonadState s (Elevator t m) where-  get = lift get-  put = lift . put+instance (Mtl.MonadSelect r m, MonadTrans t) => Mtl.MonadSelect r (Elevator t m) where+  select = lift . Mtl.select -instance (Monad (t m), MonadTransControl t, MonadWriter w m) => MonadWriter w (Elevator t m) where-  tell = lift . tell-  listen tma = liftWith (\ runT -> listen $ runT tma) >>= \ (sta, w) ->+instance (Mtl.MonadState s m, MonadTrans t) => Mtl.MonadState s (Elevator t m) where+  get = lift Mtl.get+  put = lift . Mtl.put++instance (Mtl.MonadWriter w m, MonadTransControl t) => Mtl.MonadWriter w (Elevator t m) where+  tell = lift . Mtl.tell+  listen tma = liftWith (\ runT -> Mtl.listen $ runT tma) >>= \ (sta, w) ->     (, w) <$> restoreT (pure sta)-  pass tma = lift . pass . pure =<< tma+  pass tma = lift . Mtl.pass . pure =<< tma #endif  #if defined(VERSION_primitive)-instance (Monad (t m), MonadTrans t, PrimMonad m) => PrimMonad (Elevator t m) where-  type PrimState (Elevator t m) = PrimState m-  primitive = lift . primitive+instance (Primitive.PrimMonad m, MonadTrans t) => Primitive.PrimMonad (Elevator t m) where+  type PrimState (Elevator t m) = Primitive.PrimState m+  primitive = lift . Primitive.primitive #endif +#if defined(VERSION_resourcet)+instance (ResourceT.MonadResource m, MonadTrans t) => ResourceT.MonadResource (Elevator t m) where+  liftResourceT = lift . ResourceT.liftResourceT+#endif+ #if defined(VERSION_unliftio_core)-instance (Monad (t m), MonadTransControlIdentity t, MonadUnliftIO m) => MonadUnliftIO (Elevator t m) where-  withRunInIO f = liftWithIdentity $ \runT -> withRunInIO $ \runInIO -> f $ runInIO . runT+instance (UnliftIO.MonadUnliftIO m, MonadTransControlIdentity t) => UnliftIO.MonadUnliftIO (Elevator t m) where+  withRunInIO f = liftWithIdentity $ \runT -> UnliftIO.withRunInIO $ \runInIO -> f $ runInIO . runT #endif  -- * Examples