anchor.diff:    void bind(name, model, String path) {
       unbind(name);
   
  -     // TODO(jmesserly): should we avoid observing until we are observed,
  -     // similar to PathObserver? Similar for unobserving?
  -    _bindings[name] = new PathObserver(model, path).bindSync((value) {
  +     // TODO(jmesserly): should we delay observing until we are observed,
  +     // similar to PathObserver?
  +    _observers[name] = new PathObserver(model, path).bindSync((value) {
         _values[name] = value;
         _scheduleResolve();
       });
     }
   
     void unbind(name, {bool suppressResolve: false}) {
  -    var binding = _bindings.remove(name);
  +    var binding = _observers.remove(name);
       if (binding == null) return;
   
       binding.cancel();
  
positive.code:     value = _combinator(_values);
    }
  
    void dispose() {
      for (var binding in _bindings.values) {
        binding.cancel();
      }
      _bindings.clear();
      _values.clear();
  
      _disposed = true;
      value = null;
    }
  }
  
negative.code: 
    // TODO(jmesserly): ideally these would be String keys, but sometimes we
    // use integers.
    Map<dynamic, StreamSubscription> _observers = new Map();
    Map _values = new Map();
    bool _scheduled = false;
    Object _value;
  
    CompoundBinding([CompoundBindingCombinator combinator]) {
  