PureScript HTTP client and custom effect interpreter integration: JavaScript exception propagation in Effect monad

Answer

The PureScript FFI does not automatically turn a JavaScript exception thrown inside a foreign effect interpreter into a PureScript error in the Effect monad. If the interpreter lets the exception escape, it will propagate as a normal JavaScript exception and can terminate the Node.js process or be caught only by a global window.onerror handler in the browser.

Confirmed facts

• The Effect monad models synchronous JavaScript side‑effects; the FFI executes the foreign code directly.
• Unless the foreign code catches the exception and returns a PureScript value (e.g., via throwException from purescript-exceptions or an Either/Maybe), the exception bubbles out of the Effect.
• The older Eff monad behaved the same way; the change to Effect only refined the type‑level effect tracking, not exception handling.

Steps to make mock‑interpreter exceptions safe

1. Wrap every JavaScript call that may throw in a try/catch block inside the foreign function.
2. In the catch clause, convert the caught value to a PureScript error, for example:

   foreign import throwMockError :: forall e. String -> Effect e Unit
   throwMockError = function(msg) {
     try {
       throw new Error(msg);
     } catch (err) {
       // Use purescript-exceptions to lift the exception
       return require('purescript-exceptions').throwException(err);
     }
   };

3. If you prefer explicit error values, return an Either or Maybe instead of throwing:

   foreign import mockRequest :: String -> Effect e (Either String Response)
   mockRequest = function(url) {
     try {
       // pretend to fetch
       return { right: { status: 200, body: "ok" } };
     } catch (e) {
       return { left: e.message };
     }
   };

4. In PureScript code, handle the result with catchError (for throwException) or pattern‑match on Either/Maybe.
5. Run the compiled JavaScript in Node.js or a browser and verify that no uncaughtException or unhandledRejection events are emitted when the interpreter throws.

What to verify

If you are unsure whether your test environment swallows exceptions (e.g., a test framework that catches them globally), run a minimal test that deliberately throws from the interpreter and observe whether the process exits with a non‑zero code or prints an uncaught‑exception trace. That observation will tell you whether additional wrapping is needed.