anchor.diff:      return thenFuture;
     }
   
  +  /** Handle a late listener on a completed future with an error. */
     Future _handleError(onError(AsyncError error), bool test(error)) {
       assert(_hasError);
  +    _clearUnhandledError();
       AsyncError error = _resultOrListeners;
       _CatchErrorFuture errorFuture = new _CatchErrorFuture(onError, test);
       new Timer(0, (_) { errorFuture._sendError(error); });
  
positive.code:         return;
        }
      } on AsyncError catch (e) {
        _setError(e);
        return;
      } catch (e, s) {
        error = new AsyncError.withCause(e, s, error);
      }
  
negative.code:     _state = _ERROR;
      _resultOrListeners = error;
      if (listeners == null) {
        _scheduleUnhandledError();
        return;
      }
      do {
        _FutureListener listener = listeners;
        listeners = listener._nextListener;
        listener._nextListener = null;
        listener._sendError(error);
      } while (listeners != null);
    }
  
    void _scheduleUnhandledError() {
      _state |= _UNHANDLED_ERROR;
      // Wait for the rest of the current event's duration to see
      // if a subscriber is added to handle the error.
      new Timer(0, (_) {
        if (_hasUnhandledError) {
          // No error handler has been added since the error was set.
          _clearUnhandledError();
          AsyncError error = _resultOrListeners;
          print("Uncaught Error: ${error.error}");
          if (stackTrace != null) {
            print("Stack Trace:\n${error.stackTrace}\n");
          }
          throw error.error;
        }
      });
    }
  
    void _addListener(_FutureListener listener) {
  