An IO-like monad with the capability of async/await-style futures.

Synchronous (blocking) computations in this monad can be created using lift and liftIO. Asynchronous computations that can run in the background are created with freeAsync or asyncMVar.

To leverage the asynchronicity, you can schedule computations with MonadSchedule operations such as schedule or race.

Caution: Composing computations with Applicative or Monad operations like <*>, >>= and do-notation will force all but the final computation in order: When running a *> b *> c, b will not be started before a has completed. To start all operations and run them concurrently, use e.g. scheduleWith. To use an Applicative interface for concurrency, have a look at ConcurrentlyT.

Run an IO computation in the background.

This returns a "promise", or "future", which completes the computation when run.

Asynchronously await an MVar.

asyncMVar var will attempt takeMVar in a way that can be scheduled concurrently with other asyncMVars or freeAsyncs.

Like runFreeAsyncT, but specialized to IO.

Complete all computations and remove the FreeAsyncT layer.

Like FreeAsyncT, but leverages concurrency in the Applicative interface.

The central difference to FreeAsyncT is the Applicative instance: concurrently a *> concurrently b *> concurrently c will launch all three actions immediately and return when all actions have completed. On the other hand, concurrently a >>= f has to compute sequentially.

For more readable syntax, it can be useful to switch the ApplicativeDo extension on.

The downside of this Applicative instance is that ConcurrentlyT can't be an instance of MonadTrans. As a drop-in replacement, the function lift' is supplied.

Caution: To lift an IO action concurrently, you need to use concurrently and not liftIO.

Lift an IO action such that it can be run concurrently.

See freeAsync.

Like asyncMVar

Lift a computation to ConcurrentlyT.

This replaces the missing MonadTrans instance.

Caution: Computations lifted with this function cannot be scheduled concurrently! If this is your intention, concurrently needs to be used instead.

Run a ConcurrentlyT computation to completion, removing the newtype layers.

Like runConcurrently, but specialised to IO.