deriving-trans 0.8.0.0 → 0.8.1.0

raw patch · 4 files changed

+121/−3 lines, 4 filesdep +logictPVP ok

version bump matches the API change (PVP)

Dependencies added: logict

API changes (from Hackage documentation)

Files

• CHANGELOG.md +7/−0
• deriving-trans.cabal +9/−1
• src/Control/Monad/Trans/Compose.hs +71/−2
• src/Control/Monad/Trans/Elevator.hs +34/−0

@@ -1,5 +1,12 @@ # Revision history for deriving-trans +## 0.8.1.0 *20 Feb 2023*++* Support new optional dependency logict `>= 0.8.0.0`.+* Add `MonadLogic` instances to `Elevator` and `ComposeT` including a `LogicT` "base-case" instance.+* Add `MonadMask` instances to `Elevator` and `ComposeT` including a `CatchT` "base-case" instance.+* Add `MonadPlus` "base-case" instances for `ExceptT`, `MaybeT`, `CatchT` and `LogicT`.+ ## 0.8.0.0 *31 Jan 2023*  * Update version boundaries of dependencies:

@@ -1,6 +1,6 @@ cabal-version: 3.0 name: deriving-trans-version: 0.8.0.0+version: 0.8.1.0 synopsis: Derive instances for monad transformer stacks description:   Implementing instances for monad transformer stacks can be tedious.@@ -30,6 +30,11 @@   description:     Implement instances for 'MonadThrow' and 'MonadCatch'. +flag logict+  default: True+  description:+    Implement instances for `MonadLogic`.+ flag mtl   default: True   description:@@ -71,6 +76,9 @@   if flag(exceptions)     build-depends:       , exceptions >= 0.10.5+  if flag(logict)+    build-depends:+      , logict >= 0.8.0.0   if flag(mtl)     other-modules:       Control.Monad.Accum.OrphanInstances

@@ -24,6 +24,11 @@ import Control.Monad.Catch.Pure qualified as Exceptions.T #endif +#if defined(VERSION_logict)+import Control.Monad.Logic qualified as LogicT.T+import Control.Monad.Logic.Class qualified as LogicT+#endif+ #if defined(VERSION_mtl) import Control.Monad.Accum qualified as Mtl import Control.Monad.Accum.OrphanInstances qualified as Mtl ()@@ -180,9 +185,27 @@     , MonadTrans (ComposeT t1 t2)     ) => MonadIO (ComposeT t1 t2 m) --- | Determined by 'Alternative'.-instance (MonadPlus (t2 m), MonadTransControl t1) => MonadPlus (ComposeT t1 t2 m)+-- | /OVERLAPPABLE/.+-- Elevated to @(t2 m)@.+deriving via Elevator t1 (t2 (m :: Type -> Type))+  instance {-# OVERLAPPABLE #-}+    ( MonadPlus (t2 m)+    , MonadTransControl t1+    ) => MonadPlus (ComposeT t1 t2 m) +-- | Set by 'T.ExceptT'.+deriving via T.ExceptT e (t2 (m :: Type -> Type))+  instance+    ( Monoid e+    , Monad (t2 m)+    ) => MonadPlus (ComposeT (T.ExceptT e) t2 m)++-- | Set by 'T.MaybeT'.+deriving via T.MaybeT (t2 (m :: Type -> Type))+  instance+    ( Monad (t2 m)+    ) => MonadPlus (ComposeT T.MaybeT t2 m)+ -- | /OVERLAPPABLE/. -- Elevated to @(t2 m)@. deriving via Elevator t1 (t2 (m :: Type -> Type))@@ -204,6 +227,12 @@     ( Monad (t2 m)     ) => MonadFail (ComposeT Exceptions.T.CatchT t2 m) +-- | Set by 'Exceptions.T.CatchT'.+deriving via Exceptions.T.CatchT (t2 (m :: Type -> Type))+  instance+    ( Monad (t2 m)+    ) => MonadPlus (ComposeT Exceptions.T.CatchT t2 m)+ -- | /OVERLAPPABLE/. -- Elevated to @(t2 m)@. deriving via Elevator t1 (t2 (m :: Type -> Type))@@ -231,6 +260,46 @@   instance     ( Monad (t2 m)     ) => Exceptions.MonadCatch (ComposeT Exceptions.T.CatchT t2 m)++-- | /OVERLAPPABLE/.+-- Elevated to @(t2 m)@.+deriving via Elevator t1 (t2 (m :: Type -> Type))+  instance {-# OVERLAPPABLE #-}+    ( Exceptions.MonadMask (t2 m)+    , MonadTransControl t1+    ) => Exceptions.MonadMask (ComposeT t1 t2 m)++-- | Set by 'Exceptions.T.CatchT'.+deriving via Exceptions.T.CatchT (t2 (m :: Type -> Type))+  instance+    ( Monad (t2 m)+    ) => Exceptions.MonadMask (ComposeT Exceptions.T.CatchT t2 m)+#endif++#if defined(VERSION_logict)+-- | Set by 'LogicT.T.LogicT'.+deriving via LogicT.T.LogicT (t2 (m :: Type -> Type))+  instance Alternative (ComposeT LogicT.T.LogicT t2 m)++-- | Set by 'Logic.T.LogicT'.+deriving via LogicT.T.LogicT (t2 (m :: Type -> Type))+  instance MonadFail (ComposeT LogicT.T.LogicT t2 m)++-- | Set by 'LogicT.T.LogicT'.+deriving via LogicT.T.LogicT (t2 (m :: Type -> Type))+  instance MonadPlus (ComposeT LogicT.T.LogicT t2 m)++-- | /OVERLAPPABLE/.+-- Elevated to @(t2 m)@.+instance {-# OVERLAPPABLE #-} (LogicT.MonadLogic (t2 m), MonadTransControlIdentity t1) => LogicT.MonadLogic (ComposeT t1 t2 m) where+  msplit = (((\(a, b) -> (a, ComposeT $ descend b)) <$>) <$>) .+    ComposeT . descend . LogicT.msplit . Ascend . deComposeT++-- | Set by 'LogicT.T.LogicT'.+deriving via LogicT.T.LogicT (t2 (m :: Type -> Type))+  instance+    ( Monad (t2 m)+    ) => LogicT.MonadLogic (ComposeT LogicT.T.LogicT t2 m) #endif  #if defined(VERSION_mtl)

