Remove Stream.cyclic/superceding.

sdk/lib/async/stream.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 part of dart.async;
 
 // -------------------------------------------------------------------
 // Core Stream types
 // -------------------------------------------------------------------
 
@@ skipping 79 matching lines @@
    * cancelled.
    *
    * If this stream is already a broadcast stream, it is returned unmodified.
    */
   Stream<T> asBroadcastStream() {
     if (isBroadcast) return this;
     return new _SingleStreamMultiplexer<T>(this);
   }
 
   /**
-   * Stream that outputs events from the [sources] in cyclic order.
-   *
-   * The merged streams are paused and resumed in order to ensure the proper
-   * order of output events.
-   */
-  factory Stream.cyclic(Iterable<Stream> sources) {
-    return new _CyclicScheduleStream<T>(sources);
-  }
-
- /**
-   * Create a stream that forwards data from the highest priority active source.
-   *
-   * Sources are provided in order of increasing priority, and only data from
-   * the highest priority source stream that has provided data are output
-   * on the created stream.
-   *
-   * Errors from the most recent active stream, and any higher priority stream,
-   * are forwarded to the created stream.
-   *
-   * If a higher priority source stream completes without providing data,
-   * it will have no effect on lower priority streams.
-   */
-  factory Stream.superceding(Iterable<Stream<T>> sources) {
-    return new _SupercedeStream<T>(sources);
-  }
-
-  /**
    * Add a subscription to this stream.
    *
    * On each data event from this stream, the subscribers [onData] handler
    * is called. If [onData] is null, nothing happens.
    *
    * On errors from this stream, the [onError] handler is given a
    * [AsyncError] object describing the error.
    *
    * If this stream closes, the [onDone] handler is called.
    *
@@ skipping 52 matching lines @@
    * and each of these new events are then sent by the returned stream
    * in order.
    */
   Stream expand(Iterable convert(T value)) {
     return new _ExpandStream<T, dynamic>(this, convert);
   }
 
   /**
    * Bind this stream as the input of the provided [StreamConsumer].
    */
-  Future pipe(StreamConsumer<dynamic, T> streamConsumer) {
+  Future pipe(StreamConsumer<T, dynamic> streamConsumer) {
     return streamConsumer.consume(this);
   }
 
   /**
    * Chain this stream as the input of the provided [StreamTransformer].
    *
    * Returns the result of [:streamTransformer.bind:] itself.
    */
   Stream transform(StreamTransformer<T, dynamic> streamTransformer) {
     return streamTransformer.bind(this);
@@ skipping 915 matching lines @@
 }
 
 class _StreamOutputSinkWrapper<T> implements StreamSink<T> {
   _StreamOutputSink _sink;
   _StreamOutputSinkWrapper(this._sink);
 
   void add(T data) => _sink._sendData(data);
   void signalError(AsyncError error) => _sink._sendError(error);
   void close() => _sink._sendDone();
 }