monadology 0.3 → 0.4

raw patch · 24 files changed

+152/−153 lines, 24 filesdep ~basedep ~constraintsdep ~transformersPVP ok

version bump matches the API change (PVP)

Dependency ranges changed: base, constraints, transformers, witness

API changes (from Hackage documentation)

Files

• changelog.md +5/−0
• monadology.cabal +19/−61
• src/Control/Monad/Ology/Data/Param.hs +7/−0
• src/Control/Monad/Ology/Data/Ref.hs +13/−10
• src/Control/Monad/Ology/General/Catch.hs +1/−1
• src/Control/Monad/Ology/General/Coroutine.hs +2/−7
• src/Control/Monad/Ology/General/Exception.hs +1/−1
• src/Control/Monad/Ology/General/Exception/Class.hs +1/−1
• src/Control/Monad/Ology/General/Function.hs +2/−0
• src/Control/Monad/Ology/General/Throw.hs +1/−1
• src/Control/Monad/Ology/General/Trans/AskUnlift.hs +2/−3
• src/Control/Monad/Ology/General/Trans/Tunnel.hs +15/−1
• src/Control/Monad/Ology/General/Trans/Unlift.hs +2/−2
• src/Control/Monad/Ology/Specific/ComposeInner.hs +34/−29
• src/Control/Monad/Ology/Specific/ComposeOuter.hs +22/−20
• src/Control/Monad/Ology/Specific/ComposeT.hs +7/−7
• src/Control/Monad/Ology/Specific/ContT.hs +1/−1
• src/Control/Monad/Ology/Specific/ExceptT.hs +1/−1
• src/Control/Monad/Ology/Specific/LifecycleT.hs +1/−1
• src/Control/Monad/Ology/Specific/Result.hs +1/−1
• src/Control/Monad/Ology/Specific/StackT.hs +1/−3
• src/Control/Monad/Ology/Specific/StepT.hs +11/−0
• src/Control/Monad/Ology/Specific/WriterT.hs +1/−1
• test/Exception.hs +1/−1

@@ -1,3 +1,8 @@+## [0.4] - 2024-12-15++- fix for GHC 9.8, 9.10+- add refPutRestore+ ## [0.3] - 2023-07-25  - LifecycleT: improve to make closing more robust

