[Haskell-cafe] Asynchronous exceptions and the RealWorld

[Yang]

- I want to set timeouts on various IO operations in an existing 
library, ftphs. However, even if I wrap every call in `block`, it's 
unclear whether ftphs has been coded to deal with asynchronous 
exceptions, or whether state could be rendered inconsistent. Is there 
any solution for this aside from auditing/changing ftphs?

- I can't find any documentation on which calls are (either directly or 
indirectly, or parametrically) "interruptible operations" (to use the 
term from the Async Exceptions paper). For instance, I experimentally 
determined that hPutStrLn on a socket is *not*. Does such documentation 
exist anywhere? Furthermore, is there any way to embed this information 
in the type system, so that Haskellers don't produce 
async-exception-unaware code? (Effectively, introducing checked interrupts?)

- The above finding of hPutStrLn (as an example) is somewhat surprising, 
since the socket buffer may be full, causing the call to block 
indefinitely. We can unblock that call, but unless there's a way to 
atomically reinstate the block and save the result of the computation 
(the unit value), this effectively makes it impossible to determine 
whether the hPutStrLn returned. (Admittedly, this is a contrived 
example, since whether a call to hPutStrLn returns is usually not a 
useful result - but this is the first thing I tried, and I'm guessing 
there are more such IO operations that actually yield useful results.)

- Are there any higher-level concurrency libraries that actually tackle 
these hand-in-hand issues (safe asynchronous interruptible IO, 
two-phase-commit to prevent dropping results, choice, etc.)? I tried 
searching for a while, coming up with PiMonad, HAppS.Util, 
MissingH.Threads.Timeout, but none of them really address these issues. 
Perhaps this is just impossible in Concurrent Haskell, and one would 
need to resort to the sure-fire home-rolled solution using delimited 
continuations and cooperative scheduling for any serious concurrency 
abstractions for systems programming.

Thanks in advance for any answers!