Provide the ability to run Eff computations concurrently in multiple threads and communicate between them.

Warning: unless you stick to high level functions from the withAsync family, the Concurrent effect makes it possible to escape the scope of any scoped effect operation. Consider the following:

>>> import qualified Effectful.Reader.Static as R

>>> printAsk msg = liftIO . putStrLn . (msg ++) . (": " ++) =<< R.ask

>>> :{
  runEff . R.runReader "GLOBAL" . runConcurrent $ do
    a <- R.local (const "LOCAL") $ do
      a <- async $ do
        printAsk "child (first)"
        threadDelay 20000
        printAsk "child (second)"
      threadDelay 10000
      printAsk "parent (inside)"
      pure a
    printAsk "parent (outside)"
    wait a
:}
child (first): LOCAL
parent (inside): LOCAL
parent (outside): GLOBAL
child (second): LOCAL

Note that the asynchronous computation doesn't respect the scope of local, i.e. the child thread still behaves like it's inside the local block, even though the parent thread already got out of it.

This is because the value provided by the Reader effect is thread local, i.e. each thread manages its own version of it. For the Reader it is the only reasonable behavior, it wouldn't be very useful if its "read only" value was affected by calls to local from its parent or child threads.

However, the cut isn't so clear if it comes to effects that provide access to a mutable state. That's why statically dispatched State and Writer effects come in two flavors, local and shared:

>>> import qualified Effectful.State.Static.Local as SL
>>> :{
  runEff . SL.execState "Hi" . runConcurrent $ do
    replicateConcurrently_ 3 $ SL.modify (++ "!")
:}
"Hi"

>>> import qualified Effectful.State.Static.Shared as SS
>>> :{
  runEff . SS.execState "Hi" . runConcurrent $ do
    replicateConcurrently_ 3 $ SS.modify (++ "!")
:}
"Hi!!!"

In the first example state updates made concurrently are not reflected in the parent thread because the value is thread local, but in the second example they are, because the value is shared.

Run the Concurrent effect.

An asynchronous action spawned by async or withAsync. Asynchronous actions are executed in a separate thread, and operations are provided for waiting for asynchronous actions to complete and obtaining their results (see e.g. wait).

Lifted withAsync.

Lifted withAsyncBound.

Lifted withAsyncOn.

Lifted withAsyncWithUnmask.

Lifted withAsyncOnWithUnmask.

Lifted wait.

Lifted poll.

Lifted waitCatch.

Returns the ThreadId of the thread running the given Async.

Lifted cancel.

Lifted uninterruptibleCancel.

Lifted cancelWith.

The exception thrown by cancel to terminate a thread.

Compare two Asyncs that may have different types by their ThreadId.

Lifted race.

Lifted race_.

Lifted concurrently.

Lifted concurrently_.

Lifted mapConcurrently.

Lifted forConcurrently.

Lifted mapConcurrently_.

Lifted forConcurrently_.

Lifted replicateConcurrently.

Lifted replicateConcurrently_.

Lifted Concurrently.

Lifted Conc.

Lifted conc.

Lifted runConc.

Things that can go wrong in the structure of a Conc. These are programmer errors.

Since: unliftio-0.2.9.0

Lifted pooledMapConcurrentlyN.

Lifted pooledMapConcurrently.

Lifted pooledMapConcurrentlyN.

Lifted pooledMapConcurrently_.

Lifted pooledForConcurrentlyN.

Lifted pooledForConcurrently.

Lifted pooledForConcurrentlyN.

Lifted pooledForConcurrently_.

Lifted pooledReplicateConcurrentlyN.

Lifted pooledReplicateConcurrently.

Lifted pooledReplicateConcurrentlyN_.

Lifted pooledReplicateConcurrently_.

A version of wait that can be used inside an STM transaction.

A version of poll that can be used inside an STM transaction.

A version of waitCatch that can be used inside an STM transaction.

Lifted waitAny.

Lifted waitAnyCatch.

Lifted waitAnyCancel.

Lifted waitAnyCatchCancel.

Lifted waitEither.

Lifted waitEitherCatch.

Lifted waitEitherCancel.

Lifted waitEitherCatchCancel.

Lifted waitEither_.

Lifted waitBoth.

A version of waitAny that can be used inside an STM transaction.

Since: async-2.1.0

A version of waitAnyCatch that can be used inside an STM transaction.

Since: async-2.1.0

A version of waitEither that can be used inside an STM transaction.

Since: async-2.1.0

A version of waitEitherCatch that can be used inside an STM transaction.

Since: async-2.1.0

A version of waitEither_ that can be used inside an STM transaction.

Since: async-2.1.0

A version of waitBoth that can be used inside an STM transaction.

Since: async-2.1.0

Lifted async.

Lifted asyncBound.

Lifted asyncOn.

Lifted asyncWithUnmask.

Lifted asyncOnWithUnmask.

Lifted link.

Lifted linkOnly.

Lifted link2.

Lifted link2Only.