effet 0.2.0.0 → 0.3.0.0

raw patch · 11 files changed

+391/−228 lines, 11 filesdep ~template-haskellPVP ok

version bump matches the API change (PVP)

Dependency ranges changed: template-haskell

API changes (from Hackage documentation)

Files

• ChangeLog.md +7/−1
• README.md +2/−2
• effet.cabal +4/−4
• src/Control/Effect/Embed.hs +106/−16
• src/Control/Effect/Machinery.hs +4/−4
• src/Control/Effect/Machinery/Default.hs +0/−54
• src/Control/Effect/Machinery/Tagger.hs +3/−4
• src/Control/Effect/Machinery/Via.hs +140/−140
• src/Control/Effect/Managed.hs +122/−0
• src/Control/Effect/RWS.hs +2/−2
• src/Control/Effect/Resource.hs +1/−1

@@ -7,4 +7,10 @@ ## 0.2.0.0 (2020-07-29)
 
 * Lifted the restriction that one handler can exactly handle one effect. Handlers can now handle multiple effects.
-* Effects whose definitions refer to other effects (see the RWS effect, for example) are now possible to implement, but only manually for now (i.e., no code generation).+* Effects whose definitions refer to other effects (see the RWS effect, for example) are now possible to implement, but only manually for now (i.e., no code generation).
+
+## 0.3.0.0 (2020-10-13)
+
+* Adapted the embed effect which now supports tagging/retagging/untagging.
+* Introduced the managed effect.
+* Relaxed bounds a bit for better compilation.

