Control.Effect.Managed

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 bracket-style operations of the Control.Effect.Resource effect.

Tagged Managed Effect

class MonadIO m => Managed' tag m where

An effect that allows a computation to allocate resources which are guaranteed to be released after the computation.

Since: 0.4.0.0

Methods

manage'

Arguments

:: m a

The computation which acquires the resource.

-> (a -> m b)

The computation which releases the resource.

-> m a

The acquired resource.

Acquire a resource by specifying an acquisition action and a release action to be used for cleanup after the computation.

Since: 0.4.0.0

Instances

(MonadBase IO m, MonadIO m) => Managed' (tag :: k) (Bracket m m)

Defined in Control.Effect.Managed

Methods

manage' :: Bracket m m a -> (a -> Bracket m m b) -> Bracket m m a

Handle '[MonadIO] (Managed' tag) others t m => Managed' (tag :: k) (EachVia (Managed' tag ': others) t m)

Defined in Control.Effect.Managed

Methods

manage' :: EachVia (Managed' tag ': others) t m a -> (a -> EachVia (Managed' tag ': others) t m b) -> EachVia (Managed' tag ': others) t m a

Find '[MonadIO] (Managed' tag) other effs t m => Managed' (tag :: k) (EachVia (other ': effs) t m)

Defined in Control.Effect.Managed

Methods

manage' :: EachVia (other ': effs) t m a -> (a -> EachVia (other ': effs) t m b) -> EachVia (other ': effs) t m a

Control '[MonadIO] (Managed' tag) t m => Managed' (tag :: k) (EachVia ('[] :: [Effect]) t m)

Defined in Control.Effect.Managed

Methods

manage' :: EachVia '[] t m a -> (a -> EachVia '[] t m b) -> EachVia '[] t m a

Managed' new m => Managed' (tag :: k2) (Tagger tag new m)

Defined in Control.Effect.Managed

Methods

manage' :: Tagger tag new m a -> (a -> Tagger tag new m b) -> Tagger tag new m a

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.

type Managed = Managed' G

manage :: Managed m => m a -> (a -> m b) -> m a

Interpretations

data Bracket n m a

The bracket-based interpreter of the managed effect. This type implements the Managed' type class by using 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.4.0.0

Instances

(MonadBase IO m, MonadIO m) => Managed' (tag :: k) (Bracket m m)

Defined in Control.Effect.Managed

Methods

manage' :: Bracket m m a -> (a -> Bracket m m b) -> Bracket m m a

MonadBase b m => MonadBase b (Bracket n m)

Defined in Control.Effect.Managed

Methods

liftBase :: b α -> Bracket n m α

MonadBaseControl b m => MonadBaseControl b (Bracket n m)

Defined in Control.Effect.Managed

Associated Types

type StM (Bracket n m) a

Methods

liftBaseWith :: (RunInBase (Bracket n m) b -> b a) -> Bracket n m a

restoreM :: StM (Bracket n m) a -> Bracket n m a

MonadTrans (Bracket n)

Defined in Control.Effect.Managed

Methods

lift :: Monad m => m a -> Bracket n m a

MonadTransControl (Bracket n)

Defined in Control.Effect.Managed

Associated Types

type StT (Bracket n) a

Methods

liftWith :: Monad m => (Run (Bracket n) -> m a) -> Bracket n m a

restoreT :: Monad m => m (StT (Bracket n) a) -> Bracket n m a

Monad m => Monad (Bracket n m)

Defined in Control.Effect.Managed

Methods

(>>=) :: Bracket n m a -> (a -> Bracket n m b) -> Bracket n m b

(>>) :: Bracket n m a -> Bracket n m b -> Bracket n m b

return :: a -> Bracket n m a

Functor m => Functor (Bracket n m)

Defined in Control.Effect.Managed

Methods

fmap :: (a -> b) -> Bracket n m a -> Bracket n m b

(<$) :: a -> Bracket n m b -> Bracket n m a

Applicative m => Applicative (Bracket n m)

Defined in Control.Effect.Managed

Methods

pure :: a -> Bracket n m a

(<*>) :: Bracket n m (a -> b) -> Bracket n m a -> Bracket n m b

liftA2 :: (a -> b -> c) -> Bracket n m a -> Bracket n m b -> Bracket n m c

(*>) :: Bracket n m a -> Bracket n m b -> Bracket n m b

(<*) :: Bracket n m a -> Bracket n m b -> Bracket n m a

MonadIO m => MonadIO (Bracket n m)

Defined in Control.Effect.Managed

Methods

liftIO :: IO a -> Bracket n m a

type StT (Bracket n) a

Defined in Control.Effect.Managed

type StT (Bracket n) a = StT (ReaderT (IORef [n ()])) a

type StM (Bracket n m) a

Defined in Control.Effect.Managed

type StM (Bracket n m) a = StM (ReaderT (IORef [n ()]) m) a

runManaged' :: forall tag m a. MonadBaseControl IO m => (Managed' tag `Via` Bracket m) m a -> m a

Runs the managed effect using bracket.

Since: 0.4.0.0

runManaged :: MonadBaseControl IO m => (Managed `Via` Bracket m) m a -> m a

The untagged version of runManaged'.

Since: 0.4.0.0

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' :: forall new m a. (Managed' G `Via` Tagger G new) m a -> m a

retagManaged' :: forall tag new m a. (Managed' tag `Via` Tagger tag new) m a -> m a

untagManaged' :: forall tag m a. (Managed' tag `Via` Tagger tag G) m a -> m a