One more thought on the subject: you could separate your classes even further by using an interface. For example:

// Abstracts the class that emits the click signal
interface Clickable
{
    function get click(): Signal0;
}
 
// Same button as above, but now implementing the Clickable interface
class ButtonTS implements Clickable
{
    private const __click:Signal0 = new Signal0();
    public function get click(): Signal0
    {
        return __click;
    }
    private function someFunction(): void
    {
        __click.dispatch();
    }
}
 
// Code that uses a Clickable instead of ButtonTS directly
function listenForClicks(clicker:Clickable): void
{
    clicker.click.addSlot(new FunctionSlot0(onClick));
}

This is a lot harder and messier than with EventDispatcher since classes using that approach don’t have any strongly-typed definition of what events they dispatch. I’ll leave it up to you to think about how you’d even go about making an interface like Clickable with the EventDispatcher system. :)

I think you undestood my question even better than I did. After a while fiddling both with ED and TS, yep, code is moved a bit here and there, but as long as you don’t rely on event bubbling things don’t change that much.

I guess that when I saw that public variables had to be declared, it came to my mind all this things actual programmers say about how bad dependencies are for encapsulation and so, but after a while dealing with your code I think I’m rather uninformed on the subject.

Thanks again for sharing your knowledge.

class ButtonED extends EventDispatcher
{
    private function someFunction(): void
    {
        dispatchEvent(new Event("mouseDown"));
        // or...
        dispatchEvent(new Event("mouseUp"));
    }
}
class ButtonTS
{
    public const mouseDown:Signal0 = new Signal0();
    public const mouseUp:Signal0 = new Signal0();
    private function someFunction(): void
    {
        mouseDown.dispatch();
        // or...
        mouseUp.dispatch();
    }
}

And some code that uses them:

var buttonED:ButtonED = new ButtonED();
buttonED.addEventListener("mouseDown", onMouseDown);
buttonED.addEventListener("mouseUp", onMouseUp);
 
var buttonTS:ButtonTS = new ButtonTS();
buttonTS.mouseDown.addSlot(new FunctionSlot0(onMouseDown));
buttonTS.mouseUp.addSlot(new FunctionSlot0(onMouseUp));

If I understand your question correctly, you’re wondering about how the user will change when the button changes. Say the two events are replaced by a single “click” event. Here’s what the button classes would look like:

class ButtonED extends EventDispatcher
{
    private function someFunction(): void
    {
        dispatchEvent(new Event("click"));
    }
}
class ButtonTS
{
    public const click:Signal0 = new Signal0();
    private function someFunction(): void
    {
        click.dispatch();
    }
}

And here’s the user code:

var buttonED:ButtonED = new ButtonED();
buttonED.addEventListener("click", onClick);
 
var buttonTS:ButtonTS = new ButtonTS();
buttonTS.click.addSlot(new FunctionSlot0(onClick));

To me, it’s about the same level of maintenance required by both versions.

I’m not a hardcore programmer, so maybe my question is kind of illiterate:
This way Turbosignals or Signals work, isn’t all this against encapsulation?

Let’s picture a menu and a menuButton for folding or unfolding it.

I use the flash IDE events (addEventListener, dispatchEvent… you’ll know better) and doing so, menuButton need no public vars and I can reuse it everywhere, as long as I add addEventListener (custom_event). I can reuse it in other projects, classes, clips on the stage, and if I remove it or simply don’t use it, I don’t need to make any changes in the code besides removing new:menuButton

But using Turbosignals I cannot move my menuButton between classes or even different projects, I have first to implement access to every public var:Turbosigna in menuButtnl, or, if I later regret, I end up with a lot of referenceless variables I have to deal with.

Is it that I’m missing something, or, to say it clearly, the problem is that I do need serious programming tuition?

Anyways, as far as the parts I’m able to understand, great blog

https://gist.github.com/9aeb57a266c7435684ef

private var heroAdded:FunctionSignal1 = new FunctionSignal1();
 
// add 'listeners' like this
heroAdded.addSlot(onHeroAdded);
 
// remove it like this:
heroAdded.removeSlot(onHeroAdded);
 
private function onHeroAdded(hero:Object):void 
{
    trace("cool, there is a hero added");
}

I don’t know if this is performing as fast as the normal Signal1 with a FunctionSignal, haven’t tested that, but I think this is more useable in normal projects since you can normally pass the listener function.

var heroFunctionSlot:FunctionSlot1;
 
heroAdded.addSlot(heroFunctionSlot = new FunctionSlot1(onHeroAdded)); // add slot
 
heroAdded.removeSlot( heroFunctionSlot );

It would be great if there is an alternative to this. Maybe a FunctionSignal or something would be a great addition, which creates FunctionSlots inside the class like addSlot(func);