@@ -108,7 +108,7 @@ newtype LocalFS m a =   LocalFS { runLocalFS :: m a }     deriving (Applicative, Functor, Monad, MonadIO)-    deriving (MonadTrans, MonadTransControl) via Default+    deriving (MonadTrans, MonadTransControl) via IdentityT     deriving (MonadBase b, MonadBaseControl b) ``` @@ -142,7 +142,7 @@ newtype VirtualFS m a =   VirtualFS { runVirtualFS :: m a }     deriving (Applicative, Functor, Monad, MonadIO)-    deriving (MonadTrans, MonadTransControl) via Default+    deriving (MonadTrans, MonadTransControl) via IdentityT     deriving (MonadBase b, MonadBaseControl b)  instance Map' tag FilePath String m => FileSystem' tag (VirtualFS m) where

@@ -4,10 +4,10 @@ -- -- see: https://github.com/sol/hpack ----- hash: 397bba600623b58701020a4ec01a2dff5e707d155f8f98e84f63423537604919+-- hash: df92fee8597297b24a1a0e0ac46f0b028382ad585bd69cc307e0701203bd4502  name:           effet-version:        0.2.0.0+version:        0.3.0.0 synopsis:       An Effect System based on Type Classes description:    Please see the README on GitHub at <https://github.com/typedbyte/effet#readme> category:       Control@@ -33,10 +33,10 @@       Control.Effect.Embed       Control.Effect.Error       Control.Effect.Machinery-      Control.Effect.Machinery.Default       Control.Effect.Machinery.Tagger       Control.Effect.Machinery.TH       Control.Effect.Machinery.Via+      Control.Effect.Managed       Control.Effect.Map       Control.Effect.Map.Lazy       Control.Effect.Map.Strict@@ -61,7 +61,7 @@       base >=4.7 && <5     , containers >=0.6.2.1 && <0.7     , monad-control >=1.0.2.3 && <1.1-    , template-haskell >=2.15.0.0 && <2.16+    , template-haskell >=2.14.0.0 && <3     , transformers >=0.5.6.2 && <0.6     , transformers-base >=0.4.5.2 && <0.5   default-language: Haskell2010

@@ -11,32 +11,77 @@ -- The embed effect for integrating arbitrary monads into the effect system. ----------------------------------------------------------------------------- module Control.Effect.Embed-  ( -- * Embed Effect-    Embed(..)+  ( -- * Tagged Embed Effect+    Embed'(..)+    -- * Untagged Embed Effect+    -- | If you don't require disambiguation of multiple embed effects+    -- (i.e., you only have one embed effect in your monadic context),+    -- it is recommended to always use the untagged embed effect.+  , Embed+  , embed     -- * Interpretations+    -- ** Via Transformation   , Transformation+  , runEmbed'   , runEmbed+    -- ** Via Finalization+  , Finalization+  , runFinal'+  , runFinal+    -- * Tagging and Untagging+    -- | Conversion functions between the tagged and untagged embed effect,+    -- usually used in combination with type applications, like:+    --+    -- @+    --     'tagEmbed'' \@\"newTag\" program+    --     'retagEmbed'' \@\"oldTag\" \@\"newTag\" program+    --     'untagEmbed'' \@\"erasedTag\" program+    -- @+    -- +  , tagEmbed'+  , retagEmbed'+  , untagEmbed'   ) where +-- base+import Data.Coerce           (coerce)+import Data.Functor.Identity (Identity)+ -- transformers import Control.Monad.Trans.Reader (ReaderT(ReaderT), runReaderT)  import Control.Effect.Machinery hiding (embed)  -- | An effect that integrates a monad @n@ into the computation @m@.-class Monad m => Embed n m where+--+-- @since 0.3.0.0+class Monad m => Embed' tag n m | tag m -> n where   -- | Monadic actions in @n@ can be lifted into @m@ via 'embed'.   --   -- 'embed' is like 'liftIO', but not limited to 'IO'. In fact, 'liftIO' can   -- be realized using 'embed' by specializing @n@ to @IO@.-  embed :: n a -> m a+  --+  -- @since 0.3.0.0+  embed' :: n a -> m a -makeEffect ''Embed+makeTaggedEffect ''Embed' -instance Monad m => Embed m m where-  embed = id-  {-# INLINE embed #-}+instance Embed' tag IO IO where+  embed' = id+  {-# INLINE embed' #-} +instance Embed' tag Maybe Maybe where+  embed' = id+  {-# INLINE embed' #-}++instance Embed' tag [] [] where+  embed' = id+  {-# INLINE embed' #-}++instance Embed' tag Identity Identity where+  embed' = id+  {-# INLINE embed' #-}+ newtype F n t = F (forall b. n b -> t b)  -- | The transformation interpreter of the embed effect. This type implements the@@ -51,15 +96,60 @@     deriving (MonadTrans, MonadTransControl)     deriving (MonadBase b, MonadBaseControl b) -instance Embed t m => Embed n (Transformation n t m) where-  embed na = Transformation . ReaderT $-    \(F f) -> embed (f na)-  {-# INLINE embed #-}+instance Embed' tag t m => Embed' tag n (Transformation n t m) where+  embed' na = Transformation . ReaderT $+    \(F f) -> embed' @tag (f na)+  {-# INLINE embed' #-}  -- | Runs the embed effect by transforming the integrated monad @n@ into another -- integrated monad @t@.-runEmbed :: (forall b. n b -> t b)                 -- ^ The natural transformation from monad @n@ to monad @t@.-         -> (Embed n `Via` Transformation n t) m a -- ^ The program whose embed effect should be handled.-         -> m a                                    -- ^ The program with its embed effect handled.-runEmbed f = flip runReaderT (F f) . runTransformation . runVia+--+-- @since 0.3.0.0+runEmbed' :: forall tag n t m a+           . (forall b. n b -> t b)                      -- ^ The natural transformation from monad @n@ to monad @t@.+          -> (Embed' tag n `Via` Transformation n t) m a -- ^ The program whose embed effect should be handled.+          -> m a                                         -- ^ The program with its embed effect handled.+runEmbed' f = flip runReaderT (F f) . runTransformation . runVia+{-# INLINE runEmbed' #-}++-- | The untagged version of 'runEmbed''.+runEmbed :: (forall b. n b -> t b) -> (Embed n `Via` Transformation n t) m a -> m a+runEmbed = runEmbed' @G {-# INLINE runEmbed #-}++-- | The finalization interpreter of the embed effect. This type implements the+-- 'Embed' type class by declaring the integrated monad the final monad @m@+-- (also called the \"base monad\").+--+-- Chances are very high that you only need this interpreter if you have a+-- custom final monad because the 'Embed'' effect is already implemented for+-- final monads like 'IO', 'Maybe', @[]@ and 'Identity'.+--+-- When interpreting the effect, you usually don\'t interact with this type directly,+-- but instead use one of its corresponding interpretation functions.+--+-- @since 0.3.0.0+newtype Finalization m a =+  Finalization { _runFinalization :: m a }+    deriving (Applicative, Functor, Monad, MonadIO)+    deriving (MonadTrans, MonadTransControl) via IdentityT+    deriving (MonadBase b, MonadBaseControl b)++instance Monad n => Embed' tag n (Finalization n) where+  embed' = Finalization+  {-# INLINE embed' #-}++-- | Runs the embed effect by declaring the integrated monad the final monad.+--+-- @since 0.3.0.0+runFinal' :: (Embed' tag m `Via` Finalization) m a -- ^ The program whose embed effect should be handled.+          -> m a                                   -- ^ The program with its embed effect handled.+runFinal' = coerce+{-# INLINE runFinal' #-}++-- | The untagged version of 'runFinal''.+--+-- @since 0.3.0.0+runFinal :: (Embed m `Via` Finalization) m a -> m a+runFinal = runFinal' @G+{-# INLINE runFinal #-}

@@ -13,8 +13,7 @@ ----------------------------------------------------------------------------- module Control.Effect.Machinery   ( -- * Re-exports from @effet@-    module Control.Effect.Machinery.Default-  , module Control.Effect.Machinery.Tagger+    module Control.Effect.Machinery.Tagger   , module Control.Effect.Machinery.TH   , module Control.Effect.Machinery.Via     -- * Re-exports from @base@@@ -23,6 +22,7 @@   , module Control.Monad.Trans.Control     -- * Re-exports from @transformers@   , module Control.Monad.Trans.Class+  , module Control.Monad.Trans.Identity     -- * Re-exports from @transformers-base@   , module Control.Monad.Base   ) where@@ -31,15 +31,15 @@ import Control.Monad.IO.Class  -- monad-control-import Control.Monad.Trans.Control -- hiding (embed)+import Control.Monad.Trans.Control  -- transformers import Control.Monad.Trans.Class+import Control.Monad.Trans.Identity  -- transformers-base import Control.Monad.Base -import Control.Effect.Machinery.Default import Control.Effect.Machinery.Tagger import Control.Effect.Machinery.TH import Control.Effect.Machinery.Via

@@ -1,54 +0,0 @@--------------------------------------------------------------------------------- |--- Module      :  Control.Effect.Machinery.Default--- Copyright   :  (c) Michael Szvetits, 2020--- License     :  BSD3 (see the file LICENSE)--- Maintainer  :  typedbyte@qualified.name--- Stability   :  stable--- Portability :  portable------ This module provides default implementations for the 'MonadTrans' and--- 'MonadTransControl' type classes.-------------------------------------------------------------------------------module Control.Effect.Machinery.Default (Default(..)) where---- base-import Control.Monad.IO.Class (MonadIO)---- monad-control-import Control.Monad.Trans.Control (MonadBaseControl, MonadTransControl, StT,-                                    liftWith, restoreT)---- transformers-import Control.Monad.Trans.Class (MonadTrans, lift)---- transformers-base-import Control.Monad.Base (MonadBase)---- | This type provides default implementations for the 'MonadTrans' and--- 'MonadTransControl' type classes. The type is intended to be targeted by the--- @DerivingVia@ language extension when writing an effect handler newtype that--- wraps a monad @m a@ :------ @---     newtype MyHandler m a =---       MyHandler { runMyHandler :: m a }---         deriving (Applicative, Functor, Monad, MonadIO)---         deriving (MonadTrans, MonadTransControl) via 'Default'---         deriving (MonadBase b, MonadBaseControl b)--- @-newtype Default m a =-  Default { runDefault :: m a }-    deriving (Applicative, Functor, Monad, MonadIO)-    deriving (MonadBase b, MonadBaseControl b)--instance MonadTrans Default where-  lift = Default-  {-# INLINE lift #-}--instance MonadTransControl Default where-  type StT Default a = a-  liftWith f = Default (f runDefault)-  {-# INLINE liftWith #-}-  restoreT = Default-  {-# INLINE restoreT #-}

@@ -19,13 +19,12 @@ import Control.Monad.Trans.Control (MonadBaseControl, MonadTransControl)  -- transformers-import Control.Monad.Trans.Class (MonadTrans)+import Control.Monad.Trans.Class    (MonadTrans)+import Control.Monad.Trans.Identity (IdentityT(IdentityT))  -- transformers-base import Control.Monad.Base (MonadBase) -import Control.Effect.Machinery.Default (Default(Default))- -- | This type provides instances for effect type classes in order to enable -- tagging, retagging and untagging of effects. Whenever this type is used as -- handler of an effect, the effect previously tagged with @tag@ will be@@ -37,5 +36,5 @@ newtype Tagger tag new m a =   Tagger { runTagger :: m a }     deriving (Applicative, Functor, Monad, MonadIO)-    deriving (MonadTrans, MonadTransControl) via Default+    deriving (MonadTrans, MonadTransControl) via IdentityT     deriving (MonadBase b, MonadBaseControl b)

@@ -1,141 +1,141 @@--------------------------------------------------------------------------------- |--- Module      :  Control.Effect.Machinery.Via--- Copyright   :  (c) Michael Szvetits, 2020--- License     :  BSD3 (see the file LICENSE)--- Maintainer  :  typedbyte@qualified.name--- Stability   :  stable--- Portability :  portable------ This module defines the types 'EachVia' and its corresponding type synonym--- 'Via' which indicate that specific effects are handled by a specific monad--- transformer (also known as effect handler or effect interpreter).------ It also defines the 'G' type, which is the global tag that is used for--- untagged effects.--- --- Last but not least, it defines some constraint synonyms and kinds that are--- used throughout this library, hopefully to increase the readability of the--- code at some points.-------------------------------------------------------------------------------module Control.Effect.Machinery.Via-  ( -- * Core Types-    EachVia(..)-  , Via-  , G-    -- * Constraint Synonyms and Kinds-  , SomeMonad-  , Effect-  , Transformer-  , Handle-  , Find-  , Lift-  , Control-  ) where---- base-import Control.Monad.IO.Class (MonadIO)-import Data.Kind              (Constraint, Type)---- monad-control-import Control.Monad.Trans.Control (ComposeSt, MonadBaseControl,-                                    MonadTransControl, StM, defaultLiftBaseWith,-                                    defaultRestoreM,liftBaseWith, restoreM)---- transformers-import Control.Monad.Trans.Class (MonadTrans)---- transformers-base-import Control.Monad.Base (MonadBase, liftBase, liftBaseDefault)---- | This type indicates that the effects (i.e., type classes) @effs@ are handled by--- a specific monad transformer @t@. The type is a simple wrapper around the--- monad transformer itself. The whole purpose of this type is to guide the type--- system to pick the instances of type classes @effs@ given by the type @t@, and--- to delegate all other effects that are not in @effs@ to their handlers which are--- located somewhere further down the monad transformer stack.------ @since 0.2.0.0-newtype EachVia (effs :: [Effect]) (t :: Transformer) m a =-  EachVia { runVia :: t m a }-    deriving (Applicative, Functor, Monad, MonadIO)-    deriving (MonadTrans, MonadTransControl)--instance (Monad (t m), MonadBase b m, MonadTrans t) => MonadBase b (EachVia effs t m) where-  liftBase = liftBaseDefault-  {-# INLINE liftBase #-}--instance (Monad (t m), MonadBaseControl b m, MonadTransControl t) => MonadBaseControl b (EachVia effs t m) where-  type StM (EachVia effs t m) a = ComposeSt t m a-  liftBaseWith = defaultLiftBaseWith-  {-# INLINE liftBaseWith #-}-  restoreM = defaultRestoreM-  {-# INLINE restoreM #-}---- | This type synonym can be used to indicate that a single effect @eff@ is--- handled by a specific monad transformer @t@.------ @since 0.2.0.0-type Via eff t m a = EachVia '[eff] t m a---- | This type is used as tag for all untagged effects. In order words, every--- effect is tagged, even untagged ones, but all the untagged ones simply have--- the same tag @G@ (short for \"Global\", because you can view tags as some--- kind of namespace mechanism, and all untagged effects live in the same--- global namespace).------ If you don\'t want to use tagged effects (i.e., you write effect type classes--- without a tag type parameter), you can ignore this type completely.-data G---- | The kind of monads.-type SomeMonad = Type -> Type---- | The kind of effects, which are type classes with a monad type parameter at--- the end.-type Effect = SomeMonad -> Constraint---- | The kind of monad transformers, also known as effect handlers or effect--- interpreters.-type Transformer = SomeMonad -> Type -> Type---- | This type synonym indicates that an effect is handled by a specific monad--- transformer.-type Handle (eff :: Effect) (t :: Transformer) m =-  eff (t m)---- | This type synonym indicates that an effect @eff@ is not at the head of the--- type level list of effects to be handled, so the effect must be found further--- down in the tail @effs@.------ @since 0.2.0.0-type Find eff effs t m = (Monad (t m), eff (EachVia effs t m))---- | This constraint synonym indicates that a first-order effect is not handled--- by a specific monad transformer and must thus be delegated (\"lifted\")--- further down the monad transformer stack in order to find its associated--- handler.------ Roughly speaking, a first-order effect is a type class whose monad type--- parameter @m@ appears only in positive position when looking at the types of--- its corresponding class methods (e.g., @m@ appears only in the result type).------ An example of a first-order effect is the 'Control.Effect.State.State'' effect.-type Lift (eff :: Effect) (t :: Transformer) m =-  (eff m, Monad (t m), MonadTrans t)---- | This constraint synonym indicates that a higher-order effect is not handled--- by a specific monad transformer and must thus be delegated (\"lifted\")--- further down the monad transformer stack in order to find its associated--- handler.------ Roughly speaking, a higher-order effect is a type class whose monad type--- parameter @m@ appears in negative position when looking at the types of its--- corresponding class methods (e.g., @m@ appears in the type of a method--- parameter).------ An example of a higher-order effect is the 'Control.Effect.Reader.Reader'' effect,--- since its class method 'Control.Effect.Reader.local'' has a parameter of--- type @m a@.-type Control (eff :: Effect) (t :: Transformer) m =+-----------------------------------------------------------------------------
+-- |
+-- Module      :  Control.Effect.Machinery.Via
+-- Copyright   :  (c) Michael Szvetits, 2020
+-- License     :  BSD3 (see the file LICENSE)
+-- Maintainer  :  typedbyte@qualified.name
+-- Stability   :  stable
+-- Portability :  portable
+--
+-- This module defines the types 'EachVia' and its corresponding type synonym
+-- 'Via' which indicate that specific effects are handled by a specific monad
+-- transformer (also known as effect handler or effect interpreter).
+--
+-- It also defines the 'G' type, which is the global tag that is used for
+-- untagged effects.
+-- 
+-- Last but not least, it defines some constraint synonyms and kinds that are
+-- used throughout this library, hopefully to increase the readability of the
+-- code at some points.
+-----------------------------------------------------------------------------
+module Control.Effect.Machinery.Via
+  ( -- * Core Types
+    EachVia(..)
+  , Via
+  , G
+    -- * Constraint Synonyms and Kinds
+  , SomeMonad
+  , Effect
+  , Transformer
+  , Handle
+  , Find
+  , Lift
+  , Control
+  ) where
+
+-- base
+import Control.Monad.IO.Class (MonadIO)
+import Data.Kind              (Constraint, Type)
+
+-- monad-control
+import Control.Monad.Trans.Control (ComposeSt, MonadBaseControl,
+                                    MonadTransControl, StM, defaultLiftBaseWith,
+                                    defaultRestoreM,liftBaseWith, restoreM)
+
+-- transformers
+import Control.Monad.Trans.Class (MonadTrans)
+
+-- transformers-base
+import Control.Monad.Base (MonadBase, liftBase, liftBaseDefault)
+
+-- | This type indicates that the effects (i.e., type classes) @effs@ are handled by
+-- a specific monad transformer @t@. The type is a simple wrapper around the
+-- monad transformer itself. The whole purpose of this type is to guide the type
+-- system to pick the instances of type classes @effs@ given by the type @t@, and
+-- to delegate all other effects that are not in @effs@ to their handlers which are
+-- located somewhere further down the monad transformer stack.
+--
+-- @since 0.2.0.0
+newtype EachVia (effs :: [Effect]) (t :: Transformer) m a =
+  EachVia { runVia :: t m a }
+    deriving (Applicative, Functor, Monad, MonadIO)
+    deriving (MonadTrans, MonadTransControl)
+
+instance (Monad (t m), MonadBase b m, MonadTrans t) => MonadBase b (EachVia effs t m) where
+  liftBase = liftBaseDefault
+  {-# INLINE liftBase #-}
+
+instance (Monad (t m), MonadBaseControl b m, MonadTransControl t) => MonadBaseControl b (EachVia effs t m) where
+  type StM (EachVia effs t m) a = ComposeSt t m a
+  liftBaseWith = defaultLiftBaseWith
+  {-# INLINE liftBaseWith #-}
+  restoreM = defaultRestoreM
+  {-# INLINE restoreM #-}
+
+-- | This type synonym can be used to indicate that a single effect @eff@ is
+-- handled by a specific monad transformer @t@.
+--
+-- @since 0.2.0.0
+type Via eff t m a = EachVia '[eff] t m a
+
+-- | This type is used as tag for all untagged effects. In order words, every
+-- effect is tagged, even untagged ones, but all the untagged ones simply have
+-- the same tag @G@ (short for \"Global\", because you can view tags as some
+-- kind of namespace mechanism, and all untagged effects live in the same
+-- global namespace).
+--
+-- If you don\'t want to use tagged effects (i.e., you write effect type classes
+-- without a tag type parameter), you can ignore this type completely.
+data G
+
+-- | The kind of monads.
+type SomeMonad = Type -> Type
+
+-- | The kind of effects, which are type classes with a monad type parameter at
+-- the end.
+type Effect = SomeMonad -> Constraint
+
+-- | The kind of monad transformers, also known as effect handlers or effect
+-- interpreters.
+type Transformer = SomeMonad -> Type -> Type
+
+-- | This constraint synonym indicates that an effect is handled by a specific monad
+-- transformer.
+type Handle (eff :: Effect) (t :: Transformer) m =
+  eff (t m)
+
+-- | This constraint synonym indicates that an effect @eff@ is not at the head of the
+-- type level list of effects to be handled, so the effect must be found further
+-- down in the tail @effs@.
+--
+-- @since 0.2.0.0
+type Find eff effs t m = (Monad (t m), eff (EachVia effs t m))
+
+-- | This constraint synonym indicates that a first-order effect is not handled
+-- by a specific monad transformer and must thus be delegated (\"lifted\")
+-- further down the monad transformer stack in order to find its associated
+-- handler.
+--
+-- Roughly speaking, a first-order effect is a type class whose monad type
+-- parameter @m@ appears only in positive position when looking at the types of
+-- its corresponding class methods (e.g., @m@ appears only in the result type).
+--
+-- An example of a first-order effect is the 'Control.Effect.State.State'' effect.
+type Lift (eff :: Effect) (t :: Transformer) m =
+  (eff m, Monad (t m), MonadTrans t)
+
+-- | This constraint synonym indicates that a higher-order effect is not handled
+-- by a specific monad transformer and must thus be delegated (\"lifted\")
+-- further down the monad transformer stack in order to find its associated
+-- handler.
+--
+-- Roughly speaking, a higher-order effect is a type class whose monad type
+-- parameter @m@ appears in negative position when looking at the types of its
+-- corresponding class methods (e.g., @m@ appears in the type of a method
+-- parameter).
+--
+-- An example of a higher-order effect is the 'Control.Effect.Reader.Reader'' effect,
+-- since its class method 'Control.Effect.Reader.local'' has a parameter of
+-- type @m a@.
+type Control (eff :: Effect) (t :: Transformer) m =
   (eff m, Monad (t m), MonadTransControl t)

@@ -0,0 +1,122 @@+{-# LANGUAGE TemplateHaskell #-}+-----------------------------------------------------------------------------+-- |+-- Module      :  Control.Effect.Managed+-- Copyright   :  (c) Michael Szvetits, 2020+-- License     :  BSD3 (see the file LICENSE)+-- Maintainer  :  typedbyte@qualified.name+-- Stability   :  stable+-- Portability :  portable+--+-- The managed effect allows a computation to allocate resources which are+-- guaranteed to be released after the end of the computation. This effect+-- provides a monadic interface for managing one or more long-living+-- resources in a more readable way than nesting 'IO.bracket'-style+-- operations of the "Control.Effect.Resource" effect.+-----------------------------------------------------------------------------+module Control.Effect.Managed+  ( -- * Tagged Managed Effect+    Managed'(..)+    -- * Untagged Managed Effect+    -- | If you don't require disambiguation of multiple managed effects+    -- (i.e., you only have one managed effect in your monadic context),+    -- it is recommended to always use the untagged managed effect.+  , Managed+  , manage+    -- * Interpretations+  , Bracket+  , runManaged'+  , runManaged+    -- * Tagging and Untagging+    -- | Conversion functions between the tagged and untagged managed effect,+    -- usually used in combination with type applications, like:+    --+    -- @+    --     'tagManaged'' \@\"newTag\" program+    --     'retagManaged'' \@\"oldTag\" \@\"newTag\" program+    --     'untagManaged'' \@\"erasedTag\" program+    -- @+    -- +  , tagManaged'+  , retagManaged'+  , untagManaged'+  ) where++-- base+import qualified Control.Exception as IO+import Data.IORef (IORef, atomicModifyIORef', newIORef, readIORef)++-- transformers+import Control.Monad.Trans.Reader (ReaderT(ReaderT), runReaderT)++import Control.Effect.Machinery++-- | An effect that allows a computation to allocate resources which are+-- guaranteed to be released after the computation.+--+-- @since 0.3.0.0+class Monad m => Managed' tag m where+  -- | Acquire a resource by specifying an acquisition action and a release+  -- action to be used for cleanup after the computation.+  --+  -- @since 0.3.0.0+  manage' :: m a        -- ^ The computation which acquires the resource.+          -> (a -> m b) -- ^ The computation which releases the resource.+          -> m a        -- ^ The acquired resource.++makeTaggedEffect ''Managed'++-- | The bracket-based interpreter of the managed effect. This type implements+-- the 'Managed'' type class by using 'IO.bracket', thus requiring 'IO' at the+-- bottom of the monad transformer stack.+--+-- When interpreting the effect, you usually don\'t interact with this type directly,+-- but instead use one of its corresponding interpretation functions.+--+-- @since 0.3.0.0+newtype Bracket n m a = Bracket { runBracket :: ReaderT (IORef [n ()]) m a }+  deriving (Applicative, Functor, Monad, MonadIO)+  deriving (MonadTrans, MonadTransControl)+  deriving (MonadBase b, MonadBaseControl b)++instance MonadBase IO m => Managed' tag (Bracket m m) where+  manage' alloc free = Bracket . ReaderT $+    \ref -> do+      a <- runReaderT (runBracket alloc) ref+      liftBase $+        atomicModifyIORef' ref $+          \frees -> (runReaderT (runBracket (free a >> pure ())) ref : frees, ())+      pure a+  {-# INLINE manage' #-}++-- | Runs the managed effect using 'IO.bracket'.+--+-- @since 0.3.0.0+runManaged' :: forall tag m a. MonadBaseControl IO m => (Managed' tag `Via` Bracket m) m a -> m a+runManaged' program =+  liftedBracket+    ( allocRef )+    ( freeRef  )+    ( runReaderT (runBracket (runVia program)) )+  where+    allocRef :: forall n. MonadBase IO n => n (IORef [n ()])+    allocRef = liftBase $ newIORef []+    +    freeRef :: forall n. MonadBase IO n => IORef [n ()] -> n ()+    freeRef = (sequence_ =<<) . liftBase . readIORef+    +    liftedBracket :: forall n b c d. MonadBaseControl IO n => n b -> (b -> n c) -> (b -> n d) -> n d+    liftedBracket alloc free use =+      control $ \run ->+        IO.bracket+          ( run alloc )+          ( \a -> run (restoreM a >>= free) )+          ( \a -> run (restoreM a >>= use) )+{-# INLINE runManaged' #-}++-- | The untagged version of 'runManaged''.+--+-- @since 0.3.0.0+runManaged :: MonadBaseControl IO m => (Managed `Via` Bracket m) m a -> m a+runManaged = runManaged' @G+{-# INLINE runManaged #-}

@@ -89,7 +89,7 @@ newtype Separation m a =   Separation { _runSeparation :: m a }     deriving (Applicative, Functor, Monad, MonadIO)-    deriving (MonadTrans, MonadTransControl) via Default+    deriving (MonadTrans, MonadTransControl) via IdentityT     deriving (MonadBase b, MonadBaseControl b)     deriving (R.Reader' tag r, W.Writer' tag w, S.State' tag s) @@ -120,7 +120,7 @@ newtype Tagger tag new m a =   Tagger { runRWSTagger :: m a }     deriving (Applicative, Functor, Monad, MonadIO)-    deriving (MonadTrans, MonadTransControl) via Default+    deriving (MonadTrans, MonadTransControl) via IdentityT     deriving (MonadBase b, MonadBaseControl b)  instance RWS' new r w s m => RWS' tag r w s (Tagger tag new m)

@@ -113,7 +113,7 @@ newtype LowerIO m a =   LowerIO { _runLowerIO :: m a }     deriving (Applicative, Functor, Monad, MonadIO)-    deriving (MonadTrans, MonadTransControl) via Default+    deriving (MonadTrans, MonadTransControl) via IdentityT     deriving (MonadBase b, MonadBaseControl b)  instance MonadBaseControl IO m => Resource' tag (LowerIO m) where