my $matrix_id = $cdat->add_matrix( $matrix );
my $tree_id   = $cdat->add_tree( $tree );
$cdat->add_handler(
    'listener'   => $tree_id,
    'observable' => $matrix_id,
    'handler'    => \&handler,
);
sub handler {
    my ( $listener, $observable, $method, @args ) = @_;
    # $method is called on $observable,
    # but supervisor $cdat creates an 
    # indirection layer to notify listeners
    print "$method '@args'" # prints "set_name 'New matrix'"
}
$matrix->set_name( 'New matrix' );
[download]

I've not thought it through in detail, but I envisage a forward_message method on your CDAT object that disallows recursive calls with the same message object. Consider:

sub forward_message {
    my ($self, $message) = @_;

    return undef if exists $self->{activeMessages}{$message->id_hash};

    $self->{activeMessages}{$message->id_hash} = 1;
    # forward messages to all objects. Objects determine applicability

    delete $self->{activeMessages}{$message->{id_hash}};
    return 1;
}
[download]

Note that both CDAT and the message are objects and retain state. Messages may trigger the immediate processing of more messages, but reprocessing "identical" messages is prohibited. The id_hash determines what is considered to be "identical".

The idea of dynamic dispatch appeals to me for this application so I'd likely have a chunk of code in the target objects's message handlers that looks like:

sub message_handler {
    my ($self, $message) = @_
    my $handler = 'handler_' . $message->{action};

    return undef if ! $self->can ($handler);
    return $self->$handler ($message);
}

sub handler_addTaxonName {
    my ($self, $message) = @_;
    my $newTaxon = $message->{newTaxon};

    ...

    my $balance = $self->create_message ('rebalance', -taxon => $newTa
+xon, ...);

    $self->{CDAT}->forward_message ($balance);
    return 1;
}

sub handler_rebalance {
    my ($self, $message) = @_;
    my $newTaxon = $message->{newTaxon};

    ...
}
[download]

---

DWIM is Perl's answer to Gödel

Thanks for these suggestions! I'm going to have to meditate on this a bit more. Sounds like a good way to avoid deep recursions.