code: function(subclass, baseclass){
  
  	// Create a temporary nothing so that we don't fiddle the
  	// baseclass's(?) with what we do to subclass later on.
  	function tmp_object(){}
  
  	// This nothings prototype gets the base class's.
  	tmp_object.prototype = baseclass.prototype;
  
  	// We instantiate the tmp_object, whose prototype is the
  	// baseclass's; we make subclass's prototype this object, giving
  	// us something that is very much like baseclass.
  	subclass.prototype = new tmp_object; // same as: "new tmp_object();"
  
  	// Now we go back and make the constructor of subclass actually
  	// subclass again--we blew it away in the last step. Now we have a
  	// subclass constructor with the protoype of baseclass.
  	subclass.prototype.constructor = subclass;
  
  	// // Create a property to allow access to the constructor of
  	// // baseclass. This is useful when subclass needs access to
  	// // baseclass's constructor for property setting.
  	// subclass.base_constructor = baseclass;
  
  	// // Create a property to
  	// subclass.parent_class = baseclass.prototype;
      }
docs: return [retval, retval_str, okay_p, env_type]; }; 
  What seems to be a typical idiom for subclassing in JavaScript.
  
  This attempt has been scraped together from bits here and there and
  lucid explanations from Mozilla:
  
  https://developer.mozilla.org/en-US/docs/JavaScript/Introduction_to_Object-Oriented_JavaScript
  https://developer.mozilla.org/en-US/docs/JavaScript/Guide/Details_of_the_Object_Model
  https://developer.mozilla.org/en-US/docs/JavaScript/Guide/Inheritance_Revisited
  https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Operators/new
  
  @param {} subclass - the subclass object
  @param {} superclass - the superclass object