{-# LANGUAGE RankNTypes, TypeFamilies, FlexibleContexts, FlexibleInstances,
MultiParamTypeClasses, UndecidableInstances, ScopedTypeVariables,
GeneralizedNewtypeDeriving, Trustworthy #-}
{-# OPTIONS_GHC -fno-warn-orphans #-}
module Pipes.Safe
(
SafeT(SafeT)
, runSafeT
, runSafeP
, ReleaseKey
, MonadSafe(..)
, onException
, tryP
, catchP
, finally
, bracket
, bracket_
, bracketOnError
, Env
, module Control.Monad.Catch
, module Control.Exception
) where
import Control.Applicative (Alternative)
import Control.Exception(Exception(..), SomeException(..))
import qualified Control.Monad.Catch as C
import Control.Monad.Catch
( MonadCatch(..)
, MonadThrow(..)
, MonadMask(..)
, ExitCase(..)
, mask_
, uninterruptibleMask_
, catchAll
, catchIOError
, catchJust
, catchIf
, Handler(..)
, catches
, handle
, handleAll
, handleIOError
, handleJust
, handleIf
, tryJust
, Exception(..)
, SomeException
)
import Control.Monad (MonadPlus, liftM)
import Control.Monad.Fix (MonadFix)
import Control.Monad.IO.Class (MonadIO(liftIO))
import Control.Monad.Trans.Control (MonadBaseControl(..))
import Control.Monad.Trans.Class (MonadTrans(lift))
import qualified Control.Monad.Base as B
import qualified Control.Monad.Catch.Pure as E
import qualified Control.Monad.Trans.Identity as I
import qualified Control.Monad.Cont.Class as CC
import qualified Control.Monad.Error.Class as EC
import qualified Control.Monad.Primitive as Prim
import qualified Control.Monad.Trans.Reader as R
import qualified Control.Monad.Trans.RWS.Lazy as RWS
import qualified Control.Monad.Trans.RWS.Strict as RWS'
import qualified Control.Monad.Trans.State.Lazy as S
import qualified Control.Monad.Trans.State.Strict as S'
import qualified Control.Monad.State.Class as SC
import qualified Control.Monad.Trans.Writer.Lazy as W
import qualified Control.Monad.Trans.Writer.Strict as W'
import qualified Control.Monad.Writer.Class as WC
import Data.IORef (IORef, newIORef, readIORef, writeIORef, atomicModifyIORef')
import Data.Kind (Type)
import qualified Data.Map as M
import Pipes (Proxy, Effect, Effect', runEffect)
import Pipes.Internal (Proxy(..))
data Restore m = Unmasked | Masked (forall x . m x -> m x)
liftMask
:: forall m a' a b' b r . (MonadIO m, MonadCatch m)
=> (forall s . ((forall x . m x -> m x) -> m s) -> m s)
-> ((forall x . Proxy a' a b' b m x -> Proxy a' a b' b m x)
-> Proxy a' a b' b m r)
-> Proxy a' a b' b m r
liftMask :: forall (m :: * -> *) a' a b' b r.
(MonadIO m, MonadCatch m) =>
(forall s. ((forall x. m x -> m x) -> m s) -> m s)
-> ((forall x. Proxy a' a b' b m x -> Proxy a' a b' b m x)
-> Proxy a' a b' b m r)
-> Proxy a' a b' b m r
liftMask forall s. ((forall x. m x -> m x) -> m s) -> m s
maskVariant (forall x. Proxy a' a b' b m x -> Proxy a' a b' b m x)
-> Proxy a' a b' b m r
k = do
IORef (Restore m)
ioref <- forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a. a -> IO (IORef a)
newIORef forall (m :: * -> *). Restore m
Unmasked
let
loop :: Proxy a' a b' b m r -> Proxy a' a b' b m r
loop :: Proxy a' a b' b m r -> Proxy a' a b' b m r
loop (Request a'
a' a -> Proxy a' a b' b m r
fa ) = forall a' a b' b (m :: * -> *) r.
a' -> (a -> Proxy a' a b' b m r) -> Proxy a' a b' b m r
Request a'
a' (Proxy a' a b' b m r -> Proxy a' a b' b m r
loop forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Proxy a' a b' b m r
fa )
loop (Respond b
b b' -> Proxy a' a b' b m r
fb') = forall a' a b' b (m :: * -> *) r.
b -> (b' -> Proxy a' a b' b m r) -> Proxy a' a b' b m r
Respond b
b (Proxy a' a b' b m r -> Proxy a' a b' b m r
loop forall b c a. (b -> c) -> (a -> b) -> a -> c
. b' -> Proxy a' a b' b m r
fb')
loop (M m (Proxy a' a b' b m r)
m) = forall a' a b' b (m :: * -> *) r.
m (Proxy a' a b' b m r) -> Proxy a' a b' b m r
M forall a b. (a -> b) -> a -> b
$ forall s. ((forall x. m x -> m x) -> m s) -> m s
maskVariant forall a b. (a -> b) -> a -> b
$ \forall x. m x -> m x
unmaskVariant -> do
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a. IORef a -> a -> IO ()
writeIORef IORef (Restore m)
ioref forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *). (forall x. m x -> m x) -> Restore m
Masked forall x. m x -> m x
unmaskVariant
m (Proxy a' a b' b m r)
m forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall s. Proxy a' a b' b m s -> m (Proxy a' a b' b m s)
chunk forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. Proxy a' a b' b m r -> Proxy a' a b' b m r
loop
loop (Pure r
r) = forall a' a b' b (m :: * -> *) r. r -> Proxy a' a b' b m r
Pure r
r
unmask :: forall q. Proxy a' a b' b m q -> Proxy a' a b' b m q
unmask :: forall x. Proxy a' a b' b m x -> Proxy a' a b' b m x
unmask (Request a'
a' a -> Proxy a' a b' b m q
fa ) = forall a' a b' b (m :: * -> *) r.
a' -> (a -> Proxy a' a b' b m r) -> Proxy a' a b' b m r
Request a'
a' (forall x. Proxy a' a b' b m x -> Proxy a' a b' b m x
unmask forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Proxy a' a b' b m q
fa )
unmask (Respond b
b b' -> Proxy a' a b' b m q
fb') = forall a' a b' b (m :: * -> *) r.
b -> (b' -> Proxy a' a b' b m r) -> Proxy a' a b' b m r
Respond b
b (forall x. Proxy a' a b' b m x -> Proxy a' a b' b m x
unmask forall b c a. (b -> c) -> (a -> b) -> a -> c
. b' -> Proxy a' a b' b m q
fb')
unmask (M m (Proxy a' a b' b m q)
m) = forall a' a b' b (m :: * -> *) r.
m (Proxy a' a b' b m r) -> Proxy a' a b' b m r
M forall a b. (a -> b) -> a -> b
$ do
m (Proxy a' a b' b m q) -> m (Proxy a' a b' b m q)
unmaskVariant <- forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Masked forall x. m x -> m x
unmaskVariant <- forall a. IORef a -> IO a
readIORef IORef (Restore m)
ioref
forall (m :: * -> *) a. Monad m => a -> m a
return forall x. m x -> m x
unmaskVariant
m (Proxy a' a b' b m q) -> m (Proxy a' a b' b m q)
unmaskVariant (m (Proxy a' a b' b m q)
m forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall s. Proxy a' a b' b m s -> m (Proxy a' a b' b m s)
chunk forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall x. Proxy a' a b' b m x -> Proxy a' a b' b m x
unmask)
unmask (Pure q
q) = forall a' a b' b (m :: * -> *) r. r -> Proxy a' a b' b m r
Pure q
q
chunk :: forall s. Proxy a' a b' b m s -> m (Proxy a' a b' b m s)
chunk :: forall s. Proxy a' a b' b m s -> m (Proxy a' a b' b m s)
chunk (M m (Proxy a' a b' b m s)
m) = m (Proxy a' a b' b m s)
m forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall s. Proxy a' a b' b m s -> m (Proxy a' a b' b m s)
chunk
chunk Proxy a' a b' b m s
s = forall (m :: * -> *) a. Monad m => a -> m a
return Proxy a' a b' b m s
s
Proxy a' a b' b m r -> Proxy a' a b' b m r
loop forall a b. (a -> b) -> a -> b
$ (forall x. Proxy a' a b' b m x -> Proxy a' a b' b m x)
-> Proxy a' a b' b m r
k forall x. Proxy a' a b' b m x -> Proxy a' a b' b m x
unmask
instance (MonadMask m, MonadIO m) => MonadMask (Proxy a' a b' b m) where
mask :: forall b.
((forall a. Proxy a' a b' b m a -> Proxy a' a b' b m a)
-> Proxy a' a b' b m b)
-> Proxy a' a b' b m b
mask = forall (m :: * -> *) a' a b' b r.
(MonadIO m, MonadCatch m) =>
(forall s. ((forall x. m x -> m x) -> m s) -> m s)
-> ((forall x. Proxy a' a b' b m x -> Proxy a' a b' b m x)
-> Proxy a' a b' b m r)
-> Proxy a' a b' b m r
liftMask forall (m :: * -> *) b.
MonadMask m =>
((forall a. m a -> m a) -> m b) -> m b
mask
uninterruptibleMask :: forall b.
((forall a. Proxy a' a b' b m a -> Proxy a' a b' b m a)
-> Proxy a' a b' b m b)
-> Proxy a' a b' b m b
uninterruptibleMask = forall (m :: * -> *) a' a b' b r.
(MonadIO m, MonadCatch m) =>
(forall s. ((forall x. m x -> m x) -> m s) -> m s)
-> ((forall x. Proxy a' a b' b m x -> Proxy a' a b' b m x)
-> Proxy a' a b' b m r)
-> Proxy a' a b' b m r
liftMask forall (m :: * -> *) b.
MonadMask m =>
((forall a. m a -> m a) -> m b) -> m b
uninterruptibleMask
generalBracket :: forall a b c.
Proxy a' a b' b m a
-> (a -> ExitCase b -> Proxy a' a b' b m c)
-> (a -> Proxy a' a b' b m b)
-> Proxy a' a b' b m (b, c)
generalBracket Proxy a' a b' b m a
acquire a -> ExitCase b -> Proxy a' a b' b m c
release_ a -> Proxy a' a b' b m b
use = forall (m :: * -> *) b.
MonadMask m =>
((forall a. m a -> m a) -> m b) -> m b
mask forall a b. (a -> b) -> a -> b
$ \forall a. Proxy a' a b' b m a -> Proxy a' a b' b m a
unmasked -> do
a
a <- Proxy a' a b' b m a
acquire
let action :: Proxy a' a b' b m (ExitCase b, ExitCase_ b)
action = do
b
b <- a -> Proxy a' a b' b m b
use a
a
forall (m :: * -> *) a. Monad m => a -> m a
return (forall a. a -> ExitCase a
ExitCaseSuccess b
b, forall a. a -> ExitCase_ a
ExitCaseSuccess_ b
b)
let handler :: SomeException -> m (ExitCase a, ExitCase_ a)
handler SomeException
e = forall (m :: * -> *) a. Monad m => a -> m a
return (forall a. SomeException -> ExitCase a
ExitCaseException SomeException
e, forall a. SomeException -> ExitCase_ a
ExitCaseException_ SomeException
e)
(ExitCase b
exitCase, ExitCase_ b
exitCase_) <- forall a. Proxy a' a b' b m a -> Proxy a' a b' b m a
unmasked Proxy a' a b' b m (ExitCase b, ExitCase_ b)
action forall (m :: * -> *) e a.
(MonadCatch m, Exception e) =>
m a -> (e -> m a) -> m a
`catch` forall {m :: * -> *} {a} {a}.
Monad m =>
SomeException -> m (ExitCase a, ExitCase_ a)
handler
c
c <- a -> ExitCase b -> Proxy a' a b' b m c
release_ a
a ExitCase b
exitCase
case ExitCase_ b
exitCase_ of
ExitCaseException_ SomeException
e -> forall (m :: * -> *) e a. (MonadThrow m, Exception e) => e -> m a
throwM SomeException
e
ExitCaseSuccess_ b
b -> forall (m :: * -> *) a. Monad m => a -> m a
return (b
b, c
c)
data ExitCase_ a = ExitCaseSuccess_ a | ExitCaseException_ SomeException
data Finalizers m = Finalizers
{ forall (m :: * -> *). Finalizers m -> Integer
_nextKey :: !Integer
, forall (m :: * -> *). Finalizers m -> Map Integer (m ())
_finalizers :: !(M.Map Integer (m ()))
}
newtype Env m = Env (IORef (Maybe (Finalizers m)))
newtype SafeT m r
=
SafeT (R.ReaderT (Env m) m r)
deriving
( forall a b. a -> SafeT m b -> SafeT m a
forall a b. (a -> b) -> SafeT m a -> SafeT m b
forall (m :: * -> *) a b. Functor m => a -> SafeT m b -> SafeT m a
forall (m :: * -> *) a b.
Functor m =>
(a -> b) -> SafeT m a -> SafeT m b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> SafeT m b -> SafeT m a
$c<$ :: forall (m :: * -> *) a b. Functor m => a -> SafeT m b -> SafeT m a
fmap :: forall a b. (a -> b) -> SafeT m a -> SafeT m b
$cfmap :: forall (m :: * -> *) a b.
Functor m =>
(a -> b) -> SafeT m a -> SafeT m b
Functor
, forall a. a -> SafeT m a
forall a b. SafeT m a -> SafeT m b -> SafeT m a
forall a b. SafeT m a -> SafeT m b -> SafeT m b
forall a b. SafeT m (a -> b) -> SafeT m a -> SafeT m b
forall a b c. (a -> b -> c) -> SafeT m a -> SafeT m b -> SafeT m c
forall (f :: * -> *).
Functor f
-> (forall a. a -> f a)
-> (forall a b. f (a -> b) -> f a -> f b)
-> (forall a b c. (a -> b -> c) -> f a -> f b -> f c)
-> (forall a b. f a -> f b -> f b)
-> (forall a b. f a -> f b -> f a)
-> Applicative f
forall {m :: * -> *}. Applicative m => Functor (SafeT m)
forall (m :: * -> *) a. Applicative m => a -> SafeT m a
forall (m :: * -> *) a b.
Applicative m =>
SafeT m a -> SafeT m b -> SafeT m a
forall (m :: * -> *) a b.
Applicative m =>
SafeT m a -> SafeT m b -> SafeT m b
forall (m :: * -> *) a b.
Applicative m =>
SafeT m (a -> b) -> SafeT m a -> SafeT m b
forall (m :: * -> *) a b c.
Applicative m =>
(a -> b -> c) -> SafeT m a -> SafeT m b -> SafeT m c
<* :: forall a b. SafeT m a -> SafeT m b -> SafeT m a
$c<* :: forall (m :: * -> *) a b.
Applicative m =>
SafeT m a -> SafeT m b -> SafeT m a
*> :: forall a b. SafeT m a -> SafeT m b -> SafeT m b
$c*> :: forall (m :: * -> *) a b.
Applicative m =>
SafeT m a -> SafeT m b -> SafeT m b
liftA2 :: forall a b c. (a -> b -> c) -> SafeT m a -> SafeT m b -> SafeT m c
$cliftA2 :: forall (m :: * -> *) a b c.
Applicative m =>
(a -> b -> c) -> SafeT m a -> SafeT m b -> SafeT m c
<*> :: forall a b. SafeT m (a -> b) -> SafeT m a -> SafeT m b
$c<*> :: forall (m :: * -> *) a b.
Applicative m =>
SafeT m (a -> b) -> SafeT m a -> SafeT m b
pure :: forall a. a -> SafeT m a
$cpure :: forall (m :: * -> *) a. Applicative m => a -> SafeT m a
Applicative
, forall a. SafeT m a
forall a. SafeT m a -> SafeT m [a]
forall a. SafeT m a -> SafeT m a -> SafeT m a
forall (f :: * -> *).
Applicative f
-> (forall a. f a)
-> (forall a. f a -> f a -> f a)
-> (forall a. f a -> f [a])
-> (forall a. f a -> f [a])
-> Alternative f
forall {m :: * -> *}. Alternative m => Applicative (SafeT m)
forall (m :: * -> *) a. Alternative m => SafeT m a
forall (m :: * -> *) a. Alternative m => SafeT m a -> SafeT m [a]
forall (m :: * -> *) a.
Alternative m =>
SafeT m a -> SafeT m a -> SafeT m a
many :: forall a. SafeT m a -> SafeT m [a]
$cmany :: forall (m :: * -> *) a. Alternative m => SafeT m a -> SafeT m [a]
some :: forall a. SafeT m a -> SafeT m [a]
$csome :: forall (m :: * -> *) a. Alternative m => SafeT m a -> SafeT m [a]
<|> :: forall a. SafeT m a -> SafeT m a -> SafeT m a
$c<|> :: forall (m :: * -> *) a.
Alternative m =>
SafeT m a -> SafeT m a -> SafeT m a
empty :: forall a. SafeT m a
$cempty :: forall (m :: * -> *) a. Alternative m => SafeT m a
Alternative
, forall a. a -> SafeT m a
forall a b. SafeT m a -> SafeT m b -> SafeT m b
forall a b. SafeT m a -> (a -> SafeT m b) -> SafeT m b
forall {m :: * -> *}. Monad m => Applicative (SafeT m)
forall (m :: * -> *) a. Monad m => a -> SafeT m a
forall (m :: * -> *) a b.
Monad m =>
SafeT m a -> SafeT m b -> SafeT m b
forall (m :: * -> *) a b.
Monad m =>
SafeT m a -> (a -> SafeT m b) -> SafeT m b
forall (m :: * -> *).
Applicative m
-> (forall a b. m a -> (a -> m b) -> m b)
-> (forall a b. m a -> m b -> m b)
-> (forall a. a -> m a)
-> Monad m
return :: forall a. a -> SafeT m a
$creturn :: forall (m :: * -> *) a. Monad m => a -> SafeT m a
>> :: forall a b. SafeT m a -> SafeT m b -> SafeT m b
$c>> :: forall (m :: * -> *) a b.
Monad m =>
SafeT m a -> SafeT m b -> SafeT m b
>>= :: forall a b. SafeT m a -> (a -> SafeT m b) -> SafeT m b
$c>>= :: forall (m :: * -> *) a b.
Monad m =>
SafeT m a -> (a -> SafeT m b) -> SafeT m b
Monad
, forall a. String -> SafeT m a
forall (m :: * -> *).
Monad m -> (forall a. String -> m a) -> MonadFail m
forall {m :: * -> *}. MonadFail m => Monad (SafeT m)
forall (m :: * -> *) a. MonadFail m => String -> SafeT m a
fail :: forall a. String -> SafeT m a
$cfail :: forall (m :: * -> *) a. MonadFail m => String -> SafeT m a
MonadFail
, forall a. SafeT m a
forall a. SafeT m a -> SafeT m a -> SafeT m a
forall {m :: * -> *}. MonadPlus m => Monad (SafeT m)
forall {m :: * -> *}. MonadPlus m => Alternative (SafeT m)
forall (m :: * -> *) a. MonadPlus m => SafeT m a
forall (m :: * -> *) a.
MonadPlus m =>
SafeT m a -> SafeT m a -> SafeT m a
forall (m :: * -> *).
Alternative m
-> Monad m
-> (forall a. m a)
-> (forall a. m a -> m a -> m a)
-> MonadPlus m
mplus :: forall a. SafeT m a -> SafeT m a -> SafeT m a
$cmplus :: forall (m :: * -> *) a.
MonadPlus m =>
SafeT m a -> SafeT m a -> SafeT m a
mzero :: forall a. SafeT m a
$cmzero :: forall (m :: * -> *) a. MonadPlus m => SafeT m a
MonadPlus
, forall a. (a -> SafeT m a) -> SafeT m a
forall (m :: * -> *).
Monad m -> (forall a. (a -> m a) -> m a) -> MonadFix m
forall {m :: * -> *}. MonadFix m => Monad (SafeT m)
forall (m :: * -> *) a. MonadFix m => (a -> SafeT m a) -> SafeT m a
mfix :: forall a. (a -> SafeT m a) -> SafeT m a
$cmfix :: forall (m :: * -> *) a. MonadFix m => (a -> SafeT m a) -> SafeT m a
MonadFix
, EC.MonadError e
, SC.MonadState s
, WC.MonadWriter w
, forall a b. ((a -> SafeT m b) -> SafeT m a) -> SafeT m a
forall (m :: * -> *).
Monad m -> (forall a b. ((a -> m b) -> m a) -> m a) -> MonadCont m
forall {m :: * -> *}. MonadCont m => Monad (SafeT m)
forall (m :: * -> *) a b.
MonadCont m =>
((a -> SafeT m b) -> SafeT m a) -> SafeT m a
callCC :: forall a b. ((a -> SafeT m b) -> SafeT m a) -> SafeT m a
$ccallCC :: forall (m :: * -> *) a b.
MonadCont m =>
((a -> SafeT m b) -> SafeT m a) -> SafeT m a
CC.MonadCont
, forall e a. Exception e => e -> SafeT m a
forall (m :: * -> *).
Monad m -> (forall e a. Exception e => e -> m a) -> MonadThrow m
forall {m :: * -> *}. MonadThrow m => Monad (SafeT m)
forall (m :: * -> *) e a.
(MonadThrow m, Exception e) =>
e -> SafeT m a
throwM :: forall e a. Exception e => e -> SafeT m a
$cthrowM :: forall (m :: * -> *) e a.
(MonadThrow m, Exception e) =>
e -> SafeT m a
MonadThrow
, forall e a.
Exception e =>
SafeT m a -> (e -> SafeT m a) -> SafeT m a
forall (m :: * -> *).
MonadThrow m
-> (forall e a. Exception e => m a -> (e -> m a) -> m a)
-> MonadCatch m
forall {m :: * -> *}. MonadCatch m => MonadThrow (SafeT m)
forall (m :: * -> *) e a.
(MonadCatch m, Exception e) =>
SafeT m a -> (e -> SafeT m a) -> SafeT m a
catch :: forall e a.
Exception e =>
SafeT m a -> (e -> SafeT m a) -> SafeT m a
$ccatch :: forall (m :: * -> *) e a.
(MonadCatch m, Exception e) =>
SafeT m a -> (e -> SafeT m a) -> SafeT m a
MonadCatch
, forall b.
((forall a. SafeT m a -> SafeT m a) -> SafeT m b) -> SafeT m b
forall a b c.
SafeT m a
-> (a -> ExitCase b -> SafeT m c)
-> (a -> SafeT m b)
-> SafeT m (b, c)
forall {m :: * -> *}. MonadMask m => MonadCatch (SafeT m)
forall (m :: * -> *) b.
MonadMask m =>
((forall a. SafeT m a -> SafeT m a) -> SafeT m b) -> SafeT m b
forall (m :: * -> *) a b c.
MonadMask m =>
SafeT m a
-> (a -> ExitCase b -> SafeT m c)
-> (a -> SafeT m b)
-> SafeT m (b, c)
forall (m :: * -> *).
MonadCatch m
-> (forall b. ((forall a. m a -> m a) -> m b) -> m b)
-> (forall b. ((forall a. m a -> m a) -> m b) -> m b)
-> (forall a b c.
m a -> (a -> ExitCase b -> m c) -> (a -> m b) -> m (b, c))
-> MonadMask m
generalBracket :: forall a b c.
SafeT m a
-> (a -> ExitCase b -> SafeT m c)
-> (a -> SafeT m b)
-> SafeT m (b, c)
$cgeneralBracket :: forall (m :: * -> *) a b c.
MonadMask m =>
SafeT m a
-> (a -> ExitCase b -> SafeT m c)
-> (a -> SafeT m b)
-> SafeT m (b, c)
uninterruptibleMask :: forall b.
((forall a. SafeT m a -> SafeT m a) -> SafeT m b) -> SafeT m b
$cuninterruptibleMask :: forall (m :: * -> *) b.
MonadMask m =>
((forall a. SafeT m a -> SafeT m a) -> SafeT m b) -> SafeT m b
mask :: forall b.
((forall a. SafeT m a -> SafeT m a) -> SafeT m b) -> SafeT m b
$cmask :: forall (m :: * -> *) b.
MonadMask m =>
((forall a. SafeT m a -> SafeT m a) -> SafeT m b) -> SafeT m b
MonadMask
, forall a. IO a -> SafeT m a
forall (m :: * -> *).
Monad m -> (forall a. IO a -> m a) -> MonadIO m
forall {m :: * -> *}. MonadIO m => Monad (SafeT m)
forall (m :: * -> *) a. MonadIO m => IO a -> SafeT m a
liftIO :: forall a. IO a -> SafeT m a
$cliftIO :: forall (m :: * -> *) a. MonadIO m => IO a -> SafeT m a
MonadIO
, B.MonadBase b
)
instance MonadTrans SafeT where
lift :: forall (m :: * -> *) a. Monad m => m a -> SafeT m a
lift m a
m = forall (m :: * -> *) r. ReaderT (Env m) m r -> SafeT m r
SafeT (forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift m a
m)
instance MonadBaseControl b m => MonadBaseControl b (SafeT m) where
type StM (SafeT m) a = StM m a
liftBaseWith :: forall a. (RunInBase (SafeT m) b -> b a) -> SafeT m a
liftBaseWith RunInBase (SafeT m) b -> b a
f = forall (m :: * -> *) r. ReaderT (Env m) m r -> SafeT m r
SafeT forall a b. (a -> b) -> a -> b
$ forall r (m :: * -> *) a. (r -> m a) -> ReaderT r m a
R.ReaderT forall a b. (a -> b) -> a -> b
$ \Env m
reader' ->
forall (b :: * -> *) (m :: * -> *) a.
MonadBaseControl b m =>
(RunInBase m b -> b a) -> m a
liftBaseWith forall a b. (a -> b) -> a -> b
$ \RunInBase m b
runInBase ->
RunInBase (SafeT m) b -> b a
f forall a b. (a -> b) -> a -> b
$ RunInBase m b
runInBase forall b c a. (b -> c) -> (a -> b) -> a -> c
. (\(SafeT ReaderT (Env m) m a
r) -> forall r (m :: * -> *) a. ReaderT r m a -> r -> m a
R.runReaderT ReaderT (Env m) m a
r Env m
reader' )
restoreM :: forall a. StM (SafeT m) a -> SafeT m a
restoreM = forall (m :: * -> *) r. ReaderT (Env m) m r -> SafeT m r
SafeT forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall r (m :: * -> *) a. (r -> m a) -> ReaderT r m a
R.ReaderT forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. a -> b -> a
const forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (b :: * -> *) (m :: * -> *) a.
MonadBaseControl b m =>
StM m a -> m a
restoreM
instance Prim.PrimMonad m => Prim.PrimMonad (SafeT m) where
type PrimState (SafeT m) = Prim.PrimState m
primitive :: forall a.
(State# (PrimState (SafeT m))
-> (# State# (PrimState (SafeT m)), a #))
-> SafeT m a
primitive = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a.
PrimMonad m =>
(State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a
Prim.primitive
{-# INLINE primitive #-}
runSafeT :: (MonadMask m, MonadIO m) => SafeT m r -> m r
runSafeT :: forall (m :: * -> *) r.
(MonadMask m, MonadIO m) =>
SafeT m r -> m r
runSafeT (SafeT ReaderT (Env m) m r
m) = forall (m :: * -> *) a c b.
MonadMask m =>
m a -> (a -> m c) -> (a -> m b) -> m b
C.bracket
(forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a. a -> IO (IORef a)
newIORef forall a b. (a -> b) -> a -> b
$! forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$! forall (m :: * -> *). Integer -> Map Integer (m ()) -> Finalizers m
Finalizers Integer
0 forall k a. Map k a
M.empty)
(\IORef (Maybe (Finalizers m))
ioref -> do
Maybe (Finalizers m)
mres <- forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a b. IORef a -> (a -> (a, b)) -> IO b
atomicModifyIORef' IORef (Maybe (Finalizers m))
ioref forall a b. (a -> b) -> a -> b
$ \Maybe (Finalizers m)
val ->
(forall a. Maybe a
Nothing, Maybe (Finalizers m)
val)
case Maybe (Finalizers m)
mres of
Maybe (Finalizers m)
Nothing -> forall a. HasCallStack => String -> a
error String
"runSafeT's resources were freed by another"
Just (Finalizers Integer
_ Map Integer (m ())
fs) -> forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM forall a b. (a, b) -> b
snd (forall k a. Map k a -> [(k, a)]
M.toDescList Map Integer (m ())
fs) )
(forall r (m :: * -> *) a. ReaderT r m a -> r -> m a
R.runReaderT ReaderT (Env m) m r
m forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *). IORef (Maybe (Finalizers m)) -> Env m
Env)
{-# INLINABLE runSafeT #-}
runSafeP :: (MonadMask m, MonadIO m) => Effect (SafeT m) r -> Effect' m r
runSafeP :: forall (m :: * -> *) r.
(MonadMask m, MonadIO m) =>
Effect (SafeT m) r -> Effect' m r
runSafeP Effect (SafeT m) r
e = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) r.
(MonadMask m, MonadIO m) =>
SafeT m r -> m r
runSafeT forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) r. Monad m => Effect m r -> m r
runEffect forall a b. (a -> b) -> a -> b
$ Effect (SafeT m) r
e
{-# INLINABLE runSafeP #-}
newtype ReleaseKey = ReleaseKey { ReleaseKey -> Integer
unlock :: Integer }
class (MonadCatch m, MonadMask m, MonadIO m, MonadIO (Base m)) => MonadSafe m where
type Base (m :: Type -> Type) :: Type -> Type
liftBase :: Base m r -> m r
register :: Base m () -> m ReleaseKey
release :: ReleaseKey -> m ()
instance (MonadIO m, MonadCatch m, MonadMask m) => MonadSafe (SafeT m) where
type Base (SafeT m) = m
liftBase :: forall r. Base (SafeT m) r -> SafeT m r
liftBase = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift
register :: Base (SafeT m) () -> SafeT m ReleaseKey
register Base (SafeT m) ()
io = do
Env IORef (Maybe (Finalizers m))
ioref <- forall (m :: * -> *) r. ReaderT (Env m) m r -> SafeT m r
SafeT forall (m :: * -> *) r. Monad m => ReaderT r m r
R.ask
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Integer
n <- forall a b. IORef a -> (a -> (a, b)) -> IO b
atomicModifyIORef' IORef (Maybe (Finalizers m))
ioref forall a b. (a -> b) -> a -> b
$ \Maybe (Finalizers m)
val ->
case Maybe (Finalizers m)
val of
Maybe (Finalizers m)
Nothing -> forall a. HasCallStack => String -> a
error String
"register: SafeT block is closed"
Just (Finalizers Integer
n Map Integer (m ())
fs) ->
(forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$! forall (m :: * -> *). Integer -> Map Integer (m ()) -> Finalizers m
Finalizers (Integer
n forall a. Num a => a -> a -> a
+ Integer
1) (forall k a. Ord k => k -> a -> Map k a -> Map k a
M.insert Integer
n Base (SafeT m) ()
io Map Integer (m ())
fs), Integer
n)
forall (m :: * -> *) a. Monad m => a -> m a
return (Integer -> ReleaseKey
ReleaseKey Integer
n)
release :: ReleaseKey -> SafeT m ()
release ReleaseKey
key = do
Env IORef (Maybe (Finalizers m))
ioref <- forall (m :: * -> *) r. ReaderT (Env m) m r -> SafeT m r
SafeT forall (m :: * -> *) r. Monad m => ReaderT r m r
R.ask
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a b. IORef a -> (a -> (a, b)) -> IO b
atomicModifyIORef' IORef (Maybe (Finalizers m))
ioref forall a b. (a -> b) -> a -> b
$ \Maybe (Finalizers m)
val ->
case Maybe (Finalizers m)
val of
Maybe (Finalizers m)
Nothing -> forall a. HasCallStack => String -> a
error String
"release: SafeT block is closed"
Just (Finalizers Integer
n Map Integer (m ())
fs) ->
(forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$! forall (m :: * -> *). Integer -> Map Integer (m ()) -> Finalizers m
Finalizers Integer
n (forall k a. Ord k => k -> Map k a -> Map k a
M.delete (ReleaseKey -> Integer
unlock ReleaseKey
key) Map Integer (m ())
fs), ())
instance MonadSafe m => MonadSafe (Proxy a' a b' b m) where
type Base (Proxy a' a b' b m) = Base m
liftBase :: forall r. Base (Proxy a' a b' b m) r -> Proxy a' a b' b m r
liftBase = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) r. MonadSafe m => Base m r -> m r
liftBase
register :: Base (Proxy a' a b' b m) () -> Proxy a' a b' b m ReleaseKey
register = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *). MonadSafe m => Base m () -> m ReleaseKey
register
release :: ReleaseKey -> Proxy a' a b' b m ()
release = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *). MonadSafe m => ReleaseKey -> m ()
release
instance (MonadSafe m) => MonadSafe (I.IdentityT m) where
type Base (I.IdentityT m) = Base m
liftBase :: forall r. Base (IdentityT m) r -> IdentityT m r
liftBase = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) r. MonadSafe m => Base m r -> m r
liftBase
register :: Base (IdentityT m) () -> IdentityT m ReleaseKey
register = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *). MonadSafe m => Base m () -> m ReleaseKey
register
release :: ReleaseKey -> IdentityT m ()
release = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *). MonadSafe m => ReleaseKey -> m ()
release
instance (MonadSafe m) => MonadSafe (E.CatchT m) where
type Base (E.CatchT m) = Base m
liftBase :: forall r. Base (CatchT m) r -> CatchT m r
liftBase = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) r. MonadSafe m => Base m r -> m r
liftBase
register :: Base (CatchT m) () -> CatchT m ReleaseKey
register = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *). MonadSafe m => Base m () -> m ReleaseKey
register
release :: ReleaseKey -> CatchT m ()
release = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *). MonadSafe m => ReleaseKey -> m ()
release
instance (MonadSafe m) => MonadSafe (R.ReaderT i m) where
type Base (R.ReaderT i m) = Base m
liftBase :: forall r. Base (ReaderT i m) r -> ReaderT i m r
liftBase = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) r. MonadSafe m => Base m r -> m r
liftBase
register :: Base (ReaderT i m) () -> ReaderT i m ReleaseKey
register = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *). MonadSafe m => Base m () -> m ReleaseKey
register
release :: ReleaseKey -> ReaderT i m ()
release = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *). MonadSafe m => ReleaseKey -> m ()
release
instance (MonadSafe m) => MonadSafe (S.StateT s m) where
type Base (S.StateT s m) = Base m
liftBase :: forall r. Base (StateT s m) r -> StateT s m r
liftBase = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) r. MonadSafe m => Base m r -> m r
liftBase
register :: Base (StateT s m) () -> StateT s m ReleaseKey
register = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *). MonadSafe m => Base m () -> m ReleaseKey
register
release :: ReleaseKey -> StateT s m ()
release = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *). MonadSafe m => ReleaseKey -> m ()
release
instance (MonadSafe m) => MonadSafe (S'.StateT s m) where
type Base (S'.StateT s m) = Base m
liftBase :: forall r. Base (StateT s m) r -> StateT s m r
liftBase = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) r. MonadSafe m => Base m r -> m r
liftBase
register :: Base (StateT s m) () -> StateT s m ReleaseKey
register = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *). MonadSafe m => Base m () -> m ReleaseKey
register
release :: ReleaseKey -> StateT s m ()
release = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *). MonadSafe m => ReleaseKey -> m ()
release
instance (MonadSafe m, Monoid w) => MonadSafe (W.WriterT w m) where
type Base (W.WriterT w m) = Base m
liftBase :: forall r. Base (WriterT w m) r -> WriterT w m r
liftBase = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) r. MonadSafe m => Base m r -> m r
liftBase
register :: Base (WriterT w m) () -> WriterT w m ReleaseKey
register = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *). MonadSafe m => Base m () -> m ReleaseKey
register
release :: ReleaseKey -> WriterT w m ()
release = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *). MonadSafe m => ReleaseKey -> m ()
release
instance (MonadSafe m, Monoid w) => MonadSafe (W'.WriterT w m) where
type Base (W'.WriterT w m) = Base m
liftBase :: forall r. Base (WriterT w m) r -> WriterT w m r
liftBase = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) r. MonadSafe m => Base m r -> m r
liftBase
register :: Base (WriterT w m) () -> WriterT w m ReleaseKey
register = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *). MonadSafe m => Base m () -> m ReleaseKey
register
release :: ReleaseKey -> WriterT w m ()
release = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *). MonadSafe m => ReleaseKey -> m ()
release
instance (MonadSafe m, Monoid w) => MonadSafe (RWS.RWST i w s m) where
type Base (RWS.RWST i w s m) = Base m
liftBase :: forall r. Base (RWST i w s m) r -> RWST i w s m r
liftBase = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) r. MonadSafe m => Base m r -> m r
liftBase
register :: Base (RWST i w s m) () -> RWST i w s m ReleaseKey
register = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *). MonadSafe m => Base m () -> m ReleaseKey
register
release :: ReleaseKey -> RWST i w s m ()
release = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *). MonadSafe m => ReleaseKey -> m ()
release
instance (MonadSafe m, Monoid w) => MonadSafe (RWS'.RWST i w s m) where
type Base (RWS'.RWST i w s m) = Base m
liftBase :: forall r. Base (RWST i w s m) r -> RWST i w s m r
liftBase = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) r. MonadSafe m => Base m r -> m r
liftBase
register :: Base (RWST i w s m) () -> RWST i w s m ReleaseKey
register = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *). MonadSafe m => Base m () -> m ReleaseKey
register
release :: ReleaseKey -> RWST i w s m ()
release = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *). MonadSafe m => ReleaseKey -> m ()
release
onException :: (MonadSafe m) => m a -> Base m b -> m a
m a
m1 onException :: forall (m :: * -> *) a b. MonadSafe m => m a -> Base m b -> m a
`onException` Base m b
io = do
ReleaseKey
key <- forall (m :: * -> *). MonadSafe m => Base m () -> m ReleaseKey
register (Base m b
io forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return ())
a
r <- m a
m1
forall (m :: * -> *). MonadSafe m => ReleaseKey -> m ()
release ReleaseKey
key
forall (m :: * -> *) a. Monad m => a -> m a
return a
r
{-# INLINABLE onException #-}
finally :: (MonadSafe m) => m a -> Base m b -> m a
m a
m1 finally :: forall (m :: * -> *) a b. MonadSafe m => m a -> Base m b -> m a
`finally` Base m b
after = forall (m :: * -> *) a b c.
MonadSafe m =>
Base m a -> Base m b -> m c -> m c
bracket_ (forall (m :: * -> *) a. Monad m => a -> m a
return ()) Base m b
after m a
m1
{-# INLINABLE finally #-}
bracket :: (MonadSafe m) => Base m a -> (a -> Base m b) -> (a -> m c) -> m c
bracket :: forall (m :: * -> *) a b c.
MonadSafe m =>
Base m a -> (a -> Base m b) -> (a -> m c) -> m c
bracket Base m a
before a -> Base m b
after a -> m c
action = forall (m :: * -> *) b.
MonadMask m =>
((forall a. m a -> m a) -> m b) -> m b
mask forall a b. (a -> b) -> a -> b
$ \forall a. m a -> m a
restore -> do
a
h <- forall (m :: * -> *) r. MonadSafe m => Base m r -> m r
liftBase Base m a
before
c
r <- forall a. m a -> m a
restore (a -> m c
action a
h) forall (m :: * -> *) a b. MonadSafe m => m a -> Base m b -> m a
`onException` a -> Base m b
after a
h
b
_ <- forall (m :: * -> *) r. MonadSafe m => Base m r -> m r
liftBase (a -> Base m b
after a
h)
forall (m :: * -> *) a. Monad m => a -> m a
return c
r
{-# INLINABLE bracket #-}
bracket_ :: (MonadSafe m) => Base m a -> Base m b -> m c -> m c
bracket_ :: forall (m :: * -> *) a b c.
MonadSafe m =>
Base m a -> Base m b -> m c -> m c
bracket_ Base m a
before Base m b
after m c
action = forall (m :: * -> *) a b c.
MonadSafe m =>
Base m a -> (a -> Base m b) -> (a -> m c) -> m c
bracket Base m a
before (\a
_ -> Base m b
after) (\a
_ -> m c
action)
{-# INLINABLE bracket_ #-}
bracketOnError
:: (MonadSafe m) => Base m a -> (a -> Base m b) -> (a -> m c) -> m c
bracketOnError :: forall (m :: * -> *) a b c.
MonadSafe m =>
Base m a -> (a -> Base m b) -> (a -> m c) -> m c
bracketOnError Base m a
before a -> Base m b
after a -> m c
action = forall (m :: * -> *) b.
MonadMask m =>
((forall a. m a -> m a) -> m b) -> m b
mask forall a b. (a -> b) -> a -> b
$ \forall a. m a -> m a
restore -> do
a
h <- forall (m :: * -> *) r. MonadSafe m => Base m r -> m r
liftBase Base m a
before
forall a. m a -> m a
restore (a -> m c
action a
h) forall (m :: * -> *) a b. MonadSafe m => m a -> Base m b -> m a
`onException` a -> Base m b
after a
h
{-# INLINABLE bracketOnError #-}
tryP :: (MonadSafe m, Exception e)
=> Proxy a' a b' b m r -> Proxy a' a b' b m (Either e r)
tryP :: forall (m :: * -> *) e a' a b' b r.
(MonadSafe m, Exception e) =>
Proxy a' a b' b m r -> Proxy a' a b' b m (Either e r)
tryP Proxy a' a b' b m r
p = case Proxy a' a b' b m r
p of
Request a'
a' a -> Proxy a' a b' b m r
fa -> forall a' a b' b (m :: * -> *) r.
a' -> (a -> Proxy a' a b' b m r) -> Proxy a' a b' b m r
Request a'
a' (\a
a -> forall (m :: * -> *) e a' a b' b r.
(MonadSafe m, Exception e) =>
Proxy a' a b' b m r -> Proxy a' a b' b m (Either e r)
tryP (a -> Proxy a' a b' b m r
fa a
a))
Respond b
b b' -> Proxy a' a b' b m r
fb' -> forall a' a b' b (m :: * -> *) r.
b -> (b' -> Proxy a' a b' b m r) -> Proxy a' a b' b m r
Respond b
b (\b'
b' -> forall (m :: * -> *) e a' a b' b r.
(MonadSafe m, Exception e) =>
Proxy a' a b' b m r -> Proxy a' a b' b m (Either e r)
tryP (b' -> Proxy a' a b' b m r
fb' b'
b'))
M m (Proxy a' a b' b m r)
m -> forall a' a b' b (m :: * -> *) r.
m (Proxy a' a b' b m r) -> Proxy a' a b' b m r
M forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) e a.
(MonadCatch m, Exception e) =>
m a -> m (Either e a)
C.try m (Proxy a' a b' b m r)
m forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Either e (Proxy a' a b' b m r)
eres -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ case Either e (Proxy a' a b' b m r)
eres of
Left e
e -> forall a' a b' b (m :: * -> *) r. r -> Proxy a' a b' b m r
Pure (forall a b. a -> Either a b
Left e
e)
Right Proxy a' a b' b m r
a -> forall (m :: * -> *) e a' a b' b r.
(MonadSafe m, Exception e) =>
Proxy a' a b' b m r -> Proxy a' a b' b m (Either e r)
tryP Proxy a' a b' b m r
a
Pure r
r -> forall a' a b' b (m :: * -> *) r. r -> Proxy a' a b' b m r
Pure (forall a b. b -> Either a b
Right r
r)
catchP :: (MonadSafe m, Exception e)
=> Proxy a' a b' b m r -> (e -> Proxy a' a b' b m r)
-> Proxy a' a b' b m r
catchP :: forall (m :: * -> *) e a' a b' b r.
(MonadSafe m, Exception e) =>
Proxy a' a b' b m r
-> (e -> Proxy a' a b' b m r) -> Proxy a' a b' b m r
catchP Proxy a' a b' b m r
p0 e -> Proxy a' a b' b m r
f = Proxy a' a b' b m r -> Proxy a' a b' b m r
go Proxy a' a b' b m r
p0
where
go :: Proxy a' a b' b m r -> Proxy a' a b' b m r
go Proxy a' a b' b m r
p = case Proxy a' a b' b m r
p of
Request a'
a' a -> Proxy a' a b' b m r
fa -> forall a' a b' b (m :: * -> *) r.
a' -> (a -> Proxy a' a b' b m r) -> Proxy a' a b' b m r
Request a'
a' (\a
a -> Proxy a' a b' b m r -> Proxy a' a b' b m r
go (a -> Proxy a' a b' b m r
fa a
a))
Respond b
b b' -> Proxy a' a b' b m r
fb' -> forall a' a b' b (m :: * -> *) r.
b -> (b' -> Proxy a' a b' b m r) -> Proxy a' a b' b m r
Respond b
b (\b'
b' -> Proxy a' a b' b m r -> Proxy a' a b' b m r
go (b' -> Proxy a' a b' b m r
fb' b'
b'))
M m (Proxy a' a b' b m r)
m -> forall a' a b' b (m :: * -> *) r.
m (Proxy a' a b' b m r) -> Proxy a' a b' b m r
M forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) e a.
(MonadCatch m, Exception e) =>
m a -> (e -> m a) -> m a
C.catch (forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM Proxy a' a b' b m r -> Proxy a' a b' b m r
go m (Proxy a' a b' b m r)
m) (forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. e -> Proxy a' a b' b m r
f)
Pure r
r -> forall a' a b' b (m :: * -> *) r. r -> Proxy a' a b' b m r
Pure r
r