[Haskell] Composing channels

[Setzer, Sebastian (ext)]

Hi,
Suppose you've got two tasks, A and B, A wants sends a request to B, B
sends a response. Both are sent through Control.Concurrent.Chan:
+---+                    +---+
| A |<--aChan    bChan-->| B |
+---+                    +---+
A writes to bChan, B writes to aChan.

Because B gets requests from several tasks, the request (and the type of
bChan) includes aChan.

As long as these tasks are threads of the same process, that's fine.

But what can you do if there's a network (or some other kind of IPC) in
between?

If you didn't need to respond, you could try something like this:
+---+            +---+           +---+            +---+
| A |    cChan-->| C |--network--| D |    bChan-->| B |
+---+            +---+           +---+            +---+
A sends to cChan. C serializes the request, D deserializes it and sends
to bChan.

If you want to respond, it gets difficult.

In order to send aChan through the network, you have to serialize it.
When deserializing it, you have to create a channel in the process of D
and B, which you can write into bChan and which B uses to respond. This
channel will be read by a task which serializes the response, sends it
through the network to the process of A and C, where it will be
deserialized and written to aChan.

Of course, you need to keep the serializing/deserializing in both
processes consistent. For example by using the same shared object.

Looks quite difficult. Are there any simpler solutions for typesafe
network-communications? Are there plans to include some kind of "network
transparent channels" in the haskell library (or are they already there
and I overlooked them)?

Sebastian Setzer