UnliftIO.Internals.Async

Unlifted async.

Unlifted asyncBound.

Unlifted asyncOn.

Unlifted asyncWithUnmask.

Unlifted asyncOnWithUnmask.

Unlifted withAsync.

Unlifted withAsyncBound.

Unlifted withAsyncOn.

Unlifted withAsyncWithUnmask.

Unlifted A.withAsyncOnWithMask.

Lifted wait.

Lifted poll.

Lifted waitCatch.

Lifted cancel.

Lifted uninterruptibleCancel.

Lifted cancelWith. Additionally uses toAsyncException to ensure async exception safety.

Lifted waitAny.

Lifted waitAnyCatch.

Lifted waitAnyCancel.

Lifted waitAnyCatchCancel.

Lifted waitEither.

Lifted waitEitherCatch.

Lifted waitEitherCancel.

Lifted waitEitherCatchCancel.

Lifted waitEither_.

Lifted waitBoth.

Lifted link.

Lifted link2.

Unlifted race.

Unlifted race_.

Unlifted concurrently.

Unlifted concurrently_.

Unlifted Concurrently.

Similar to mapConcurrently but with arguments flipped

Similar to mapConcurrently_ but with arguments flipped

Unlifted replicateConcurrently.

Unlifted replicateConcurrently_.

Executes a Traversable container of items concurrently, it uses the Flat type internally.

Executes a Traversable container of items concurrently, it uses the Flat type internally. This function ignores the results.

A more efficient alternative to Concurrently, which reduces the number of threads that need to be forked. For more information, see this blog post. This is provided as a separate type to Concurrently as it has a slightly different API.

Use the conc function to construct values of type Conc, and runConc to execute the composed actions. You can use the Applicative instance to run different actions and wait for all of them to complete, or the Alternative instance to wait for the first thread to complete.

In the event of a runtime exception thrown by any of the children threads, or an asynchronous exception received in the parent thread, all threads will be killed with an AsyncCancelled exception and the original exception rethrown. If multiple exceptions are generated by different threads, there are no guarantees on which exception will end up getting rethrown.

For many common use cases, you may prefer using helper functions in this module like mapConcurrently.

There are some intentional differences in behavior to Concurrently:

• Children threads are always launched in an unmasked state, not the inherited state of the parent thread.

Note that it is a programmer error to use the Alternative instance in such a way that there are no alternatives to an empty, e.g. runConc (empty | empty). In such a case, a ConcException will be thrown. If there was an Alternative in the standard libraries without empty, this library would use it instead.

Construct a value of type Conc from an action. Compose these values using the typeclass instances (most commonly Applicative and Alternative) and then run with runConc.

Run a Conc value on multiple threads.

Flattened structure, either Applicative or Alternative

Flattened Applicative. No Alternative stuff directly in here, but may be in the children. Notice this type doesn't have a type parameter for monadic contexts, it hardwires the base monad to IO given concurrency relies eventually on that.

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

Simple difference list, for nicer types below

Turn a Conc into a Flat. Note that thanks to the ugliness of empty, this may fail, e.g. flatten Empty.

Run a Flat a on multiple threads.

Like mapConcurrently from async, but instead of one thread per element, it does pooling from a set of threads. This is useful in scenarios where resource consumption is bounded and for use cases where too many concurrent tasks aren't allowed.

Example usage

import Say

action :: Int -> IO Int
action n = do
  tid <- myThreadId
  sayString $ show tid
  threadDelay (2 * 10^6) -- 2 seconds
  return n

main :: IO ()
main = do
  yx <- pooledMapConcurrentlyN 5 (\x -> action x) [1..5]
  print yx

On executing you can see that five threads have been spawned:

$ ./pool
ThreadId 36
ThreadId 38
ThreadId 40
ThreadId 42
ThreadId 44
[1,2,3,4,5]

Let's modify the above program such that there are less threads than the number of items in the list:

import Say

action :: Int -> IO Int
action n = do
  tid <- myThreadId
  sayString $ show tid
  threadDelay (2 * 10^6) -- 2 seconds
  return n

main :: IO ()
main = do
  yx <- pooledMapConcurrentlyN 3 (\x -> action x) [1..5]
  print yx

On executing you can see that only three threads are active totally:

$ ./pool
ThreadId 35
ThreadId 37
ThreadId 39
ThreadId 35
ThreadId 39
[1,2,3,4,5]

Similar to pooledMapConcurrentlyN but with number of threads set from getNumCapabilities. Usually this is useful for CPU bound tasks.

Similar to pooledMapConcurrentlyN but with flipped arguments.

Similar to pooledForConcurrentlyN but with number of threads set from getNumCapabilities. Usually this is useful for CPU bound tasks.

Performs the actual pooling for the tasks. This function will continue execution until the task queue becomes empty. When one of the pooled thread finishes it's task, it will pickup the next task from the queue if an job is available.

Like pooledMapConcurrentlyN but with the return value discarded.

Like pooledMapConcurrently but with the return value discarded.

Like pooledMapConcurrently_ but with flipped arguments.

Like pooledMapConcurrentlyN_ but with flipped arguments.

Pooled version of replicateConcurrently. Performs the action in the pooled threads.

Similar to pooledReplicateConcurrentlyN but with number of threads set from getNumCapabilities. Usually this is useful for CPU bound tasks.

Pooled version of replicateConcurrently_. Performs the action in the pooled threads.

Similar to pooledReplicateConcurrently_ but with number of threads set from getNumCapabilities. Usually this is useful for CPU bound tasks.