@@ -1,11 +1,11 @@ cabal-version: 2.2 --- This file has been generated from package.yaml by hpack version 0.35.0.+-- This file has been generated from package.yaml by hpack version 0.37.0. -- -- see: https://github.com/sol/hpack  name:           monadology-version:        0.3+version:        0.4 synopsis:       The best ideas in monad-related classes and types. description:    Monadology is intended as a collection of the best ideas in monad-related classes and types, with a focus on correctness and elegance, and theoretical understanding, rather than practical performance. category:       Monads@@ -13,15 +13,14 @@ bug-reports:    https://github.com/AshleyYakeley/monadology/issues author:         Ashley Yakeley maintainer:     <ashley@semantic.org>-copyright:      (c) 2017-2023 Ashley Yakeley+copyright:      (c) 2017-2024 Ashley Yakeley license:        BSD-2-Clause license-file:   LICENSE build-type:     Simple tested-with:-    GHC == 9.2.8-  , GHC == 9.4.5-  , GHC == 9.6.2-extra-source-files:+    GHC == 9.8.4+  , GHC == 9.10.1+extra-doc-files:     changelog.md  source-repository head@@ -81,58 +80,38 @@   default-extensions:       AllowAmbiguousTypes       Arrows-      ConstraintKinds       DataKinds       DefaultSignatures-      EmptyCase-      EmptyDataDecls-      ExistentialQuantification-      FlexibleContexts-      FlexibleInstances-      ForeignFunctionInterface+      DerivingStrategies       FunctionalDependencies-      GADTs-      GeneralizedNewtypeDeriving       ImplicitParams       NoImplicitPrelude-      InstanceSigs-      KindSignatures       LambdaCase-      MultiParamTypeClasses       OverloadedLabels       OverloadedStrings       PartialTypeSignatures-      PatternGuards       PatternSynonyms-      PolyKinds       QuantifiedConstraints-      RankNTypes       RecordWildCards       RecursiveDo       RoleAnnotations-      ScopedTypeVariables-      StandaloneDeriving-      StandaloneKindSignatures       NoStarIsType       TemplateHaskell-      TypeApplications+      TypeAbstractions       TypeFamilies       TypeFamilyDependencies-      TypeInType-      TypeOperators-      TypeSynonymInstances       UndecidableInstances       UndecidableSuperClasses       ViewPatterns-  ghc-options: -Wall -Wincomplete-uni-patterns -Wincomplete-record-updates -Wcompat -Wnoncanonical-monad-instances -Wno-partial-type-signatures+  ghc-options: -Weverything -Wno-missing-import-lists -Wno-missing-export-lists -Wno-unsafe -Wno-missing-safe-haskell-mode -Wno-missing-kind-signatures -Wno-partial-type-signatures -Wno-missing-role-annotations -Wno-monomorphism-restriction -Wno-missing-local-signatures -Wno-partial-fields -Wno-all-missed-specialisations -Wno-missed-specialisations   build-depends:-      base >=4.15 && <5-    , constraints >=0.13+      base >=4.19 && <5+    , constraints >=0.14     , invariant >=0.6-    , transformers >=0.5+    , transformers >=0.6     , type-rig >=0.1-    , witness >=0.6.1-  default-language: Haskell2010+    , witness >=0.7+  default-language: GHC2021  test-suite test   type: exitcode-stdio-1.0@@ -149,55 +128,34 @@   default-extensions:       AllowAmbiguousTypes       Arrows-      ConstraintKinds       DataKinds       DefaultSignatures-      EmptyCase-      EmptyDataDecls-      ExistentialQuantification-      FlexibleContexts-      FlexibleInstances-      ForeignFunctionInterface+      DerivingStrategies       FunctionalDependencies-      GADTs-      GeneralizedNewtypeDeriving       ImplicitParams       NoImplicitPrelude-      InstanceSigs-      KindSignatures       LambdaCase-      MultiParamTypeClasses       OverloadedLabels       OverloadedStrings       PartialTypeSignatures-      PatternGuards       PatternSynonyms-      PolyKinds       QuantifiedConstraints-      RankNTypes       RecordWildCards       RecursiveDo       RoleAnnotations-      ScopedTypeVariables-      StandaloneDeriving-      StandaloneKindSignatures       NoStarIsType       TemplateHaskell-      TypeApplications+      TypeAbstractions       TypeFamilies       TypeFamilyDependencies-      TypeInType-      TypeOperators-      TypeSynonymInstances       UndecidableInstances       UndecidableSuperClasses       ViewPatterns-  ghc-options: -Wall -Wincomplete-uni-patterns -Wincomplete-record-updates -Wcompat -Wnoncanonical-monad-instances -Wno-partial-type-signatures -threaded+  ghc-options: -Weverything -Wno-missing-import-lists -Wno-missing-export-lists -Wno-unsafe -Wno-missing-safe-haskell-mode -Wno-missing-kind-signatures -Wno-partial-type-signatures -Wno-missing-role-annotations -Wno-monomorphism-restriction -Wno-missing-local-signatures -Wno-partial-fields -Wno-all-missed-specialisations -Wno-missed-specialisations -threaded   build-depends:-      base >=4.15 && <5+      base >=4.19 && <5     , monadology     , tasty >=1.4     , tasty-hunit >=0.10     , text >=2.0-    , transformers >=0.5-  default-language: Haskell2010+  default-language: GHC2021

@@ -20,6 +20,13 @@     rUnit = MkParam (pure ()) (\() -> id)     pa <***> pb = MkParam (liftA2 (,) (paramAsk pa) (paramAsk pb)) (\(a, b) -> paramWith pa a . paramWith pb b) +paramAsks ::+       forall m a b. Monad m+    => Param m a+    -> (a -> b)+    -> m b+paramAsks param ab = fmap ab $ paramAsk param+ paramLocalM ::        forall m a. Monad m     => Param m a

@@ -4,11 +4,11 @@ import Control.Monad.Ology.Data.Prod import Control.Monad.Ology.General import Control.Monad.Ology.Specific.StateT-import qualified Control.Monad.ST.Lazy as Lazy-import qualified Control.Monad.ST.Strict as Strict+import Control.Monad.ST.Lazy qualified as Lazy+import Control.Monad.ST.Strict qualified as Strict import Data.IORef-import qualified Data.STRef.Lazy as Lazy-import qualified Data.STRef.Strict as Strict+import Data.STRef.Lazy qualified as Lazy+import Data.STRef.Strict qualified as Strict import Import  -- | A reference of a monad (as in 'StateT').@@ -39,6 +39,13 @@ refRestore :: MonadException m => Ref m a -> m --> m refRestore ref mr = bracketNoMask (refGet ref) (refPut ref) $ \_ -> mr +-- | Put and restore the original value of this reference after the operation.+refPutRestore :: MonadException m => Ref m a -> a -> m --> m+refPutRestore ref a mr =+    refRestore ref $ do+        refPut ref a+        mr+ lensMapRef ::        forall m a b. Monad m     => Lens' a b@@ -82,10 +89,7 @@ refParam ref = let     paramAsk = refGet ref     paramWith :: a -> m --> m-    paramWith a mr =-        refRestore ref $ do-            refPut ref a-            mr+    paramWith = refPutRestore ref     in MkParam {..}  -- | Use a reference as a product.@@ -97,8 +101,7 @@     prodTell a = refModify ref $ (<>) a     prodCollect :: forall r. m r -> m (r, a)     prodCollect mr =-        refRestore ref $ do-            refPut ref mempty+        refPutRestore ref mempty $ do             r <- mr             a <- refGet ref             return (r, a)

