Multitasking

Haskell has great tools for dealing with concurrency. However, in praxis they are difficult to use.

This library aims to make concurrency easy by providing many built-in solutions for common concurrency patterns. It is based on structured concurrency, not letting threads outlive their parent scope. Additionally, exceptions are propagated automatically. This means that you do not have to worry about:

• Ghost processes, since a thread can never outlive its parent scope.
• Dead processes, since exceptions will propagate to the parent thread.

Examples

awaitAllExample :: IO ()
awaitAllExample =
  -- open up a concurrency scope
  multitask $ \coordinator -> do
    -- launch tasks
    task1 <- start coordinator action1
    task2 <- start coordinator action2
    -- Wait for all actions to complete
    await coordinator

awaitTaskExample :: IO ()
awaitTaskExample =
  -- open up a concurrency scope
  multitask $ \coordinator -> do
    -- start task
    task <- start coordinator $ pure 10
    
    -- do some work
    let x = 10

    -- wait for task to complete and get the result
    result <- await task

    -- prints 20
    print $ x + result

raceTasksExample :: IO ()
raceTasksExample = multitask $ \coordinator ->
  slot <- newSlot
  _ <- start coordinator $ action1 >>= putSlot slot
  _ <- start coordinator $ action2 >>= putSlot slot
  result <- awaitSlot slot
  print result

builtinRaceExample :: IO ()
builtinRaceExample = do
    result <- raceTwo (threadDelay 1000000 >> pure 10) (pure 20)
    print result

Comparison with other libraries

• ki: Implements structured concurrency, but provides no high-level functionality. multitasking uses ki internally and additionally implements commonly used patterns.
• async: Does not implement structured concurrency

Acknowledgements

• Inspired by Notes on structured concurrency, which is implemented in the trio Python library.