Report a bug
If you spot a problem with this page, click here to create a Bugzilla issue.
Improve this page
Quickly fork, edit online, and submit a pull request for this page. Requires a signed-in GitHub account. This works well for small changes. If you'd like to make larger changes you may want to consider using a local clone.


Signals and Slots are an implementation of the Observer Pattern. Essentially, when a Signal is emitted, a list of connected Observers (called slots) are called.
There have been several D implementations of Signals and Slots. This version makes use of several new features in D, which make using it simpler and less error prone. In particular, it is no longer necessary to instrument the slots.
Slots can only be delegates formed from class objects or interfaces to class objects. If a delegate to something else is passed to connect(), such as a struct member function, a nested function or a COM interface, undefined behavior will result.

Not safe for multiple threads operating on the same signals or slots.
template Signal(T1...)
Mixin to create a signal within a class object.
Different signals can be added to a class by naming the mixins.
import std.signals;

int observedMessageCounter = 0;

class Observer
{   // our slot
    void watch(string msg, int value)
            case 0:
                assert(msg == "setting new value");
                assert(value == 4);
            case 1:
                assert(msg == "setting new value");
                assert(value == 6);
                assert(0, "Unknown observation");

class Foo
    int value() { return _value; }

    int value(int v)
        if (v != _value)
        {   _value = v;
            // call all the connected slots with the two parameters
            emit("setting new value", v);
        return v;

    // Mix in all the code we need to make Foo into a signal
    mixin Signal!(string, int);

  private :
    int _value;

Foo a = new Foo;
Observer o = new Observer;

a.value = 3;                // should not call
a.connect(&;        // is the slot
a.value = 4;                // should call
a.disconnect(&;     // is no longer a slot
a.value = 5;                // so should not call
a.connect(&;        // connect again
a.value = 6;                // should call
destroy(o);                 // destroying o should automatically disconnect it
a.value = 7;                // should not call

assert(observedMessageCounter == 2);
alias slot_t = void delegate(T1);
A slot is implemented as a delegate. The slot_t is the type of the delegate. The delegate must be to an instance of a class or an interface to a class instance. Delegates to struct instances or nested functions must not be used as slots.
final void emit(T1 i);
Call each of the connected slots, passing the argument(s) i to them.
final void connect(slot_t slot);
Add a slot to the list of slots to be called when emit() is called.
final void disconnect(slot_t slot);
Remove a slot from the list of slots to be called when emit() is called.