Control.Monad.Finally

Guarding monadic computations with cleanup actions.

Documentation

class (Applicative μ, Monad μ) => MonadFinally μ where

Class of monads that support guarding computations with cleanup actions.

Minimal complete definition

finally' | bracket'

Methods

finally' :: μ α -> (Maybe α -> μ β) -> μ (α, β)

finally' m f runs computation m and then

1. runs f (Just x) if m produced a result x. The result of that is returned alongside with x.
2. runs f Nothing otherwise.

finally :: μ α -> μ β -> μ α

A simplified version of finally' in which the cleanup action does not care about the result of the main computation. The default implementation is

    finally m = fmap fst . finally' m . const

bracket'

Arguments

:: μ r

Acquire resource

-> (r -> Maybe α -> μ β)

Release resource

-> (r -> μ α)

Main computation

-> μ (α, β)

Safely acquire a resource and use it in a computation, releasing it even when the computation does not produce a result.

bracket :: μ r -> (r -> μ β) -> (r -> μ α) -> μ α

A simplified version of bracket' in which the releasing action does not care about the result of the main computation. The default implementation is

    bracket acquire release =
      fmap fst . bracket' acquire (const . release)

Instances

MonadFinally IO

Methods

finally' :: IO α -> (Maybe α -> IO β) -> IO (α, β)

finally :: IO α -> IO β -> IO α

bracket' :: IO r -> (r -> Maybe α -> IO β) -> (r -> IO α) -> IO (α, β)

bracket :: IO r -> (r -> IO β) -> (r -> IO α) -> IO α

MonadFinally Identity

Methods

finally' :: Identity α -> (Maybe α -> Identity β) -> Identity (α, β)

finally :: Identity α -> Identity β -> Identity α

bracket' :: Identity r -> (r -> Maybe α -> Identity β) -> (r -> Identity α) -> Identity (α, β)

bracket :: Identity r -> (r -> Identity β) -> (r -> Identity α) -> Identity α

MonadFinally μ => MonadFinally (MaybeT μ)

Methods

finally' :: MaybeT μ α -> (Maybe α -> MaybeT μ β) -> MaybeT μ (α, β)

finally :: MaybeT μ α -> MaybeT μ β -> MaybeT μ α

bracket' :: MaybeT μ r -> (r -> Maybe α -> MaybeT μ β) -> (r -> MaybeT μ α) -> MaybeT μ (α, β)

bracket :: MaybeT μ r -> (r -> MaybeT μ β) -> (r -> MaybeT μ α) -> MaybeT μ α

MonadFinally μ => MonadFinally (ExceptT e μ)

Methods

finally' :: ExceptT e μ α -> (Maybe α -> ExceptT e μ β) -> ExceptT e μ (α, β)

finally :: ExceptT e μ α -> ExceptT e μ β -> ExceptT e μ α

bracket' :: ExceptT e μ r -> (r -> Maybe α -> ExceptT e μ β) -> (r -> ExceptT e μ α) -> ExceptT e μ (α, β)

bracket :: ExceptT e μ r -> (r -> ExceptT e μ β) -> (r -> ExceptT e μ α) -> ExceptT e μ α

MonadFinally μ => MonadFinally (AbortT e μ)

Methods

finally' :: AbortT e μ α -> (Maybe α -> AbortT e μ β) -> AbortT e μ (α, β)

finally :: AbortT e μ α -> AbortT e μ β -> AbortT e μ α

bracket' :: AbortT e μ r -> (r -> Maybe α -> AbortT e μ β) -> (r -> AbortT e μ α) -> AbortT e μ (α, β)

bracket :: AbortT e μ r -> (r -> AbortT e μ β) -> (r -> AbortT e μ α) -> AbortT e μ α

MonadFinally μ => MonadFinally (FinishT β μ)

Methods

finally' :: FinishT β μ α -> (Maybe α -> FinishT β μ β) -> FinishT β μ (α, β)

finally :: FinishT β μ α -> FinishT β μ β -> FinishT β μ α

bracket' :: FinishT β μ r -> (r -> Maybe α -> FinishT β μ β) -> (r -> FinishT β μ α) -> FinishT β μ (α, β)

bracket :: FinishT β μ r -> (r -> FinishT β μ β) -> (r -> FinishT β μ α) -> FinishT β μ α

(MonadFinally μ, Monoid w) => MonadFinally (WriterT w μ)

Methods

finally' :: WriterT w μ α -> (Maybe α -> WriterT w μ β) -> WriterT w μ (α, β)

finally :: WriterT w μ α -> WriterT w μ β -> WriterT w μ α

bracket' :: WriterT w μ r -> (r -> Maybe α -> WriterT w μ β) -> (r -> WriterT w μ α) -> WriterT w μ (α, β)

bracket :: WriterT w μ r -> (r -> WriterT w μ β) -> (r -> WriterT w μ α) -> WriterT w μ α

MonadFinally μ => MonadFinally (StateT s μ)

Methods

finally' :: StateT s μ α -> (Maybe α -> StateT s μ β) -> StateT s μ (α, β)

finally :: StateT s μ α -> StateT s μ β -> StateT s μ α

bracket' :: StateT s μ r -> (r -> Maybe α -> StateT s μ β) -> (r -> StateT s μ α) -> StateT s μ (α, β)

bracket :: StateT s μ r -> (r -> StateT s μ β) -> (r -> StateT s μ α) -> StateT s μ α