@@ -19,6 +19,10 @@ import Control.Monad.Catch qualified as Exceptions #endif +#if defined(VERSION_logict)+import Control.Monad.Logic.Class qualified as LogicT+#endif+ #if defined(VERSION_mtl) import Control.Monad.Accum qualified as Mtl import Control.Monad.Cont.Class qualified as Mtl@@ -111,6 +115,36 @@ instance (Exceptions.MonadCatch m, MonadTransControl t) => Exceptions.MonadCatch (Elevator t m) where   catch throwing catching = (restoreT . pure =<<) $ liftWith $ \ runT ->     Exceptions.catch (runT throwing) (runT . catching)++instance (Exceptions.MonadMask m, MonadTransControl t) => Exceptions.MonadMask (Elevator t m) where+  mask f = (restoreT . pure =<<) $ liftWith $ \ runT ->+    Exceptions.mask $ \ u -> runT $ f $ restoreT . u . runT+  uninterruptibleMask f = (restoreT . pure =<<) $ liftWith $ \ runT ->+    Exceptions.uninterruptibleMask $ \ u -> runT $ f $ restoreT . u . runT+  generalBracket acquire release use = do+    (usageResult', releaseResult') <- liftWith $ \ runT -> do+      Exceptions.generalBracket+        (runT acquire)+        (\ resource' exitCase' -> runT $ do+          resource <- restoreT $ pure resource'+          case exitCase' of+            Exceptions.ExitCaseSuccess x' ->+              release resource . Exceptions.ExitCaseSuccess =<< restoreT (pure x')+            Exceptions.ExitCaseException e ->+              release resource (Exceptions.ExitCaseException e)+            Exceptions.ExitCaseAbort ->+              release resource Exceptions.ExitCaseAbort+        )+        (\ resource -> runT $ use =<< restoreT (pure resource))+    usageResult <- restoreT $ pure usageResult'+    releaseResult <- restoreT $ pure releaseResult'+    pure (usageResult, releaseResult)+#endif++#if defined(VERSION_logict)+instance (LogicT.MonadLogic m, MonadTransControlIdentity t) => LogicT.MonadLogic (Elevator t m) where+  msplit tma = (((\(a, b) -> (a, lift b)) <$>) <$>) $+    liftWithIdentity $ \runT -> LogicT.msplit $ runT tma #endif  #if defined(VERSION_mtl)