Infrequently Noted

My MBP batteries keep dying after about a year (each). I usually have 2 that I tote around with me, and each tends to be good for 1.5-2hrs of actual work. This means that I tend not to be able to work through a cross-country flight, and particularly not if I need a VM for anything (which is most of the time). I think that if Apple does rev the MBP's on the 14th, the things I'd pay for boil down to "more memory and much longer battery life". The 5+ hour flight to TAE then provided a short window to do work in before I retreated to watching episodes of The Colbert Report on my phone. Knowing that i wouldn't be able to work the whole time, I brought a copy of a great paper on Traits. The paper got me thinking a lot about dojo.declare() and dojo.delegate().

Today, Dojo's delegate() function is a straightforward implementation of the Boodman/Crockford delegation pattern which Doug calls "beget" and which ES 3.1 will refer to as Object.create:

dojo.delegate = (function(){
    // boodman/crockford delegation w/ cornford optimization
    function TMP(){};
    return function(obj, props){
        TMP.prototype = obj;
        var tmp = new TMP();
        if(props){
            dojo._mixin(tmp, props);
        }
        return tmp; // Object
    }
})();

This function returns a new object which looks to the old object for things it does not itself have. Imagine an object foo which contains pithy truisms:

var foo = {
  science: "rocks!",
  learning: "is how you know you're alive"
};

We now want to promigulate our opinions, so we can delegate the responsibility of forming them:

var bar = dojo.delegate(foo, {
  testify: function(){
    console.debug("science ", this.science, "and learning", this.learning);
  }
);

Now, our bar object can change its mind independently of foo, but until it does, it'll behave as though foo's views are its own:

bar.testify(); // outputs: "science rocks and learning is how you know you're alive"
// bar refines its opinion
bar.science = "is a process";
bar.learning = "requires humility";
foo.science == "rocks!"; // still true
bar.testify(); // outputs: "science is a process and learning requires humility"

But what about when the chain gets deeper? The fact that bar can't "see" foo's values via this isn't much of a problem when the hierarchy isn't very long, but if you're specializing a behavior or complex interaction, making it possible to get at the parent's values for properties and methods becomes more pressing.

Neil has previously written about lightweight subclassing, but for as good as it its, it doesn't get us all the way there either. In regular OO-style languages, the inheritance system gives you an out via a "super" keyword or convention. This type of property shadowing-with-exceptions is a huge boon to composition in class-based languages, but it's not the whole story. Indeed, the Traits paper was all about the shortcomings of this special-purpose mechanism. What we want for both long delegation chains and long inheritance hierarchies is a more general system; in essence a way to say "I want to control how things are shadowed and which ones an item points at in each level of the hierarchy".

What if we could make delegate() savvy of this type of indirection? Here's my quick prototype:

delegate = (function(){
    var tobj = {};
    var TMP = function(){};
    return function(obj, props){
        TMP.prototype = obj;
        var tmp = new TMP();
        if(props){
            var remaps = props["->"];
            if(remaps){
                delete props["->"];
                for(var x in remaps){
                    if(tobj[x] === undefined || tobj[x] != remaps[x]){
                        if(remaps[x] == null){
                            // support hiding via null assignment
                            tmp[x] = null;
                        }else{
                            // alias the local version away
                            tmp[remaps[x]] = obj[x];
                        }
                    }
                }
            }
            dojo.mixin(tmp, props);
        }
        return tmp; // Object
    }
})();

This new version of delegate() accepts a specially named "->" property in the list of items to add to the destination object. Items in this list can either "shadow null" (hide entirely) the parent's property or can provide a new name for it, assuming of course that the new object will also have a property of that name. Here's a quick example of "->" at work with our previous example. This time, foo also has a "testify" method that we'd like bar to be able to control without having to copy the implementation:

var foo = {
    science: "rocks!",
    learning: "is how you know you're alive",
    testify: function(){
        console.debug("science ", this.science, "and learning", this.learning);
    }
};
var bar = delegate(foo, {
"->": {
"testify": "grampsSays" // maps foo's "testify" to bar's "grampsSays"
},
testify: function(){
if(this.science && this.learning){
this.grampsSays(); // call the re-named "testify"
}else{
console.debug("this object is strikingly ignorant");
}
},
});
bar.testify(); // outputs: "science rocks and learning is how you know you're alive"
bar.science = false;
bar.testify(); // outputs: "this object is strikingly ignorant"

That New Object Smell

The last missing piece of the hierarchy pie here is that there's no initializer for the objects which come from a delegation. A simple addition of some property detection code to look for an initializer can easily handle that:

delegate = (function(){
    var tobj = {};
    var TMP = function(){};
    return function(obj, props){
        // boodman/crockford delegation w/ cornford optimization.
TMP.prototype = obj;
var tmp = new TMP();
if(props){
var remaps = props["->"];
if(remaps){
delete props["->"];
// like dojo.mixin(), except w/o key/key mapping
for(var x in remaps){
// "safe" copy properties
if(tobj[x] === undefined || tobj[x] != remaps[x]){
if(remaps[x] == null){
// support hiding via null assignment
tmp[x] = null;
}else{
// alias the local version away
tmp[remaps[x]] = obj[x];
}
}
}
}
dojo.mixin(tmp, props);
}
// support for "constructor" functions. The name "init" is arbitrary.
if(typeof tmp["init"] == "function"){
tmp.init.call(tmp);
}
return tmp; // Object
}
})();

And there we have it. A style of delegation that easily supports both Trait-like name aliasing (and null shadowing) as well as internal initializers. Since our upgraded delegate can handle nulling out a parent's value for a property, we also have a straightforward way to prevent parent initializers from being called (or being called/chained - at our discretion - by a new name):

var foo = {
    science: "rocks!",
    learning: "is how you know you're alive",
    testify: function(){
        console.debug("science ", this.science, "and learning", this.learning);
    }
};
var bar = delegate(foo, {
init: function(){ this.testify(); }
});
// outputs: "science rocks and learning is how you know you're alive"
var baz = delegate(bar, {
// map away the parent's constructor
"->": {
"init": "superInit"
},
// provide our own constructor
init: function(){
console.debug("howdy!");
this.superInit(); // call the super-object ctor
}
});
// outputs: "howdy", "science rocks and learning is how you know you're alive"
var thud = delegate(baz, {
"->": { "init": null } // hide the parent ctor
});
// outputs: nothing

This form of delegate is likely to appear in Dojo 1.3 along with similar improvements to dojo.declare() to help alleviate the composition problems associated with using complex sets of mixins.

Update: corrected the null-out branch and updated the text with Doug's note that beget/delegate will be called Object.create() in 3.1.