@@ -1,6 +1,6 @@ module Control.Monad.Ology.General.Catch where -import qualified Control.Exception as CE+import Control.Exception qualified as CE import Control.Monad.Ology.General.Exception import Control.Monad.Ology.General.Throw import Control.Monad.Ology.Specific.Result

@@ -1,9 +1,7 @@ module Control.Monad.Ology.General.Coroutine where -import Control.Monad.Ology.General.Trans.Hoist import Control.Monad.Ology.General.Trans.Trans import Control.Monad.Ology.General.Trans.Tunnel-import Control.Monad.Ology.General.Trans.Unlift import Control.Monad.Ology.Specific.CoroutineT import Control.Monad.Ology.Specific.StepT import Import@@ -33,11 +31,8 @@                     putMVar outvar $ Left r             takeMVar outvar -instance (MonadTransUnlift t, MonadCoroutine m, MonadTunnelIO m, Monad (t m)) => MonadCoroutine (t m) where-    coroutineSuspend call =-        MkStepT $-        liftWithUnlift $ \unlift ->-            (fmap $ fmap $ fmap $ hoist lift) $ unStepT $ coroutineSuspend $ \pmq -> unlift $ call $ \p -> lift $ pmq p+instance (MonadTransTunnel t, MonadCoroutine m) => MonadCoroutine (t m) where+    coroutineSuspend call = underTunnelStepT $ \tun -> coroutineSuspend $ \pmq -> tun $ call $ \p -> lift $ pmq p  -- | A type synoynm for a common pattern for closing opened resources, e.g. -- 'System.IO.withFile',

@@ -5,7 +5,7 @@     , CE.evaluate     ) where -import qualified Control.Exception as CE+import Control.Exception qualified as CE import Control.Monad.Ology.General.Exception.Class import Control.Monad.Ology.General.Function import Control.Monad.Ology.General.Trans.Hoist

@@ -1,6 +1,6 @@ module Control.Monad.Ology.General.Exception.Class where -import qualified Control.Exception as CE+import Control.Exception qualified as CE import Control.Monad.Ology.Specific.Result import Import 

@@ -30,6 +30,7 @@ type Raised :: forall k. (k -> Type) -> (k -> Type) -> Type type Raised p q = forall a. p a -> q a +type (-->) :: forall k. (k -> Type) -> (k -> Type) -> Type type p --> q = Raised p q  type WRaised :: forall k. (k -> Type) -> (k -> Type) -> Type@@ -50,6 +51,7 @@ type Backraised :: forall k. (k -> Type) -> (k -> Type) -> Type type Backraised ma mb = forall r. ((mb --> ma) -> ma r) -> mb r +type (-/->) :: forall k. (k -> Type) -> (k -> Type) -> Type type ma -/-> mb = Backraised ma mb  backraisedToRaised :: (ma -/-> mb) -> ma --> mb

@@ -6,7 +6,7 @@     , CE.IOException     ) where -import qualified Control.Exception as CE+import Control.Exception qualified as CE import Control.Monad.Ology.General.Exception import Control.Monad.Ology.Specific.Result import Import

@@ -3,7 +3,6 @@ import Control.Monad.Ology.General.Extract import Control.Monad.Ology.General.Function import Control.Monad.Ology.General.IO-import Control.Monad.Ology.General.Identity import Control.Monad.Ology.General.Outer import Control.Monad.Ology.General.Trans.Constraint import Control.Monad.Ology.General.Trans.Trans@@ -17,7 +16,7 @@     askUnlift ::            forall m. Monad m         => t m (WUnlift Monad t)-    default askUnlift :: forall m. (MonadIdentity (Tunnel t), Monad m) => t m (WUnlift Monad t)+    default askUnlift :: forall m. Monad m => t m (WUnlift Monad t)     askUnlift = tunnel $ \unlift -> pure $ pure $ MkWUnlift $ \tma -> fmap mToValue $ unlift tma  -- | A monad that has no effects over IO (such as state change or output).@@ -39,7 +38,7 @@     hasTransConstraint =         withTransConstraintDict @MonadFail $ withTransConstraintDict @MonadIO $ withTransConstraintDict @MonadFix $ Dict -instance MonadOuter outer => MonadTransAskUnlift (ComposeOuter outer)+instance forall outer. MonadOuter outer => MonadTransAskUnlift (ComposeOuter outer)  contractT ::        forall (t :: TransKind) m. (MonadTransAskUnlift t, Monad m)

