code: function Chain(fns) {
  	if (fns instanceof Array)
  		this.fns = fns.map(this.wrap);
  	else
  		this.fns = slice.call(arguments).map(this.wrap);
  
  	var that = this;
  	this.bind_after_env = false;
  	this.name = '(anonymous chain)';
  
  	// To simplify making the length (which indicates argument count) reflect what the first function needs
  	this.__defineGetter__('length', function() {
  		if (that.fns[0])
  			return that.fns[0].params;
  		return 0;
  	});
  }
docs: Creates an object that represents a series of functions that will be called sequentially
  These functions must have "prototype" information given through mkfn. This is because fn.length
  is not a reliable way to get the number of arguments. For instance, if Function.prototype.bind()
  is used to save a context, fn.length will produce zero, even though there are additional required
  arguments for the wrapped function. That said, if someone passes a function instead of the result
  from mkfn(), we will try to wrap it as best we can, and so we have to trust Function.length
  @param fns Array of functions to form the chain, with definitions given by mkfn()
  @param ... Or, a bunch of functions not as an array, will convert them appropriately