Is there interest in a std.http?

[Adam D. Ruppe]

On Tuesday, 20 November 2012 at 15:21:12 UTC, H. S. Teoh wrote:
> It should work at the file descriptor level, perhaps even
> combining with signal handling (using the self-pipe trick)

I was thinking we'd send pointers and a type hash through a pipe. 
It'd keep the read/write very simple.

Now, the event data must be defined to be transient, unless 
specifically told otherwise (e.g. immutable types), because then 
we can reuse the data structures to avoid allocations.

But take a gander at this:
http://arsdnet.net/dcode/typehash.d

We can take any type tuple, do a mangle of and get a unique
name for any combination of arguments. Then hash it, and we
have a nicely unique, fixed size message to send down the pipe.


One one end, we'll cast to a void* and send that along with the 
hash.

On the other side, only listener functions who's 
ParameterTypeTuple matches the typehash will receive a message. 
They can then cast the void* back to the argument type with 
confidence.



This lets us define custom messages as plain types:

struct MyMessage {
    string text;
}


event.listen((MyMessage m) { writeln("Received: ", m.text); }
event.send(MyMessage("hello!"));

event.loop(); // we should receive the message and call the above 
func



If there's no listener that matches the hash, we ignore the 
message. Now there'd be some care needed to not send pointers to 
stack data down the pipe, as that could be destroyed, but eh.

Some details gotta be worked out but I really like the idea of 
using type names like this.