@@ -24,6 +24,13 @@     -> t m1 --> t m2 tunnelHoist mma sm1 = tunnel $ \tun -> mma $ tun sm1 +hoistWith ::+       forall t m1 m2 f r. (MonadTransTunnel t, Traversable f, Monad m1, Monad m2)+    => (forall a. m1 a -> m2 (f a))+    -> t m1 r+    -> t m2 (f r)+hoistWith mma sm1 = tunnel $ \tun -> fmap sequenceA $ mma $ tun sm1+ backHoist :: (MonadTransTunnel t, Monad ma, Monad mb) => (ma -/-> mb) -> t ma -/-> t mb backHoist wt tm = tunnel $ \unlift -> wt $ \tba -> unlift $ tm $ hoist tba @@ -52,13 +59,20 @@     => ta (tb m) -/-> tb (ta m) commuteTBack call = commuteT $ call commuteT -instance MonadInner inner => MonadTransTunnel (ComposeInner inner) where+instance forall inner. MonadInner inner => MonadTransTunnel (ComposeInner inner) where     type Tunnel (ComposeInner inner) = inner     tunnel call = MkComposeInner $ call unComposeInner  class (MonadHoistIO m, MonadInner (TunnelIO m)) => MonadTunnelIO m where     type TunnelIO m :: Type -> Type     tunnelIO :: forall r. ((forall a. m a -> IO (TunnelIO m a)) -> IO (TunnelIO m r)) -> m r++hoistWithIO ::+       forall m f r. (MonadTunnelIO m, Traversable f)+    => (forall a. IO a -> IO (f a))+    -> m r+    -> m (f r)+hoistWithIO iifa mr = tunnelIO $ \tun -> fmap sequenceA $ iifa $ tun mr  instance MonadTunnelIO IO where     type TunnelIO IO = Identity

@@ -41,7 +41,7 @@     => WBackraised m (t m) wLiftWithUnlift = MkWBackraised $ \call -> liftWithUnlift $ \unlift -> call unlift -composeUnliftRaised :: (MonadTransUnlift t, MonadUnliftIO m) => Unlift Functor t -> (m --> n) -> (t m --> n)+composeUnliftRaised :: MonadUnliftIO m => Unlift Functor t -> (m --> n) -> (t m --> n) composeUnliftRaised rt rm tma = rm $ rt tma  composeUnliftRaisedCommute ::@@ -68,7 +68,7 @@     hasTransConstraint =         withTransConstraintDict @MonadFail $ withTransConstraintDict @MonadIO $ withTransConstraintDict @MonadFix $ Dict -instance MonadOuter outer => MonadTransUnlift (ComposeOuter outer) where+instance forall outer. MonadOuter outer => MonadTransUnlift (ComposeOuter outer) where     liftWithUnlift call =         MkComposeOuter $ do             MkWExtract extract <- getExtract

