anchor.diff:      _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);
  -}
  
positive.code:   }
  
    void _addListener(_FutureListener listener) {
      assert(!_isComplete);
      assert(listener._nextListener == null);
      listener._nextListener = _resultOrListeners;
      _resultOrListeners = listener;
    }
  
    _FutureListener _removeListeners() {
  
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);
  