Update charted to 0.4.8 and roll

packages/async/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.
 
-library async.stream_group;
-
 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
 /// the group won't be listened to until [stream] has a listener. **Note that
 /// this means that events emitted by broadcast streams will be dropped until
 /// [stream] has a listener.**
 ///
-/// If the `StreamGroup` is constructed using [new StreamGroup], [stream] will be
-/// single-subscription. In this case, if [stream] is paused or canceled, all
+/// If the `StreamGroup` is constructed using [new StreamGroup], [stream] will
+/// be single-subscription. In this case, if [stream] is paused or canceled, all
 /// streams in the group will likewise be paused or canceled, respectively.
 ///
 /// If the `StreamGroup` is constructed using [new StreamGroup.broadcast],
 /// [stream] will be a broadcast stream. In this case, the streams in the group
 /// will never be paused and single-subscription streams in the group will never
 /// be canceled. **Note that single-subscription streams in a broadcast group
 /// may drop events if a listener is added and later removed.** Broadcast
 /// streams in the group will be canceled once [stream] has no listeners, and
 /// will be listened to again once [stream] has listeners.
 ///
@@ skipping 19 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 merge(Iterable<Stream> streams) {
-    var group = new StreamGroup();
+  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 96 matching lines @@
       // it has no listeners.
       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 _listenToStream(Stream stream) {
-    var subscription = stream.listen(
-        _controller.add,
-        onError: _controller.addError,
-        onDone: () => remove(stream));
+  StreamSubscription<T> _listenToStream(Stream<T> 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;
 }