docs: function(context, params){
  
      context || (context = this.__parent__);
  
      // Only re-evaluate this Computed Property if this value is dirty, not already
      // evaluating, and part of a data tree.
      if( !this.isDirty || this.isChanging || !context ){ return void 0; }
  
      // Mark this Computed Property as in the process of changing
      this.isChanging = true;
  
      // Check all of our dependancies to see if they are evaluating.
      // If we have a dependancy that is dirty and this isnt its first run,
      // Let this dependancy know that we are waiting for it.
      // It will re-run this Computed Property after it finishes.
      _.each(this.deps, function(dep){
        var dependancy = context.get(dep, {raw: true, isPath: true});
        if( !dependancy || !dependancy.isComputedProperty ){ return void 0; }
        if(dependancy.isDirty && dependancy.returnType !== null){
          dependancy.waiting[this.cid] = this;
          dependancy.apply(); // Try to re-evaluate this dependancy if it is dirty
          if(dependancy.isDirty){ return this.isChanging = false; }
        }
        delete dependancy.waiting[this.cid];
        // TODO: There can be a check here looking for cyclic dependancies.
      }, this);
  
      if(!this.isChanging){ return void 0; }
  
      // Run our getter method to fetch the new result value and retreive current
      // value from the cache
      var result = this.getter.apply(context, params);
      var value = this.cache[this.returnType];
  
      // Promote vanilla objects to Rebound Data keeping the same original objects
      if(_.isArray(result)){ result = new Rebound.Collection(result, {clone: false}); }
      else if(_.isObject(result) && !result.isData){ result = new Rebound.Model(result, {clone: false}); }
  
      // If result is undefined, reset our cache item
      if(_.isUndefined(result) || _.isNull(result)){
        this.returnType = 'value';
        this.isCollection = this.isModel = false;
        this.set(undefined);
      }
  
      // Set result and return types, bind events
      // Ensure that the collection's model constructor and comparator matches the returned collection.
      // Use .set instead of .reset to trigger individual changes for internal models
      else if(result.isCollection){
        this.returnType = 'collection';
        this.isCollection = true;
        this.isModel = false;
        this.cache.collection.model = result.model;
        this.cache.collection.comparator = result.comparator;
        this.set(result);
        this.track(result);
      }
  
      // If this is a model, set the return types and bind events.
      // If this model is the same as a previus run, just apply the changes to it.
      // If this is a different model, reset all of the values to the new ones.
      else if(result.isModel){
        this.returnType = 'model';
        this.isCollection = false;
        this.isModel = true;
        this.reset(result);
        this.track(result);
      }
  
      // Otherwise, result is a primitive. Set values appropreately.
      else{
        this.returnType = 'value';
        this.isCollection = this.isModel = false;
        this.set(result);
      }
  
      return this.value();
    }