Make core libraries use generic method syntax.

sdk/lib/async/stream.dart

 // Copyright (c) 2013, 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 366 matching lines @@
    * If [convert] throws, the returned stream reports the exception as an error
    * event instead.
    *
    * Error and done events are passed through unchanged to the returned stream.
    *
    * The returned stream is a broadcast stream if this stream is.
    * The [convert] function is called once per data event per listener.
    * If a broadcast stream is listened to more than once, each subscription
    * will individually call [convert] on each data event.
    */
-  Stream/*<S>*/ map/*<S>*/(/*=S*/ convert(T event)) {
-    return new _MapStream<T, dynamic/*=S*/>(this, convert);
+  Stream<S> map<S>(S convert(T event)) {
+    return new _MapStream<T, S>(this, convert);
   }
 
   /**
    * Creates a new stream with each data event of this stream asynchronously
    * mapped to a new event.
    *
    * This acts like [map], except that [convert] may return a [Future],
    * and in that case, the stream waits for that future to complete before
    * continuing with its result.
    *
    * The returned stream is a broadcast stream if this stream is.
    */
-  Stream/*<E>*/ asyncMap/*<E>*/(convert(T event)) {
-    StreamController/*<E>*/ controller;
-    StreamSubscription/*<T>*/ subscription;
+  Stream<E> asyncMap<E>(convert(T event)) {
+    StreamController<E> controller;
+    StreamSubscription<T> subscription;
 
     void onListen() {
       final add = controller.add;
       assert(controller is _StreamController ||
              controller is _BroadcastStreamController);
-      final _EventSink/*<E>*/ eventSink =
+      final _EventSink<E> eventSink =
           controller as Object /*=_EventSink<E>*/;
       final addError = eventSink._addError;
       subscription = this.listen(
           (T event) {
             dynamic newValue;
             try {
               newValue = convert(event);
             } catch (e, s) {
               controller.addError(e, s);
               return;
             }
             if (newValue is Future) {
               subscription.pause();
               newValue.then(add, onError: addError)
                       .whenComplete(subscription.resume);
             } else {
               controller.add(newValue as Object/*=E*/);
             }
           },
           onError: addError,
           onDone: controller.close
       );
     }
 
     if (this.isBroadcast) {
-      controller = new StreamController/*<E>*/.broadcast(
+      controller = new StreamController<E>.broadcast(
         onListen: onListen,
         onCancel: () { subscription.cancel(); },
         sync: true
       );
     } else {
-      controller = new StreamController/*<E>*/(
+      controller = new StreamController<E>(
         onListen: onListen,
         onPause: () { subscription.pause(); },
         onResume: () { subscription.resume(); },
         onCancel: () => subscription.cancel(),
         sync: true
       );
     }
     return controller.stream;
   }
 
   /**
    * Creates a new stream with the events of a stream per original event.
    *
    * This acts like [expand], except that [convert] returns a [Stream]
    * instead of an [Iterable].
    * The events of the returned stream becomes the events of the returned
    * stream, in the order they are produced.
    *
    * If [convert] returns `null`, no value is put on the output stream,
    * just as if it returned an empty stream.
    *
    * The returned stream is a broadcast stream if this stream is.
    */
-  Stream/*<E>*/ asyncExpand/*<E>*/(Stream/*<E>*/ convert(T event)) {
-    StreamController/*<E>*/ controller;
+  Stream<E> asyncExpand<E>(Stream<E> convert(T event)) {
+    StreamController<E> controller;
     StreamSubscription<T> subscription;
     void onListen() {
       assert(controller is _StreamController ||
              controller is _BroadcastStreamController);
-      final _EventSink/*<E>*/ eventSink =
+      final _EventSink<E> eventSink =
           controller as Object /*=_EventSink<E>*/;
       subscription = this.listen(
           (T event) {
-            Stream/*<E>*/ newStream;
+            Stream<E> newStream;
             try {
               newStream = convert(event);
             } catch (e, s) {
               controller.addError(e, s);
               return;
             }
             if (newStream != null) {
               subscription.pause();
               controller.addStream(newStream)
                         .whenComplete(subscription.resume);
             }
           },
           onError: eventSink._addError,  // Avoid Zone error replacement.
           onDone: controller.close
       );
     }
     if (this.isBroadcast) {
-      controller = new StreamController/*<E>*/.broadcast(
+      controller = new StreamController<E>.broadcast(
         onListen: onListen,
         onCancel: () { subscription.cancel(); },
         sync: true
       );
     } else {
-      controller = new StreamController/*<E>*/(
+      controller = new StreamController<E>(
         onListen: onListen,
         onPause: () { subscription.pause(); },
         onResume: () { subscription.resume(); },
         onCancel: () => subscription.cancel(),
         sync: true
       );
     }
     return controller.stream;
   }
 
@@ skipping 34 matching lines @@
    * into zero or more events.
    *
    * Each incoming event is converted to an [Iterable] of new events,
    * and each of these new events are then sent by the returned stream
    * in order.
    *
    * The returned stream is a broadcast stream if this stream is.
    * If a broadcast stream is listened to more than once, each subscription
    * will individually call `convert` and expand the events.
    */
-  Stream/*<S>*/ expand/*<S>*/(Iterable/*<S>*/ convert(T value)) {
-    return new _ExpandStream<T, dynamic/*=S*/>(this, convert);
+  Stream<S> expand<S>(Iterable<S> convert(T value)) {
+    return new _ExpandStream<T, S>(this, convert);
   }
 
   /**
    * Pipe the events of this stream into [streamConsumer].
    *
    * The events of this stream are added to `streamConsumer` using
    * [StreamConsumer.addStream].
    * The `streamConsumer` is closed when this stream has been successfully added
    * to it - when the future returned by `addStream` completes without an error.
    *
@@ skipping 12 matching lines @@
   }
 
   /**
    * Chains this stream as the input of the provided [StreamTransformer].
    *
    * Returns the result of [:streamTransformer.bind:] itself.
    *
    * The `streamTransformer` can decide whether it wants to return a
    * broadcast stream or not.
    */
-  Stream/*<S>*/ transform/*<S>*/(
-      StreamTransformer<T, dynamic/*=S*/ > streamTransformer) {
+  Stream<S> transform<S>(
+      StreamTransformer<T, S > streamTransformer) {
     return streamTransformer.bind(this);
   }
 
   /**
    * Reduces a sequence of values by repeatedly applying [combine].
    */
   Future<T> reduce(T combine(T previous, T element)) {
     _Future<T> result = new _Future<T>();
     bool seenFirst = false;
     T value;
@@ skipping 20 matching lines @@
         } else {
           result._complete(value);
         }
       },
       cancelOnError: true
     );
     return result;
   }
 
   /** Reduces a sequence of values by repeatedly applying [combine]. */
-  Future/*<S>*/ fold/*<S>*/(var/*=S*/ initialValue,
-      /*=S*/ combine(var/*=S*/ previous, T element)) {
+  Future<S> fold<S>(S initialValue,
+      S combine(S previous, T element)) {
 
-    _Future/*<S>*/ result = new _Future/*<S>*/();
-    var/*=S*/ value = initialValue;
+    _Future<S> result = new _Future<S>();
+    S value = initialValue;
     StreamSubscription subscription;
     subscription = this.listen(
       (T element) {
         _runUserCode(
           () => combine(value, element),
-          (/*=S*/ newValue) { value = newValue; },
+          (S newValue) { value = newValue; },
           _cancelAndErrorClosure(subscription, result)
         );
       },
       onError: (e, st) {
         result._completeError(e, st);
       },
       onDone: () {
         result._complete(value);
       },
       cancelOnError: true);
@@ skipping 241 matching lines @@
    * Discards all data on the stream, but signals when it's done or an error
    * occured.
    *
    * When subscribing using [drain], cancelOnError will be true. This means
    * that the future will complete with the first error on the stream and then
    * cancel the subscription.
    *
    * In case of a `done` event the future completes with the given
    * [futureValue].
    */
-  Future/*<E>*/ drain/*<E>*/([/*=E*/ futureValue])
-      => listen(null, cancelOnError: true).asFuture/*<E>*/(futureValue);
+  Future<E> drain<E>([E futureValue])
+      => listen(null, cancelOnError: true).asFuture<E>(futureValue);
 
   /**
    * Provides at most the first [count] data events of this stream.
    *
    * Forwards all events of this stream to the returned stream
    * until [count] data events have been forwarded or this stream ends,
    * then ends the returned stream with a done event.
    *
    * If this stream produces fewer than [count] data events before it's done,
    * so will the returned stream.
@@ skipping 430 matching lines @@
       zone = Zone.current;
       if (onTimeout == null) {
         timeout = () {
           controller.addError(new TimeoutException("No stream event",
                                                    timeLimit), null);
         };
       } else {
         // TODO(floitsch): the return type should be 'void', and the type
         // should be inferred.
         var registeredOnTimeout =
-            zone.registerUnaryCallback/*<dynamic, EventSink<T>>*/(onTimeout);
+            zone.registerUnaryCallback<dynamic, EventSink<T>>(onTimeout);
         _ControllerEventSinkWrapper wrapper =
             new _ControllerEventSinkWrapper(null);
         timeout = () {
           wrapper._sink = controller;  // Only valid during call.
           zone.runUnaryGuarded(registeredOnTimeout, wrapper);
           wrapper._sink = null;
         };
       }
 
       subscription = this.listen(onData, onError: onError, onDone: onDone);
@@ skipping 126 matching lines @@
    *
    * This method *overwrites* the existing [onDone] and [onError] callbacks
    * with new ones that complete the returned future.
    *
    * In case of an error the subscription will automatically cancel (even
    * when it was listening with `cancelOnError` set to `false`).
    *
    * In case of a `done` event the future completes with the given
    * [futureValue].
    */
-  Future/*<E>*/ asFuture/*<E>*/([var/*=E*/ futureValue]);
+  Future<E> asFuture<E>([E futureValue]);
 }
 
 
 /**
  * An interface that abstracts creation or handling of [Stream] events.
  */
 abstract class EventSink<T> implements Sink<T> {
   /** Send a data event to a stream. */
   void add(T event);
 
@@ skipping 315 matching lines @@
 class _ControllerEventSinkWrapper<T> implements EventSink<T> {
   EventSink _sink;
   _ControllerEventSinkWrapper(this._sink);
 
   void add(T data) { _sink.add(data); }
   void addError(error, [StackTrace stackTrace]) {
     _sink.addError(error, stackTrace);
   }
   void close() { _sink.close(); }
 }