(MonadFinally μ, Error e) => MonadFinally (ErrorT e μ)

Methods

finally' :: ErrorT e μ α -> (Maybe α -> ErrorT e μ β) -> ErrorT e μ (α, β)

finally :: ErrorT e μ α -> ErrorT e μ β -> ErrorT e μ α

bracket' :: ErrorT e μ r -> (r -> Maybe α -> ErrorT e μ β) -> (r -> ErrorT e μ α) -> ErrorT e μ (α, β)

bracket :: ErrorT e μ r -> (r -> ErrorT e μ β) -> (r -> ErrorT e μ α) -> ErrorT e μ α

MonadFinally μ => MonadFinally (StateT s μ)

Methods

finally' :: StateT s μ α -> (Maybe α -> StateT s μ β) -> StateT s μ (α, β)

finally :: StateT s μ α -> StateT s μ β -> StateT s μ α

bracket' :: StateT s μ r -> (r -> Maybe α -> StateT s μ β) -> (r -> StateT s μ α) -> StateT s μ (α, β)

bracket :: StateT s μ r -> (r -> StateT s μ β) -> (r -> StateT s μ α) -> StateT s μ α

(MonadFinally μ, Monoid w) => MonadFinally (WriterT w μ)

Methods

finally' :: WriterT w μ α -> (Maybe α -> WriterT w μ β) -> WriterT w μ (α, β)

finally :: WriterT w μ α -> WriterT w μ β -> WriterT w μ α

bracket' :: WriterT w μ r -> (r -> Maybe α -> WriterT w μ β) -> (r -> WriterT w μ α) -> WriterT w μ (α, β)

bracket :: WriterT w μ r -> (r -> WriterT w μ β) -> (r -> WriterT w μ α) -> WriterT w μ α

(MonadFinally μ, Monoid w) => MonadFinally (AccumT w μ)

Methods

finally' :: AccumT w μ α -> (Maybe α -> AccumT w μ β) -> AccumT w μ (α, β)

finally :: AccumT w μ α -> AccumT w μ β -> AccumT w μ α

bracket' :: AccumT w μ r -> (r -> Maybe α -> AccumT w μ β) -> (r -> AccumT w μ α) -> AccumT w μ (α, β)

bracket :: AccumT w μ r -> (r -> AccumT w μ β) -> (r -> AccumT w μ α) -> AccumT w μ α

MonadFinally μ => MonadFinally (ReaderT * r μ)

Methods

finally' :: ReaderT * r μ α -> (Maybe α -> ReaderT * r μ β) -> ReaderT * r μ (α, β)

finally :: ReaderT * r μ α -> ReaderT * r μ β -> ReaderT * r μ α

bracket' :: ReaderT * r μ r -> (r -> Maybe α -> ReaderT * r μ β) -> (r -> ReaderT * r μ α) -> ReaderT * r μ (α, β)

bracket :: ReaderT * r μ r -> (r -> ReaderT * r μ β) -> (r -> ReaderT * r μ α) -> ReaderT * r μ α

(MonadFinally μ, Monoid w) => MonadFinally (RWST r w s μ)

Methods

finally' :: RWST r w s μ α -> (Maybe α -> RWST r w s μ β) -> RWST r w s μ (α, β)

finally :: RWST r w s μ α -> RWST r w s μ β -> RWST r w s μ α

bracket' :: RWST r w s μ r -> (r -> Maybe α -> RWST r w s μ β) -> (r -> RWST r w s μ α) -> RWST r w s μ (α, β)

bracket :: RWST r w s μ r -> (r -> RWST r w s μ β) -> (r -> RWST r w s μ α) -> RWST r w s μ α

(MonadFinally μ, Monoid w) => MonadFinally (RWST r w s μ)

Methods

finally' :: RWST r w s μ α -> (Maybe α -> RWST r w s μ β) -> RWST r w s μ (α, β)

finally :: RWST r w s μ α -> RWST r w s μ β -> RWST r w s μ α

bracket' :: RWST r w s μ r -> (r -> Maybe α -> RWST r w s μ β) -> (r -> RWST r w s μ α) -> RWST r w s μ (α, β)

bracket :: RWST r w s μ r -> (r -> RWST r w s μ β) -> (r -> RWST r w s μ α) -> RWST r w s μ α

chainCleanups :: MonadFinally μ => [μ α] -> μ ()

Run the provided list of cleanup actions sequentually, attempting to run the next action even if the previous one did not produce a result.

finallyMany :: MonadFinally μ => μ α -> [μ β] -> μ α

A variant of finally that combines multiple cleanup actions with chainCleanups.

onEscape :: MonadFinally μ => μ α -> μ β -> μ α

onEscape m c runs computation m and then, if it did not produce a result, runs computation c.

onEscapeMany :: MonadFinally μ => μ α -> [μ β] -> μ α

A variant of onEscape that combines multiple cleanup actions with chainCleanups.

bracket_

Arguments

:: MonadFinally μ

=> μ r

Acquire resource

-> μ β

Release resource

-> μ α

Main computation

-> μ α

A variant of bracket where acquired value is not needed (e.g. using a static resource).

bracketOnEscape

Arguments

:: MonadFinally μ

=> μ r

Acquire resource

-> (r -> μ β)

Release resource

-> (r -> μ α)

Main computation

-> μ α

A variant of bracket that releases the acquired resource only when the main computation does not produce a value.