docs: function(initialValue, settings){
  		var self = this;
  		// This is the async getter function.  Depending on how many arguments the function takes,
  		// we setup bindings differently.
  		var getter = settings.fn;
  		var bindings;
  
  		this.value = initialValue;
  
  		// This compute will call update with the new value itself.
  		this._setUpdates = true;
  
  		// An "async" compute has a `lastSetValue` that represents
  		// the last value `compute.set` was called with.
  		// The following creates `lastSetValue` as a can.Compute so when
  		//  `lastSetValue` is changed, the `getter` can see that change
  		// and automatically update itself.
  		this.lastSetValue = new Compute(initialValue);
  
  		// Wires up setting this compute to set `lastSetValue`.
  		// If the new value matches the last setValue, do nothing.
  		this._set = function(newVal){
  			if(newVal === self.lastSetValue.get()) {
  				return this.value;
  			}
  
  			return self.lastSetValue.set(newVal);
  		};
  
  		// Wire up the get to pass the lastNewValue
  		this._get = function() {
  			return getter.call(settings.context, self.lastSetValue.get() );
  		};
  
  		if(getter.length === 0) {
  			// If it takes no arguments, it should behave just like a Getter compute.
  			bindings = setupComputeHandlers(this, getter, settings.context);
  		} else if(getter.length === 1) {
  			// If it has a single argument, pass it the last setValue.
  			bindings = setupComputeHandlers(this, function() {
  				return getter.call(settings.context, self.lastSetValue.get() );
  			}, settings);
  
  		} else {
  			// If the function takes 2 arguments, the second argument is a function
  			// that should update the value of the compute (`setValue`). To make this we need
  			// the "normal" updater function because we are about to overwrite it.
  			var oldUpdater = this.updater,
  				resolve = ObservationRecorder.ignore(function(newVal) {
  					oldUpdater.call(self, newVal, self.value);
  				});
  
  			// Because `setupComputeHandlers` calls `updater` internally with its
  			// observation._value as `oldValue` and that might not be up to date,
  			// we overwrite updater to always use self.value.
  			this.updater = function(newVal) {
  				oldUpdater.call(self, newVal, self.value);
  			};
  
  
  			bindings = setupComputeHandlers(this, function() {
  				// Call getter, and get new value
  				var res = getter.call(settings.context, self.lastSetValue.get(), resolve);
  				// If undefined is returned, don't update the value.
  				return res !== undefined ? res : this.value;
  			}, this);
  		}
  
  		assign(this, bindings);
  	}