JavaScript: Constructor returning a "function" instance.

ctor-return-function.js

var util = require("util");

function Thing() {
  // The instance is also a proxy function for its __default method.
  var instance = function() {
    return instance.__default.apply(instance, arguments);
  };
  // The instance needs to inherit from Thing.prototype.
  instance.__proto__ = Thing.prototype;
  // Initialize the instance with the __ctor method.
  instance.__ctor.apply(instance, arguments);
  // The instance must be returned!
  return instance;
}

// All "instances" of Thing need to inherit from Function, as they are
// functions!
util.inherits(Thing, Function);

// Used to initialize each new Thing instance.
Thing.prototype.__ctor = function(options) {
  this.value = options.value;
};

// Used when each Thing instance is invoked.
Thing.prototype.__default = function(value) {
  this.value = value;
  return value;
};

// One of many possible methods.
Thing.prototype.getValue = function() {
  return this.value;
};

usage.js

var thing = new Thing({value: "initial"});
console.log(thing.getValue()); // "initial"

console.log(thing("changed")); // "changed"
console.log(thing.getValue()); // "changed"

thing.value = "changed again";
console.log(thing.getValue()); // "changed again"

The idea for this is to be able to create instances of what's currently a singleton pattern, where the "namespace object" is a function and not a plain object, like:

var thing = function() {
 // do something
};

thing.method = function() {
 // do something else
};

module.exports = thing;

Another alternative would be to throw everything in a factory function, like so:

exports.makeThing = function() {
  var thing = function() {
   // do something
  };

  thing.method = function() {
   // do something else
  };

  return thing;
};