Open a connection, and manage it so it can be used as a TDuplex.

This works by spawning two threads, one which receives messages and another which sends messages. If the recvMsg callback throws an exception, it will be forwarded to the next recv call (once the receive queue is empty).

When the inner computation completes (or throws an exception), the send queue is flushed and the connection is closed.

An abstract object that supports sending and receiving messages in STM.

Internally, it is a pair of TChans, with additional flags to check for I/O errors on recv, and to avoid filling the send queue with messages that will never be sent.

Read a message from the receive queue. retry if no message is available yet.

This will throw an exception if the reading thread encountered an error, or if the connection is closed.

Remember that STM transactions have no effect until they commit. Thus, to send a message and wait for a response, you will need to use two separate transactions:

atomically $ send duplex "What is your name?"
name <- atomically $ recv duplex

Write a message to the send queue.

If an error occurred while sending a previous message, or if the connection is closed, send silently ignores the message and returns. Rationale: suppose you have threads for clients A and B. A sends a message to B. If send were to throw an exception on failure, you might inadvertently disconnect A because of a failure that is B's fault.

Like send, but throw an exception if the message was discarded (either because sendMsg failed on a previous message, or because the connection has been closed).

Callbacks telling channelize how to use a duplex connection.

Treat stdin and stdout as a "connection", where each message corresponds to a line.

This sets the buffering mode of stdin and stdout to LineBuffering.

Wrap a duplex Handle in a ChannelizeConfig. Each message corresponds to a line.

Example (client):

let connect = connectTo "localhost" (PortNumber 1234) >>= connectHandle
 in channelize connect $ \duplex -> do
        ...

Example (Telnet server):

(handle, host, port) <- accept sock
putStrLn $ "Accepted connection from " ++ host ++ ":" ++ show port

-- Swallow carriage returns sent by telnet clients
hSetNewlineMode handle universalNewlineMode

forkIO $ channelize (connectHandle handle) $ \duplex -> do
    ...

Perform a read action on a Handle. Try to ensure that it can be interrupted by an asynchronous exception.

On Windows with -threaded, a thread reading a Handle cannot be interrupted by an asynchronous exception. The exception will not be delivered until the receive operation completes or fails.

hGetInterruptible works around this problem (when present) by calling hWaitForInput over and over with a delay of one second.