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"

Each inhabitant of Effects is a set of effect tags, used for effect tracking to ensure that effects don't escape the scope of their handler

The subset constraint on sets of effect tags

Please use the type synonym <: instead of :>. The former is a better name for this constraint and :> will be renamed <: in a future version.

The subset constraint on sets of effect tags. <: is a type operator (see the extension TypeOperators) so in order to import it you need to use the ExplicitNamespaces extension and the type import qualifier, like this:

{-# LANUGAGE ExplicitNamespaces #-}
import Bluefin.Eff (type (<:))

"<:" is a synonym for ":>". "<:" is a better name for this constraint than ":>" because it is more evocative of mathematical relations like <, <=, ⊂ and ⊆ which hold when the argument on the left of the operator is "smaller than" the argument on the right. In the case of <: we have that e1 <: e2 when the set of effect tags e1 is a subset of or equal to e2, i.e. "e1 is smaller than (or equal to) e2". For example, the following constraints hold (note that :& is the union of sets of effect tags):

• e <: e

• e <: (e1 :& ... :& e :& ... :& en)

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

Union of sets of effect tags