Primero que todo yono hacer desea agregar metodos aFunction.prototype. Hacer eso los pondría a disposición paratodos Funciones y eso no es lo que estoy buscando.

En JavaScript puedes crear objetos con prototipos personalizados como este:

function CustomObj() {}
CustomObj.prototype = {};
CustomObj.prototype.sayFoo = function () { return 'foo' };

var myCustomObj = new CustomObj(); //=> returns an object: {}
myCusomObj.sayFoo(); //=> 'foo'

También puede crear objetos de tipo matriz con prototipos personalizados como este:

function CustomArr() {}
CustomArr.prototype = [];
CustomObj.prototype.sayFoo = function () { return 'foo' };

var myCustomArr = new CustomArr(); //=> returns an ordered object: []
myCustomArr.sayFoo(); //=> 'foo'

Lo que me gustaría hacer es usar algún tipo de constructor para crear una función con su propio prototipo personalizado de la misma manera. Sin embargo, lo siguiente no funciona:

function CustomFn() {}
CustomFn.prototype = function () {};
CustomFn.prototype.sayFoo = function () { return 'foo' };

var myCustomFn = new CustomFn(); //=> PROBLEM! returns an object: {}
myCustomFn.sayFoo(); //=> 'foo'

// ^^ Here, the prototype was applied but the output was not a function.
myCustomFn(); //=> TypeError: object is not a function

Entonces, ¿hay alguna manera de lograr lo que estoy tratando de hacer?

ACTUALIZAR

Tal vez haya otra forma en la que podría estar haciendo esta pregunta que lo haría un poco más claro.

Hay un problema con la idea de un cierre:

function makeFn() {
  var output = function () { /* do some stuff */ };
  output.foo = function () { /* do some stuff */ };
  return output;
}
var specialFn = makeFn();

Esencialmente, esta técnica me da lo que quiero. Sin embargo, el problema es que cada vez que llamomakeFn, output.foo Tiene que ser creado como una función totalmente independiente que ocupa su propia memoria. Bruto. Así que podría sacar ese método del cierre:

var protoMethods = {
  "foo" : function () { /* do some stuff */ }
};
function makeFn() {
  var output = function () { /* do some stuff */ };
  for (var i in protoMethods) {
    Object.prototype.hasOwnProperty.call(protoMethods, i) &&
      (output[i] = protoMethods[i]);
  }
  return output;
}
var specialFn = makeFn();

Pero ahora tengo que hacer manualmente una iteración cada vez que llamomakeFn lo que sería menos eficiente que si pudiera simplemente asignarprotoMethods ser el prototipo deoutput. Entonces, con esta nueva actualización, ¿alguna idea?