Typecasting delegates

[Seiji Emery via Digitalmars-d]

Hi, bit of a long-time lurker here.

I had a few questions about D delegates: first, D delegates are 
the size of two pointers (16 bytes) on my machine, so I'd assume 
that they're implemented as a pair of pointers; presumably a C 
function pointer, and a GC-managed payload / context / this 
pointer – is this correct?

Secondly, is it safe to typecast delegates for storage purposes – 
ie. cast `void delegate (ref Foo)` to `void delegate()`, or 
something similar? Since delegates seem to just be a pair of 
pointers, it seems like this should work; it's perfectly safe to 
cast C function pointers, for instance, provided that they're 
cast back to the correct type before actually being called. The 
main worry that I have is that this could somehow wreak havoc 
with the GC-managed payload pointer, but I'm not sure. It seems 
like this shouldn't be a problem since payloads change between 
delegates anyways (reference to object vs reference to function 
scope), and delegates with different signatures could point to 
the same object / scope – ie. the payload type and pointed-to 
function signature have nothing to do with each other, and GC 
references to and within the payload should still work properly 
even if I cast a delegate with N arguments to one with zero. But 
I'm just guessing here.


For context, I'm working on an event system for a small hobby 
project, and it would be extremely useful if I could store 
delegates with different type signatures in the same storage 
container; these delegates will always be converted back to the 
correct type signature before being called (probably by storing 
typeinfo of the first / only event argument and comparing that), 
so that's a non-issue. Using a different approach than putting 
listeners that can listen to any kind of event everywhere might 
be better and more efficient architecturally, but would be much 
less flexible / powerful I think. And yes, I've looked into 
std.variadic; I just want something slightly lower-level with 
more control over how I actually dispatch and filter events.


Ah, and uh... one last thing. What's the worst that could happen 
from calling a `ref Foo` signature through a void* pointer? Once 
again, using delegate / function pointer casting shenanigans. Foo 
is a struct. The memory layout seems to be the same, so this 
technically works.

Thanks!