ghc-slave-thread

Vanilla thread management in Haskell is low level and it does not approach the
problems related to thread deaths. When it's used naively the following typical
problems arise:

When a forked thread dies due to an uncaught exception, the exception does

not get raised in the main thread, which is why the program continues to run as
if nothing happened, i.e., with the presumption that the already dead thread is
running normally. Naturally this may very well bring your program to a chaotic
state.

Another issue is that one thread dying does not affect any of the threads

forked from it. That's why your program may be accumulating ghost threads.

Ever dealt with your program ignoring the <Ctrl-C> strikes?

This library solves all the issues above with a concept of a slave thread.
A slave thread has the following properties:

When it dies for whatever reason (exception or finishing normally) it kills

all the slave threads that were forked from it. This protects you from ghost
threads.

It waits for all slaves to die and execute their finalizers before executing

its own finalizer and getting released itself. This gives you hierarchical
releasing of resources.

When a slave thread dies with an uncaught exception it reraises it in the

master thread. This protects you from silent exceptions and lets you be sure of
getting informed if your program gets brought to an erroneous state.

          

---

License: MIT
URL: https://hackage.haskell.org/package/slave-thread