Add reactive-inspired stream transformers:

lib/src/transformers/scan.dart

+// 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";
+
+/// Updates an accumulator with each event and emits the intermediate results.
+///
+/// Combines each event with the previous accumulator value
+/// and emits the new result.
+///
+/// Example:
+/// ```dart
+/// var stream = new Stream.fromIterable([1, 2, 3, 4, 5]);
+/// var result = await stream.transform(new Scan(1, (a, b) => a * b)).toList();
+/// print(result);  // [1, 2, 6, 24, 120]
+/// ```
+///
+/// The last result emitted by `stream.transform(new Scan(a, c))`
+/// is the same result that would be computed by `stream.fold(a, c)`.
+///
+/// Errors in the source stream or from calling the combine function
+/// are reported on the result stream and abort the transformation.
+class Scan<S, A> implements StreamTransformer<S, A> {

[floitsch, 2016/02/26 13:50:44]

I'm still not convinced that "Scan" is a good name.
MapFold ?

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

I think matching Reactive here is worth the odd name. There was a mailing list
post about this just today: people are coming from other languages looking
specifically for reactive stuff using reactive terminology.

+  final A _initial;
+  final Function _combine;
+
+  /// Accumulates stream events using [combine] starting with [initial].
+  Scan(A initial, A combine(A accumulator, S source))
+      : _initial = initial, _combine = combine;
+
+  Stream<A> bind(Stream<S> stream) async* {
+    A accumulator = _initial;
+    await for (S source in stream) {
+      accumulator = _combine(accumulator, source);
+      yield accumulator;
+    }
+  }
+}