Error/NonDet and threads

[torgeirsh]

Consider this contrived example:

withEffToIO (ConcUnlift Ephemeral Unlimited) $ \unliftIO -> forkIO (unliftIO empty)

Since the Error and NonDet effects are implemented with the ErrorWrapper exception, and exceptions aren't automatically propagated to the parent thread in Haskell, the example just prints "Effectful.Error.Static.ErrorWrapper: Effectful.NonDet.ErrorEmpty" along with a call stack, and continues execution. One could argue that it's the user's responsibility to catch and re-throw exceptions, but one could also argue that it's an internal implementation detail in Effectful, especially since the ErrorWrapper type isn't exported. Would it be better if the use of ConcUnlift implied automatic propagation of ErrorWrapper exceptions?

[arybczak]

Would it be better if the use of ConcUnlift implied automatic propagation of ErrorWrapper exceptions?

I don't see how that would be possible, e.g. forkIO completely detaches and it's not clear how the re-attachment could work.

This is already somewhat explained in here, though not exactly this particular behavior, but AFAIK it's unavoidable. Maybe the documentation could use some improvement, though not sure which place.

If you want to ensure error propagation and respecting scope, you need to stick to withAsync-like stuff.

[torgeirsh]

I haven't looked at the implementation, so it may not be feasible, but I imagined something like withEffToIO obtaining the id of the calling thread, and the unliftIO function that is passed to the user code catches ErrorWrapper exceptions and propagates them with throwTo.

For regular application threads I agree that it's better to use Async, but I don't think it's possible in cases when the application doesn't control the thread, e.g. System.Posix.Signals.installHandler.

If it's not possible to handle propagation transparently, I think the documentation could be improved by making it clear that Error and NonDet are implemented with the ErrorWrapper runtime exception, and that it's the user's responsibility to both properly propagate it, and to not catch it by accident (#232). To that end, it would be helpful if ErrorWrapper was exported, with a suitable warning about not abusing it.

[torgeirsh]

Here's a related edge case I came across by accident:

ghci> runEff . runConcurrent . runErrorNoCallStack . withAsync (throwError_ ()) $ \thread -> wait thread
Left ()
ghci> runEff . runConcurrent . runErrorNoCallStack . withAsync (throwError_ ()) $ \thread -> do link thread; threadDelay 1000000000
*** Exception: ExceptionInLinkedThread (ThreadId 667) Effectful.Error.Static.ErrorWrapper: <opaque>