Control.Effects.Async

The Async effect allows you to fork new threads in monads other than just IO.

Documentation

data Async

The name of the effect

Instances

Effect Async

Associated Types

data EffMethods Async (m :: * -> *) :: *

type CanLift Async (t :: (* -> *) -> * -> *) :: Constraint

Methods

liftThrough :: (CanLift Async t, Monad m, Monad (t m)) => EffMethods Async m -> EffMethods Async (t m)

mergeContext :: Monad m => m (EffMethods Async m) -> EffMethods Async m

MonadEffect Async IO

The IO implementation uses the async library.

Methods

effect :: EffMethods Async IO

data EffMethods Async

data EffMethods Async = AsyncMethods {

• _async :: forall a. m a -> m (AsyncThread m a)
• _waitAsync :: forall a. AsyncThread m a -> m a

}

type CanLift Async t

type CanLift Async t = RunnableTrans t

newtype AsyncThread m a

The type that represents the forked computation in the monad m that eventually computes a value of type a. Depending on the monad, the computation may produce zero, one or even multiple values of that type.

Constructors

AsyncThread (Async (m a))

Instances

Functor m => Functor (AsyncThread m)

Methods

fmap :: (a -> b) -> AsyncThread m a -> AsyncThread m b

(<$) :: a -> AsyncThread m b -> AsyncThread m a

Eq (AsyncThread m a)

Methods

(==) :: AsyncThread m a -> AsyncThread m a -> Bool

(/=) :: AsyncThread m a -> AsyncThread m a -> Bool

Ord (AsyncThread m a)

Methods

compare :: AsyncThread m a -> AsyncThread m a -> Ordering

(<) :: AsyncThread m a -> AsyncThread m a -> Bool

(<=) :: AsyncThread m a -> AsyncThread m a -> Bool

(>) :: AsyncThread m a -> AsyncThread m a -> Bool

(>=) :: AsyncThread m a -> AsyncThread m a -> Bool

max :: AsyncThread m a -> AsyncThread m a -> AsyncThread m a

min :: AsyncThread m a -> AsyncThread m a -> AsyncThread m a

async :: MonadEffect Async m => m a -> m (AsyncThread m a)

Fork a new thread to run the given computation. The monadic context is forked into the new thread.

For example, if we use state, the current state value will be visible int he forked computation. Depending on how we ultimately implement the state, modifying it may or may not be visible from the main thread. If we use implementStateViaStateT then setting the state in the forked thread will just modify the thread-local value. On the other hand, if we use implementStateViaIORef then both the main thread and the new thread will use the same reference meaning they can interact through it.

waitAsync :: MonadEffect Async m => AsyncThread m a -> m a

Wait for the thread to finish and return it's result. The monadic context will also be merged.

Example:

 setState @Int 1
 th <- async $ do
     setState @Int 2
 waitAsync th
 print =<< getState @Int -- Outputs 2

implementAsyncViaIO :: IO a -> IO a

This will discard the MonadEffect Async m constraint by forcing m to be IO. The functions doesn't actually do anything, the real implementation is given by the MonadEffect Async IO instance which uses the async package.