A checked IO action that can only throw synchronous exceptions of the given type.

Morally equivalent to UIO (Either e a), but implemented without the Either for performance.

Run an IOE action in the given monad.

e.g. to convert an IOE action to an ExceptT stack on top of UIO:

newtype ExceptT e m a = ExceptT { unExceptT :: m (Either e a) }
  deriving (Functor, Applicative, Monad)

instance MonadRunUIO m => MonadRunIOE e (ExceptT e m) where
  runIOE = ExceptT . try

Provide a function for running an action in the given monad in IOE.

Instances must satisfy the following laws:

Identity

withRunAsIOE (\run -> run m) === m

Inverse

withRunAsIOE (\_ -> m) === runIOE m

A helper containing any synchronous exception.

MonadRunIOE specialized to IO

MonadRunAsIOE specialized to IO

runIOE specialized to IO

withRunAsIOE specialized to IO

A checked IO action that cannot throw any (synchronous) exceptions.

Convert UIO (Either e a) to IOE e a (or any other monad with a MonadRunIOE instance).

fromUIO m = runUIO m >>= either throw pure

Convert UIO (Either e1 a) to IOE e2 a (or any other monad with a MonadRunIOE instance) with the given transformation function.

Same as mapExceptionM f . fromUIO, but more performant.

Convert UIO (Either e a) action to IO a (or any other monad with a MonadRunIO instance).

Same as liftE . fromUIO, but more performant.

Throw the given exception.

Throw the given exception as an asynchronous exception to the given thread.

Throw an imprecise exception in a pure context.

Warning: Because the exception isn't tracked at the type level, this should be reserved for unrecoverable errors that aren't expected to be handled. Also, if this value is not evaluated before uncheckIOE is called, it'll remain wrapped in AnyException.

Handle the exception tracked in IOE if one is thrown.

Handle all exceptions in the given IOE action, including non-synchronous exceptions.

Warning: You probably want catch instead; if you catch an async exception, you must be careful to rethrow it after.

More information:

• https://www.fpcomplete.com/blog/2018/04/async-exception-handling-haskell/
• https://www.tweag.io/blog/2020-04-16-exceptions-in-haskell/

Get an Either containing either the result or the exception thrown.

Lift an exception to SomeSyncException, useful for converting to IO.

liftE = mapExceptionM SomeSyncException

Example

foo :: String -> IOE MyException Int

bar :: IO Int
bar = liftE $ foo "hello world"

Allocate and clean up a resource safely.

Runs the clean up in an uninterruptible mask. For more information:

• https://hackage.haskell.org/package/unliftio-0.2.23.0/docs/UnliftIO-Exception.html#v:bracket
• https://hackage.haskell.org/package/base-4.17.0.0/docs/Control-Exception-Base.html#v:bracket

Same as bracket, except without passing the result of the acquire action to the release or run actions.

Same as bracket, but only perform the cleanup if an exception is thrown.

Same as bracket_, but only perform the cleanup if an exception is thrown.

A specialized variant of bracket that just runs a computation afterward.

Like finally, except only runs the cleanup if an exception occurs.

Like onException, except passing the exception to the cleanup function.

Unlike catchAny, you don't need to worry about rethrowing async exceptions because withException always rethrows the exception after running the cleanup.

Execute an IO action with asynchronous exceptions masked.

https://hackage.haskell.org/package/base-4.17.0.0/docs/GHC-IO.html#v:mask

Like mask, but the masked computation is not interruptible.

Warning: Use with great care, as a thread running with uninterruptibleMask will be unresponsive and unkillable if it blocks at all.

https://hackage.haskell.org/package/base-4.17.0.0/docs/GHC-IO.html#v:uninterruptibleMask

Like mask, but does not pass a restore action to the argument.

Like uninterruptibleMask, but does not pass a restore action to the argument.

try generalized to any MonadCatchIO + MonadRunIOE

bracket generalized to any MonadCatchIO

bracket_ generalized to any MonadCatchIO

bracketOnError generalized to any MonadCatchIO

bracketOnError_ generalized to any MonadCatchIO

finally generalized to any MonadCatchIO

onException generalized to any MonadCatchIO

withException generalized to any MonadCatchIO

mask generalized to any MonadCatchIO

uninterruptibleMask generalized to any MonadCatchIO

mask_ generalized to any MonadCatchIO

uninterruptibleMask_ generalized to any MonadCatchIO

A convenient alias for main functions

An alias for the normal unsafe IO type.

Convert an unchecked IO action into a checked IO action.

Same as checkIO except converting a synchronous exception with the given function.

Equivalent to mapExceptionM f . checkIO, except more performant.

Same as checkIOWith except returning the exception as an Either instead of throwing it.

Convert an unchecked IO action into a checked IO action that can throw the given exception type.

Warning: If the IO action threw a different synchronous exception, this function will error. Prefer using checkIOWith and calling error yourself with a better error message.

Same as unsafeCheckIO, except expects no exceptions to be thrown.

Unchecks an IOE action back into the normal IO monad.

Warning: Imprecise exceptions might be wrapped in AnyException after converting to UnsafeIO. See throwImprecise for more details.

uncheckIOE specialized to UIO.

All exceptions floating around IOE (synchronous or otherwise) will be an AnyException SomeException.