Bluefin.Internal

Documentation

data Effects

Constructors

Union Effects Effects

type (:&) = Union infixr 9

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

Union of effects

newtype Eff (es :: Effects) a

Constructors

UnsafeMkEff

Fields

• unsafeUnEff :: IO a

Instances

Applicative (Eff es)

Defined in Bluefin.Internal

Methods

pure :: a -> Eff es a

(<*>) :: Eff es (a -> b) -> Eff es a -> Eff es b

liftA2 :: (a -> b -> c) -> Eff es a -> Eff es b -> Eff es c

(*>) :: Eff es a -> Eff es b -> Eff es b

(<*) :: Eff es a -> Eff es b -> Eff es a

Functor (Eff es)

Defined in Bluefin.Internal

Methods

fmap :: (a -> b) -> Eff es a -> Eff es b

(<$) :: a -> Eff es b -> Eff es a

Monad (Eff es)

Defined in Bluefin.Internal

Methods

(>>=) :: Eff es a -> (a -> Eff es b) -> Eff es b

(>>) :: Eff es a -> Eff es b -> Eff es b

return :: a -> Eff es a

newtype EffReader r es a

Because doing IO operations inside Eff requires a value-level argument we can't give IO-related instances to Eff directly. Instead we wrap it in EffReader.

Constructors

MkEffReader

Fields

• unEffReader :: r -> Eff es a

Instances

e :> es => MonadBaseControl IO (EffReader (IOE e) es)

Defined in Bluefin.Internal

Associated Types

type StM (EffReader (IOE e) es) a

Methods

liftBaseWith :: (RunInBase (EffReader (IOE e) es) IO -> IO a) -> EffReader (IOE e) es a

restoreM :: StM (EffReader (IOE e) es) a -> EffReader (IOE e) es a

e :> es => MonadBase IO (EffReader (IOE e) es)

Defined in Bluefin.Internal

Methods

liftBase :: IO α -> EffReader (IOE e) es α

e :> es => MonadFail (EffReader (Exception String e) es)

Defined in Bluefin.Internal

Methods

fail :: String -> EffReader (Exception String e) es a

e :> es => MonadIO (EffReader (IOE e) es)

Defined in Bluefin.Internal

Methods

liftIO :: IO a -> EffReader (IOE e) es a

Applicative (EffReader r es)

Defined in Bluefin.Internal

Methods

pure :: a -> EffReader r es a

(<*>) :: EffReader r es (a -> b) -> EffReader r es a -> EffReader r es b

liftA2 :: (a -> b -> c) -> EffReader r es a -> EffReader r es b -> EffReader r es c

(*>) :: EffReader r es a -> EffReader r es b -> EffReader r es b

(<*) :: EffReader r es a -> EffReader r es b -> EffReader r es a

Functor (EffReader r es)

Defined in Bluefin.Internal

Methods

fmap :: (a -> b) -> EffReader r es a -> EffReader r es b

(<$) :: a -> EffReader r es b -> EffReader r es a

Monad (EffReader r es)

Defined in Bluefin.Internal

Methods

(>>=) :: EffReader r es a -> (a -> EffReader r es b) -> EffReader r es b

(>>) :: EffReader r es a -> EffReader r es b -> EffReader r es b

return :: a -> EffReader r es a

e :> es => MonadUnliftIO (EffReader (IOE e) es)

Defined in Bluefin.Internal

Methods

withRunInIO :: ((forall a. EffReader (IOE e) es a -> IO a) -> IO b) -> EffReader (IOE e) es b

type StM (EffReader (IOE e) es) a

Defined in Bluefin.Internal

type StM (EffReader (IOE e) es) a = a

effReader :: (r -> Eff es a) -> EffReader r es a

runEffReader :: r -> EffReader r es a -> Eff es a

withEffToIO

Arguments

:: e2 :> es

=> ((forall r. (forall e1. IOE e1 -> Eff (e1 :& es) r) -> IO r) -> IO a)

Continuation with the unlifting function in scope.

-> IOE e2

-> Eff es a

withEffToIO'

Arguments

:: e2 :> es

=> IOE e2

Continuation with the unlifting function in scope.

-> ((forall r. (forall e1. IOE e1 -> Eff (e1 :& es) r) -> IO r) -> IO a)

