Compose in Javascript - Go ahead with this example? I'm trying to use the good parts of Javascript and dont follow the classical inheritance.
I studied and created this example of compose in Javascript, https://gist.github.com/fernandoperigolo/7789866.

My question is. You think this example have a good implementations of composition? Can i go ahead with it? If not, What you suggest?

(function(){
  // Adding compose to Function prototype
  Function.prototype.compose = function(argFn) {
    var fnToCall = this;
    return function() {
      // This line is really complex and i don't know exactly what this line do
      return fnToCall.call(this, argFn.apply(this,arguments));
    }
  }

  // Eletronic atributes and methods
  var asEletronic = function(){
    this.voltage = '220v';
    this.power = false;
    this.switchPower = function(){
      if (this.power === true) {
        this.power = false;
        console.info('Eletronic are off now.');
      }else{
        this.power = true;
        console.info('Eletronic are on now.');
      };
    }
    return this;
  };

  // Sound Reproducer atributes and methods
  var asSoundReproducer = function(){
    this.watts = 60;
    this.playSound = function(sound){
      console.info('Playing the sound: '+sound);
    };
    return this;
  };
  // All sound reproducer is a eletronic
  // Composing first level
  asSoundReproducer = asSoundReproducer.compose(asEletronic)

  // Micro System atributes and methods
  // Not used, just example
  var asMicroSystem = function(){
    this.cd = false;
    this.mp3 = true;
    return this;
  };

  // TV atributes and methods
  var TV = function(){
    this.pol = 42;
    this.hdmi = true;
    return this;
  };

  // Compose a TV with full resources
  // Compose second level, asSoundReproducer is a composed object
  // This line looks me strange...
  TV = TV.compose(asSoundReproducer);

  // Create a new TV
  var myTV = new TV();

  // Looking my TV
  console.log(myTV);

  // Call a Eletronic method
  myTV.switchPower();

  // Call a Sound Reproducer method
  myTV.playSound('guitar.mp3');
})();
Interesting question,

from your comments inside the code you seem to not have written the code or have heavily borrowed from somebody else's code..

From a high level I have only a  few misgivings:


Do not modify standard JS objects, so do not add compose to the prototype of Function,  I grant you that it looks cool but it will bite you at some point
myTV instanceof asSoundReproducer does not work, so figuring what kind of object you are dealing with can be painful ( this is a drawback from not using standard js OO )
You have some provision for passing parameters to functions with argFn.apply(this,arguments) but the function signatures might look ugly since you do not cut out argFn from arguments
When reading up on composing, I prefer much to be able to compose in one go like TV = compose( asSoundReproducer, asMicroSystem );
I am not sure what as stands for in your function names, I would drop anything that resembles Hungarian notation.


This counter proposal is more complicated, but handles multiple constructors in 1 go, amd  provides support for parameters and typeof.

function merge(object, boltOn) {
  //Simply merge the properties of boltOn into object, overriding existing properties
  for(var property in boltOn)
    if(boltOn.hasOwnProperty(property))
      object[property] = boltOn[property];
  return object;
}

function compose(/*Constructor1, Constructor2, ..*/) {
  //Keep a closure reference for later
  var constructorReferences = arguments;

  return function ComposedConstructor(/*parameter1, parameter2, ..*/) {

    //Clone the constructors, we will modify the clones
    var constructorClones = Array.prototype.slice.call(constructorReferences).map(function(Constructor) {
      return new Object(Constructor);
    });

    var constructor = constructorClones.pop();
    //Set up the prototype chain, without loosing the original prototypes thru `merge`
    while(constructorClones.length) {

      var nextConstructor = constructorClones.pop();
      nextConstructor.prototype = merge(new constructor(arguments), nextConstructor.prototype);
      constructor = nextConstructor;

    }
    //Call the first constructor with the arguments provided to the constructor
    constructor = constructor.bind.apply(constructor, [null].concat(Array.prototype.slice.call(arguments)));
    return new constructor();
  };
}


function A(name) {
  this.a = name;
  console.log(arguments);
}
A.prototype.sayA = function() {};

function B() {
  this.b = 2;
  console.log(arguments);
}
B.prototype.sayB = function() {};

function C() {
  this.c = 3;
  console.log(arguments);
}
C.prototype.sayC = function() {};

var O = compose(A, B, C);
var o = new O('Samsung');

// {[object Object] { a: "Samsung",b: 2,c: 3,sayA: function,sayB: function,sayC: function}
console.log(o); 
console.log(o instanceof A); //true
console.log(o instanceof B); //true
console.log(o instanceof C); //true