@@ -18,22 +18,22 @@     { unComposeInner :: outer (inner a)     } -instance (Foldable inner, Foldable outer, Functor outer) => Foldable (ComposeInner inner outer) where+instance forall inner outer. (Foldable inner, Foldable outer, Functor outer) => Foldable (ComposeInner inner outer) where     foldMap am (MkComposeInner oia) = foldMap id $ fmap (foldMap am) oia -instance (Traversable inner, Traversable outer) => Traversable (ComposeInner inner outer) where+instance forall inner outer. (Traversable inner, Traversable outer) => Traversable (ComposeInner inner outer) where     traverse afb (MkComposeInner oia) = fmap MkComposeInner $ traverse (traverse afb) oia -instance Traversable inner => TransConstraint Traversable (ComposeInner inner) where+instance forall inner. Traversable inner => TransConstraint Traversable (ComposeInner inner) where     hasTransConstraint = Dict -instance (Functor inner, Functor outer) => Functor (ComposeInner inner outer) where+instance forall inner outer. (Functor inner, Functor outer) => Functor (ComposeInner inner outer) where     fmap ab (MkComposeInner oia) = MkComposeInner $ fmap (fmap ab) oia -instance Functor inner => TransConstraint Functor (ComposeInner inner) where+instance forall inner. Functor inner => TransConstraint Functor (ComposeInner inner) where     hasTransConstraint = Dict -instance (MonadInner inner, Monad outer) => Applicative (ComposeInner inner outer) where+instance forall inner outer. (MonadInner inner, Monad outer) => Applicative (ComposeInner inner outer) where     pure a = MkComposeInner $ pure $ pure a     -- cannot use obvious definition for <*>, because that would incorrectly execute the outer part of ma even if mab fails     mab <*> ma = do@@ -41,7 +41,8 @@         a <- ma         return $ ab a -instance (MonadInner inner, Monad outer, Alternative inner) => Alternative (ComposeInner inner outer) where+instance forall inner outer. (MonadInner inner, Monad outer, Alternative inner) =>+             Alternative (ComposeInner inner outer) where     empty = MkComposeInner $ pure empty     -- cannot use obvious definition for <|> for similar reasons as in <*>     (MkComposeInner oia) <|> cb = do@@ -53,7 +54,7 @@             Just a -> return a             Nothing -> cb -instance (MonadInner inner, Monad outer) => Monad (ComposeInner inner outer) where+instance forall inner outer. (MonadInner inner, Monad outer) => Monad (ComposeInner inner outer) where     return = pure     (MkComposeInner oia) >>= p =         MkComposeInner $ do@@ -64,16 +65,16 @@                     return $ ia >> ib                 FailureResult e -> return $ throwExc e -instance MonadInner inner => TransConstraint Monad (ComposeInner inner) where+instance forall inner. MonadInner inner => TransConstraint Monad (ComposeInner inner) where     hasTransConstraint = Dict -instance (MonadInner inner, MonadFail outer) => MonadFail (ComposeInner inner outer) where+instance forall inner outer. (MonadInner inner, MonadFail outer) => MonadFail (ComposeInner inner outer) where     fail s = lift $ fail s -instance MonadInner inner => TransConstraint MonadFail (ComposeInner inner) where+instance forall inner. MonadInner inner => TransConstraint MonadFail (ComposeInner inner) where     hasTransConstraint = Dict -instance (MonadInner inner, MonadInner outer) => MonadInner (ComposeInner inner outer) where+instance forall inner outer. (MonadInner inner, MonadInner outer) => MonadInner (ComposeInner inner outer) where     retrieveInner (MkComposeInner oia) =         case retrieveInner oia of             SuccessResult ia ->@@ -82,10 +83,11 @@                     FailureResult e -> FailureResult $ Left e             FailureResult e -> FailureResult $ Right e -instance MonadInner inner => TransConstraint MonadInner (ComposeInner inner) where+instance forall inner. MonadInner inner => TransConstraint MonadInner (ComposeInner inner) where     hasTransConstraint = Dict -instance (MonadInner inner, MonadOuter inner, MonadOuter outer) => MonadOuter (ComposeInner inner outer) where+instance forall inner outer. (MonadInner inner, MonadOuter inner, MonadOuter outer) =>+             MonadOuter (ComposeInner inner outer) where     getExtract =         MkComposeInner $ do             MkWExtract oaa <- getExtract@@ -93,10 +95,10 @@                 MkWExtract iaa <- getExtract                 return $ MkWExtract $ \(MkComposeInner oia) -> iaa $ oaa oia -instance (MonadInner inner, MonadOuter inner) => TransConstraint MonadOuter (ComposeInner inner) where+instance forall inner. (MonadInner inner, MonadOuter inner) => TransConstraint MonadOuter (ComposeInner inner) where     hasTransConstraint = Dict -instance (MonadInner inner, MonadFix outer) => MonadFix (ComposeInner inner outer) where+instance forall inner outer. (MonadInner inner, MonadFix outer) => MonadFix (ComposeInner inner outer) where     mfix ama =         MkComposeInner $         mfix $ \ia ->@@ -106,32 +108,35 @@                 SuccessResult a -> a                 FailureResult _ -> error "bad ComposeInner mfix" -instance MonadInner inner => TransConstraint MonadFix (ComposeInner inner) where+instance forall inner. MonadInner inner => TransConstraint MonadFix (ComposeInner inner) where     hasTransConstraint = Dict -instance (MonadInner inner, Monad outer, Alternative inner) => MonadPlus (ComposeInner inner outer)+instance forall inner outer. (MonadInner inner, Monad outer, Alternative inner) => MonadPlus (ComposeInner inner outer) -instance (MonadExtract inner, MonadExtract outer) => MonadExtract (ComposeInner inner outer) where+instance forall inner outer. (MonadExtract inner, MonadExtract outer) => MonadExtract (ComposeInner inner outer) where     mToValue (MkComposeInner oia) = mToValue $ mToValue oia -instance MonadExtract inner => TransConstraint MonadExtract (ComposeInner inner) where+instance forall inner. MonadExtract inner => TransConstraint MonadExtract (ComposeInner inner) where     hasTransConstraint = Dict -instance (MonadIdentity inner, MonadIdentity outer) => MonadIdentity (ComposeInner inner outer)+instance forall inner outer. (MonadIdentity inner, MonadIdentity outer) => MonadIdentity (ComposeInner inner outer) -instance MonadIdentity inner => TransConstraint MonadIdentity (ComposeInner inner) where+instance forall inner. MonadIdentity inner => TransConstraint MonadIdentity (ComposeInner inner) where     hasTransConstraint = Dict -instance (MonadInner inner, MonadIO outer) => MonadIO (ComposeInner inner outer) where+instance forall inner outer. (MonadInner inner, MonadIO outer) => MonadIO (ComposeInner inner outer) where     liftIO ioa = lift $ liftIO ioa -instance MonadInner inner => TransConstraint MonadIO (ComposeInner inner) where+instance forall inner. MonadInner inner => TransConstraint MonadIO (ComposeInner inner) where     hasTransConstraint = Dict -liftInner :: Applicative outer => inner --> ComposeInner inner outer+liftInner ::+       forall inner outer. Applicative outer+    => inner --> ComposeInner inner outer liftInner na = MkComposeInner $ pure na -instance (MonadInner inner, MonadException inner, MonadException m) => MonadException (ComposeInner inner m) where+instance forall inner m. (MonadInner inner, MonadException inner, MonadException m) =>+             MonadException (ComposeInner inner m) where     type Exc (ComposeInner inner m) = Either (Exc inner) (Exc m)     throwExc (Left e) = liftInner $ throwExc e     throwExc (Right e) = lift $ throwExc e@@ -143,11 +148,11 @@                 SuccessResult (FailureResult e) -> unComposeInner $ handler $ Left e                 SuccessResult (SuccessResult a) -> return $ return a -instance (MonadInner inner, MonadException inner) => TransConstraint MonadException (ComposeInner inner) where+instance forall inner. (MonadInner inner, MonadException inner) => TransConstraint MonadException (ComposeInner inner) where     hasTransConstraint = Dict -instance MonadInner inner => MonadTrans (ComposeInner inner) where+instance forall inner. MonadInner inner => MonadTrans (ComposeInner inner) where     lift ma = MkComposeInner $ fmap pure ma -instance MonadInner inner => MonadTransHoist (ComposeInner inner) where+instance forall inner. MonadInner inner => MonadTransHoist (ComposeInner inner) where     hoist ii (MkComposeInner ma) = MkComposeInner $ ii ma