-> Eff es a

race :: e2 :> es => (forall e. IOE e -> Eff (e :& es) a) -> (forall e. IOE e -> Eff (e :& es) a) -> IOE e2 -> Eff es a

connectCoroutines

Arguments

:: forall es a b r. (forall e. Coroutine a b e -> Eff (e :& es) r)

-> (forall e. a -> Coroutine b a e -> Eff (e :& es) r)

-> Eff es r

͘

Connect two coroutines. Their execution is interleaved by exchanging as and bs. When the first yields its first a it starts the second (which is awaiting an a).

receiveStream :: (forall e. Consume a e -> Eff (e :& es) r) -> (forall e. Stream a e -> Eff (e :& es) r) -> Eff es r

Old name for consumeStream. receiveStream will be deprecated in a future version.

consumeStream

Arguments

:: (forall e. Consume a e -> Eff (e :& es) r)

Each await from the Consume ...

-> (forall e. Stream a e -> Eff (e :& es) r)

... receives the value yielded from the Stream

-> Eff es r

zipCoroutines

Arguments

:: e1 :> es

=> Coroutine (a1, a2) b e1

-> (forall e. Coroutine a1 b e -> Eff (e :& es) r)

-> (forall e. Coroutine a2 b e -> Eff (e :& es) r)

-> Eff es r

͘

hoistReader :: (forall b. m b -> n b) -> ReaderT r m a -> ReaderT r n a

withMonadIO

Arguments

:: e :> es

=> IOE e

-> (forall m. MonadIO m => m r)

MonadIO operation

-> Eff es r

MonadIO operation run in Eff

Run MonadIO operations in Eff.

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

withMonadFail

Arguments

:: e :> es

=> Exception String e

Exception to throw on fail

-> (forall m. MonadFail m => m r)

MonadFail operation

-> Eff es r

MonadFail operation run in Eff

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"

unsafeRemoveEff :: Eff (e :& es) a -> Eff es a

runPureEff :: (forall es. Eff es a) -> a

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

