Events in D

[bitwise via Digitalmars-d]

I needed some C# style events, so I rolled my own. Long story 
short, the result was unsatisfactory.

Library based events are inadequate for basically the same 
reasons as library based properties (often suggested/attempted in 
C++). The problem is that the properties/events don't have access 
to the fields or methods of the containing object, and as such, 
incur the cost of an extra pointer per event/property, or worse, 
a delegate if custom behavior per event is needed, in order to 
provide that access. One obvious example would be synchronized 
properties/events.

Anyways, I threw together some code while thinking about what an 
event may look like in D:

struct Foo
{
    List!(void function()) callbacks;

    @event void onEvent(string op, Args...)(Args args)
    {
        static if(op == "+")
        {
            callbacks.add(args[0]);
        }
        else static if(op == "-")
        {
            callbacks.remove(args[0])
        }
        else static if(op == "()")
        {
            foreach(cb; callbacks)
                cb(args);
        }
    }

    // or..

    @event {
        void onEvent(string op, Args...)(Args args)
            if(op == "+" && Args.length == 1 && 
isSomeFunction(Args[0]))
        {
            callbacks.add(args[0]);
        }

        void onEvent(string op, Args...)(Args args)
            if(op == "-" && Args.length == 1 && 
isSomeFunction(Args[0]))
        {
            callbacks.remove(args[0]);
        }

        void onEvent(string op, Args...)(Args args)
            if(op == "()" && __traits(compiles, { 
callbacks[0](args); })
        {
            foreach(cb; callbacks)
                cb(args);
        }

        // this could work in the example above
        // if events just always returned an int
        bool onEvent(string op, Args...)(Args args)
            if(op == "!!" && Args.length == 0)
        {
            return !callbacks.empty;
        }
    }
}

void baz(int n) {
    writeln(n);
}

so usage like this:

`
Foo foo;
foo.onEvent += (int n) => writeln(n);
foo.onEvent += &baz;
foo.onEvent -= &baz;

if(foo.onEvent)
    foo.onEvent(1);
`

becomes this:

`
Foo foo;
foo.onEvent!"+"(() => writeln("bar"));
foo.onEvent!"+"(&baz);
foo.onEvent!"-"(&baz);

if(foo.onEvent!"!!"())
     foo.onEvent!"()"(1);
`

and outputs this:

1