@@ -15,29 +15,29 @@     { unComposeOuter :: outer (inner a)     } -instance (Foldable inner, Foldable outer, Functor outer) => Foldable (ComposeOuter outer inner) where+instance forall outer inner. (Foldable inner, Foldable outer, Functor outer) => Foldable (ComposeOuter outer inner) where     foldMap am (MkComposeOuter oia) = foldMap id $ fmap (foldMap am) oia -instance (Traversable inner, Traversable outer) => Traversable (ComposeOuter outer inner) where+instance forall outer inner. (Traversable inner, Traversable outer) => Traversable (ComposeOuter outer inner) where     traverse afb (MkComposeOuter oia) = fmap MkComposeOuter $ traverse (traverse afb) oia -instance Traversable outer => TransConstraint Traversable (ComposeOuter outer) where+instance forall outer. Traversable outer => TransConstraint Traversable (ComposeOuter outer) where     hasTransConstraint = Dict -instance (Functor inner, Functor outer) => Functor (ComposeOuter outer inner) where+instance forall outer inner. (Functor inner, Functor outer) => Functor (ComposeOuter outer inner) where     fmap ab (MkComposeOuter oia) = MkComposeOuter $ fmap (fmap ab) oia -instance Functor outer => TransConstraint Functor (ComposeOuter outer) where+instance forall outer. Functor outer => TransConstraint Functor (ComposeOuter outer) where     hasTransConstraint = Dict -instance (Applicative inner, Applicative outer) => Applicative (ComposeOuter outer inner) where+instance forall outer inner. (Applicative inner, Applicative outer) => Applicative (ComposeOuter outer inner) where     pure a = MkComposeOuter $ pure $ pure a     MkComposeOuter mab <*> MkComposeOuter ma = MkComposeOuter $ liftA2 (<*>) mab ma -instance Applicative outer => TransConstraint Applicative (ComposeOuter outer) where+instance forall outer. Applicative outer => TransConstraint Applicative (ComposeOuter outer) where     hasTransConstraint = Dict -instance (Monad inner, MonadOuter outer) => Monad (ComposeOuter outer inner) where+instance forall outer inner. (Monad inner, MonadOuter outer) => Monad (ComposeOuter outer inner) where     return = pure     MkComposeOuter oia >>= f =         MkComposeOuter $ do@@ -47,45 +47,47 @@                 a <- ia                 oaa $ unComposeOuter $ f a -instance MonadOuter outer => TransConstraint Monad (ComposeOuter outer) where+instance forall outer. MonadOuter outer => TransConstraint Monad (ComposeOuter outer) where     hasTransConstraint = Dict -liftOuter :: (Functor outer, Applicative inner) => outer --> ComposeOuter outer inner+liftOuter ::+       forall outer inner. (Functor outer, Applicative inner)+    => outer --> ComposeOuter outer inner liftOuter oa = MkComposeOuter $ fmap pure oa -instance MonadOuter outer => MonadTrans (ComposeOuter outer) where+instance forall outer. MonadOuter outer => MonadTrans (ComposeOuter outer) where     lift ma = MkComposeOuter $ pure ma -instance (MonadOuter outer, MonadIO inner) => MonadIO (ComposeOuter outer inner) where+instance forall outer inner. (MonadOuter outer, MonadIO inner) => MonadIO (ComposeOuter outer inner) where     liftIO ioa = lift $ liftIO ioa -instance MonadOuter outer => TransConstraint MonadIO (ComposeOuter outer) where+instance forall outer. MonadOuter outer => TransConstraint MonadIO (ComposeOuter outer) where     hasTransConstraint = Dict -instance (MonadOuter outer, MonadFail inner) => MonadFail (ComposeOuter outer inner) where+instance forall outer inner. (MonadOuter outer, MonadFail inner) => MonadFail (ComposeOuter outer inner) where     fail e = MkComposeOuter $ return $ fail e -instance MonadOuter outer => TransConstraint MonadFail (ComposeOuter outer) where+instance forall outer. MonadOuter outer => TransConstraint MonadFail (ComposeOuter outer) where     hasTransConstraint = Dict -instance (MonadOuter outer, MonadFix inner) => MonadFix (ComposeOuter outer inner) where+instance forall outer inner. (MonadOuter outer, MonadFix inner) => MonadFix (ComposeOuter outer inner) where     mfix f =         MkComposeOuter $ do             MkWExtract extract <- getExtract             return $ mfix $ \a -> extract $ unComposeOuter $ f a -instance MonadOuter outer => TransConstraint MonadFix (ComposeOuter outer) where+instance forall outer. MonadOuter outer => TransConstraint MonadFix (ComposeOuter outer) where     hasTransConstraint = Dict -instance (MonadOuter outer, MonadException m) => MonadException (ComposeOuter outer m) where+instance forall outer m. (MonadOuter outer, MonadException m) => MonadException (ComposeOuter outer m) where     type Exc (ComposeOuter outer m) = Exc m     throwExc e = lift $ throwExc e     catchExc tma handler = tunnel $ \unlift -> catchExc (unlift tma) $ \e -> unlift $ handler e -instance MonadOuter outer => MonadTransHoist (ComposeOuter outer) where+instance forall outer. MonadOuter outer => MonadTransHoist (ComposeOuter outer) where     hoist = tunnelHoist -instance MonadOuter outer => MonadTransTunnel (ComposeOuter outer) where+instance forall outer. MonadOuter outer => MonadTransTunnel (ComposeOuter outer) where     type Tunnel (ComposeOuter outer) = Identity     tunnel call =         MkComposeOuter $ do