weakenEff :: (t `In` t') -> Eff t r -> Eff t' r

insertFirst :: Eff b r -> Eff (c1 :& b) r

insertSecond :: Eff (c1 :& b) r -> Eff (c1 :& (c2 :& b)) r

insertManySecond :: b :> c => Eff (c1 :& b) r -> Eff (c1 :& c) r

assoc1Eff :: Eff ((a :& b) :& c) r -> Eff (a :& (b :& c)) r

pushFirst :: Eff a r -> Eff (a :& b) r

mergeEff :: Eff (a :& a) r -> Eff a r

inContext :: e2 :> e1 => Eff (e1 :& e2) r -> Eff e1 r

useImpl :: e :> es => Eff e r -> Eff es r

Used to define dynamic effects.

useImplIn

Arguments

:: e :> es

=> (t -> Eff (es :& e) r)

-> t

-> Eff es r

͘

Used to define handlers of compound effects.

useImplWithin

Arguments

:: e :> es

=> (t -> Eff (e1 :& e) r)

-> t

-> Eff (e1 :& es) r

͘

Like useImplIn

data StateSource (e :: Effects)

Handle to a capability to create strict mutable state handles

Constructors

StateSource

newtype Exception exn (e :: Effects)

Handle to an exception of type exn

Constructors

UnsafeMkException (forall a. exn -> IO a)

Instances

Handle (Exception s)

Defined in Bluefin.Internal

Methods

mapHandle :: forall (e :: Effects) (es :: Effects). e :> es => Exception s e -> Exception s es

e :> es => MonadFail (EffReader (Exception String e) es)

Defined in Bluefin.Internal

Methods

fail :: String -> EffReader (Exception String e) es a

newtype State s (e :: Effects)

A handle to a strict mutable state of type s

Constructors

UnsafeMkState (IORef s)

Instances

Handle (State s)

Defined in Bluefin.Internal

Methods

mapHandle :: forall (e :: Effects) (es :: Effects). e :> es => State s e -> State s es

newtype Coroutine a b (e :: Effects)

A handle to a coroutine that yields values of type a and then expects values of type b.

Constructors

MkCoroutine (a -> Eff e b)

Instances

Handle (Coroutine a b)

Defined in Bluefin.Internal

Methods

mapHandle :: forall (e :: Effects) (es :: Effects). e :> es => Coroutine a b e -> Coroutine a b es

type Stream a = Coroutine a ()

A handle to a stream that yields values of type a. It is implemented as a handle to a coroutine that yields values of type a and then expects values of type ().

type Consume a = Coroutine () a

class Handle (h :: Effects -> Type) where

You can define a Handle instance for your compound handles. As an example, an "application" handle with a dynamic effect for database queries, a concrete effect for application state and a concrete effect for a logging effect might look like this:

data Application e = MkApplication
  { queryDatabase :: String -> Int -> Eff e [String],
    applicationState :: State (Int, Bool) e,
    logger :: Stream String e
  }

To define mapHandle for Application you should apply mapHandle to all the fields that are themeselevs handles and apply useImpl to all the fields that are dynamic effects:

instance Handle Application where
  mapHandle
    MkApplication
      { queryDatabase = q,
        applicationState = a,
        logger = l
      } =
      MkApplication
        { queryDatabase = (fmap . fmap) useImpl q,
          applicationState = mapHandle a,
          logger = mapHandle l
        }

Note that preceding useImpl on the dynamic effect there is one fmap per -> that appears in type of the dynamic effect. That is, queryDatabase has type String -> Int -> Eff e [String], which has two ->, so there are two fmaps before useImpl.

Methods

mapHandle :: e :> es => h e -> h es

Used to create compound effects, i.e. handles that contain other handles.

Instances

Handle IOE

Defined in Bluefin.Internal

Methods

mapHandle :: forall (e :: Effects) (es :: Effects). e :> es => IOE e -> IOE es

Handle Application

Defined in Bluefin.Internal.Examples

Methods

mapHandle :: forall (e :: Effects) (es :: Effects). e :> es => Application e -> Application es

Handle Handle

Defined in Bluefin.Internal.System.IO

Methods

mapHandle :: forall (e :: Effects) (es :: Effects). e :> es => Handle e -> Handle es

Handle (Exception s)

Defined in Bluefin.Internal

Methods

mapHandle :: forall (e :: Effects) (es :: Effects). e :> es => Exception s e -> Exception s es

Handle (Reader r)

Defined in Bluefin.Internal

Methods

mapHandle :: forall (e :: Effects) (es :: Effects). e :> es => Reader r e -> Reader r es

Handle (State s)

Defined in Bluefin.Internal

Methods

mapHandle :: forall (e :: Effects) (es :: Effects). e :> es => State s e -> State s es

Handle (Writer w)

Defined in Bluefin.Internal

Methods

mapHandle :: forall (e :: Effects) (es :: Effects). e :> es => Writer w e -> Writer w es

Handle (Coroutine a b)

Defined in Bluefin.Internal

Methods

mapHandle :: forall (e :: Effects) (es :: Effects). e :> es => Coroutine a b e -> Coroutine a b es

newtype In (a :: Effects) (b :: Effects)

Constructors

In# (# #)

merge :: (# #) -> (a :& a) `In` a

eq :: (# #) -> a `In` a

fstI :: (# #) -> a `In` (a :& b)

sndI :: (# #) -> a `In` (b :& a)

cmp :: (a `In` b) -> (b `In` c) -> a `In` c

bimap :: (a `In` b) -> (c `In` d) -> (a :& c) `In` (b :& d)

assoc1 :: (# #) -> ((a :& b) :& c) `In` (a :& (b :& c))

drop :: (a `In` b) -> a `In` (c :& b)

here :: (a `In` b) -> a `In` (b :& c)

w :: ((a :& b) `In` c) -> a `In` c

w2 :: ((b :& a) `In` c) -> a `In` c

b2 :: (a `In` b) -> (a :& c) `In` (b :& c)

b :: (a `In` b) -> (c :& a) `In` (c :& b)

subsume1 :: (e2 `In` e1) -> (e1 :& e2) `In` e1

class (es1 :: Effects) :> (es2 :: Effects)

Effect subset constraint

Instances

e :> e

A set of effects e is a subset of itself

Defined in Bluefin.Internal

e :> (e :& es)

e is a subset of a larger set e :& es

Defined in Bluefin.Internal

e :> es => e :> (x :& es)

If e is subset of es then e is a subset of a larger set, x :& es

Defined in Bluefin.Internal

throw

Arguments

:: e :> es

=> Exception ex e

-> ex

Value to throw

-> Eff es a

>>> runPureEff $ try $ \e -> do
      throw e 42
      pure "No exception thrown"
Left 42

>>> runPureEff $ try $ \e -> do
      pure "No exception thrown"
Right "No exception thrown"

has :: forall a b. a :> b => a `In` b

data Dict c where

Constructors

Dict :: forall c. c => Dict c

have :: forall a b. (a `In` b) -> Dict (a :> b)

try

Arguments

:: forall exn (es :: Effects) a. (forall e. Exception exn e -> Eff (e :& es) a)

-> Eff es (Either exn a)

Left if the exception was thrown, Right otherwise

>>> runPureEff $ try $ \e -> do
      throw e 42
      pure "No exception thrown"
Left 42

handle

Arguments

:: forall exn (es :: Effects) a. (exn -> Eff es a)

If the exception is thrown, apply this handler

-> (forall e. Exception exn e -> Eff (e :& es) a)

-> Eff es a

handle, but with the argument order swapped

>>> runPureEff $ handle (pure . show) $ \e -> do
      throw e 42
      pure "No exception thrown"
"42"

catch

Arguments

:: forall exn (es :: Effects) a. (forall e. Exception exn e -> Eff (e :& es) a)

-> (exn -> Eff es a)

If the exception is thrown, apply this handler

-> Eff es a

rethrowIO

Arguments

:: forall ex es e1 e2 r. (e1 :> es, e2 :> es, Exception ex)

=> IOE e1

-> Exception ex e2

-> Eff es r

-> Eff es r

͘

Rethrow an exception raised by an IO action as a Bluefin exception.

runEff $ \io -> do
  r <- try $ \ex -> do
    rethrowIO @IOException io ex $ do
      effIO io (readFile "/tmp/doesnt-exist")

  effIO io $ putStrLn $ case r of
    Left e -> "Caught IOException:\n" ++ show e
    Right contents -> contents

Caught ErrorCall:
/tmp/doesnt-exist: openFile: does not exist (No such file or directory)

bracket

Arguments

:: Eff es a

Acquire the resource

-> (a -> Eff es ())

Release the resource

-> (a -> Eff es b)

Run the body

-> Eff es b

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.

get

Arguments

:: e :> es

=> State s e

-> Eff es s

The current value of the state

>>> runPureEff $ runState 10 $ \st -> do
      n <- get st
      pure (2 * n)
(20,10)

put

Arguments

:: e :> es

=> State s e

-> s

The new value of the state. The new value is forced before writing it to the state.

-> Eff es ()

Set the value of the state

>>> runPureEff $ runState 10 $ \st -> do
      put st 30
((), 30)

modify

Arguments

:: e :> es

=> State s e

-> (s -> s)

Apply this function to the state. The new value of the state is forced before writing it to the state.

-> Eff es ()

>>> runPureEff $ runState 10 $ \st -> do
      modify st (* 2)
((), 20)

data MyException where

Constructors

MyException :: e -> Unique -> MyException

Instances

Exception MyException

Defined in Bluefin.Internal

Methods

toException :: MyException -> SomeException

fromException :: SomeException -> Maybe MyException

displayException :: MyException -> String

Show MyException

Defined in Bluefin.Internal

Methods

showsPrec :: Int -> MyException -> ShowS

show :: MyException -> String

showList :: [MyException] -> ShowS

withScopedException_ :: ((forall a. e -> IO a) -> IO r) -> IO (Either e r)

withStateSource

Arguments

:: (forall e. StateSource e -> Eff (e :& es) a)

-> Eff es a

͘

runPureEff $ withStateSource $ \source -> do
  n <- newState source 5
  total <- newState source 0

  withJump $ \done -> forever $ do
    n' <- get n
    modify total (+ n')
    when (n' == 0) $ jumpTo done
    modify n (subtract 1)

  get total
15

newState

Arguments

:: StateSource e

-> s

The initial value for the state handle

-> Eff es (State s e)

A new state handle

runPureEff $ withStateSource $ \source -> do
  n <- newState source 5
  total <- newState source 0

  withJump $ \done -> forever $ do
    n' <- get n
    modify total (+ n')
    when (n' == 0) $ jumpTo done
    modify n (subtract 1)

  get total
15

runState

Arguments

:: s

Initial state

-> (forall e. State s e -> Eff (e :& es) a)

Stateful computation

-> Eff es (a, s)

Result and final state

>>> runPureEff $ runState 10 $ \st -> do
      n <- get st
      pure (2 * n)
(20,10)

yieldCoroutine

Arguments

:: e1 :> es

=> Coroutine a b e1

-> a

͘

-> Eff es b

yield

Arguments

:: e1 :> es

=> Stream a e1

-> a

Yield this value from the stream

-> Eff es ()

>>> runPureEff $ yieldToList $ \y -> do
      yield y 1
      yield y 2
      yield y 100
([1,2,100], ())

handleCoroutine :: (a -> Eff es b) -> (z -> Eff es r) -> (forall e1. Coroutine a b e1 -> Eff (e1 :& es) z) -> Eff es r

forEach

Arguments

:: (forall e1. Coroutine a b e1 -> Eff (e1 :& es) r)

-> (a -> Eff es b)

Apply this effectful function for each element of the coroutine

-> Eff es r

>>> runPureEff $ yieldToList $ \y -> do
      forEach (inFoldable [0 .. 3]) $ \i -> do
        yield y i
        yield y (i * 10)
([0, 0, 1, 10, 2, 20, 3, 30], ())

inFoldable

Arguments

:: (Foldable t, e1 :> es)

=> t a

Yield all these values from the stream

-> Stream a e1

-> Eff es ()

>>> runPureEff $ yieldToList $ inFoldable [1, 2, 100]
([1, 2, 100], ())

enumerate

Arguments

:: e2 :> es

=> (forall e1. Stream a e1 -> Eff (e1 :& es) r)

͘

-> Stream (Int, a) e2

-> Eff es r

Pair each element in the stream with an increasing index, starting from 0.

>>> runPureEff $ yieldToList $ enumerate (inFoldable ["A", "B", "C"])
([(0, "A"), (1, "B"), (2, "C")], ())

enumerateFrom

Arguments

:: e2 :> es

=> Int

Initial value

-> (forall e1. Stream a e1 -> Eff (e1 :& es) r)

-> Stream (Int, a) e2

-> Eff es r

Pair each element in the stream with an increasing index, starting from an inital value.

>>> runPureEff $ yieldToList $ enumerateFrom1 (inFoldable ["A", "B", "C"])
([(1, "A"), (2, "B"), (3, "C")], ())

consumeEach

Arguments

:: (forall e. Consume b e -> Eff (e :& es) r)

Body

-> Eff es b

Value to send to each await in the body.

-> Eff es r

A version of forEach specialized to Consume. Every time the Consume is used to await a b, feed it the one created by the handler.

await :: e :> es => Consume a e -> Eff es a

type EarlyReturn = Exception

withEarlyReturn

Arguments

:: (forall e. EarlyReturn r e -> Eff (e :& es) r)

-> Eff es r

͘

Run an Eff action with the ability to return early to this point. In the language of exceptions, withEarlyReturn installs an exception handler for an exception of type r.

>>> runPureEff $ withEarlyReturn $ \e -> do
      for_ [1 .. 10] $ \i -> do
        when (i >= 5) $
          returnEarly e ("Returned early with " ++ show i)
      pure "End of loop"
"Returned early with 5"

returnEarly

Arguments

:: e :> es

=> EarlyReturn r e

-> r

Return early to the handler, with this value.

-> Eff es a

>>> runPureEff $ withEarlyReturn $ \e -> do
      for_ [1 .. 10] $ \i -> do
        when (i >= 5) $
          returnEarly e ("Returned early with " ++ show i)
      pure "End of loop"
"Returned early with 5"

evalState

Arguments

:: s

Initial state

-> (forall e. State s e -> Eff (e :& es) a)

Stateful computation

-> Eff es a

Result

>>> runPureEff $ evalState 10 $ \st -> do
      n <- get st
      pure (2 * n)
20

withState

Arguments

:: s

Initial state

-> (forall st. State s st -> Eff (st :& es) (s -> a))

Stateful computation

-> Eff es a

Result

>>> runPureEff $ withState 10 $ \st -> do
      n <- get st
      pure (s -> (2 * n, s))
(20,10)

data Compound e1 e2 ss where

Constructors

Compound :: Proxy# s1 -> Proxy# s2 -> e1 s1 -> e2 s2 -> Compound e1 e2 (s1 :& s2)

compound

Arguments

:: h1 e1

-> h2 e2

͘

-> Compound h1 h2 (e1 :& e2)

inComp :: forall a b c r. a :> b => b :> c => (a :> c => r) -> r

withCompound

Arguments

:: forall h1 h2 e es r. e :> es

=> Compound h1 h2 e

-> (forall e1 e2. (e1 :> es, e2 :> es) => h1 e1 -> h2 e2 -> Eff es r)

͘

-> Eff es r

withC1 :: forall e1 e2 ss es r. ss :> es => Compound e1 e2 ss -> (forall st. st :> es => e1 st -> Eff es r) -> Eff es r

withC2 :: forall e1 e2 ss es r. ss :> es => Compound e1 e2 ss -> (forall st. st :> es => e2 st -> Eff es r) -> Eff es r

putC :: forall ss es e. ss :> es => Compound e (State Int) ss -> Int -> Eff es ()

getC :: forall ss es e. ss :> es => Compound e (State Int) ss -> Eff es Int

runCompound

Arguments

:: e1 s1

-> e2 s2

͘

-> (forall es'. Compound e1 e2 es' -> Eff (es' :& es) r)

-> Eff (s1 :& (s2 :& es)) r

yieldToList

Arguments

:: (forall e1. Stream a e1 -> Eff (e1 :& es) r)

-> Eff es ([a], r)

Yielded elements and final result

>>> runPureEff $ yieldToList $ \y -> do
      yield y 1
      yield y 2
      yield y 100
([1,2,100], ())

withYieldToList

Arguments

:: (forall e. Stream a e -> Eff (e :& es) ([a] -> r))

Stream computation

-> Eff es r

Result

>>> runPureEff $ withYieldToList $ \y -> do
  yield y 1
  yield y 2
  yield y 100
  pure length
3

yieldToReverseList

Arguments

:: (forall e. Stream a e -> Eff (e :& es) r)

-> Eff es ([a], r)

Yielded elements in reverse order, and final result

This is more efficient than yieldToList because it gathers the elements into a stack in reverse order. yieldToList then reverses that stack.

>>> runPureEff $ yieldToReverseList $ \y -> do
      yield y 1
      yield y 2
      yield y 100
([100,2,1], ())

mapStream

Arguments

:: e2 :> es

=> (a -> b)

Apply this function to all elements of the input stream.

-> (forall e1. Stream a e1 -> Eff (e1 :& es) r)

Input stream

-> Stream b e2

-> Eff es r

mapMaybe

Arguments

:: e2 :> es

=> (a -> Maybe b)

Yield from the output stream all of the elemnts of the input stream for which this function returns Just

-> (forall e1. Stream a e1 -> Eff (e1 :& es) r)

Input stream

-> Stream b e2

-> Eff es r

catMaybes

Arguments

:: e2 :> es

=> (forall e1. Stream (Maybe a) e1 -> Eff (e1 :& es) r)

Input stream

-> Stream a e2

-> Eff es r

Remove Nothing elements from a stream.

type Jump = EarlyReturn ()

withJump

Arguments

:: (forall e. Jump e -> Eff (e :& es) ())

-> Eff es ()

͘

runPureEff $ withStateSource $ \source -> do
  n <- newState source 5
  total <- newState source 0

  withJump $ \done -> forever $ do
    n' <- get n
    modify total (+ n')
    when (n' == 0) $ jumpTo done
    modify n (subtract 1)

  get total
15

jumpTo

Arguments

:: e :> es

=> Jump e

-> Eff es a

͘

runPureEff $ withStateSource $ \source -> do
  n <- newState source 5
  total <- newState source 0

  withJump $ \done -> forever $ do
    n' <- get n
    modify total (+ n')
    when (n' == 0) $ jumpTo done
    modify n (subtract 1)

  get total
15

unwrap :: e :> es => Jump e -> Maybe a -> Eff es a

data IOE (e :: Effects)

Handle that allows you to run IO operations

Constructors

MkIOE

Instances

Handle IOE

Defined in Bluefin.Internal

Methods

mapHandle :: forall (e :: Effects) (es :: Effects). e :> es => IOE e -> IOE es

e :> es => MonadBaseControl IO (EffReader (IOE e) es)

Defined in Bluefin.Internal

Associated Types

type StM (EffReader (IOE e) es) a

Methods

liftBaseWith :: (RunInBase (EffReader (IOE e) es) IO -> IO a) -> EffReader (IOE e) es a

restoreM :: StM (EffReader (IOE e) es) a -> EffReader (IOE e) es a

e :> es => MonadBase IO (EffReader (IOE e) es)

Defined in Bluefin.Internal

Methods

liftBase :: IO α -> EffReader (IOE e) es α

e :> es => MonadIO (EffReader (IOE e) es)

Defined in Bluefin.Internal

Methods

liftIO :: IO a -> EffReader (IOE e) es a

e :> es => MonadUnliftIO (EffReader (IOE e) es)

Defined in Bluefin.Internal

Methods

withRunInIO :: ((forall a. EffReader (IOE e) es a -> IO a) -> IO b) -> EffReader (IOE e) es b

type StM (EffReader (IOE e) es) a

Defined in Bluefin.Internal

type StM (EffReader (IOE e) es) a = a

effIO

Arguments

:: e :> es

=> IOE e

-> IO a

-> Eff es a

͘

Run an IO operation in Eff

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

runEff

Arguments

:: (forall e es. IOE e -> Eff (e :& es) a)

-> IO a

͘

Run an Eff whose only unhandled effect is IO.

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

unsafeProvideIO

Arguments

:: (forall e. IOE e -> Eff (e :& es) a)

-> Eff es a

͘

connect :: (forall e1. Coroutine a b e1 -> Eff (e1 :& es) r1) -> (forall e2. a -> Coroutine b a e2 -> Eff (e2 :& es) r2) -> forall e1 e2. (e1 :> es, e2 :> es) => Eff es (Either (r1, a -> Coroutine b a e2 -> Eff es r2) (r2, b -> Coroutine a b e1 -> Eff es r1))

head' :: forall a b r es. (forall e. Coroutine a b e -> Eff (e :& es) r) -> forall e. e :> es => Eff es (Either r (a, b -> Coroutine a b e -> Eff es r))

newtype Writer w e

Constructors

Writer (Stream w e)

Instances

Handle (Writer w)

Defined in Bluefin.Internal

Methods

mapHandle :: forall (e :: Effects) (es :: Effects). e :> es => Writer w e -> Writer w es

runWriter

Arguments

:: Monoid w

=> (forall e. Writer w e -> Eff (e :& es) r)

͘

-> Eff es (r, w)

>>> getAny $ snd $ runPureEff $ runWriter $ \w -> do
      -- Non-empty list (the tell event does happen)
      for_ [1 .. 10] $ \_ -> tell w (Any True)
True

execWriter

Arguments

:: Monoid w

=> (forall e. Writer w e -> Eff (e :& es) r)

͘

-> Eff es w

>>> getAny $ runPureEff $ execWriter $ \w -> do
      -- Non-empty list (the tell event does happen)
      for_ [1 .. 10] $ \_ -> tell w (Any True)
True

>>> getAny $ runPureEff $ execWriter $ \w -> do
      -- Empty list (the tell event does not happen)
      for_ [] $ \_ -> tell w (Any True)
False

tell

Arguments

:: e :> es

=> Writer w e

-> w

͘

-> Eff es ()

>>> getAny $ runPureEff $ execWriter $ \w -> do
      -- Non-empty list (the tell event does happen)
      for_ [1 .. 10] $ \_ -> tell w (Any True)
True

newtype Reader r (e :: Effects)

Constructors

MkReader r

Instances

Handle (Reader r)

Defined in Bluefin.Internal

Methods

mapHandle :: forall (e :: Effects) (es :: Effects). e :> es => Reader r e -> Reader r es

runReader

Arguments

:: r

͘

-> (forall e. Reader r e -> Eff (e :& es) a)

-> Eff es a

ask

Arguments

:: e :> es

=> Reader r e

͘

-> Eff es r