Run an Eff that doesn't contain any unhandled effects.

Run an Eff whose only unhandled effect is IO.

>>> runEff_ $ \io -> do
      effIO io (putStrLn "Hello world!")
Hello, world!

This probably has better type inference properties than runEff and so will probably replace it in a later version.

Run an Eff whose only unhandled effect is IO.

>>> runEff_ $ \io -> do
      effIO io (putStrLn "Hello world!")
Hello, world!

We suggest you use runEff_ instead, as it probably has better type inference properties.

bracket acquire release body: acquire a resource, perform the body with it, and release the resource even if body threw an exception. This is essentially the same as Control.Exception.bracket, whose documentation you can inspect for further details.

bracket has a very general type that does not require es to contain an exception or IO effect. The reason that this is safe is:

• While bracket does catch exceptions, this is unobservable, since the exception is re-thrown; the cleanup action happens unconditionally; and no part of it gets access to the thrown exception.
• Eff itself is able to guarantee that any exceptions thrown in the body will be actually thrown before bracket exits. This is inherited from the fact that Eff is a wrapper around IO.

While it is usually the case that the cleanup action will in fact want to use IO effects, this is not universally true, see the polymorphicBracket example for an example.

A simpler variant of bracket for use when you don't need to acquire a resource.

Run MonadIO operations in Eff.

>>> runEff_ $ \io -> withMonadIO io $ liftIO $ do
      putStrLn "Hello world!"
Hello, world!

Run MonadFail operations in Eff.

>>> runPureEff $ try $ \e ->
      when (2 > 1) $
        withMonadFail e (fail "2 was bigger than 1")
Left "2 was bigger than 1"

Effect subset constraint

type (:&) :: Effects -> Effects -> Effects

Union of effects