@@ -16,7 +16,7 @@ type ComposeT :: TransKind -> TransKind -> TransKind newtype ComposeT (outerT :: TransKind) (innerT :: TransKind) (m :: Type -> Type) (a :: Type) = MkComposeT     { unComposeT :: outerT (innerT m) a-    } deriving (Functor, Applicative, Alternative, Monad, MonadFail, MonadIO, MonadFix, MonadPlus)+    } deriving newtype (Functor, Applicative, Alternative, Monad, MonadFail, MonadIO, MonadFix, MonadPlus)  liftOuterComposeT ::        forall outerT innerT m a. (MonadTransTunnel outerT, MonadTrans innerT, TransConstraint Monad innerT, Monad m)@@ -53,14 +53,14 @@         Dict -> MkComposeT $ liftWithUnlift $ \unlift -> call $ \(MkComposeT ttma) -> unlift ttma  composeTUnlift ::-       forall c outerT innerT. (MonadTransUnlift innerT, TransConstraint c innerT)+       forall c outerT innerT. TransConstraint c innerT     => Unlift c outerT     -> Unlift c innerT     -> Unlift c (ComposeT outerT innerT) composeTUnlift ua ub (MkComposeT tatbma) = ub $ withTransConstraintTM @c $ ua tatbma  composeTWUnlift ::-       forall c outerT innerT. (MonadTransUnlift innerT, TransConstraint c innerT)+       forall c outerT innerT. TransConstraint c innerT     => WUnlift c outerT     -> WUnlift c innerT     -> WUnlift c (ComposeT outerT innerT)@@ -103,7 +103,7 @@                 case hasTransConstraint @Monad @outerT @(innerT m) of                     Dict -> Dict -instance (TransConstraint MonadIO outerT, TransConstraint Monad innerT, TransConstraint MonadIO innerT) =>+instance (TransConstraint MonadIO outerT, TransConstraint MonadIO innerT) =>              TransConstraint MonadIO (ComposeT outerT innerT) where     hasTransConstraint ::            forall m. MonadIO m@@ -114,7 +114,7 @@                 case hasTransConstraint @MonadIO @outerT @(innerT m) of                     Dict -> Dict -instance (TransConstraint MonadFail outerT, TransConstraint Monad innerT, TransConstraint MonadFail innerT) =>+instance (TransConstraint MonadFail outerT, TransConstraint MonadFail innerT) =>              TransConstraint MonadFail (ComposeT outerT innerT) where     hasTransConstraint ::            forall m. MonadFail m@@ -125,7 +125,7 @@                 case hasTransConstraint @MonadFail @outerT @(innerT m) of                     Dict -> Dict -instance (TransConstraint MonadFix outerT, TransConstraint Monad innerT, TransConstraint MonadFix innerT) =>+instance (TransConstraint MonadFix outerT, TransConstraint MonadFix innerT) =>              TransConstraint MonadFix (ComposeT outerT innerT) where     hasTransConstraint ::            forall m. MonadFix m@@ -136,7 +136,7 @@                 case hasTransConstraint @MonadFix @outerT @(innerT m) of                     Dict -> Dict -instance (TransConstraint MonadPlus outerT, TransConstraint Monad innerT, TransConstraint MonadPlus innerT) =>+instance (TransConstraint MonadPlus outerT, TransConstraint MonadPlus innerT) =>              TransConstraint MonadPlus (ComposeT outerT innerT) where     hasTransConstraint ::            forall m. MonadPlus m

