Change generic comment syntax to real generic syntax.

lib/src/stream_group.dart

 // Copyright (c) 2015, 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.
 
 import 'dart:async';
 
 /// A collection of streams whose events are unified and sent through a central
 /// stream.
 ///
 /// Both errors and data events are forwarded through [stream]. The streams in
@@ skipping 35 matching lines @@
   /// If it's a broadcast group and it goes dormant again, broadcast stream
   /// subscriptions will be canceled and set to null again. Single-subscriber
   /// stream subscriptions will be left intact, since they can't be
   /// re-subscribed.
   final _subscriptions = new Map<Stream<T>, StreamSubscription<T>>();
 
   /// Merges the events from [streams] into a single (single-subscriber) stream.
   ///
   /// This is equivalent to adding [streams] to a group, closing that group, and
   /// returning its stream.
-  static Stream/*<T>*/ merge/*<T>*/(Iterable<Stream/*<T>*/> streams) {
-    var group = new StreamGroup/*<T>*/();
+  static Stream<T> merge<T>(Iterable<Stream<T>> streams) {
+    var group = new StreamGroup<T>();
     streams.forEach(group.add);
     group.close();
     return group.stream;
   }
 
   /// Creates a new stream group where [stream] is single-subscriber.
   StreamGroup() {
     _controller = new StreamController<T>(
         onListen: _onListen,
         onPause: _onPause,
         onResume: _onResume,
         onCancel: _onCancel,
         sync: true);
   }
 
   /// Creates a new stream group where [stream] is a broadcast stream.
   StreamGroup.broadcast() {
     _controller = new StreamController<T>.broadcast(
-        onListen: _onListen,
-        onCancel: _onCancelBroadcast,
-        sync: true);
+        onListen: _onListen, onCancel: _onCancelBroadcast, sync: true);
   }
 
   /// Adds [stream] as a member of this group.
   ///
   /// Any events from [stream] will be emitted through [this.stream]. If this
   /// group has a listener, [stream] will be listened to immediately; otherwise
   /// it will only be listened to once this group gets a listener.
   ///
   /// If this is a single-subscription group and its subscription has been
   /// canceled, [stream] will be canceled as soon as its added. If this returns
@@ skipping 97 matching lines @@
       if (!stream.isBroadcast) return;
       subscription.cancel();
       _subscriptions[stream] = null;
     });
   }
 
   /// Starts actively forwarding events from [stream] to [_controller].
   ///
   /// This will pause the resulting subscription if [this] is paused.
   StreamSubscription<T> _listenToStream(Stream<T> stream) {
-    var subscription = stream.listen(
-        _controller.add,
-        onError: _controller.addError,
-        onDone: () => remove(stream));
+    var subscription = stream.listen(_controller.add,
+        onError: _controller.addError, onDone: () => remove(stream));
     if (_state == _StreamGroupState.paused) subscription.pause();
     return subscription;
   }
 
   /// Closes the group, indicating that no more streams will be added.
   ///
   /// If there are no streams in the group, [stream] is closed immediately.
   /// Otherwise, [stream] will close once all streams in the group close.
   ///
   /// Returns a [Future] that completes once [stream] has actually been closed.
@@ skipping 38 matching lines @@
 
   /// The name of the state.
   ///
   /// Used for debugging.
   final String name;
 
   const _StreamGroupState(this.name);
 
   String toString() => name;
 }