Add reactive-inspired stream transformers:

lib/src/concatenate_streams.dart

Index: lib/src/concatenate_streams.dart
diff --git a/lib/src/concatenate_streams.dart b/lib/src/concatenate_streams.dart
new file mode 100644
index 0000000000000000000000000000000000000000..d910be0f1b8bfabe72201be8aeeb81732fcbec3e
--- /dev/null
+++ b/lib/src/concatenate_streams.dart
@@ -0,0 +1,19 @@
+// Copyright (c) 2016, 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";
+
+/// Concatenates streams.
+///
+/// The events of each stream in [streams] are emitted, one stream at a time
+/// in iteration order. When the final stream in [streams] has been processed,
+/// the returned stream closes.
+///
+/// If the listener on the concatenated stream cancels early, later streams are
+/// not listened to at all.

[nweiz, 2016/03/01 02:10:03]

It may be worth mentioning that an iterator may be active on [streams] for the
duration of the steam's life. The caller may need to know to avoid modifying the
underlying source of the iterable for that time.

[Lasse Reichstein Nielsen, 2016/03/01 16:51:16]

Good point.

+Stream concatenateStreams(Iterable<Stream> streams) async* {

[nweiz, 2016/03/01 02:10:03]

I can buy having fatal errors in scan, because there's no way to accumulate an
error (and it matches fold), but it *really* feels like concatenated streams
should concatenate errors as well. I'm pretty sure throttling and debouncing
should also forward errors as-is, since they're purely about choosing whether to
forward events.

[Lasse Reichstein Nielsen, 2016/03/01 16:51:16]

This will forward both value and error events to the concatenated stream. A
`yield*` forwards all events. That's why you can use
  yield* new Future.error(error, stack).asStream();
to emit an error in an async* function without breaking the stream.

Throttling and debouncing - I decided not to handle errors because I couldn't
decide whether they should count towards the throttling or not . Forwarding all
errors is another choice, and I think you are right that it is better - the user
can always cancel on error if they want that.

[nweiz, 2016/03/08 23:57:34]

Oh, interesting. I was under the impression that async* _guaranteed_ that only
one error would be emitted.

+  for (var stream in streams) {
+    yield* stream;
+  }
+}