anchor.diff:    }
   
     void _addListener(_FutureListener listener) {
  -    assert(!_isComplete);
  -    assert(listener._nextListener == null);
  -    listener._nextListener = _resultOrListeners;
  -    _resultOrListeners = listener;
  +    if (_isComplete) {
  +      _clearUnhandledError();
  +      // Handle late listeners asynchronously.
  +      Timer.run(() {
  +        if (_hasValue) {
  +          T value = _resultOrListeners;
  +          listener._sendValue(value);
  +        } else {
  +          assert(_hasError);
  +          listener._sendError(_resultOrListeners);
  +        }
  +      });
  +    } else {
  +      assert(!_isComplete);
  +      assert(listener._nextListener == null);
  +      listener._nextListener = _resultOrListeners;
  +      _resultOrListeners = listener;
  +    }
     }
   
     _FutureListener _removeListeners() {
  
positive.code:     _setError(error);
    }
  }
  
  /**
   * Thin wrapper around a [Future].
   *
   * This is used to return a "new" [Future] that effectively work just
   * as an existing [Future], without making this discoverable by comparing
   * identities.
   */
  class _FutureWrapper<T> implements Future<T> {
    final Future<T> _future;
  
    _FutureWrapper(this._future);
  
    Future then(function(T value), { onError(error) }) {
      return _future.then(function, onError: onError);
    }
  
    Future catchError(function(error), {bool test(var error)}) {
      return _future.catchError(function, test: test);
    }
  
    Future<T> whenComplete(action()) {
      return _future.whenComplete(action);
    }
  
    Stream<T> asStream() => new Stream.fromFuture(_future);
  }
  
negative.code:   }
  
    Future then(f(T value), { onError(error) }) {
      if (onError == null) {
        return new _ThenFuture(f).._subscribeTo(this);
      }
      return new _SubscribeFuture(f, onError).._subscribeTo(this);
    }
  
    Future catchError(f(error), { bool test(error) }) {
      return new _CatchErrorFuture(f, test).._subscribeTo(this);
    }
  
    Future<T> whenComplete(action()) {
      return new _WhenFuture<T>(action).._subscribeTo(this);
    }
  
    Stream<T> asStream() => new Stream.fromFuture(this);
  