anchor.diff:    }
   
     @override
  -  Stream<T> get values async* {
  +  Future<T> get firstNonNull => value != null
  +      ? Future.value(value)
  +      : stream.firstWhere((value) => value != null);
  +
  +  @override
  +  Stream<T> get values {
       // Unlike with `changes`, we're OK here returning an async non-broadcast
       // stream instead of trying to inherit the broadcastness/syncness of the
       // underlying `stream` -- if `stream` were sync, then
       // `ref.values.asBroadcastStream()` would end up yielding the current value
       // before anything could possibly listen to it, which really defeats the
       // point of even calling `values` in the first place.
  -    yield value;
  -    yield* stream;
  -  }
  +
  +    StreamController<T> controller;
  +    controller = StreamController(onListen: () {
  +      controller.add(value);
  +      controller.addStream(stream).then((_) => controller.close());
  +    });
  +    return controller.stream;
  +  }
  +
  +  @override
  +  Stream<T> get nonNullValues => values.where((value) => value != null);
   
     @override
     ObservableView<M> map<M>(M Function(T) mapper) =>
  
positive.code:     });
      return _listenSub.asFuture();
    }
  
    @override
    void dispose() {
  
negative.code: abstract class ObservableView<T> extends ChangeAware<T> implements Disposable {
    T get value;
  
    /// Blocks until [value] is non-null, and then completes with that value.
    ///
    /// If [value] is already non-null, completes immediately.
    ///
    /// The implementation may internally subscribe to [stream], so if [stream] is
    /// single-subscription (non-broadcast), it won't be possible to listen to it
    /// separately.
    Future<T> get firstNonNull;
  
    /// A [Stream] of all values on this view, including the current [value] at
    /// the time the stream is listened to.
    Stream<T> get values;
  
    /// A [Stream] of all non-null values on this view, including the current
    /// [value] at the time the stream is listened to (if it's non-null).
    ///
    /// This interface does not guarantee that consecutive data events are
    /// distinct, but subclasses may do so.
    Stream<T> get nonNullValues;
  
    /// Returns a new [ObservableView] which is created by lazily calling [mapper]
    /// on this view's [value], [stream], and [changes] properties.
  