@@ -9,7 +9,7 @@ import Control.Monad.Ology.Specific.ReaderT import Control.Monad.Ology.Specific.StateT import Control.Monad.Trans.Cont hiding (callCC)-import qualified Control.Monad.Trans.Cont as T+import Control.Monad.Trans.Cont qualified as T import Import  instance TransConstraint Functor (ContT s) where

@@ -70,7 +70,7 @@                 SuccessResult (Right a) -> return $ return a  transExcept ::-       forall t m e a. (MonadTransTunnel t, Applicative (Tunnel t), Monad m)+       forall t m e a. (MonadTransTunnel t, Monad m)     => t (ExceptT e m) a     -> t m (Either e a) transExcept tema = tunnel $ \unlift -> fmap commuteInner $ runExceptT $ unlift tema

@@ -74,7 +74,7 @@     mempty = MkLifeState Nothing  -- | This is for managing the automatic closing of opened resources.-newtype LifecycleT m a = MkLifecycleT+newtype LifecycleT (m :: Type -> Type) (a :: Type) = MkLifecycleT     { unLifecycleT :: MVar LifeState -> m a     } 

@@ -29,7 +29,7 @@ maybeToM :: MonadFail m => String -> Maybe a -> m a maybeToM e = resultToM . resultFromMaybe e -deriving instance (Eq e, Eq a) => Eq (Result e a)+deriving stock instance (Eq e, Eq a) => Eq (Result e a)  instance Functor (Result e) where     fmap ab (SuccessResult a) = SuccessResult (ab a)

@@ -76,8 +76,7 @@ instance (IsStack (TransConstraint Monad) tt, IsStack MonadTrans tt, MonadFail m) => MonadFail (StackT tt m) where     fail s = lift $ fail s -instance (IsStack (TransConstraint Monad) tt, IsStack (TransConstraint MonadFail) tt, IsStack MonadTrans tt) =>-             TransConstraint MonadFail (StackT tt) where+instance (IsStack (TransConstraint Monad) tt, IsStack MonadTrans tt) => TransConstraint MonadFail (StackT tt) where     hasTransConstraint = Dict  instance (IsStack (TransConstraint Monad) tt, IsStack (TransConstraint MonadFix) tt, MonadFix m) =>@@ -254,7 +253,6 @@ instance ( IsStack (WithTunnelConstraint Functor) tt          , IsStack (WithTunnelConstraint MonadInner) tt          , IsStack (WithTunnelConstraint MonadExtract) tt-         , IsStack MonadTransUnlift tt          ) => MonadExtract (StackTunnel tt) where     mToValue =         case isWithTunnelConstraint @MonadExtract @tt of

@@ -5,6 +5,7 @@ import Control.Monad.Ology.General.Trans.Constraint import Control.Monad.Ology.General.Trans.Hoist import Control.Monad.Ology.General.Trans.Trans+import Control.Monad.Ology.General.Trans.Tunnel import Import  -- | A monad that can be run step-by-step until the result.@@ -48,6 +49,16 @@  instance Functor f => MonadTransHoist (StepT f) where     hoist f (MkStepT ma) = MkStepT $ (fmap $ fmap $ fmap $ hoist f) $ f ma++underTunnelStepT ::+       forall t m turn r. (MonadTransTunnel t, Monad m, Functor turn)+    => ((forall m1 a. Monad m1 => t m1 a -> m1 (Tunnel t a)) -> StepT turn m (Tunnel t r))+    -> StepT turn (t m) r+underTunnelStepT call = let+    conv :: Either (Tunnel t r) (turn (StepT turn m (Tunnel t r))) -> Tunnel t (Either r (turn (StepT turn (t m) r)))+    conv (Left tr) = fmap Left tr+    conv (Right turn) = return $ Right $ fmap (\step -> underTunnelStepT $ \_ -> step) turn+    in MkStepT $ tunnel $ \tun -> fmap conv $ unStepT $ call tun  -- | Run all the steps until done. runSteps :: Monad m => Extract f -> StepT f m --> m

@@ -15,7 +15,7 @@ evalWriterT :: Monad m => WriterT w m a -> m a evalWriterT wma = fmap fst $ runWriterT wma -instance Monoid w => TransConstraint Functor (WriterT w) where+instance TransConstraint Functor (WriterT w) where     hasTransConstraint = Dict  instance Monoid w => TransConstraint Applicative (WriterT w) where

@@ -64,7 +64,7 @@  newtype TestExc =     MkTestExc Int-    deriving (Eq, Show)+    deriving newtype (Eq, Show)  instance Exception TestExc