docs: function(key, options) {
                      options = options || {
                          args: []
                      };
                      var self = this,
                          rootObserve,
                          rootReads,
                          computeData = {
                              // computeData.compute returns a get-set compute that is tied to the first location of the provided
                              // key in the context of the scope.
                              compute: can.compute(function(newVal) {
                                  // **Compute setter**
                                  if (arguments.length) {
                                      if (rootObserve.isComputed && !rootReads.length) {
                                          rootObserve(newVal);
                                      } else {
                                          var last = rootReads.length - 1;
                                          can.compute.read(rootObserve, rootReads.slice(0, last))
                                              .value.attr(rootReads[last], newVal);
                                      }
                                      // **Compute getter**
                                  } else {
                                      // If computeData has found the value for the key in the past in an observable then go directly to
                                      // the observable (rootObserve) that the value was found in the last time and return the new value.  This
                                      // is a huge performance gain for the fact that we aren't having to check the entire scope each time.
                                      if (rootObserve) {
                                          return can.compute.read(rootObserve, rootReads, options)
                                              .value;
                                      }
                                      // If the key has not already been located in a observable then we need to search the scope for the
                                      // key.  Once we find the key then we need to return it's value and if it is found in an observable
                                      // then we need to store the observable so the next time this compute is called it can grab the value
                                      // directly from the observable.
                                      var data = self.read(key, options);
                                      rootObserve = data.rootObserve;
                                      rootReads = data.reads;
                                      computeData.scope = data.scope;
                                      computeData.initialValue = data.value;
                                      return data.value;
                                  }
                              })
                          };
                      return computeData;
                  }