anchor.diff:    }
   
     SettableScope.entered() : this._(true);
  -
     SettableScope.notEntered() : this._(false);
   
     /// Immediately changes scope state and calls onEnter listeners.
  
positive.code:   Stream<T> get onEnter => _settable.onEnter;
  
    Stream<T> get onExit => _settable.onExit;
  }
  
  typedef T GetNewValue<T>(T currentValue);
  
negative.code:   Stream<T> get onExit => _onExit;
  
    // TODO onClose ?
  
    Scope<T> transform(
        {void onEnter(T value, SettableScope<T> scope),
        void onExit(T value, SettableScope<T> scope)}) {
      return isEntered
          ? new TransformScope.entered(this, onEnter: onEnter, onExit: onExit)
          : new TransformScope.notEntered(this, onEnter: onEnter, onExit: onExit);
    }
  }
  
  // TODO type parameters
  class ForwardingScope extends Scope {
    // TODO: API for closing scope
    // Closing scope cant come from delegate because we can change the delegate
    // Would have to be API on forwarding scope itself to close this scope
    // "I'm done and won't delegate anything else with this scope"
    // Alternatively we could flag delegate with whether to use the delegate's
    // close or not... in either case delegating again after close must be an
    // error.
    final StreamController _enters = new StreamController.broadcast(sync: true);
    final StreamController _exits = new StreamController.broadcast(sync: true);
  
  