anchor.diff:      return result;
     }
   
  -  /** Reduces a sequence of values by repeatedly applying [combine]. */
  +  /**
  +   * Combines a sequence of values by repeatedly applying [combine].
  +   *
  +   * Similar to [Iterable.fold], this function maintains a value,
  +   * starting with [initialValue] and updated for each element of
  +   * this stream.
  +   * For each element, the value is updated to the result of calling
  +   * [combine] with the previous value and the element.
  +   *
  +   * When this stream is done, the returned future is completed with
  +   * the value at that time.
  +   * For an empty stream, the future is completed with [initialValue].
  +   *
  +   * If this stream emits an error, or the call to [combine] throws,
  +   * the returned future is completed with that error,
  +   * and processing is stopped.
  +   */
     Future<S> fold<S>(S initialValue, S combine(S previous, T element)) {
       _Future<S> result = new _Future<S>();
       S value = initialValue;
       StreamSubscription subscription;
  -    subscription = this.listen((T element) {
  -      _runUserCode(() => combine(value, element), (S newValue) {
  -        value = newValue;
  -      }, _cancelAndErrorClosure(subscription, result));
  -    }, onError: (e, st) {
  -      result._completeError(e, st);
  -    }, onDone: () {
  -      result._complete(value);
  -    }, cancelOnError: true);
  +    subscription = this.listen(
  +        (T element) {
  +          _runUserCode(() => combine(value, element), (S newValue) {
  +            value = newValue;
  +          }, _cancelAndErrorClosure(subscription, result));
  +        },
  +        onError: result._completeError,
  +        onDone: () {
  +          result._complete(value);
  +        },
  +        cancelOnError: true);
       return result;
     }
   
     /**
  -   * Collects string of data events' string representations.
  -   *
  -   * If [separator] is provided, it is inserted between any two
  -   * elements.
  -   *
  -   * Any error in the stream causes the future to complete with that
  -   * error. Otherwise it completes with the collected string when
  -   * the "done" event arrives.
  +   * Combines the string representation of elements into a single string.
  +   *
  +   * Each element is converted to a string using its [Object.toString] method.
  +   * If [separator] is provided, it is inserted between element string
  +   * representations.
  +   *
  +   * The returned future is completed with the combined string when the stream
  +   * is done.
  +   *
  +   * If the stream contains an error, or if the call to [Object.toString]
  +   * throws, the returned future is completed with that error,
  +   * and processing stops.
      */
     Future<String> join([String separator = ""]) {
       _Future<String> result = new _Future<String>();
  
positive.code:     return future;
    }
  
    /** Counts the elements in the stream. */
    Future<int> get length {
      _Future<int> future = new _Future<int>();
      int count = 0;
  
negative.code:    * While paused, the subscription will not fire any events.
     * If it receives events from its source, they will be buffered until
     * the subscription is resumed.
     * For non-broadcast streams, the underlying source is usually informed
     * about the pause,
     * so it can stop generating events until the subscription is resumed.
     *
     * To avoid buffering events on a broadcast stream, it is better to
     * cancel this subscription, and start to listen again when events
     * are needed, if the intermediate events are not important.
     *
     * If [resumeSignal] is provided, the stream subscription will undo the pause
     * when the future completes, as if by a call to [resume].
     * If the future completes with an error,
     * the stream will still resume, but the error will be considered unhandled
     * and is passed to [Zone.handleUncaughtError].
     *
     * A call to [resume] will also undo a pause.
     *
  