The D Programming Language

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.

A Deeper Look at Signals and Slots
Observer pattern
Boost Signals

There has been a great deal of discussion in the D newsgroups over this, and several implementations:

signal slots library
Signals and Slots in D
Dynamic binding -- Qt's Signals and Slots vs Objective-C
Dissecting the SS
about harmonia
Another event handling module
Suggestion: signal/slot mechanism
Signals and slots?
Signals and slots ready for evaluation
Signals & Slots for Walter
Signal/Slot mechanism?
Modern Features?
Delegates vs interfaces
The importance of component programming (properties  signals and slots etc)
 signals and slots
Known Bugs
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.
Boost License 1.0.
Walter Bright

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;
import std.stdio;

class Observer
{   // our slot

    void watch(string msg, int i)
        writefln("Observed msg '%s' and value %s", msg, i);

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;

void main()
    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

which should print:
 Observed msg 'setting new value' and value 4
 Observed msg 'setting new value' and value 6

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.

void  emit(T1 i);

Call each of the connected slots, passing the argument(s) i to them.

void  connect(slot_t slot);

Add a slot to the list of slots to be called when emit() is called.

void  disconnect(slot_t slot);

Remove a slot from the list of slots to be called when emit() is called.