anchor.diff:    /// Returns a new stream that will begin forwarding events from this stream when the
     /// [future] completes.
     EventStream<T> skipUntil(Future future) {
  -    return new EventStream<T>(new _SkipUntilStream(this, future));
  +    return _asEventStream(new _SkipUntilStream(this, future));
     }
   
     /// Returns a new stream that contains events from this stream until the [future]
     /// completes.
     EventStream<T> takeUntil(Future future) {
  -    return new EventStream<T>(new _TakeUntilStream(this, future));
  +    return _asEventStream(new _TakeUntilStream(this, future));
     }
   
     /// Returns a new stream that upon forwarding an event from this stream, will ignore
  
positive.code: 
    /// Delays the delivery of each non-error event from this stream by the given [duration].
    EventStream<T> delay(Duration duration) {
      return new EventStream<T>(new _DelayStream(this, duration));
    }
  
    /// Returns a new stream that includes events and errors from only the latest stream
  
negative.code:     return new _StreamProperty.initialValue(this, initialValue);
    }
  
    /// Returns a wrapped broadcast or single-subscription version of [stream] based on
    /// [isBroadcast].
    ///
    /// All methods defined on this class that return an [EventStream] should use this
    /// method when returning their stream. It guarentees that the returned stream will be
    /// the same type of stream as this stream (either broadcast or single-subscription).
    EventStream _asEventStream(Stream stream) {
      return new EventStream(isBroadcast ? stream.asBroadcastStream() : stream);
    }
  
    //
    // Wrappers for Dart Stream methods
    //
  