function AbstractHandlerFunction (scope, func, inputs, start_index) {
  // TODO: mutability (opt-in)
  //       * Initially we won't be doing this, we won't be able to until the many spots would need to be updated to have a mutable flag.  Everything that can be passed in as mutable, will need to be passed in as mutable.
  //       * This is based on there being a mutable reference hint on the input.  Look at the saved AST output.
  //       * We might also determine that a mutable input refrence isn't ever actually mutated, thus making it false.  We might make that some sort of warning.

  // TODO: reference retention (opt-in)
  //       * Initially we won't be doing this, we won't be able to until the many spots are updated to pass this flag, would break too many things.
  //       * What does it mean to have a mutable non-reference retained input?
  //       * Based on when there is a retained reference hint on the input, the type of the input could also affect this.
  //       * Possible to guess at this by looking at the saved AST for callbacks that use an input reference.
  AbstractFunctionBasedComputable.call(this, scope, func, inputs, start_index);
}
/**
 * @constructor
 * @extends AbstractFunctionBased
 * @param {Scope} scope The scope that will contain this handler.
 * @param {function} func The function to be used for the handler.
 * @param {Array.<Computable>} inputs The Computables that this handler will use.
 * @param {number} start_index The input computable start index
 */
@constructor
@extends AbstractFunctionBased
@param {Scope} scope The scope that will contain this handler.
@param {function} func The function to be used for the handler.
@param {Array.} inputs The Computables that this handler will use.
@param {number} start_index The input computable start index
@constructor @extends AbstractFunctionBased @param { Scope } scope The scope that will contain this handler . @param { function } func The function to be used for the handler . @param { Array . } inputs The Computables that this handler will use . @param { number } start_index The input computable start index
function AbstractHandlerFunction (scope, func, inputs, start_index) {
  AbstractFunctionBasedComputable.call(this, scope, func, inputs, start_index);
}
function AbstractHandlerFunction ( scope , func , inputs , start_index ) { AbstractFunctionBasedComputable . call ( this , scope , func , inputs , start_index ) ; }
@constructor
 @extends AbstractFunctionBased
 @param {Scope} scope The scope that will contain this handler.
@constructor @extends AbstractFunctionBased @param { Scope } scope The scope that will contain this handler .
// TODO: mutability (opt-in) //       * Initially we won't be doing this, we won't be able to until the many spots would need to be updated to have a mutable flag.  Everything that can be passed in as mutable, will need to be passed in as mutable. //       * This is based on there being a mutable reference hint on the input.  Look at the saved AST output. //       * We might also determine that a mutable input refrence isn't ever actually mutated, thus making it false.  We might make that some sort of warning. // TODO: reference retention (opt-in) //       * Initially we won't be doing this, we won't be able to until the many spots are updated to pass this flag, would break too many things. //       * What does it mean to have a mutable non-reference retained input? //       * Based on when there is a retained reference hint on the input, the type of the input could also affect this. //       * Possible to guess at this by looking at the saved AST for callbacks that use an input reference.